1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2012 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. */
39 #include "gdb-demangle.h"
40 #include "expression.h"
41 #include "filenames.h" /* for DOSish file names */
44 #include "complaints.h"
46 #include "dwarf2expr.h"
47 #include "dwarf2loc.h"
48 #include "cp-support.h"
54 #include "typeprint.h"
57 #include "exceptions.h"
59 #include "completer.h"
64 #include "gdbcore.h" /* for gnutarget */
65 #include "gdb/gdb-index.h"
70 #include "gdb_string.h"
71 #include "gdb_assert.h"
72 #include <sys/types.h>
74 typedef struct symbol
*symbolp
;
77 /* When non-zero, print basic high level tracing messages.
78 This is in contrast to the low level DIE reading of dwarf2_die_debug. */
79 static int dwarf2_read_debug
= 0;
81 /* When non-zero, dump DIEs after they are read in. */
82 static unsigned int dwarf2_die_debug
= 0;
84 /* When non-zero, cross-check physname against demangler. */
85 static int check_physname
= 0;
87 /* When non-zero, do not reject deprecated .gdb_index sections. */
88 static int use_deprecated_index_sections
= 0;
90 /* When set, the file that we're processing is known to have debugging
91 info for C++ namespaces. GCC 3.3.x did not produce this information,
92 but later versions do. */
94 static int processing_has_namespace_info
;
96 static const struct objfile_data
*dwarf2_objfile_data_key
;
98 struct dwarf2_section_info
103 /* True if we have tried to read this section. */
107 typedef struct dwarf2_section_info dwarf2_section_info_def
;
108 DEF_VEC_O (dwarf2_section_info_def
);
110 /* All offsets in the index are of this type. It must be
111 architecture-independent. */
112 typedef uint32_t offset_type
;
114 DEF_VEC_I (offset_type
);
116 /* Ensure only legit values are used. */
117 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
119 gdb_assert ((unsigned int) (value) <= 1); \
120 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
123 /* Ensure only legit values are used. */
124 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
126 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
127 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
128 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
131 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
132 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
134 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
135 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
138 /* A description of the mapped index. The file format is described in
139 a comment by the code that writes the index. */
142 /* Index data format version. */
145 /* The total length of the buffer. */
148 /* A pointer to the address table data. */
149 const gdb_byte
*address_table
;
151 /* Size of the address table data in bytes. */
152 offset_type address_table_size
;
154 /* The symbol table, implemented as a hash table. */
155 const offset_type
*symbol_table
;
157 /* Size in slots, each slot is 2 offset_types. */
158 offset_type symbol_table_slots
;
160 /* A pointer to the constant pool. */
161 const char *constant_pool
;
164 typedef struct dwarf2_per_cu_data
*dwarf2_per_cu_ptr
;
165 DEF_VEC_P (dwarf2_per_cu_ptr
);
167 /* Collection of data recorded per objfile.
168 This hangs off of dwarf2_objfile_data_key. */
170 struct dwarf2_per_objfile
172 struct dwarf2_section_info info
;
173 struct dwarf2_section_info abbrev
;
174 struct dwarf2_section_info line
;
175 struct dwarf2_section_info loc
;
176 struct dwarf2_section_info macinfo
;
177 struct dwarf2_section_info macro
;
178 struct dwarf2_section_info str
;
179 struct dwarf2_section_info ranges
;
180 struct dwarf2_section_info addr
;
181 struct dwarf2_section_info frame
;
182 struct dwarf2_section_info eh_frame
;
183 struct dwarf2_section_info gdb_index
;
185 VEC (dwarf2_section_info_def
) *types
;
188 struct objfile
*objfile
;
190 /* Table of all the compilation units. This is used to locate
191 the target compilation unit of a particular reference. */
192 struct dwarf2_per_cu_data
**all_comp_units
;
194 /* The number of compilation units in ALL_COMP_UNITS. */
197 /* The number of .debug_types-related CUs. */
200 /* The .debug_types-related CUs (TUs). */
201 struct signatured_type
**all_type_units
;
203 /* The number of entries in all_type_unit_groups. */
204 int n_type_unit_groups
;
206 /* Table of type unit groups.
207 This exists to make it easy to iterate over all CUs and TU groups. */
208 struct type_unit_group
**all_type_unit_groups
;
210 /* Table of struct type_unit_group objects.
211 The hash key is the DW_AT_stmt_list value. */
212 htab_t type_unit_groups
;
214 /* A table mapping .debug_types signatures to its signatured_type entry.
215 This is NULL if the .debug_types section hasn't been read in yet. */
216 htab_t signatured_types
;
218 /* Type unit statistics, to see how well the scaling improvements
222 int nr_uniq_abbrev_tables
;
224 int nr_symtab_sharers
;
225 int nr_stmt_less_type_units
;
228 /* A chain of compilation units that are currently read in, so that
229 they can be freed later. */
230 struct dwarf2_per_cu_data
*read_in_chain
;
232 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
233 This is NULL if the table hasn't been allocated yet. */
236 /* The shared '.dwz' file, if one exists. This is used when the
237 original data was compressed using 'dwz -m'. */
238 struct dwz_file
*dwz_file
;
240 /* A flag indicating wether this objfile has a section loaded at a
242 int has_section_at_zero
;
244 /* True if we are using the mapped index,
245 or we are faking it for OBJF_READNOW's sake. */
246 unsigned char using_index
;
248 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
249 struct mapped_index
*index_table
;
251 /* When using index_table, this keeps track of all quick_file_names entries.
252 TUs can share line table entries with CUs or other TUs, and there can be
253 a lot more TUs than unique line tables, so we maintain a separate table
254 of all line table entries to support the sharing. */
255 htab_t quick_file_names_table
;
257 /* Set during partial symbol reading, to prevent queueing of full
259 int reading_partial_symbols
;
261 /* Table mapping type DIEs to their struct type *.
262 This is NULL if not allocated yet.
263 The mapping is done via (CU/TU signature + DIE offset) -> type. */
264 htab_t die_type_hash
;
266 /* The CUs we recently read. */
267 VEC (dwarf2_per_cu_ptr
) *just_read_cus
;
270 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
272 /* Default names of the debugging sections. */
274 /* Note that if the debugging section has been compressed, it might
275 have a name like .zdebug_info. */
277 static const struct dwarf2_debug_sections dwarf2_elf_names
=
279 { ".debug_info", ".zdebug_info" },
280 { ".debug_abbrev", ".zdebug_abbrev" },
281 { ".debug_line", ".zdebug_line" },
282 { ".debug_loc", ".zdebug_loc" },
283 { ".debug_macinfo", ".zdebug_macinfo" },
284 { ".debug_macro", ".zdebug_macro" },
285 { ".debug_str", ".zdebug_str" },
286 { ".debug_ranges", ".zdebug_ranges" },
287 { ".debug_types", ".zdebug_types" },
288 { ".debug_addr", ".zdebug_addr" },
289 { ".debug_frame", ".zdebug_frame" },
290 { ".eh_frame", NULL
},
291 { ".gdb_index", ".zgdb_index" },
295 /* List of DWO sections. */
297 static const struct dwo_section_names
299 struct dwarf2_section_names abbrev_dwo
;
300 struct dwarf2_section_names info_dwo
;
301 struct dwarf2_section_names line_dwo
;
302 struct dwarf2_section_names loc_dwo
;
303 struct dwarf2_section_names macinfo_dwo
;
304 struct dwarf2_section_names macro_dwo
;
305 struct dwarf2_section_names str_dwo
;
306 struct dwarf2_section_names str_offsets_dwo
;
307 struct dwarf2_section_names types_dwo
;
311 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
312 { ".debug_info.dwo", ".zdebug_info.dwo" },
313 { ".debug_line.dwo", ".zdebug_line.dwo" },
314 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
315 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
316 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
317 { ".debug_str.dwo", ".zdebug_str.dwo" },
318 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
319 { ".debug_types.dwo", ".zdebug_types.dwo" },
322 /* local data types */
324 /* The data in a compilation unit header, after target2host
325 translation, looks like this. */
326 struct comp_unit_head
330 unsigned char addr_size
;
331 unsigned char signed_addr_p
;
332 sect_offset abbrev_offset
;
334 /* Size of file offsets; either 4 or 8. */
335 unsigned int offset_size
;
337 /* Size of the length field; either 4 or 12. */
338 unsigned int initial_length_size
;
340 /* Offset to the first byte of this compilation unit header in the
341 .debug_info section, for resolving relative reference dies. */
344 /* Offset to first die in this cu from the start of the cu.
345 This will be the first byte following the compilation unit header. */
346 cu_offset first_die_offset
;
349 /* Type used for delaying computation of method physnames.
350 See comments for compute_delayed_physnames. */
351 struct delayed_method_info
353 /* The type to which the method is attached, i.e., its parent class. */
356 /* The index of the method in the type's function fieldlists. */
359 /* The index of the method in the fieldlist. */
362 /* The name of the DIE. */
365 /* The DIE associated with this method. */
366 struct die_info
*die
;
369 typedef struct delayed_method_info delayed_method_info
;
370 DEF_VEC_O (delayed_method_info
);
372 /* Internal state when decoding a particular compilation unit. */
375 /* The objfile containing this compilation unit. */
376 struct objfile
*objfile
;
378 /* The header of the compilation unit. */
379 struct comp_unit_head header
;
381 /* Base address of this compilation unit. */
382 CORE_ADDR base_address
;
384 /* Non-zero if base_address has been set. */
387 /* The language we are debugging. */
388 enum language language
;
389 const struct language_defn
*language_defn
;
391 const char *producer
;
393 /* The generic symbol table building routines have separate lists for
394 file scope symbols and all all other scopes (local scopes). So
395 we need to select the right one to pass to add_symbol_to_list().
396 We do it by keeping a pointer to the correct list in list_in_scope.
398 FIXME: The original dwarf code just treated the file scope as the
399 first local scope, and all other local scopes as nested local
400 scopes, and worked fine. Check to see if we really need to
401 distinguish these in buildsym.c. */
402 struct pending
**list_in_scope
;
404 /* The abbrev table for this CU.
405 Normally this points to the abbrev table in the objfile.
406 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
407 struct abbrev_table
*abbrev_table
;
409 /* Hash table holding all the loaded partial DIEs
410 with partial_die->offset.SECT_OFF as hash. */
413 /* Storage for things with the same lifetime as this read-in compilation
414 unit, including partial DIEs. */
415 struct obstack comp_unit_obstack
;
417 /* When multiple dwarf2_cu structures are living in memory, this field
418 chains them all together, so that they can be released efficiently.
419 We will probably also want a generation counter so that most-recently-used
420 compilation units are cached... */
421 struct dwarf2_per_cu_data
*read_in_chain
;
423 /* Backchain to our per_cu entry if the tree has been built. */
424 struct dwarf2_per_cu_data
*per_cu
;
426 /* How many compilation units ago was this CU last referenced? */
429 /* A hash table of DIE cu_offset for following references with
430 die_info->offset.sect_off as hash. */
433 /* Full DIEs if read in. */
434 struct die_info
*dies
;
436 /* A set of pointers to dwarf2_per_cu_data objects for compilation
437 units referenced by this one. Only set during full symbol processing;
438 partial symbol tables do not have dependencies. */
441 /* Header data from the line table, during full symbol processing. */
442 struct line_header
*line_header
;
444 /* A list of methods which need to have physnames computed
445 after all type information has been read. */
446 VEC (delayed_method_info
) *method_list
;
448 /* To be copied to symtab->call_site_htab. */
449 htab_t call_site_htab
;
451 /* Non-NULL if this CU came from a DWO file.
452 There is an invariant here that is important to remember:
453 Except for attributes copied from the top level DIE in the "main"
454 (or "stub") file in preparation for reading the DWO file
455 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
456 Either there isn't a DWO file (in which case this is NULL and the point
457 is moot), or there is and either we're not going to read it (in which
458 case this is NULL) or there is and we are reading it (in which case this
460 struct dwo_unit
*dwo_unit
;
462 /* The DW_AT_addr_base attribute if present, zero otherwise
463 (zero is a valid value though).
464 Note this value comes from the stub CU/TU's DIE. */
467 /* The DW_AT_ranges_base attribute if present, zero otherwise
468 (zero is a valid value though).
469 Note this value comes from the stub CU/TU's DIE.
470 Also note that the value is zero in the non-DWO case so this value can
471 be used without needing to know whether DWO files are in use or not. */
472 ULONGEST ranges_base
;
474 /* Mark used when releasing cached dies. */
475 unsigned int mark
: 1;
477 /* This CU references .debug_loc. See the symtab->locations_valid field.
478 This test is imperfect as there may exist optimized debug code not using
479 any location list and still facing inlining issues if handled as
480 unoptimized code. For a future better test see GCC PR other/32998. */
481 unsigned int has_loclist
: 1;
483 /* These cache the results for producer_is_gxx_lt_4_6 and producer_is_icc.
484 CHECKED_PRODUCER is set if both PRODUCER_IS_GXX_LT_4_6 and PRODUCER_IS_ICC
485 are valid. This information is cached because profiling CU expansion
486 showed excessive time spent in producer_is_gxx_lt_4_6. */
487 unsigned int checked_producer
: 1;
488 unsigned int producer_is_gxx_lt_4_6
: 1;
489 unsigned int producer_is_icc
: 1;
492 /* Persistent data held for a compilation unit, even when not
493 processing it. We put a pointer to this structure in the
494 read_symtab_private field of the psymtab. */
496 struct dwarf2_per_cu_data
498 /* The start offset and length of this compilation unit.
499 NOTE: Unlike comp_unit_head.length, this length includes
501 If the DIE refers to a DWO file, this is always of the original die,
506 /* Flag indicating this compilation unit will be read in before
507 any of the current compilation units are processed. */
508 unsigned int queued
: 1;
510 /* This flag will be set when reading partial DIEs if we need to load
511 absolutely all DIEs for this compilation unit, instead of just the ones
512 we think are interesting. It gets set if we look for a DIE in the
513 hash table and don't find it. */
514 unsigned int load_all_dies
: 1;
516 /* Non-zero if this CU is from .debug_types. */
517 unsigned int is_debug_types
: 1;
519 /* Non-zero if this CU is from the .dwz file. */
520 unsigned int is_dwz
: 1;
522 /* The section this CU/TU lives in.
523 If the DIE refers to a DWO file, this is always the original die,
525 struct dwarf2_section_info
*info_or_types_section
;
527 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
528 of the CU cache it gets reset to NULL again. */
529 struct dwarf2_cu
*cu
;
531 /* The corresponding objfile.
532 Normally we can get the objfile from dwarf2_per_objfile.
533 However we can enter this file with just a "per_cu" handle. */
534 struct objfile
*objfile
;
536 /* When using partial symbol tables, the 'psymtab' field is active.
537 Otherwise the 'quick' field is active. */
540 /* The partial symbol table associated with this compilation unit,
541 or NULL for unread partial units. */
542 struct partial_symtab
*psymtab
;
544 /* Data needed by the "quick" functions. */
545 struct dwarf2_per_cu_quick_data
*quick
;
550 /* The CUs we import using DW_TAG_imported_unit. This is filled in
551 while reading psymtabs, used to compute the psymtab dependencies,
552 and then cleared. Then it is filled in again while reading full
553 symbols, and only deleted when the objfile is destroyed. */
554 VEC (dwarf2_per_cu_ptr
) *imported_symtabs
;
556 /* Type units are grouped by their DW_AT_stmt_list entry so that they
557 can share them. If this is a TU, this points to the containing
559 struct type_unit_group
*type_unit_group
;
563 /* Entry in the signatured_types hash table. */
565 struct signatured_type
567 /* The "per_cu" object of this type.
568 N.B.: This is the first member so that it's easy to convert pointers
570 struct dwarf2_per_cu_data per_cu
;
572 /* The type's signature. */
575 /* Offset in the TU of the type's DIE, as read from the TU header.
576 If the definition lives in a DWO file, this value is unusable. */
577 cu_offset type_offset_in_tu
;
579 /* Offset in the section of the type's DIE.
580 If the definition lives in a DWO file, this is the offset in the
581 .debug_types.dwo section.
582 The value is zero until the actual value is known.
583 Zero is otherwise not a valid section offset. */
584 sect_offset type_offset_in_section
;
587 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
588 This includes type_unit_group and quick_file_names. */
590 struct stmt_list_hash
592 /* The DWO unit this table is from or NULL if there is none. */
593 struct dwo_unit
*dwo_unit
;
595 /* Offset in .debug_line or .debug_line.dwo. */
596 sect_offset line_offset
;
599 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
600 an object of this type. */
602 struct type_unit_group
604 /* dwarf2read.c's main "handle" on the symtab.
605 To simplify things we create an artificial CU that "includes" all the
606 type units using this stmt_list so that the rest of the code still has
607 a "per_cu" handle on the symtab.
608 This PER_CU is recognized by having no section. */
609 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->info_or_types_section == NULL)
610 struct dwarf2_per_cu_data per_cu
;
614 /* The TUs that share this DW_AT_stmt_list entry.
615 This is added to while parsing type units to build partial symtabs,
616 and is deleted afterwards and not used again. */
617 VEC (dwarf2_per_cu_ptr
) *tus
;
619 /* When reading the line table in "quick" functions, we need a real TU.
620 Any will do, we know they all share the same DW_AT_stmt_list entry.
621 For simplicity's sake, we pick the first one. */
622 struct dwarf2_per_cu_data
*first_tu
;
625 /* The primary symtab.
626 Type units in a group needn't all be defined in the same source file,
627 so we create an essentially anonymous symtab as the primary symtab. */
628 struct symtab
*primary_symtab
;
630 /* The data used to construct the hash key. */
631 struct stmt_list_hash hash
;
633 /* The number of symtabs from the line header.
634 The value here must match line_header.num_file_names. */
635 unsigned int num_symtabs
;
637 /* The symbol tables for this TU (obtained from the files listed in
639 WARNING: The order of entries here must match the order of entries
640 in the line header. After the first TU using this type_unit_group, the
641 line header for the subsequent TUs is recreated from this. This is done
642 because we need to use the same symtabs for each TU using the same
643 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
644 there's no guarantee the line header doesn't have duplicate entries. */
645 struct symtab
**symtabs
;
648 /* These sections are what may appear in a "dwo" file. */
652 struct dwarf2_section_info abbrev
;
653 struct dwarf2_section_info info
;
654 struct dwarf2_section_info line
;
655 struct dwarf2_section_info loc
;
656 struct dwarf2_section_info macinfo
;
657 struct dwarf2_section_info macro
;
658 struct dwarf2_section_info str
;
659 struct dwarf2_section_info str_offsets
;
660 VEC (dwarf2_section_info_def
) *types
;
663 /* Common bits of DWO CUs/TUs. */
667 /* Backlink to the containing struct dwo_file. */
668 struct dwo_file
*dwo_file
;
670 /* The "id" that distinguishes this CU/TU.
671 .debug_info calls this "dwo_id", .debug_types calls this "signature".
672 Since signatures came first, we stick with it for consistency. */
675 /* The section this CU/TU lives in, in the DWO file. */
676 struct dwarf2_section_info
*info_or_types_section
;
678 /* Same as dwarf2_per_cu_data:{offset,length} but for the DWO section. */
682 /* For types, offset in the type's DIE of the type defined by this TU. */
683 cu_offset type_offset_in_tu
;
686 /* Data for one DWO file. */
690 /* The DW_AT_GNU_dwo_name attribute.
691 We don't manage space for this, it's an attribute. */
692 const char *dwo_name
;
694 /* The bfd, when the file is open. Otherwise this is NULL. */
697 /* Section info for this file. */
698 struct dwo_sections sections
;
700 /* Table of CUs in the file.
701 Each element is a struct dwo_unit. */
704 /* Table of TUs in the file.
705 Each element is a struct dwo_unit. */
709 /* This represents a '.dwz' file. */
713 /* A dwz file can only contain a few sections. */
714 struct dwarf2_section_info abbrev
;
715 struct dwarf2_section_info info
;
716 struct dwarf2_section_info str
;
717 struct dwarf2_section_info line
;
718 struct dwarf2_section_info macro
;
719 struct dwarf2_section_info gdb_index
;
725 /* Struct used to pass misc. parameters to read_die_and_children, et
726 al. which are used for both .debug_info and .debug_types dies.
727 All parameters here are unchanging for the life of the call. This
728 struct exists to abstract away the constant parameters of die reading. */
730 struct die_reader_specs
732 /* die_section->asection->owner. */
735 /* The CU of the DIE we are parsing. */
736 struct dwarf2_cu
*cu
;
738 /* Non-NULL if reading a DWO file. */
739 struct dwo_file
*dwo_file
;
741 /* The section the die comes from.
742 This is either .debug_info or .debug_types, or the .dwo variants. */
743 struct dwarf2_section_info
*die_section
;
745 /* die_section->buffer. */
748 /* The end of the buffer. */
749 const gdb_byte
*buffer_end
;
752 /* Type of function passed to init_cutu_and_read_dies, et.al. */
753 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
755 struct die_info
*comp_unit_die
,
759 /* The line number information for a compilation unit (found in the
760 .debug_line section) begins with a "statement program header",
761 which contains the following information. */
764 unsigned int total_length
;
765 unsigned short version
;
766 unsigned int header_length
;
767 unsigned char minimum_instruction_length
;
768 unsigned char maximum_ops_per_instruction
;
769 unsigned char default_is_stmt
;
771 unsigned char line_range
;
772 unsigned char opcode_base
;
774 /* standard_opcode_lengths[i] is the number of operands for the
775 standard opcode whose value is i. This means that
776 standard_opcode_lengths[0] is unused, and the last meaningful
777 element is standard_opcode_lengths[opcode_base - 1]. */
778 unsigned char *standard_opcode_lengths
;
780 /* The include_directories table. NOTE! These strings are not
781 allocated with xmalloc; instead, they are pointers into
782 debug_line_buffer. If you try to free them, `free' will get
784 unsigned int num_include_dirs
, include_dirs_size
;
787 /* The file_names table. NOTE! These strings are not allocated
788 with xmalloc; instead, they are pointers into debug_line_buffer.
789 Don't try to free them directly. */
790 unsigned int num_file_names
, file_names_size
;
794 unsigned int dir_index
;
795 unsigned int mod_time
;
797 int included_p
; /* Non-zero if referenced by the Line Number Program. */
798 struct symtab
*symtab
; /* The associated symbol table, if any. */
801 /* The start and end of the statement program following this
802 header. These point into dwarf2_per_objfile->line_buffer. */
803 gdb_byte
*statement_program_start
, *statement_program_end
;
806 /* When we construct a partial symbol table entry we only
807 need this much information. */
808 struct partial_die_info
810 /* Offset of this DIE. */
813 /* DWARF-2 tag for this DIE. */
814 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
816 /* Assorted flags describing the data found in this DIE. */
817 unsigned int has_children
: 1;
818 unsigned int is_external
: 1;
819 unsigned int is_declaration
: 1;
820 unsigned int has_type
: 1;
821 unsigned int has_specification
: 1;
822 unsigned int has_pc_info
: 1;
823 unsigned int may_be_inlined
: 1;
825 /* Flag set if the SCOPE field of this structure has been
827 unsigned int scope_set
: 1;
829 /* Flag set if the DIE has a byte_size attribute. */
830 unsigned int has_byte_size
: 1;
832 /* Flag set if any of the DIE's children are template arguments. */
833 unsigned int has_template_arguments
: 1;
835 /* Flag set if fixup_partial_die has been called on this die. */
836 unsigned int fixup_called
: 1;
838 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
839 unsigned int is_dwz
: 1;
841 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
842 unsigned int spec_is_dwz
: 1;
844 /* The name of this DIE. Normally the value of DW_AT_name, but
845 sometimes a default name for unnamed DIEs. */
848 /* The linkage name, if present. */
849 const char *linkage_name
;
851 /* The scope to prepend to our children. This is generally
852 allocated on the comp_unit_obstack, so will disappear
853 when this compilation unit leaves the cache. */
856 /* Some data associated with the partial DIE. The tag determines
857 which field is live. */
860 /* The location description associated with this DIE, if any. */
861 struct dwarf_block
*locdesc
;
862 /* The offset of an import, for DW_TAG_imported_unit. */
866 /* If HAS_PC_INFO, the PC range associated with this DIE. */
870 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
871 DW_AT_sibling, if any. */
872 /* NOTE: This member isn't strictly necessary, read_partial_die could
873 return DW_AT_sibling values to its caller load_partial_dies. */
876 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
877 DW_AT_specification (or DW_AT_abstract_origin or
879 sect_offset spec_offset
;
881 /* Pointers to this DIE's parent, first child, and next sibling,
883 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
886 /* This data structure holds the information of an abbrev. */
889 unsigned int number
; /* number identifying abbrev */
890 enum dwarf_tag tag
; /* dwarf tag */
891 unsigned short has_children
; /* boolean */
892 unsigned short num_attrs
; /* number of attributes */
893 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
894 struct abbrev_info
*next
; /* next in chain */
899 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
900 ENUM_BITFIELD(dwarf_form
) form
: 16;
903 /* Size of abbrev_table.abbrev_hash_table. */
904 #define ABBREV_HASH_SIZE 121
906 /* Top level data structure to contain an abbreviation table. */
910 /* Where the abbrev table came from.
911 This is used as a sanity check when the table is used. */
914 /* Storage for the abbrev table. */
915 struct obstack abbrev_obstack
;
917 /* Hash table of abbrevs.
918 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
919 It could be statically allocated, but the previous code didn't so we
921 struct abbrev_info
**abbrevs
;
924 /* Attributes have a name and a value. */
927 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
928 ENUM_BITFIELD(dwarf_form
) form
: 15;
930 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
931 field should be in u.str (existing only for DW_STRING) but it is kept
932 here for better struct attribute alignment. */
933 unsigned int string_is_canonical
: 1;
938 struct dwarf_block
*blk
;
942 struct signatured_type
*signatured_type
;
947 /* This data structure holds a complete die structure. */
950 /* DWARF-2 tag for this DIE. */
951 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
953 /* Number of attributes */
954 unsigned char num_attrs
;
956 /* True if we're presently building the full type name for the
957 type derived from this DIE. */
958 unsigned char building_fullname
: 1;
963 /* Offset in .debug_info or .debug_types section. */
966 /* The dies in a compilation unit form an n-ary tree. PARENT
967 points to this die's parent; CHILD points to the first child of
968 this node; and all the children of a given node are chained
969 together via their SIBLING fields. */
970 struct die_info
*child
; /* Its first child, if any. */
971 struct die_info
*sibling
; /* Its next sibling, if any. */
972 struct die_info
*parent
; /* Its parent, if any. */
974 /* An array of attributes, with NUM_ATTRS elements. There may be
975 zero, but it's not common and zero-sized arrays are not
976 sufficiently portable C. */
977 struct attribute attrs
[1];
980 /* Get at parts of an attribute structure. */
982 #define DW_STRING(attr) ((attr)->u.str)
983 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
984 #define DW_UNSND(attr) ((attr)->u.unsnd)
985 #define DW_BLOCK(attr) ((attr)->u.blk)
986 #define DW_SND(attr) ((attr)->u.snd)
987 #define DW_ADDR(attr) ((attr)->u.addr)
988 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
990 /* Blocks are a bunch of untyped bytes. */
995 /* Valid only if SIZE is not zero. */
999 #ifndef ATTR_ALLOC_CHUNK
1000 #define ATTR_ALLOC_CHUNK 4
1003 /* Allocate fields for structs, unions and enums in this size. */
1004 #ifndef DW_FIELD_ALLOC_CHUNK
1005 #define DW_FIELD_ALLOC_CHUNK 4
1008 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1009 but this would require a corresponding change in unpack_field_as_long
1011 static int bits_per_byte
= 8;
1013 /* The routines that read and process dies for a C struct or C++ class
1014 pass lists of data member fields and lists of member function fields
1015 in an instance of a field_info structure, as defined below. */
1018 /* List of data member and baseclasses fields. */
1021 struct nextfield
*next
;
1026 *fields
, *baseclasses
;
1028 /* Number of fields (including baseclasses). */
1031 /* Number of baseclasses. */
1034 /* Set if the accesibility of one of the fields is not public. */
1035 int non_public_fields
;
1037 /* Member function fields array, entries are allocated in the order they
1038 are encountered in the object file. */
1041 struct nextfnfield
*next
;
1042 struct fn_field fnfield
;
1046 /* Member function fieldlist array, contains name of possibly overloaded
1047 member function, number of overloaded member functions and a pointer
1048 to the head of the member function field chain. */
1053 struct nextfnfield
*head
;
1057 /* Number of entries in the fnfieldlists array. */
1060 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1061 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1062 struct typedef_field_list
1064 struct typedef_field field
;
1065 struct typedef_field_list
*next
;
1067 *typedef_field_list
;
1068 unsigned typedef_field_list_count
;
1071 /* One item on the queue of compilation units to read in full symbols
1073 struct dwarf2_queue_item
1075 struct dwarf2_per_cu_data
*per_cu
;
1076 enum language pretend_language
;
1077 struct dwarf2_queue_item
*next
;
1080 /* The current queue. */
1081 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1083 /* Loaded secondary compilation units are kept in memory until they
1084 have not been referenced for the processing of this many
1085 compilation units. Set this to zero to disable caching. Cache
1086 sizes of up to at least twenty will improve startup time for
1087 typical inter-CU-reference binaries, at an obvious memory cost. */
1088 static int dwarf2_max_cache_age
= 5;
1090 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
1091 struct cmd_list_element
*c
, const char *value
)
1093 fprintf_filtered (file
, _("The upper bound on the age of cached "
1094 "dwarf2 compilation units is %s.\n"),
1099 /* Various complaints about symbol reading that don't abort the process. */
1102 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1104 complaint (&symfile_complaints
,
1105 _("statement list doesn't fit in .debug_line section"));
1109 dwarf2_debug_line_missing_file_complaint (void)
1111 complaint (&symfile_complaints
,
1112 _(".debug_line section has line data without a file"));
1116 dwarf2_debug_line_missing_end_sequence_complaint (void)
1118 complaint (&symfile_complaints
,
1119 _(".debug_line section has line "
1120 "program sequence without an end"));
1124 dwarf2_complex_location_expr_complaint (void)
1126 complaint (&symfile_complaints
, _("location expression too complex"));
1130 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1133 complaint (&symfile_complaints
,
1134 _("const value length mismatch for '%s', got %d, expected %d"),
1139 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
1141 complaint (&symfile_complaints
,
1142 _("debug info runs off end of %s section"
1144 section
->asection
->name
,
1145 bfd_get_filename (section
->asection
->owner
));
1149 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
1151 complaint (&symfile_complaints
,
1152 _("macro debug info contains a "
1153 "malformed macro definition:\n`%s'"),
1158 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1160 complaint (&symfile_complaints
,
1161 _("invalid attribute class or form for '%s' in '%s'"),
1165 /* local function prototypes */
1167 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
1169 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
1172 static void dwarf2_find_base_address (struct die_info
*die
,
1173 struct dwarf2_cu
*cu
);
1175 static void dwarf2_build_psymtabs_hard (struct objfile
*);
1177 static void scan_partial_symbols (struct partial_die_info
*,
1178 CORE_ADDR
*, CORE_ADDR
*,
1179 int, struct dwarf2_cu
*);
1181 static void add_partial_symbol (struct partial_die_info
*,
1182 struct dwarf2_cu
*);
1184 static void add_partial_namespace (struct partial_die_info
*pdi
,
1185 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1186 int need_pc
, struct dwarf2_cu
*cu
);
1188 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1189 CORE_ADDR
*highpc
, int need_pc
,
1190 struct dwarf2_cu
*cu
);
1192 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1193 struct dwarf2_cu
*cu
);
1195 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1196 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1197 int need_pc
, struct dwarf2_cu
*cu
);
1199 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
1201 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1203 static struct abbrev_info
*abbrev_table_lookup_abbrev
1204 (const struct abbrev_table
*, unsigned int);
1206 static struct abbrev_table
*abbrev_table_read_table
1207 (struct dwarf2_section_info
*, sect_offset
);
1209 static void abbrev_table_free (struct abbrev_table
*);
1211 static void abbrev_table_free_cleanup (void *);
1213 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1214 struct dwarf2_section_info
*);
1216 static void dwarf2_free_abbrev_table (void *);
1218 static unsigned int peek_abbrev_code (bfd
*, gdb_byte
*);
1220 static struct partial_die_info
*load_partial_dies
1221 (const struct die_reader_specs
*, gdb_byte
*, int);
1223 static gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1224 struct partial_die_info
*,
1225 struct abbrev_info
*,
1229 static struct partial_die_info
*find_partial_die (sect_offset
, int,
1230 struct dwarf2_cu
*);
1232 static void fixup_partial_die (struct partial_die_info
*,
1233 struct dwarf2_cu
*);
1235 static gdb_byte
*read_attribute (const struct die_reader_specs
*,
1236 struct attribute
*, struct attr_abbrev
*,
1239 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
1241 static int read_1_signed_byte (bfd
*, gdb_byte
*);
1243 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
1245 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
1247 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
1249 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
1252 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
1254 static LONGEST read_checked_initial_length_and_offset
1255 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
1256 unsigned int *, unsigned int *);
1258 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
1261 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
1263 static sect_offset
read_abbrev_offset (struct dwarf2_section_info
*,
1266 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
1268 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
1270 static char *read_indirect_string (bfd
*, gdb_byte
*,
1271 const struct comp_unit_head
*,
1274 static char *read_indirect_string_from_dwz (struct dwz_file
*, LONGEST
);
1276 static ULONGEST
read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
1278 static LONGEST
read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
1280 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*, gdb_byte
*,
1283 static char *read_str_index (const struct die_reader_specs
*reader
,
1284 struct dwarf2_cu
*cu
, ULONGEST str_index
);
1286 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1288 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1289 struct dwarf2_cu
*);
1291 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1294 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1295 struct dwarf2_cu
*cu
);
1297 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1299 static struct die_info
*die_specification (struct die_info
*die
,
1300 struct dwarf2_cu
**);
1302 static void free_line_header (struct line_header
*lh
);
1304 static void add_file_name (struct line_header
*, char *, unsigned int,
1305 unsigned int, unsigned int);
1307 static struct line_header
*dwarf_decode_line_header (unsigned int offset
,
1308 struct dwarf2_cu
*cu
);
1310 static void dwarf_decode_lines (struct line_header
*, const char *,
1311 struct dwarf2_cu
*, struct partial_symtab
*,
1314 static void dwarf2_start_subfile (char *, const char *, const char *);
1316 static void dwarf2_start_symtab (struct dwarf2_cu
*,
1317 char *, char *, CORE_ADDR
);
1319 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1320 struct dwarf2_cu
*);
1322 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1323 struct dwarf2_cu
*, struct symbol
*);
1325 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1326 struct dwarf2_cu
*);
1328 static void dwarf2_const_value_attr (struct attribute
*attr
,
1331 struct obstack
*obstack
,
1332 struct dwarf2_cu
*cu
, LONGEST
*value
,
1334 struct dwarf2_locexpr_baton
**baton
);
1336 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1338 static int need_gnat_info (struct dwarf2_cu
*);
1340 static struct type
*die_descriptive_type (struct die_info
*,
1341 struct dwarf2_cu
*);
1343 static void set_descriptive_type (struct type
*, struct die_info
*,
1344 struct dwarf2_cu
*);
1346 static struct type
*die_containing_type (struct die_info
*,
1347 struct dwarf2_cu
*);
1349 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1350 struct dwarf2_cu
*);
1352 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1354 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1356 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1358 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1359 const char *suffix
, int physname
,
1360 struct dwarf2_cu
*cu
);
1362 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1364 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1366 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1368 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1370 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1372 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1373 struct dwarf2_cu
*, struct partial_symtab
*);
1375 static int dwarf2_get_pc_bounds (struct die_info
*,
1376 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1377 struct partial_symtab
*);
1379 static void get_scope_pc_bounds (struct die_info
*,
1380 CORE_ADDR
*, CORE_ADDR
*,
1381 struct dwarf2_cu
*);
1383 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1384 CORE_ADDR
, struct dwarf2_cu
*);
1386 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1387 struct dwarf2_cu
*);
1389 static void dwarf2_attach_fields_to_type (struct field_info
*,
1390 struct type
*, struct dwarf2_cu
*);
1392 static void dwarf2_add_member_fn (struct field_info
*,
1393 struct die_info
*, struct type
*,
1394 struct dwarf2_cu
*);
1396 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1398 struct dwarf2_cu
*);
1400 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1402 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1404 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1406 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1408 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1410 static struct type
*read_module_type (struct die_info
*die
,
1411 struct dwarf2_cu
*cu
);
1413 static const char *namespace_name (struct die_info
*die
,
1414 int *is_anonymous
, struct dwarf2_cu
*);
1416 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1418 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1420 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1421 struct dwarf2_cu
*);
1423 static struct die_info
*read_die_and_children (const struct die_reader_specs
*,
1425 gdb_byte
**new_info_ptr
,
1426 struct die_info
*parent
);
1428 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1430 gdb_byte
**new_info_ptr
,
1431 struct die_info
*parent
);
1433 static gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1434 struct die_info
**, gdb_byte
*, int *, int);
1436 static gdb_byte
*read_full_die (const struct die_reader_specs
*,
1437 struct die_info
**, gdb_byte
*, int *);
1439 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1441 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1444 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1446 static const char *dwarf2_full_name (char *name
,
1447 struct die_info
*die
,
1448 struct dwarf2_cu
*cu
);
1450 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1451 struct dwarf2_cu
**);
1453 static const char *dwarf_tag_name (unsigned int);
1455 static const char *dwarf_attr_name (unsigned int);
1457 static const char *dwarf_form_name (unsigned int);
1459 static char *dwarf_bool_name (unsigned int);
1461 static const char *dwarf_type_encoding_name (unsigned int);
1463 static struct die_info
*sibling_die (struct die_info
*);
1465 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1467 static void dump_die_for_error (struct die_info
*);
1469 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1472 /*static*/ void dump_die (struct die_info
*, int max_level
);
1474 static void store_in_ref_table (struct die_info
*,
1475 struct dwarf2_cu
*);
1477 static int is_ref_attr (struct attribute
*);
1479 static sect_offset
dwarf2_get_ref_die_offset (struct attribute
*);
1481 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1483 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1485 struct dwarf2_cu
**);
1487 static struct die_info
*follow_die_ref (struct die_info
*,
1489 struct dwarf2_cu
**);
1491 static struct die_info
*follow_die_sig (struct die_info
*,
1493 struct dwarf2_cu
**);
1495 static struct signatured_type
*lookup_signatured_type_at_offset
1496 (struct objfile
*objfile
,
1497 struct dwarf2_section_info
*section
, sect_offset offset
);
1499 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1501 static void read_signatured_type (struct signatured_type
*);
1503 static struct type_unit_group
*get_type_unit_group
1504 (struct dwarf2_cu
*, struct attribute
*);
1506 static void build_type_unit_groups (die_reader_func_ftype
*, void *);
1508 /* memory allocation interface */
1510 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1512 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1514 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int,
1517 static int attr_form_is_block (struct attribute
*);
1519 static int attr_form_is_section_offset (struct attribute
*);
1521 static int attr_form_is_constant (struct attribute
*);
1523 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1524 struct dwarf2_loclist_baton
*baton
,
1525 struct attribute
*attr
);
1527 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1529 struct dwarf2_cu
*cu
);
1531 static gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1533 struct abbrev_info
*abbrev
);
1535 static void free_stack_comp_unit (void *);
1537 static hashval_t
partial_die_hash (const void *item
);
1539 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1541 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1542 (sect_offset offset
, unsigned int offset_in_dwz
, struct objfile
*objfile
);
1544 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1545 struct dwarf2_per_cu_data
*per_cu
);
1547 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1548 struct die_info
*comp_unit_die
,
1549 enum language pretend_language
);
1551 static void free_heap_comp_unit (void *);
1553 static void free_cached_comp_units (void *);
1555 static void age_cached_comp_units (void);
1557 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1559 static struct type
*set_die_type (struct die_info
*, struct type
*,
1560 struct dwarf2_cu
*);
1562 static void create_all_comp_units (struct objfile
*);
1564 static int create_all_type_units (struct objfile
*);
1566 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1569 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1572 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1575 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1576 struct dwarf2_per_cu_data
*);
1578 static void dwarf2_mark (struct dwarf2_cu
*);
1580 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1582 static struct type
*get_die_type_at_offset (sect_offset
,
1583 struct dwarf2_per_cu_data
*per_cu
);
1585 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1587 static void dwarf2_release_queue (void *dummy
);
1589 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1590 enum language pretend_language
);
1592 static int maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
1593 struct dwarf2_per_cu_data
*per_cu
,
1594 enum language pretend_language
);
1596 static void process_queue (void);
1598 static void find_file_and_directory (struct die_info
*die
,
1599 struct dwarf2_cu
*cu
,
1600 char **name
, char **comp_dir
);
1602 static char *file_full_name (int file
, struct line_header
*lh
,
1603 const char *comp_dir
);
1605 static gdb_byte
*read_and_check_comp_unit_head
1606 (struct comp_unit_head
*header
,
1607 struct dwarf2_section_info
*section
,
1608 struct dwarf2_section_info
*abbrev_section
, gdb_byte
*info_ptr
,
1609 int is_debug_types_section
);
1611 static void init_cutu_and_read_dies
1612 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1613 int use_existing_cu
, int keep
,
1614 die_reader_func_ftype
*die_reader_func
, void *data
);
1616 static void init_cutu_and_read_dies_simple
1617 (struct dwarf2_per_cu_data
*this_cu
,
1618 die_reader_func_ftype
*die_reader_func
, void *data
);
1620 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1622 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1624 static struct dwo_unit
*lookup_dwo_comp_unit
1625 (struct dwarf2_per_cu_data
*, char *, const char *, ULONGEST
);
1627 static struct dwo_unit
*lookup_dwo_type_unit
1628 (struct signatured_type
*, char *, const char *);
1630 static void free_dwo_file_cleanup (void *);
1632 static void process_cu_includes (void);
1636 /* Convert VALUE between big- and little-endian. */
1638 byte_swap (offset_type value
)
1642 result
= (value
& 0xff) << 24;
1643 result
|= (value
& 0xff00) << 8;
1644 result
|= (value
& 0xff0000) >> 8;
1645 result
|= (value
& 0xff000000) >> 24;
1649 #define MAYBE_SWAP(V) byte_swap (V)
1652 #define MAYBE_SWAP(V) (V)
1653 #endif /* WORDS_BIGENDIAN */
1655 /* The suffix for an index file. */
1656 #define INDEX_SUFFIX ".gdb-index"
1658 static const char *dwarf2_physname (char *name
, struct die_info
*die
,
1659 struct dwarf2_cu
*cu
);
1661 /* Try to locate the sections we need for DWARF 2 debugging
1662 information and return true if we have enough to do something.
1663 NAMES points to the dwarf2 section names, or is NULL if the standard
1664 ELF names are used. */
1667 dwarf2_has_info (struct objfile
*objfile
,
1668 const struct dwarf2_debug_sections
*names
)
1670 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1671 if (!dwarf2_per_objfile
)
1673 /* Initialize per-objfile state. */
1674 struct dwarf2_per_objfile
*data
1675 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1677 memset (data
, 0, sizeof (*data
));
1678 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1679 dwarf2_per_objfile
= data
;
1681 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
1683 dwarf2_per_objfile
->objfile
= objfile
;
1685 return (dwarf2_per_objfile
->info
.asection
!= NULL
1686 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1689 /* When loading sections, we look either for uncompressed section or for
1690 compressed section names. */
1693 section_is_p (const char *section_name
,
1694 const struct dwarf2_section_names
*names
)
1696 if (names
->normal
!= NULL
1697 && strcmp (section_name
, names
->normal
) == 0)
1699 if (names
->compressed
!= NULL
1700 && strcmp (section_name
, names
->compressed
) == 0)
1705 /* This function is mapped across the sections and remembers the
1706 offset and size of each of the debugging sections we are interested
1710 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
1712 const struct dwarf2_debug_sections
*names
;
1713 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
1716 names
= &dwarf2_elf_names
;
1718 names
= (const struct dwarf2_debug_sections
*) vnames
;
1720 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
1723 else if (section_is_p (sectp
->name
, &names
->info
))
1725 dwarf2_per_objfile
->info
.asection
= sectp
;
1726 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1728 else if (section_is_p (sectp
->name
, &names
->abbrev
))
1730 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1731 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1733 else if (section_is_p (sectp
->name
, &names
->line
))
1735 dwarf2_per_objfile
->line
.asection
= sectp
;
1736 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1738 else if (section_is_p (sectp
->name
, &names
->loc
))
1740 dwarf2_per_objfile
->loc
.asection
= sectp
;
1741 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1743 else if (section_is_p (sectp
->name
, &names
->macinfo
))
1745 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1746 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1748 else if (section_is_p (sectp
->name
, &names
->macro
))
1750 dwarf2_per_objfile
->macro
.asection
= sectp
;
1751 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
1753 else if (section_is_p (sectp
->name
, &names
->str
))
1755 dwarf2_per_objfile
->str
.asection
= sectp
;
1756 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1758 else if (section_is_p (sectp
->name
, &names
->addr
))
1760 dwarf2_per_objfile
->addr
.asection
= sectp
;
1761 dwarf2_per_objfile
->addr
.size
= bfd_get_section_size (sectp
);
1763 else if (section_is_p (sectp
->name
, &names
->frame
))
1765 dwarf2_per_objfile
->frame
.asection
= sectp
;
1766 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1768 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
1770 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1771 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1773 else if (section_is_p (sectp
->name
, &names
->ranges
))
1775 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1776 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1778 else if (section_is_p (sectp
->name
, &names
->types
))
1780 struct dwarf2_section_info type_section
;
1782 memset (&type_section
, 0, sizeof (type_section
));
1783 type_section
.asection
= sectp
;
1784 type_section
.size
= bfd_get_section_size (sectp
);
1786 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
1789 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
1791 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1792 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1795 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1796 && bfd_section_vma (abfd
, sectp
) == 0)
1797 dwarf2_per_objfile
->has_section_at_zero
= 1;
1800 /* A helper function that decides whether a section is empty,
1804 dwarf2_section_empty_p (struct dwarf2_section_info
*info
)
1806 return info
->asection
== NULL
|| info
->size
== 0;
1809 /* Read the contents of the section INFO.
1810 OBJFILE is the main object file, but not necessarily the file where
1811 the section comes from. E.g., for DWO files INFO->asection->owner
1812 is the bfd of the DWO file.
1813 If the section is compressed, uncompress it before returning. */
1816 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1818 asection
*sectp
= info
->asection
;
1820 gdb_byte
*buf
, *retbuf
;
1821 unsigned char header
[4];
1825 info
->buffer
= NULL
;
1828 if (dwarf2_section_empty_p (info
))
1831 abfd
= sectp
->owner
;
1833 /* If the section has relocations, we must read it ourselves.
1834 Otherwise we attach it to the BFD. */
1835 if ((sectp
->flags
& SEC_RELOC
) == 0)
1837 const gdb_byte
*bytes
= gdb_bfd_map_section (sectp
, &info
->size
);
1839 /* We have to cast away const here for historical reasons.
1840 Fixing dwarf2read to be const-correct would be quite nice. */
1841 info
->buffer
= (gdb_byte
*) bytes
;
1845 buf
= obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1848 /* When debugging .o files, we may need to apply relocations; see
1849 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1850 We never compress sections in .o files, so we only need to
1851 try this when the section is not compressed. */
1852 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1855 info
->buffer
= retbuf
;
1859 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1860 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1861 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1862 bfd_get_filename (abfd
));
1865 /* A helper function that returns the size of a section in a safe way.
1866 If you are positive that the section has been read before using the
1867 size, then it is safe to refer to the dwarf2_section_info object's
1868 "size" field directly. In other cases, you must call this
1869 function, because for compressed sections the size field is not set
1870 correctly until the section has been read. */
1872 static bfd_size_type
1873 dwarf2_section_size (struct objfile
*objfile
,
1874 struct dwarf2_section_info
*info
)
1877 dwarf2_read_section (objfile
, info
);
1881 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1885 dwarf2_get_section_info (struct objfile
*objfile
,
1886 enum dwarf2_section_enum sect
,
1887 asection
**sectp
, gdb_byte
**bufp
,
1888 bfd_size_type
*sizep
)
1890 struct dwarf2_per_objfile
*data
1891 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1892 struct dwarf2_section_info
*info
;
1894 /* We may see an objfile without any DWARF, in which case we just
1905 case DWARF2_DEBUG_FRAME
:
1906 info
= &data
->frame
;
1908 case DWARF2_EH_FRAME
:
1909 info
= &data
->eh_frame
;
1912 gdb_assert_not_reached ("unexpected section");
1915 dwarf2_read_section (objfile
, info
);
1917 *sectp
= info
->asection
;
1918 *bufp
= info
->buffer
;
1919 *sizep
= info
->size
;
1922 /* A helper function to find the sections for a .dwz file. */
1925 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
1927 struct dwz_file
*dwz_file
= arg
;
1929 /* Note that we only support the standard ELF names, because .dwz
1930 is ELF-only (at the time of writing). */
1931 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
1933 dwz_file
->abbrev
.asection
= sectp
;
1934 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
1936 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
1938 dwz_file
->info
.asection
= sectp
;
1939 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
1941 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
1943 dwz_file
->str
.asection
= sectp
;
1944 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
1946 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
1948 dwz_file
->line
.asection
= sectp
;
1949 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
1951 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
1953 dwz_file
->macro
.asection
= sectp
;
1954 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
1956 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
1958 dwz_file
->gdb_index
.asection
= sectp
;
1959 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
1963 /* Open the separate '.dwz' debug file, if needed. Error if the file
1966 static struct dwz_file
*
1967 dwarf2_get_dwz_file (void)
1969 bfd
*abfd
, *dwz_bfd
;
1972 struct cleanup
*cleanup
;
1973 const char *filename
;
1974 struct dwz_file
*result
;
1976 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
1977 return dwarf2_per_objfile
->dwz_file
;
1979 abfd
= dwarf2_per_objfile
->objfile
->obfd
;
1980 section
= bfd_get_section_by_name (abfd
, ".gnu_debugaltlink");
1981 if (section
== NULL
)
1982 error (_("could not find '.gnu_debugaltlink' section"));
1983 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1984 error (_("could not read '.gnu_debugaltlink' section: %s"),
1985 bfd_errmsg (bfd_get_error ()));
1986 cleanup
= make_cleanup (xfree
, data
);
1989 if (!IS_ABSOLUTE_PATH (filename
))
1991 char *abs
= gdb_realpath (dwarf2_per_objfile
->objfile
->name
);
1994 make_cleanup (xfree
, abs
);
1995 abs
= ldirname (abs
);
1996 make_cleanup (xfree
, abs
);
1998 rel
= concat (abs
, SLASH_STRING
, filename
, (char *) NULL
);
1999 make_cleanup (xfree
, rel
);
2003 /* The format is just a NUL-terminated file name, followed by the
2004 build-id. For now, though, we ignore the build-id. */
2005 dwz_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2006 if (dwz_bfd
== NULL
)
2007 error (_("could not read '%s': %s"), filename
,
2008 bfd_errmsg (bfd_get_error ()));
2010 if (!bfd_check_format (dwz_bfd
, bfd_object
))
2012 gdb_bfd_unref (dwz_bfd
);
2013 error (_("file '%s' was not usable: %s"), filename
,
2014 bfd_errmsg (bfd_get_error ()));
2017 result
= OBSTACK_ZALLOC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
2019 result
->dwz_bfd
= dwz_bfd
;
2021 bfd_map_over_sections (dwz_bfd
, locate_dwz_sections
, result
);
2023 do_cleanups (cleanup
);
2028 /* DWARF quick_symbols_functions support. */
2030 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2031 unique line tables, so we maintain a separate table of all .debug_line
2032 derived entries to support the sharing.
2033 All the quick functions need is the list of file names. We discard the
2034 line_header when we're done and don't need to record it here. */
2035 struct quick_file_names
2037 /* The data used to construct the hash key. */
2038 struct stmt_list_hash hash
;
2040 /* The number of entries in file_names, real_names. */
2041 unsigned int num_file_names
;
2043 /* The file names from the line table, after being run through
2045 const char **file_names
;
2047 /* The file names from the line table after being run through
2048 gdb_realpath. These are computed lazily. */
2049 const char **real_names
;
2052 /* When using the index (and thus not using psymtabs), each CU has an
2053 object of this type. This is used to hold information needed by
2054 the various "quick" methods. */
2055 struct dwarf2_per_cu_quick_data
2057 /* The file table. This can be NULL if there was no file table
2058 or it's currently not read in.
2059 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2060 struct quick_file_names
*file_names
;
2062 /* The corresponding symbol table. This is NULL if symbols for this
2063 CU have not yet been read. */
2064 struct symtab
*symtab
;
2066 /* A temporary mark bit used when iterating over all CUs in
2067 expand_symtabs_matching. */
2068 unsigned int mark
: 1;
2070 /* True if we've tried to read the file table and found there isn't one.
2071 There will be no point in trying to read it again next time. */
2072 unsigned int no_file_data
: 1;
2075 /* Utility hash function for a stmt_list_hash. */
2078 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2082 if (stmt_list_hash
->dwo_unit
!= NULL
)
2083 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2084 v
+= stmt_list_hash
->line_offset
.sect_off
;
2088 /* Utility equality function for a stmt_list_hash. */
2091 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2092 const struct stmt_list_hash
*rhs
)
2094 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2096 if (lhs
->dwo_unit
!= NULL
2097 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2100 return lhs
->line_offset
.sect_off
== rhs
->line_offset
.sect_off
;
2103 /* Hash function for a quick_file_names. */
2106 hash_file_name_entry (const void *e
)
2108 const struct quick_file_names
*file_data
= e
;
2110 return hash_stmt_list_entry (&file_data
->hash
);
2113 /* Equality function for a quick_file_names. */
2116 eq_file_name_entry (const void *a
, const void *b
)
2118 const struct quick_file_names
*ea
= a
;
2119 const struct quick_file_names
*eb
= b
;
2121 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2124 /* Delete function for a quick_file_names. */
2127 delete_file_name_entry (void *e
)
2129 struct quick_file_names
*file_data
= e
;
2132 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2134 xfree ((void*) file_data
->file_names
[i
]);
2135 if (file_data
->real_names
)
2136 xfree ((void*) file_data
->real_names
[i
]);
2139 /* The space for the struct itself lives on objfile_obstack,
2140 so we don't free it here. */
2143 /* Create a quick_file_names hash table. */
2146 create_quick_file_names_table (unsigned int nr_initial_entries
)
2148 return htab_create_alloc (nr_initial_entries
,
2149 hash_file_name_entry
, eq_file_name_entry
,
2150 delete_file_name_entry
, xcalloc
, xfree
);
2153 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2154 have to be created afterwards. You should call age_cached_comp_units after
2155 processing PER_CU->CU. dw2_setup must have been already called. */
2158 load_cu (struct dwarf2_per_cu_data
*per_cu
)
2160 if (per_cu
->is_debug_types
)
2161 load_full_type_unit (per_cu
);
2163 load_full_comp_unit (per_cu
, language_minimal
);
2165 gdb_assert (per_cu
->cu
!= NULL
);
2167 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2170 /* Read in the symbols for PER_CU. */
2173 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2175 struct cleanup
*back_to
;
2177 /* Skip type_unit_groups, reading the type units they contain
2178 is handled elsewhere. */
2179 if (IS_TYPE_UNIT_GROUP (per_cu
))
2182 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2184 if (dwarf2_per_objfile
->using_index
2185 ? per_cu
->v
.quick
->symtab
== NULL
2186 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2188 queue_comp_unit (per_cu
, language_minimal
);
2194 /* Age the cache, releasing compilation units that have not
2195 been used recently. */
2196 age_cached_comp_units ();
2198 do_cleanups (back_to
);
2201 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2202 the objfile from which this CU came. Returns the resulting symbol
2205 static struct symtab
*
2206 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2208 gdb_assert (dwarf2_per_objfile
->using_index
);
2209 if (!per_cu
->v
.quick
->symtab
)
2211 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2212 increment_reading_symtab ();
2213 dw2_do_instantiate_symtab (per_cu
);
2214 process_cu_includes ();
2215 do_cleanups (back_to
);
2217 return per_cu
->v
.quick
->symtab
;
2220 /* Return the CU given its index.
2222 This is intended for loops like:
2224 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2225 + dwarf2_per_objfile->n_type_units); ++i)
2227 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2233 static struct dwarf2_per_cu_data
*
2234 dw2_get_cu (int index
)
2236 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2238 index
-= dwarf2_per_objfile
->n_comp_units
;
2239 gdb_assert (index
< dwarf2_per_objfile
->n_type_units
);
2240 return &dwarf2_per_objfile
->all_type_units
[index
]->per_cu
;
2243 return dwarf2_per_objfile
->all_comp_units
[index
];
2246 /* Return the primary CU given its index.
2247 The difference between this function and dw2_get_cu is in the handling
2248 of type units (TUs). Here we return the type_unit_group object.
2250 This is intended for loops like:
2252 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2253 + dwarf2_per_objfile->n_type_unit_groups); ++i)
2255 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
2261 static struct dwarf2_per_cu_data
*
2262 dw2_get_primary_cu (int index
)
2264 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2266 index
-= dwarf2_per_objfile
->n_comp_units
;
2267 gdb_assert (index
< dwarf2_per_objfile
->n_type_unit_groups
);
2268 return &dwarf2_per_objfile
->all_type_unit_groups
[index
]->per_cu
;
2271 return dwarf2_per_objfile
->all_comp_units
[index
];
2274 /* A helper function that knows how to read a 64-bit value in a way
2275 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
2279 extract_cu_value (const char *bytes
, ULONGEST
*result
)
2281 if (sizeof (ULONGEST
) < 8)
2285 /* Ignore the upper 4 bytes if they are all zero. */
2286 for (i
= 0; i
< 4; ++i
)
2287 if (bytes
[i
+ 4] != 0)
2290 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
2293 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2297 /* A helper for create_cus_from_index that handles a given list of
2301 create_cus_from_index_list (struct objfile
*objfile
,
2302 const gdb_byte
*cu_list
, offset_type n_elements
,
2303 struct dwarf2_section_info
*section
,
2309 for (i
= 0; i
< n_elements
; i
+= 2)
2311 struct dwarf2_per_cu_data
*the_cu
;
2312 ULONGEST offset
, length
;
2314 if (!extract_cu_value (cu_list
, &offset
)
2315 || !extract_cu_value (cu_list
+ 8, &length
))
2319 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2320 struct dwarf2_per_cu_data
);
2321 the_cu
->offset
.sect_off
= offset
;
2322 the_cu
->length
= length
;
2323 the_cu
->objfile
= objfile
;
2324 the_cu
->info_or_types_section
= section
;
2325 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2326 struct dwarf2_per_cu_quick_data
);
2327 the_cu
->is_dwz
= is_dwz
;
2328 dwarf2_per_objfile
->all_comp_units
[base_offset
+ i
/ 2] = the_cu
;
2334 /* Read the CU list from the mapped index, and use it to create all
2335 the CU objects for this objfile. Return 0 if something went wrong,
2336 1 if everything went ok. */
2339 create_cus_from_index (struct objfile
*objfile
,
2340 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2341 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2343 struct dwz_file
*dwz
;
2345 dwarf2_per_objfile
->n_comp_units
= (cu_list_elements
+ dwz_elements
) / 2;
2346 dwarf2_per_objfile
->all_comp_units
2347 = obstack_alloc (&objfile
->objfile_obstack
,
2348 dwarf2_per_objfile
->n_comp_units
2349 * sizeof (struct dwarf2_per_cu_data
*));
2351 if (!create_cus_from_index_list (objfile
, cu_list
, cu_list_elements
,
2352 &dwarf2_per_objfile
->info
, 0, 0))
2355 if (dwz_elements
== 0)
2358 dwz
= dwarf2_get_dwz_file ();
2359 return create_cus_from_index_list (objfile
, dwz_list
, dwz_elements
,
2360 &dwz
->info
, 1, cu_list_elements
/ 2);
2363 /* Create the signatured type hash table from the index. */
2366 create_signatured_type_table_from_index (struct objfile
*objfile
,
2367 struct dwarf2_section_info
*section
,
2368 const gdb_byte
*bytes
,
2369 offset_type elements
)
2372 htab_t sig_types_hash
;
2374 dwarf2_per_objfile
->n_type_units
= elements
/ 3;
2375 dwarf2_per_objfile
->all_type_units
2376 = obstack_alloc (&objfile
->objfile_obstack
,
2377 dwarf2_per_objfile
->n_type_units
2378 * sizeof (struct signatured_type
*));
2380 sig_types_hash
= allocate_signatured_type_table (objfile
);
2382 for (i
= 0; i
< elements
; i
+= 3)
2384 struct signatured_type
*sig_type
;
2385 ULONGEST offset
, type_offset_in_tu
, signature
;
2388 if (!extract_cu_value (bytes
, &offset
)
2389 || !extract_cu_value (bytes
+ 8, &type_offset_in_tu
))
2391 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2394 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2395 struct signatured_type
);
2396 sig_type
->signature
= signature
;
2397 sig_type
->type_offset_in_tu
.cu_off
= type_offset_in_tu
;
2398 sig_type
->per_cu
.is_debug_types
= 1;
2399 sig_type
->per_cu
.info_or_types_section
= section
;
2400 sig_type
->per_cu
.offset
.sect_off
= offset
;
2401 sig_type
->per_cu
.objfile
= objfile
;
2402 sig_type
->per_cu
.v
.quick
2403 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2404 struct dwarf2_per_cu_quick_data
);
2406 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
2409 dwarf2_per_objfile
->all_type_units
[i
/ 3] = sig_type
;
2412 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2417 /* Read the address map data from the mapped index, and use it to
2418 populate the objfile's psymtabs_addrmap. */
2421 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2423 const gdb_byte
*iter
, *end
;
2424 struct obstack temp_obstack
;
2425 struct addrmap
*mutable_map
;
2426 struct cleanup
*cleanup
;
2429 obstack_init (&temp_obstack
);
2430 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2431 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2433 iter
= index
->address_table
;
2434 end
= iter
+ index
->address_table_size
;
2436 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2440 ULONGEST hi
, lo
, cu_index
;
2441 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2443 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2445 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2448 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
2449 dw2_get_cu (cu_index
));
2452 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2453 &objfile
->objfile_obstack
);
2454 do_cleanups (cleanup
);
2457 /* The hash function for strings in the mapped index. This is the same as
2458 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2459 implementation. This is necessary because the hash function is tied to the
2460 format of the mapped index file. The hash values do not have to match with
2463 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2466 mapped_index_string_hash (int index_version
, const void *p
)
2468 const unsigned char *str
= (const unsigned char *) p
;
2472 while ((c
= *str
++) != 0)
2474 if (index_version
>= 5)
2476 r
= r
* 67 + c
- 113;
2482 /* Find a slot in the mapped index INDEX for the object named NAME.
2483 If NAME is found, set *VEC_OUT to point to the CU vector in the
2484 constant pool and return 1. If NAME cannot be found, return 0. */
2487 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2488 offset_type
**vec_out
)
2490 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2492 offset_type slot
, step
;
2493 int (*cmp
) (const char *, const char *);
2495 if (current_language
->la_language
== language_cplus
2496 || current_language
->la_language
== language_java
2497 || current_language
->la_language
== language_fortran
)
2499 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2501 const char *paren
= strchr (name
, '(');
2507 dup
= xmalloc (paren
- name
+ 1);
2508 memcpy (dup
, name
, paren
- name
);
2509 dup
[paren
- name
] = 0;
2511 make_cleanup (xfree
, dup
);
2516 /* Index version 4 did not support case insensitive searches. But the
2517 indices for case insensitive languages are built in lowercase, therefore
2518 simulate our NAME being searched is also lowercased. */
2519 hash
= mapped_index_string_hash ((index
->version
== 4
2520 && case_sensitivity
== case_sensitive_off
2521 ? 5 : index
->version
),
2524 slot
= hash
& (index
->symbol_table_slots
- 1);
2525 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2526 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2530 /* Convert a slot number to an offset into the table. */
2531 offset_type i
= 2 * slot
;
2533 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2535 do_cleanups (back_to
);
2539 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2540 if (!cmp (name
, str
))
2542 *vec_out
= (offset_type
*) (index
->constant_pool
2543 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2544 do_cleanups (back_to
);
2548 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2552 /* A helper function that reads the .gdb_index from SECTION and fills
2553 in MAP. FILENAME is the name of the file containing the section;
2554 it is used for error reporting. DEPRECATED_OK is nonzero if it is
2555 ok to use deprecated sections.
2557 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2558 out parameters that are filled in with information about the CU and
2559 TU lists in the section.
2561 Returns 1 if all went well, 0 otherwise. */
2564 read_index_from_section (struct objfile
*objfile
,
2565 const char *filename
,
2567 struct dwarf2_section_info
*section
,
2568 struct mapped_index
*map
,
2569 const gdb_byte
**cu_list
,
2570 offset_type
*cu_list_elements
,
2571 const gdb_byte
**types_list
,
2572 offset_type
*types_list_elements
)
2575 offset_type version
;
2576 offset_type
*metadata
;
2579 if (dwarf2_section_empty_p (section
))
2582 /* Older elfutils strip versions could keep the section in the main
2583 executable while splitting it for the separate debug info file. */
2584 if ((bfd_get_file_flags (section
->asection
) & SEC_HAS_CONTENTS
) == 0)
2587 dwarf2_read_section (objfile
, section
);
2589 addr
= section
->buffer
;
2590 /* Version check. */
2591 version
= MAYBE_SWAP (*(offset_type
*) addr
);
2592 /* Versions earlier than 3 emitted every copy of a psymbol. This
2593 causes the index to behave very poorly for certain requests. Version 3
2594 contained incomplete addrmap. So, it seems better to just ignore such
2598 static int warning_printed
= 0;
2599 if (!warning_printed
)
2601 warning (_("Skipping obsolete .gdb_index section in %s."),
2603 warning_printed
= 1;
2607 /* Index version 4 uses a different hash function than index version
2610 Versions earlier than 6 did not emit psymbols for inlined
2611 functions. Using these files will cause GDB not to be able to
2612 set breakpoints on inlined functions by name, so we ignore these
2613 indices unless the user has done
2614 "set use-deprecated-index-sections on". */
2615 if (version
< 6 && !deprecated_ok
)
2617 static int warning_printed
= 0;
2618 if (!warning_printed
)
2621 Skipping deprecated .gdb_index section in %s.\n\
2622 Do \"set use-deprecated-index-sections on\" before the file is read\n\
2623 to use the section anyway."),
2625 warning_printed
= 1;
2629 /* Indexes with higher version than the one supported by GDB may be no
2630 longer backward compatible. */
2634 map
->version
= version
;
2635 map
->total_size
= section
->size
;
2637 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2640 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2641 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2645 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2646 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2647 - MAYBE_SWAP (metadata
[i
]))
2651 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2652 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
2653 - MAYBE_SWAP (metadata
[i
]));
2656 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
2657 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
2658 - MAYBE_SWAP (metadata
[i
]))
2659 / (2 * sizeof (offset_type
)));
2662 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
2668 /* Read the index file. If everything went ok, initialize the "quick"
2669 elements of all the CUs and return 1. Otherwise, return 0. */
2672 dwarf2_read_index (struct objfile
*objfile
)
2674 struct mapped_index local_map
, *map
;
2675 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
2676 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
2678 if (!read_index_from_section (objfile
, objfile
->name
,
2679 use_deprecated_index_sections
,
2680 &dwarf2_per_objfile
->gdb_index
, &local_map
,
2681 &cu_list
, &cu_list_elements
,
2682 &types_list
, &types_list_elements
))
2685 /* Don't use the index if it's empty. */
2686 if (local_map
.symbol_table_slots
== 0)
2689 /* If there is a .dwz file, read it so we can get its CU list as
2691 if (bfd_get_section_by_name (objfile
->obfd
, ".gnu_debugaltlink") != NULL
)
2693 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
2694 struct mapped_index dwz_map
;
2695 const gdb_byte
*dwz_types_ignore
;
2696 offset_type dwz_types_elements_ignore
;
2698 if (!read_index_from_section (objfile
, bfd_get_filename (dwz
->dwz_bfd
),
2700 &dwz
->gdb_index
, &dwz_map
,
2701 &dwz_list
, &dwz_list_elements
,
2703 &dwz_types_elements_ignore
))
2705 warning (_("could not read '.gdb_index' section from %s; skipping"),
2706 bfd_get_filename (dwz
->dwz_bfd
));
2711 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
,
2712 dwz_list
, dwz_list_elements
))
2715 if (types_list_elements
)
2717 struct dwarf2_section_info
*section
;
2719 /* We can only handle a single .debug_types when we have an
2721 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
2724 section
= VEC_index (dwarf2_section_info_def
,
2725 dwarf2_per_objfile
->types
, 0);
2727 if (!create_signatured_type_table_from_index (objfile
, section
,
2729 types_list_elements
))
2733 create_addrmap_from_index (objfile
, &local_map
);
2735 map
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct mapped_index
));
2738 dwarf2_per_objfile
->index_table
= map
;
2739 dwarf2_per_objfile
->using_index
= 1;
2740 dwarf2_per_objfile
->quick_file_names_table
=
2741 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2746 /* A helper for the "quick" functions which sets the global
2747 dwarf2_per_objfile according to OBJFILE. */
2750 dw2_setup (struct objfile
*objfile
)
2752 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2753 gdb_assert (dwarf2_per_objfile
);
2756 /* Reader function for dw2_build_type_unit_groups. */
2759 dw2_build_type_unit_groups_reader (const struct die_reader_specs
*reader
,
2761 struct die_info
*type_unit_die
,
2765 struct dwarf2_cu
*cu
= reader
->cu
;
2766 struct attribute
*attr
;
2767 struct type_unit_group
*tu_group
;
2769 gdb_assert (data
== NULL
);
2774 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
2775 /* Call this for its side-effect of creating the associated
2776 struct type_unit_group if it doesn't already exist. */
2777 tu_group
= get_type_unit_group (cu
, attr
);
2780 /* Build dwarf2_per_objfile->type_unit_groups.
2781 This function may be called multiple times. */
2784 dw2_build_type_unit_groups (void)
2786 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
2787 build_type_unit_groups (dw2_build_type_unit_groups_reader
, NULL
);
2790 /* die_reader_func for dw2_get_file_names. */
2793 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
2795 struct die_info
*comp_unit_die
,
2799 struct dwarf2_cu
*cu
= reader
->cu
;
2800 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
2801 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2802 struct dwarf2_per_cu_data
*lh_cu
;
2803 struct line_header
*lh
;
2804 struct attribute
*attr
;
2806 char *name
, *comp_dir
;
2808 struct quick_file_names
*qfn
;
2809 unsigned int line_offset
;
2811 /* Our callers never want to match partial units -- instead they
2812 will match the enclosing full CU. */
2813 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
2815 this_cu
->v
.quick
->no_file_data
= 1;
2819 /* If we're reading the line header for TUs, store it in the "per_cu"
2821 if (this_cu
->is_debug_types
)
2823 struct type_unit_group
*tu_group
= data
;
2825 gdb_assert (tu_group
!= NULL
);
2826 lh_cu
= &tu_group
->per_cu
;
2835 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
2838 struct quick_file_names find_entry
;
2840 line_offset
= DW_UNSND (attr
);
2842 /* We may have already read in this line header (TU line header sharing).
2843 If we have we're done. */
2844 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
2845 find_entry
.hash
.line_offset
.sect_off
= line_offset
;
2846 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
2847 &find_entry
, INSERT
);
2850 lh_cu
->v
.quick
->file_names
= *slot
;
2854 lh
= dwarf_decode_line_header (line_offset
, cu
);
2858 lh_cu
->v
.quick
->no_file_data
= 1;
2862 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
2863 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
2864 qfn
->hash
.line_offset
.sect_off
= line_offset
;
2865 gdb_assert (slot
!= NULL
);
2868 find_file_and_directory (comp_unit_die
, cu
, &name
, &comp_dir
);
2870 qfn
->num_file_names
= lh
->num_file_names
;
2871 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
2872 lh
->num_file_names
* sizeof (char *));
2873 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2874 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2875 qfn
->real_names
= NULL
;
2877 free_line_header (lh
);
2879 lh_cu
->v
.quick
->file_names
= qfn
;
2882 /* A helper for the "quick" functions which attempts to read the line
2883 table for THIS_CU. */
2885 static struct quick_file_names
*
2886 dw2_get_file_names (struct objfile
*objfile
,
2887 struct dwarf2_per_cu_data
*this_cu
)
2889 /* For TUs this should only be called on the parent group. */
2890 if (this_cu
->is_debug_types
)
2891 gdb_assert (IS_TYPE_UNIT_GROUP (this_cu
));
2893 if (this_cu
->v
.quick
->file_names
!= NULL
)
2894 return this_cu
->v
.quick
->file_names
;
2895 /* If we know there is no line data, no point in looking again. */
2896 if (this_cu
->v
.quick
->no_file_data
)
2899 /* If DWO files are in use, we can still find the DW_AT_stmt_list attribute
2900 in the stub for CUs, there's is no need to lookup the DWO file.
2901 However, that's not the case for TUs where DW_AT_stmt_list lives in the
2903 if (this_cu
->is_debug_types
)
2905 struct type_unit_group
*tu_group
= this_cu
->s
.type_unit_group
;
2907 init_cutu_and_read_dies (tu_group
->t
.first_tu
, NULL
, 0, 0,
2908 dw2_get_file_names_reader
, tu_group
);
2911 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
2913 if (this_cu
->v
.quick
->no_file_data
)
2915 return this_cu
->v
.quick
->file_names
;
2918 /* A helper for the "quick" functions which computes and caches the
2919 real path for a given file name from the line table. */
2922 dw2_get_real_path (struct objfile
*objfile
,
2923 struct quick_file_names
*qfn
, int index
)
2925 if (qfn
->real_names
== NULL
)
2926 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2927 qfn
->num_file_names
, sizeof (char *));
2929 if (qfn
->real_names
[index
] == NULL
)
2930 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
2932 return qfn
->real_names
[index
];
2935 static struct symtab
*
2936 dw2_find_last_source_symtab (struct objfile
*objfile
)
2940 dw2_setup (objfile
);
2941 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2942 return dw2_instantiate_symtab (dw2_get_cu (index
));
2945 /* Traversal function for dw2_forget_cached_source_info. */
2948 dw2_free_cached_file_names (void **slot
, void *info
)
2950 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
2952 if (file_data
->real_names
)
2956 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2958 xfree ((void*) file_data
->real_names
[i
]);
2959 file_data
->real_names
[i
] = NULL
;
2967 dw2_forget_cached_source_info (struct objfile
*objfile
)
2969 dw2_setup (objfile
);
2971 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
2972 dw2_free_cached_file_names
, NULL
);
2975 /* Helper function for dw2_map_symtabs_matching_filename that expands
2976 the symtabs and calls the iterator. */
2979 dw2_map_expand_apply (struct objfile
*objfile
,
2980 struct dwarf2_per_cu_data
*per_cu
,
2982 const char *full_path
, const char *real_path
,
2983 int (*callback
) (struct symtab
*, void *),
2986 struct symtab
*last_made
= objfile
->symtabs
;
2988 /* Don't visit already-expanded CUs. */
2989 if (per_cu
->v
.quick
->symtab
)
2992 /* This may expand more than one symtab, and we want to iterate over
2994 dw2_instantiate_symtab (per_cu
);
2996 return iterate_over_some_symtabs (name
, full_path
, real_path
, callback
, data
,
2997 objfile
->symtabs
, last_made
);
3000 /* Implementation of the map_symtabs_matching_filename method. */
3003 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
3004 const char *full_path
, const char *real_path
,
3005 int (*callback
) (struct symtab
*, void *),
3009 const char *name_basename
= lbasename (name
);
3010 int name_len
= strlen (name
);
3011 int is_abs
= IS_ABSOLUTE_PATH (name
);
3013 dw2_setup (objfile
);
3015 dw2_build_type_unit_groups ();
3017 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3018 + dwarf2_per_objfile
->n_type_unit_groups
); ++i
)
3021 struct dwarf2_per_cu_data
*per_cu
= dw2_get_primary_cu (i
);
3022 struct quick_file_names
*file_data
;
3024 /* We only need to look at symtabs not already expanded. */
3025 if (per_cu
->v
.quick
->symtab
)
3028 file_data
= dw2_get_file_names (objfile
, per_cu
);
3029 if (file_data
== NULL
)
3032 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3034 const char *this_name
= file_data
->file_names
[j
];
3036 if (FILENAME_CMP (name
, this_name
) == 0
3037 || (!is_abs
&& compare_filenames_for_search (this_name
,
3040 if (dw2_map_expand_apply (objfile
, per_cu
,
3041 name
, full_path
, real_path
,
3046 /* Before we invoke realpath, which can get expensive when many
3047 files are involved, do a quick comparison of the basenames. */
3048 if (! basenames_may_differ
3049 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3052 if (full_path
!= NULL
)
3054 const char *this_real_name
= dw2_get_real_path (objfile
,
3057 if (this_real_name
!= NULL
3058 && (FILENAME_CMP (full_path
, this_real_name
) == 0
3060 && compare_filenames_for_search (this_real_name
,
3063 if (dw2_map_expand_apply (objfile
, per_cu
,
3064 name
, full_path
, real_path
,
3070 if (real_path
!= NULL
)
3072 const char *this_real_name
= dw2_get_real_path (objfile
,
3075 if (this_real_name
!= NULL
3076 && (FILENAME_CMP (real_path
, this_real_name
) == 0
3078 && compare_filenames_for_search (this_real_name
,
3081 if (dw2_map_expand_apply (objfile
, per_cu
,
3082 name
, full_path
, real_path
,
3093 static struct symtab
*
3094 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
3095 const char *name
, domain_enum domain
)
3097 /* We do all the work in the pre_expand_symtabs_matching hook
3102 /* A helper function that expands all symtabs that hold an object
3103 named NAME. If WANT_SPECIFIC_BLOCK is non-zero, only look for
3104 symbols in block BLOCK_KIND. */
3107 dw2_do_expand_symtabs_matching (struct objfile
*objfile
,
3108 int want_specific_block
,
3109 enum block_enum block_kind
,
3110 const char *name
, domain_enum domain
)
3112 struct mapped_index
*index
;
3114 dw2_setup (objfile
);
3116 index
= dwarf2_per_objfile
->index_table
;
3118 /* index_table is NULL if OBJF_READNOW. */
3123 if (find_slot_in_mapped_hash (index
, name
, &vec
))
3125 offset_type i
, len
= MAYBE_SWAP (*vec
);
3126 for (i
= 0; i
< len
; ++i
)
3128 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[i
+ 1]);
3129 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3130 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (cu_index
);
3131 int want_static
= block_kind
!= GLOBAL_BLOCK
;
3132 /* This value is only valid for index versions >= 7. */
3133 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3134 gdb_index_symbol_kind symbol_kind
=
3135 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3136 /* Only check the symbol attributes if they're present.
3137 Indices prior to version 7 don't record them,
3138 and indices >= 7 may elide them for certain symbols
3139 (gold does this). */
3141 (index
->version
>= 7
3142 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3145 && want_specific_block
3146 && want_static
!= is_static
)
3149 /* Only check the symbol's kind if it has one. */
3155 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3156 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3157 /* Some types are also in VAR_DOMAIN. */
3158 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3162 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3166 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3174 dw2_instantiate_symtab (per_cu
);
3181 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
3182 enum block_enum block_kind
, const char *name
,
3185 dw2_do_expand_symtabs_matching (objfile
, 1, block_kind
, name
, domain
);
3189 dw2_print_stats (struct objfile
*objfile
)
3193 dw2_setup (objfile
);
3195 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3196 + dwarf2_per_objfile
->n_type_units
); ++i
)
3198 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3200 if (!per_cu
->v
.quick
->symtab
)
3203 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3207 dw2_dump (struct objfile
*objfile
)
3209 /* Nothing worth printing. */
3213 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
3214 struct section_offsets
*delta
)
3216 /* There's nothing to relocate here. */
3220 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3221 const char *func_name
)
3223 /* Note: It doesn't matter what we pass for block_kind here. */
3224 dw2_do_expand_symtabs_matching (objfile
, 0, GLOBAL_BLOCK
, func_name
,
3229 dw2_expand_all_symtabs (struct objfile
*objfile
)
3233 dw2_setup (objfile
);
3235 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3236 + dwarf2_per_objfile
->n_type_units
); ++i
)
3238 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3240 dw2_instantiate_symtab (per_cu
);
3245 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
3246 const char *filename
)
3250 dw2_setup (objfile
);
3252 /* We don't need to consider type units here.
3253 This is only called for examining code, e.g. expand_line_sal.
3254 There can be an order of magnitude (or more) more type units
3255 than comp units, and we avoid them if we can. */
3257 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3260 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3261 struct quick_file_names
*file_data
;
3263 /* We only need to look at symtabs not already expanded. */
3264 if (per_cu
->v
.quick
->symtab
)
3267 file_data
= dw2_get_file_names (objfile
, per_cu
);
3268 if (file_data
== NULL
)
3271 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3273 const char *this_name
= file_data
->file_names
[j
];
3274 if (FILENAME_CMP (this_name
, filename
) == 0)
3276 dw2_instantiate_symtab (per_cu
);
3283 /* A helper function for dw2_find_symbol_file that finds the primary
3284 file name for a given CU. This is a die_reader_func. */
3287 dw2_get_primary_filename_reader (const struct die_reader_specs
*reader
,
3289 struct die_info
*comp_unit_die
,
3293 const char **result_ptr
= data
;
3294 struct dwarf2_cu
*cu
= reader
->cu
;
3295 struct attribute
*attr
;
3297 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, cu
);
3301 *result_ptr
= DW_STRING (attr
);
3305 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
3307 struct dwarf2_per_cu_data
*per_cu
;
3309 struct quick_file_names
*file_data
;
3310 const char *filename
;
3312 dw2_setup (objfile
);
3314 /* index_table is NULL if OBJF_READNOW. */
3315 if (!dwarf2_per_objfile
->index_table
)
3319 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, s
)
3321 struct blockvector
*bv
= BLOCKVECTOR (s
);
3322 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
3323 struct symbol
*sym
= lookup_block_symbol (block
, name
, VAR_DOMAIN
);
3326 return sym
->symtab
->filename
;
3331 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
3335 /* Note that this just looks at the very first one named NAME -- but
3336 actually we are looking for a function. find_main_filename
3337 should be rewritten so that it doesn't require a custom hook. It
3338 could just use the ordinary symbol tables. */
3339 /* vec[0] is the length, which must always be >0. */
3340 per_cu
= dw2_get_cu (GDB_INDEX_CU_VALUE (MAYBE_SWAP (vec
[1])));
3342 if (per_cu
->v
.quick
->symtab
!= NULL
)
3343 return per_cu
->v
.quick
->symtab
->filename
;
3345 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
3346 dw2_get_primary_filename_reader
, &filename
);
3352 dw2_map_matching_symbols (const char * name
, domain_enum
namespace,
3353 struct objfile
*objfile
, int global
,
3354 int (*callback
) (struct block
*,
3355 struct symbol
*, void *),
3356 void *data
, symbol_compare_ftype
*match
,
3357 symbol_compare_ftype
*ordered_compare
)
3359 /* Currently unimplemented; used for Ada. The function can be called if the
3360 current language is Ada for a non-Ada objfile using GNU index. As Ada
3361 does not look for non-Ada symbols this function should just return. */
3365 dw2_expand_symtabs_matching
3366 (struct objfile
*objfile
,
3367 int (*file_matcher
) (const char *, void *),
3368 int (*name_matcher
) (const char *, void *),
3369 enum search_domain kind
,
3374 struct mapped_index
*index
;
3376 dw2_setup (objfile
);
3378 /* index_table is NULL if OBJF_READNOW. */
3379 if (!dwarf2_per_objfile
->index_table
)
3381 index
= dwarf2_per_objfile
->index_table
;
3383 if (file_matcher
!= NULL
)
3385 struct cleanup
*cleanup
;
3386 htab_t visited_found
, visited_not_found
;
3388 dw2_build_type_unit_groups ();
3390 visited_found
= htab_create_alloc (10,
3391 htab_hash_pointer
, htab_eq_pointer
,
3392 NULL
, xcalloc
, xfree
);
3393 cleanup
= make_cleanup_htab_delete (visited_found
);
3394 visited_not_found
= htab_create_alloc (10,
3395 htab_hash_pointer
, htab_eq_pointer
,
3396 NULL
, xcalloc
, xfree
);
3397 make_cleanup_htab_delete (visited_not_found
);
3399 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3400 + dwarf2_per_objfile
->n_type_unit_groups
); ++i
)
3403 struct dwarf2_per_cu_data
*per_cu
= dw2_get_primary_cu (i
);
3404 struct quick_file_names
*file_data
;
3407 per_cu
->v
.quick
->mark
= 0;
3409 /* We only need to look at symtabs not already expanded. */
3410 if (per_cu
->v
.quick
->symtab
)
3413 file_data
= dw2_get_file_names (objfile
, per_cu
);
3414 if (file_data
== NULL
)
3417 if (htab_find (visited_not_found
, file_data
) != NULL
)
3419 else if (htab_find (visited_found
, file_data
) != NULL
)
3421 per_cu
->v
.quick
->mark
= 1;
3425 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3427 if (file_matcher (file_data
->file_names
[j
], data
))
3429 per_cu
->v
.quick
->mark
= 1;
3434 slot
= htab_find_slot (per_cu
->v
.quick
->mark
3436 : visited_not_found
,
3441 do_cleanups (cleanup
);
3444 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
3446 offset_type idx
= 2 * iter
;
3448 offset_type
*vec
, vec_len
, vec_idx
;
3450 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
3453 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
3455 if (! (*name_matcher
) (name
, data
))
3458 /* The name was matched, now expand corresponding CUs that were
3460 vec
= (offset_type
*) (index
->constant_pool
3461 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
3462 vec_len
= MAYBE_SWAP (vec
[0]);
3463 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
3465 struct dwarf2_per_cu_data
*per_cu
;
3466 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
3467 gdb_index_symbol_kind symbol_kind
=
3468 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3469 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3471 /* Don't crash on bad data. */
3472 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
3473 + dwarf2_per_objfile
->n_type_units
))
3476 /* Only check the symbol's kind if it has one.
3477 Indices prior to version 7 don't record it. */
3478 if (index
->version
>= 7)
3482 case VARIABLES_DOMAIN
:
3483 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
3486 case FUNCTIONS_DOMAIN
:
3487 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
3491 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3499 per_cu
= dw2_get_cu (cu_index
);
3500 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
3501 dw2_instantiate_symtab (per_cu
);
3506 /* A helper for dw2_find_pc_sect_symtab which finds the most specific
3509 static struct symtab
*
3510 recursively_find_pc_sect_symtab (struct symtab
*symtab
, CORE_ADDR pc
)
3514 if (BLOCKVECTOR (symtab
) != NULL
3515 && blockvector_contains_pc (BLOCKVECTOR (symtab
), pc
))
3518 if (symtab
->includes
== NULL
)
3521 for (i
= 0; symtab
->includes
[i
]; ++i
)
3523 struct symtab
*s
= symtab
->includes
[i
];
3525 s
= recursively_find_pc_sect_symtab (s
, pc
);
3533 static struct symtab
*
3534 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
3535 struct minimal_symbol
*msymbol
,
3537 struct obj_section
*section
,
3540 struct dwarf2_per_cu_data
*data
;
3541 struct symtab
*result
;
3543 dw2_setup (objfile
);
3545 if (!objfile
->psymtabs_addrmap
)
3548 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
3552 if (warn_if_readin
&& data
->v
.quick
->symtab
)
3553 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
3554 paddress (get_objfile_arch (objfile
), pc
));
3556 result
= recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data
), pc
);
3557 gdb_assert (result
!= NULL
);
3562 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
3563 void *data
, int need_fullname
)
3566 struct cleanup
*cleanup
;
3567 htab_t visited
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
3568 NULL
, xcalloc
, xfree
);
3570 cleanup
= make_cleanup_htab_delete (visited
);
3571 dw2_setup (objfile
);
3573 dw2_build_type_unit_groups ();
3575 /* We can ignore file names coming from already-expanded CUs. */
3576 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3577 + dwarf2_per_objfile
->n_type_units
); ++i
)
3579 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3581 if (per_cu
->v
.quick
->symtab
)
3583 void **slot
= htab_find_slot (visited
, per_cu
->v
.quick
->file_names
,
3586 *slot
= per_cu
->v
.quick
->file_names
;
3590 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3591 + dwarf2_per_objfile
->n_type_unit_groups
); ++i
)
3594 struct dwarf2_per_cu_data
*per_cu
= dw2_get_primary_cu (i
);
3595 struct quick_file_names
*file_data
;
3598 /* We only need to look at symtabs not already expanded. */
3599 if (per_cu
->v
.quick
->symtab
)
3602 file_data
= dw2_get_file_names (objfile
, per_cu
);
3603 if (file_data
== NULL
)
3606 slot
= htab_find_slot (visited
, file_data
, INSERT
);
3609 /* Already visited. */
3614 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3616 const char *this_real_name
;
3619 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3621 this_real_name
= NULL
;
3622 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
3626 do_cleanups (cleanup
);
3630 dw2_has_symbols (struct objfile
*objfile
)
3635 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
3638 dw2_find_last_source_symtab
,
3639 dw2_forget_cached_source_info
,
3640 dw2_map_symtabs_matching_filename
,
3642 dw2_pre_expand_symtabs_matching
,
3646 dw2_expand_symtabs_for_function
,
3647 dw2_expand_all_symtabs
,
3648 dw2_expand_symtabs_with_filename
,
3649 dw2_find_symbol_file
,
3650 dw2_map_matching_symbols
,
3651 dw2_expand_symtabs_matching
,
3652 dw2_find_pc_sect_symtab
,
3653 dw2_map_symbol_filenames
3656 /* Initialize for reading DWARF for this objfile. Return 0 if this
3657 file will use psymtabs, or 1 if using the GNU index. */
3660 dwarf2_initialize_objfile (struct objfile
*objfile
)
3662 /* If we're about to read full symbols, don't bother with the
3663 indices. In this case we also don't care if some other debug
3664 format is making psymtabs, because they are all about to be
3666 if ((objfile
->flags
& OBJF_READNOW
))
3670 dwarf2_per_objfile
->using_index
= 1;
3671 create_all_comp_units (objfile
);
3672 create_all_type_units (objfile
);
3673 dwarf2_per_objfile
->quick_file_names_table
=
3674 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3676 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3677 + dwarf2_per_objfile
->n_type_units
); ++i
)
3679 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3681 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3682 struct dwarf2_per_cu_quick_data
);
3685 /* Return 1 so that gdb sees the "quick" functions. However,
3686 these functions will be no-ops because we will have expanded
3691 if (dwarf2_read_index (objfile
))
3699 /* Build a partial symbol table. */
3702 dwarf2_build_psymtabs (struct objfile
*objfile
)
3704 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
3706 init_psymbol_list (objfile
, 1024);
3709 dwarf2_build_psymtabs_hard (objfile
);
3712 /* Return the total length of the CU described by HEADER. */
3715 get_cu_length (const struct comp_unit_head
*header
)
3717 return header
->initial_length_size
+ header
->length
;
3720 /* Return TRUE if OFFSET is within CU_HEADER. */
3723 offset_in_cu_p (const struct comp_unit_head
*cu_header
, sect_offset offset
)
3725 sect_offset bottom
= { cu_header
->offset
.sect_off
};
3726 sect_offset top
= { cu_header
->offset
.sect_off
+ get_cu_length (cu_header
) };
3728 return (offset
.sect_off
>= bottom
.sect_off
&& offset
.sect_off
< top
.sect_off
);
3731 /* Find the base address of the compilation unit for range lists and
3732 location lists. It will normally be specified by DW_AT_low_pc.
3733 In DWARF-3 draft 4, the base address could be overridden by
3734 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3735 compilation units with discontinuous ranges. */
3738 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
3740 struct attribute
*attr
;
3743 cu
->base_address
= 0;
3745 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
3748 cu
->base_address
= DW_ADDR (attr
);
3753 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3756 cu
->base_address
= DW_ADDR (attr
);
3762 /* Read in the comp unit header information from the debug_info at info_ptr.
3763 NOTE: This leaves members offset, first_die_offset to be filled in
3767 read_comp_unit_head (struct comp_unit_head
*cu_header
,
3768 gdb_byte
*info_ptr
, bfd
*abfd
)
3771 unsigned int bytes_read
;
3773 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
3774 cu_header
->initial_length_size
= bytes_read
;
3775 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
3776 info_ptr
+= bytes_read
;
3777 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
3779 cu_header
->abbrev_offset
.sect_off
= read_offset (abfd
, info_ptr
, cu_header
,
3781 info_ptr
+= bytes_read
;
3782 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
3784 signed_addr
= bfd_get_sign_extend_vma (abfd
);
3785 if (signed_addr
< 0)
3786 internal_error (__FILE__
, __LINE__
,
3787 _("read_comp_unit_head: dwarf from non elf file"));
3788 cu_header
->signed_addr_p
= signed_addr
;
3793 /* Helper function that returns the proper abbrev section for
3796 static struct dwarf2_section_info
*
3797 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
3799 struct dwarf2_section_info
*abbrev
;
3801 if (this_cu
->is_dwz
)
3802 abbrev
= &dwarf2_get_dwz_file ()->abbrev
;
3804 abbrev
= &dwarf2_per_objfile
->abbrev
;
3809 /* Subroutine of read_and_check_comp_unit_head and
3810 read_and_check_type_unit_head to simplify them.
3811 Perform various error checking on the header. */
3814 error_check_comp_unit_head (struct comp_unit_head
*header
,
3815 struct dwarf2_section_info
*section
,
3816 struct dwarf2_section_info
*abbrev_section
)
3818 bfd
*abfd
= section
->asection
->owner
;
3819 const char *filename
= bfd_get_filename (abfd
);
3821 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
3822 error (_("Dwarf Error: wrong version in compilation unit header "
3823 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
3826 if (header
->abbrev_offset
.sect_off
3827 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
3828 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
3829 "(offset 0x%lx + 6) [in module %s]"),
3830 (long) header
->abbrev_offset
.sect_off
, (long) header
->offset
.sect_off
,
3833 /* Cast to unsigned long to use 64-bit arithmetic when possible to
3834 avoid potential 32-bit overflow. */
3835 if (((unsigned long) header
->offset
.sect_off
+ get_cu_length (header
))
3837 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
3838 "(offset 0x%lx + 0) [in module %s]"),
3839 (long) header
->length
, (long) header
->offset
.sect_off
,
3843 /* Read in a CU/TU header and perform some basic error checking.
3844 The contents of the header are stored in HEADER.
3845 The result is a pointer to the start of the first DIE. */
3848 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
3849 struct dwarf2_section_info
*section
,
3850 struct dwarf2_section_info
*abbrev_section
,
3852 int is_debug_types_section
)
3854 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3855 bfd
*abfd
= section
->asection
->owner
;
3857 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
3859 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
3861 /* If we're reading a type unit, skip over the signature and
3862 type_offset fields. */
3863 if (is_debug_types_section
)
3864 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
3866 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
3868 error_check_comp_unit_head (header
, section
, abbrev_section
);
3873 /* Read in the types comp unit header information from .debug_types entry at
3874 types_ptr. The result is a pointer to one past the end of the header. */
3877 read_and_check_type_unit_head (struct comp_unit_head
*header
,
3878 struct dwarf2_section_info
*section
,
3879 struct dwarf2_section_info
*abbrev_section
,
3881 ULONGEST
*signature
,
3882 cu_offset
*type_offset_in_tu
)
3884 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3885 bfd
*abfd
= section
->asection
->owner
;
3887 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
3889 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
3891 /* If we're reading a type unit, skip over the signature and
3892 type_offset fields. */
3893 if (signature
!= NULL
)
3894 *signature
= read_8_bytes (abfd
, info_ptr
);
3896 if (type_offset_in_tu
!= NULL
)
3897 type_offset_in_tu
->cu_off
= read_offset_1 (abfd
, info_ptr
,
3898 header
->offset_size
);
3899 info_ptr
+= header
->offset_size
;
3901 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
3903 error_check_comp_unit_head (header
, section
, abbrev_section
);
3908 /* Fetch the abbreviation table offset from a comp or type unit header. */
3911 read_abbrev_offset (struct dwarf2_section_info
*section
,
3914 bfd
*abfd
= section
->asection
->owner
;
3916 unsigned int length
, initial_length_size
, offset_size
;
3917 sect_offset abbrev_offset
;
3919 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
3920 info_ptr
= section
->buffer
+ offset
.sect_off
;
3921 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
3922 offset_size
= initial_length_size
== 4 ? 4 : 8;
3923 info_ptr
+= initial_length_size
+ 2 /*version*/;
3924 abbrev_offset
.sect_off
= read_offset_1 (abfd
, info_ptr
, offset_size
);
3925 return abbrev_offset
;
3928 /* Allocate a new partial symtab for file named NAME and mark this new
3929 partial symtab as being an include of PST. */
3932 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
3933 struct objfile
*objfile
)
3935 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
3937 subpst
->section_offsets
= pst
->section_offsets
;
3938 subpst
->textlow
= 0;
3939 subpst
->texthigh
= 0;
3941 subpst
->dependencies
= (struct partial_symtab
**)
3942 obstack_alloc (&objfile
->objfile_obstack
,
3943 sizeof (struct partial_symtab
*));
3944 subpst
->dependencies
[0] = pst
;
3945 subpst
->number_of_dependencies
= 1;
3947 subpst
->globals_offset
= 0;
3948 subpst
->n_global_syms
= 0;
3949 subpst
->statics_offset
= 0;
3950 subpst
->n_static_syms
= 0;
3951 subpst
->symtab
= NULL
;
3952 subpst
->read_symtab
= pst
->read_symtab
;
3955 /* No private part is necessary for include psymtabs. This property
3956 can be used to differentiate between such include psymtabs and
3957 the regular ones. */
3958 subpst
->read_symtab_private
= NULL
;
3961 /* Read the Line Number Program data and extract the list of files
3962 included by the source file represented by PST. Build an include
3963 partial symtab for each of these included files. */
3966 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
3967 struct die_info
*die
,
3968 struct partial_symtab
*pst
)
3970 struct line_header
*lh
= NULL
;
3971 struct attribute
*attr
;
3973 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3975 lh
= dwarf_decode_line_header (DW_UNSND (attr
), cu
);
3977 return; /* No linetable, so no includes. */
3979 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3980 dwarf_decode_lines (lh
, pst
->dirname
, cu
, pst
, 1);
3982 free_line_header (lh
);
3986 hash_signatured_type (const void *item
)
3988 const struct signatured_type
*sig_type
= item
;
3990 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3991 return sig_type
->signature
;
3995 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
3997 const struct signatured_type
*lhs
= item_lhs
;
3998 const struct signatured_type
*rhs
= item_rhs
;
4000 return lhs
->signature
== rhs
->signature
;
4003 /* Allocate a hash table for signatured types. */
4006 allocate_signatured_type_table (struct objfile
*objfile
)
4008 return htab_create_alloc_ex (41,
4009 hash_signatured_type
,
4012 &objfile
->objfile_obstack
,
4013 hashtab_obstack_allocate
,
4014 dummy_obstack_deallocate
);
4017 /* A helper function to add a signatured type CU to a table. */
4020 add_signatured_type_cu_to_table (void **slot
, void *datum
)
4022 struct signatured_type
*sigt
= *slot
;
4023 struct signatured_type
***datap
= datum
;
4031 /* Create the hash table of all entries in the .debug_types section.
4032 DWO_FILE is a pointer to the DWO file for .debug_types.dwo, NULL otherwise.
4033 The result is a pointer to the hash table or NULL if there are
4037 create_debug_types_hash_table (struct dwo_file
*dwo_file
,
4038 VEC (dwarf2_section_info_def
) *types
)
4040 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4041 htab_t types_htab
= NULL
;
4043 struct dwarf2_section_info
*section
;
4044 struct dwarf2_section_info
*abbrev_section
;
4046 if (VEC_empty (dwarf2_section_info_def
, types
))
4049 abbrev_section
= (dwo_file
!= NULL
4050 ? &dwo_file
->sections
.abbrev
4051 : &dwarf2_per_objfile
->abbrev
);
4053 if (dwarf2_read_debug
)
4054 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_types%s for %s:\n",
4055 dwo_file
? ".dwo" : "",
4056 bfd_get_filename (abbrev_section
->asection
->owner
));
4059 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
4063 gdb_byte
*info_ptr
, *end_ptr
;
4064 struct dwarf2_section_info
*abbrev_section
;
4066 dwarf2_read_section (objfile
, section
);
4067 info_ptr
= section
->buffer
;
4069 if (info_ptr
== NULL
)
4072 /* We can't set abfd until now because the section may be empty or
4073 not present, in which case section->asection will be NULL. */
4074 abfd
= section
->asection
->owner
;
4077 abbrev_section
= &dwo_file
->sections
.abbrev
;
4079 abbrev_section
= &dwarf2_per_objfile
->abbrev
;
4081 if (types_htab
== NULL
)
4084 types_htab
= allocate_dwo_unit_table (objfile
);
4086 types_htab
= allocate_signatured_type_table (objfile
);
4089 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4090 because we don't need to read any dies: the signature is in the
4093 end_ptr
= info_ptr
+ section
->size
;
4094 while (info_ptr
< end_ptr
)
4097 cu_offset type_offset_in_tu
;
4099 struct signatured_type
*sig_type
;
4100 struct dwo_unit
*dwo_tu
;
4102 gdb_byte
*ptr
= info_ptr
;
4103 struct comp_unit_head header
;
4104 unsigned int length
;
4106 offset
.sect_off
= ptr
- section
->buffer
;
4108 /* We need to read the type's signature in order to build the hash
4109 table, but we don't need anything else just yet. */
4111 ptr
= read_and_check_type_unit_head (&header
, section
,
4112 abbrev_section
, ptr
,
4113 &signature
, &type_offset_in_tu
);
4115 length
= get_cu_length (&header
);
4117 /* Skip dummy type units. */
4118 if (ptr
>= info_ptr
+ length
4119 || peek_abbrev_code (abfd
, ptr
) == 0)
4128 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4130 dwo_tu
->dwo_file
= dwo_file
;
4131 dwo_tu
->signature
= signature
;
4132 dwo_tu
->type_offset_in_tu
= type_offset_in_tu
;
4133 dwo_tu
->info_or_types_section
= section
;
4134 dwo_tu
->offset
= offset
;
4135 dwo_tu
->length
= length
;
4139 /* N.B.: type_offset is not usable if this type uses a DWO file.
4140 The real type_offset is in the DWO file. */
4142 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4143 struct signatured_type
);
4144 sig_type
->signature
= signature
;
4145 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
4146 sig_type
->per_cu
.objfile
= objfile
;
4147 sig_type
->per_cu
.is_debug_types
= 1;
4148 sig_type
->per_cu
.info_or_types_section
= section
;
4149 sig_type
->per_cu
.offset
= offset
;
4150 sig_type
->per_cu
.length
= length
;
4153 slot
= htab_find_slot (types_htab
,
4154 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
4156 gdb_assert (slot
!= NULL
);
4159 sect_offset dup_offset
;
4163 const struct dwo_unit
*dup_tu
= *slot
;
4165 dup_offset
= dup_tu
->offset
;
4169 const struct signatured_type
*dup_tu
= *slot
;
4171 dup_offset
= dup_tu
->per_cu
.offset
;
4174 complaint (&symfile_complaints
,
4175 _("debug type entry at offset 0x%x is duplicate to the "
4176 "entry at offset 0x%x, signature 0x%s"),
4177 offset
.sect_off
, dup_offset
.sect_off
,
4178 phex (signature
, sizeof (signature
)));
4180 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
4182 if (dwarf2_read_debug
)
4183 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
4185 phex (signature
, sizeof (signature
)));
4194 /* Create the hash table of all entries in the .debug_types section,
4195 and initialize all_type_units.
4196 The result is zero if there is an error (e.g. missing .debug_types section),
4197 otherwise non-zero. */
4200 create_all_type_units (struct objfile
*objfile
)
4203 struct signatured_type
**iter
;
4205 types_htab
= create_debug_types_hash_table (NULL
, dwarf2_per_objfile
->types
);
4206 if (types_htab
== NULL
)
4208 dwarf2_per_objfile
->signatured_types
= NULL
;
4212 dwarf2_per_objfile
->signatured_types
= types_htab
;
4214 dwarf2_per_objfile
->n_type_units
= htab_elements (types_htab
);
4215 dwarf2_per_objfile
->all_type_units
4216 = obstack_alloc (&objfile
->objfile_obstack
,
4217 dwarf2_per_objfile
->n_type_units
4218 * sizeof (struct signatured_type
*));
4219 iter
= &dwarf2_per_objfile
->all_type_units
[0];
4220 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
4221 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
4222 == dwarf2_per_objfile
->n_type_units
);
4227 /* Lookup a signature based type for DW_FORM_ref_sig8.
4228 Returns NULL if signature SIG is not present in the table. */
4230 static struct signatured_type
*
4231 lookup_signatured_type (ULONGEST sig
)
4233 struct signatured_type find_entry
, *entry
;
4235 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4237 complaint (&symfile_complaints
,
4238 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
4242 find_entry
.signature
= sig
;
4243 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
4247 /* Low level DIE reading support. */
4249 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
4252 init_cu_die_reader (struct die_reader_specs
*reader
,
4253 struct dwarf2_cu
*cu
,
4254 struct dwarf2_section_info
*section
,
4255 struct dwo_file
*dwo_file
)
4257 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
4258 reader
->abfd
= section
->asection
->owner
;
4260 reader
->dwo_file
= dwo_file
;
4261 reader
->die_section
= section
;
4262 reader
->buffer
= section
->buffer
;
4263 reader
->buffer_end
= section
->buffer
+ section
->size
;
4266 /* Initialize a CU (or TU) and read its DIEs.
4267 If the CU defers to a DWO file, read the DWO file as well.
4269 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
4270 Otherwise the table specified in the comp unit header is read in and used.
4271 This is an optimization for when we already have the abbrev table.
4273 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
4274 Otherwise, a new CU is allocated with xmalloc.
4276 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
4277 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
4279 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
4280 linker) then DIE_READER_FUNC will not get called. */
4283 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
4284 struct abbrev_table
*abbrev_table
,
4285 int use_existing_cu
, int keep
,
4286 die_reader_func_ftype
*die_reader_func
,
4289 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4290 struct dwarf2_section_info
*section
= this_cu
->info_or_types_section
;
4291 bfd
*abfd
= section
->asection
->owner
;
4292 struct dwarf2_cu
*cu
;
4293 gdb_byte
*begin_info_ptr
, *info_ptr
;
4294 struct die_reader_specs reader
;
4295 struct die_info
*comp_unit_die
;
4297 struct attribute
*attr
;
4298 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
4299 struct signatured_type
*sig_type
= NULL
;
4300 struct dwarf2_section_info
*abbrev_section
;
4301 /* Non-zero if CU currently points to a DWO file and we need to
4302 reread it. When this happens we need to reread the skeleton die
4303 before we can reread the DWO file. */
4304 int rereading_dwo_cu
= 0;
4306 if (dwarf2_die_debug
)
4307 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
4308 this_cu
->is_debug_types
? "type" : "comp",
4309 this_cu
->offset
.sect_off
);
4311 if (use_existing_cu
)
4314 cleanups
= make_cleanup (null_cleanup
, NULL
);
4316 /* This is cheap if the section is already read in. */
4317 dwarf2_read_section (objfile
, section
);
4319 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
4321 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
4323 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
4327 /* If this CU is from a DWO file we need to start over, we need to
4328 refetch the attributes from the skeleton CU.
4329 This could be optimized by retrieving those attributes from when we
4330 were here the first time: the previous comp_unit_die was stored in
4331 comp_unit_obstack. But there's no data yet that we need this
4333 if (cu
->dwo_unit
!= NULL
)
4334 rereading_dwo_cu
= 1;
4338 /* If !use_existing_cu, this_cu->cu must be NULL. */
4339 gdb_assert (this_cu
->cu
== NULL
);
4341 cu
= xmalloc (sizeof (*cu
));
4342 init_one_comp_unit (cu
, this_cu
);
4344 /* If an error occurs while loading, release our storage. */
4345 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
4348 if (cu
->header
.first_die_offset
.cu_off
!= 0 && ! rereading_dwo_cu
)
4350 /* We already have the header, there's no need to read it in again. */
4351 info_ptr
+= cu
->header
.first_die_offset
.cu_off
;
4355 if (this_cu
->is_debug_types
)
4358 cu_offset type_offset_in_tu
;
4360 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
4361 abbrev_section
, info_ptr
,
4363 &type_offset_in_tu
);
4365 /* Since per_cu is the first member of struct signatured_type,
4366 we can go from a pointer to one to a pointer to the other. */
4367 sig_type
= (struct signatured_type
*) this_cu
;
4368 gdb_assert (sig_type
->signature
== signature
);
4369 gdb_assert (sig_type
->type_offset_in_tu
.cu_off
4370 == type_offset_in_tu
.cu_off
);
4371 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
4373 /* LENGTH has not been set yet for type units if we're
4374 using .gdb_index. */
4375 this_cu
->length
= get_cu_length (&cu
->header
);
4377 /* Establish the type offset that can be used to lookup the type. */
4378 sig_type
->type_offset_in_section
.sect_off
=
4379 this_cu
->offset
.sect_off
+ sig_type
->type_offset_in_tu
.cu_off
;
4383 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
4387 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
4388 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
4392 /* Skip dummy compilation units. */
4393 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
4394 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4396 do_cleanups (cleanups
);
4400 /* If we don't have them yet, read the abbrevs for this compilation unit.
4401 And if we need to read them now, make sure they're freed when we're
4402 done. Note that it's important that if the CU had an abbrev table
4403 on entry we don't free it when we're done: Somewhere up the call stack
4404 it may be in use. */
4405 if (abbrev_table
!= NULL
)
4407 gdb_assert (cu
->abbrev_table
== NULL
);
4408 gdb_assert (cu
->header
.abbrev_offset
.sect_off
4409 == abbrev_table
->offset
.sect_off
);
4410 cu
->abbrev_table
= abbrev_table
;
4412 else if (cu
->abbrev_table
== NULL
)
4414 dwarf2_read_abbrevs (cu
, abbrev_section
);
4415 make_cleanup (dwarf2_free_abbrev_table
, cu
);
4417 else if (rereading_dwo_cu
)
4419 dwarf2_free_abbrev_table (cu
);
4420 dwarf2_read_abbrevs (cu
, abbrev_section
);
4423 /* Read the top level CU/TU die. */
4424 init_cu_die_reader (&reader
, cu
, section
, NULL
);
4425 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
4427 /* If we have a DWO stub, process it and then read in the DWO file.
4428 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains
4429 a DWO CU, that this test will fail. */
4430 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
4433 char *dwo_name
= DW_STRING (attr
);
4434 const char *comp_dir_string
;
4435 struct dwo_unit
*dwo_unit
;
4436 ULONGEST signature
; /* Or dwo_id. */
4437 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
4438 int i
,num_extra_attrs
;
4439 struct dwarf2_section_info
*dwo_abbrev_section
;
4442 error (_("Dwarf Error: compilation unit with DW_AT_GNU_dwo_name"
4443 " has children (offset 0x%x) [in module %s]"),
4444 this_cu
->offset
.sect_off
, bfd_get_filename (abfd
));
4446 /* These attributes aren't processed until later:
4447 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
4448 However, the attribute is found in the stub which we won't have later.
4449 In order to not impose this complication on the rest of the code,
4450 we read them here and copy them to the DWO CU/TU die. */
4452 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
4455 if (! this_cu
->is_debug_types
)
4456 stmt_list
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
4457 low_pc
= dwarf2_attr (comp_unit_die
, DW_AT_low_pc
, cu
);
4458 high_pc
= dwarf2_attr (comp_unit_die
, DW_AT_high_pc
, cu
);
4459 ranges
= dwarf2_attr (comp_unit_die
, DW_AT_ranges
, cu
);
4460 comp_dir
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
4462 /* There should be a DW_AT_addr_base attribute here (if needed).
4463 We need the value before we can process DW_FORM_GNU_addr_index. */
4465 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
4467 cu
->addr_base
= DW_UNSND (attr
);
4469 /* There should be a DW_AT_ranges_base attribute here (if needed).
4470 We need the value before we can process DW_AT_ranges. */
4471 cu
->ranges_base
= 0;
4472 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
4474 cu
->ranges_base
= DW_UNSND (attr
);
4476 if (this_cu
->is_debug_types
)
4478 gdb_assert (sig_type
!= NULL
);
4479 signature
= sig_type
->signature
;
4483 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
4485 error (_("Dwarf Error: missing dwo_id [in module %s]"),
4487 signature
= DW_UNSND (attr
);
4490 /* We may need the comp_dir in order to find the DWO file. */
4491 comp_dir_string
= NULL
;
4493 comp_dir_string
= DW_STRING (comp_dir
);
4495 if (this_cu
->is_debug_types
)
4496 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir_string
);
4498 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir_string
,
4501 if (dwo_unit
== NULL
)
4503 error (_("Dwarf Error: CU at offset 0x%x references unknown DWO"
4504 " with ID %s [in module %s]"),
4505 this_cu
->offset
.sect_off
,
4506 phex (signature
, sizeof (signature
)),
4510 /* Set up for reading the DWO CU/TU. */
4511 cu
->dwo_unit
= dwo_unit
;
4512 section
= dwo_unit
->info_or_types_section
;
4513 begin_info_ptr
= info_ptr
= section
->buffer
+ dwo_unit
->offset
.sect_off
;
4514 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
4515 init_cu_die_reader (&reader
, cu
, section
, dwo_unit
->dwo_file
);
4517 if (this_cu
->is_debug_types
)
4521 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
4525 gdb_assert (sig_type
->signature
== signature
);
4526 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
4527 gdb_assert (dwo_unit
->length
== get_cu_length (&cu
->header
));
4529 /* Establish the type offset that can be used to lookup the type.
4530 For DWO files, we don't know it until now. */
4531 sig_type
->type_offset_in_section
.sect_off
=
4532 dwo_unit
->offset
.sect_off
+ dwo_unit
->type_offset_in_tu
.cu_off
;
4536 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
4539 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
4540 gdb_assert (dwo_unit
->length
== get_cu_length (&cu
->header
));
4543 /* Discard the original CU's abbrev table, and read the DWO's. */
4544 if (abbrev_table
== NULL
)
4546 dwarf2_free_abbrev_table (cu
);
4547 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
4551 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
4552 make_cleanup (dwarf2_free_abbrev_table
, cu
);
4555 /* Read in the die, but leave space to copy over the attributes
4556 from the stub. This has the benefit of simplifying the rest of
4557 the code - all the real work is done here. */
4558 num_extra_attrs
= ((stmt_list
!= NULL
)
4562 + (comp_dir
!= NULL
));
4563 info_ptr
= read_full_die_1 (&reader
, &comp_unit_die
, info_ptr
,
4564 &has_children
, num_extra_attrs
);
4566 /* Copy over the attributes from the stub to the DWO die. */
4567 i
= comp_unit_die
->num_attrs
;
4568 if (stmt_list
!= NULL
)
4569 comp_unit_die
->attrs
[i
++] = *stmt_list
;
4571 comp_unit_die
->attrs
[i
++] = *low_pc
;
4572 if (high_pc
!= NULL
)
4573 comp_unit_die
->attrs
[i
++] = *high_pc
;
4575 comp_unit_die
->attrs
[i
++] = *ranges
;
4576 if (comp_dir
!= NULL
)
4577 comp_unit_die
->attrs
[i
++] = *comp_dir
;
4578 comp_unit_die
->num_attrs
+= num_extra_attrs
;
4580 /* Skip dummy compilation units. */
4581 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
4582 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4584 do_cleanups (cleanups
);
4589 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
4591 if (free_cu_cleanup
!= NULL
)
4595 /* We've successfully allocated this compilation unit. Let our
4596 caller clean it up when finished with it. */
4597 discard_cleanups (free_cu_cleanup
);
4599 /* We can only discard free_cu_cleanup and all subsequent cleanups.
4600 So we have to manually free the abbrev table. */
4601 dwarf2_free_abbrev_table (cu
);
4603 /* Link this CU into read_in_chain. */
4604 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4605 dwarf2_per_objfile
->read_in_chain
= this_cu
;
4608 do_cleanups (free_cu_cleanup
);
4611 do_cleanups (cleanups
);
4614 /* Read CU/TU THIS_CU in section SECTION,
4615 but do not follow DW_AT_GNU_dwo_name if present.
4616 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed to
4617 have already done the lookup to find the DWO file).
4619 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
4620 THIS_CU->is_debug_types, but nothing else.
4622 We fill in THIS_CU->length.
4624 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
4625 linker) then DIE_READER_FUNC will not get called.
4627 THIS_CU->cu is always freed when done.
4628 This is done in order to not leave THIS_CU->cu in a state where we have
4629 to care whether it refers to the "main" CU or the DWO CU. */
4632 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
4633 struct dwarf2_section_info
*abbrev_section
,
4634 struct dwo_file
*dwo_file
,
4635 die_reader_func_ftype
*die_reader_func
,
4638 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4639 struct dwarf2_section_info
*section
= this_cu
->info_or_types_section
;
4640 bfd
*abfd
= section
->asection
->owner
;
4641 struct dwarf2_cu cu
;
4642 gdb_byte
*begin_info_ptr
, *info_ptr
;
4643 struct die_reader_specs reader
;
4644 struct cleanup
*cleanups
;
4645 struct die_info
*comp_unit_die
;
4648 if (dwarf2_die_debug
)
4649 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
4650 this_cu
->is_debug_types
? "type" : "comp",
4651 this_cu
->offset
.sect_off
);
4653 gdb_assert (this_cu
->cu
== NULL
);
4655 /* This is cheap if the section is already read in. */
4656 dwarf2_read_section (objfile
, section
);
4658 init_one_comp_unit (&cu
, this_cu
);
4660 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
4662 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
4663 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
,
4664 abbrev_section
, info_ptr
,
4665 this_cu
->is_debug_types
);
4667 this_cu
->length
= get_cu_length (&cu
.header
);
4669 /* Skip dummy compilation units. */
4670 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
4671 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4673 do_cleanups (cleanups
);
4677 dwarf2_read_abbrevs (&cu
, abbrev_section
);
4678 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
4680 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
4681 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
4683 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
4685 do_cleanups (cleanups
);
4688 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
4689 does not lookup the specified DWO file.
4690 This cannot be used to read DWO files.
4692 THIS_CU->cu is always freed when done.
4693 This is done in order to not leave THIS_CU->cu in a state where we have
4694 to care whether it refers to the "main" CU or the DWO CU.
4695 We can revisit this if the data shows there's a performance issue. */
4698 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
4699 die_reader_func_ftype
*die_reader_func
,
4702 init_cutu_and_read_dies_no_follow (this_cu
,
4703 get_abbrev_section_for_cu (this_cu
),
4705 die_reader_func
, data
);
4708 /* Create a psymtab named NAME and assign it to PER_CU.
4710 The caller must fill in the following details:
4711 dirname, textlow, texthigh. */
4713 static struct partial_symtab
*
4714 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
4716 struct objfile
*objfile
= per_cu
->objfile
;
4717 struct partial_symtab
*pst
;
4719 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
4721 objfile
->global_psymbols
.next
,
4722 objfile
->static_psymbols
.next
);
4724 pst
->psymtabs_addrmap_supported
= 1;
4726 /* This is the glue that links PST into GDB's symbol API. */
4727 pst
->read_symtab_private
= per_cu
;
4728 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
4729 per_cu
->v
.psymtab
= pst
;
4734 /* die_reader_func for process_psymtab_comp_unit. */
4737 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
4739 struct die_info
*comp_unit_die
,
4743 struct dwarf2_cu
*cu
= reader
->cu
;
4744 struct objfile
*objfile
= cu
->objfile
;
4745 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
4746 struct attribute
*attr
;
4748 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
4749 struct partial_symtab
*pst
;
4751 const char *filename
;
4752 int *want_partial_unit_ptr
= data
;
4754 if (comp_unit_die
->tag
== DW_TAG_partial_unit
4755 && (want_partial_unit_ptr
== NULL
4756 || !*want_partial_unit_ptr
))
4759 gdb_assert (! per_cu
->is_debug_types
);
4761 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
4763 cu
->list_in_scope
= &file_symbols
;
4765 /* Allocate a new partial symbol table structure. */
4766 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, cu
);
4767 if (attr
== NULL
|| !DW_STRING (attr
))
4770 filename
= DW_STRING (attr
);
4772 pst
= create_partial_symtab (per_cu
, filename
);
4774 /* This must be done before calling dwarf2_build_include_psymtabs. */
4775 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
4777 pst
->dirname
= DW_STRING (attr
);
4779 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4781 dwarf2_find_base_address (comp_unit_die
, cu
);
4783 /* Possibly set the default values of LOWPC and HIGHPC from
4785 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
4786 &best_highpc
, cu
, pst
);
4787 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
4788 /* Store the contiguous range if it is not empty; it can be empty for
4789 CUs with no code. */
4790 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4791 best_lowpc
+ baseaddr
,
4792 best_highpc
+ baseaddr
- 1, pst
);
4794 /* Check if comp unit has_children.
4795 If so, read the rest of the partial symbols from this comp unit.
4796 If not, there's no more debug_info for this comp unit. */
4799 struct partial_die_info
*first_die
;
4800 CORE_ADDR lowpc
, highpc
;
4802 lowpc
= ((CORE_ADDR
) -1);
4803 highpc
= ((CORE_ADDR
) 0);
4805 first_die
= load_partial_dies (reader
, info_ptr
, 1);
4807 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
4810 /* If we didn't find a lowpc, set it to highpc to avoid
4811 complaints from `maint check'. */
4812 if (lowpc
== ((CORE_ADDR
) -1))
4815 /* If the compilation unit didn't have an explicit address range,
4816 then use the information extracted from its child dies. */
4820 best_highpc
= highpc
;
4823 pst
->textlow
= best_lowpc
+ baseaddr
;
4824 pst
->texthigh
= best_highpc
+ baseaddr
;
4826 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
4827 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
4828 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
4829 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
4830 sort_pst_symbols (pst
);
4832 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->s
.imported_symtabs
))
4835 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->s
.imported_symtabs
);
4836 struct dwarf2_per_cu_data
*iter
;
4838 /* Fill in 'dependencies' here; we fill in 'users' in a
4840 pst
->number_of_dependencies
= len
;
4841 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
4842 len
* sizeof (struct symtab
*));
4844 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->s
.imported_symtabs
,
4847 pst
->dependencies
[i
] = iter
->v
.psymtab
;
4849 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->s
.imported_symtabs
);
4852 /* Get the list of files included in the current compilation unit,
4853 and build a psymtab for each of them. */
4854 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
4856 if (dwarf2_read_debug
)
4858 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4860 fprintf_unfiltered (gdb_stdlog
,
4861 "Psymtab for %s unit @0x%x: 0x%s - 0x%s"
4862 ", %d global, %d static syms\n",
4863 per_cu
->is_debug_types
? "type" : "comp",
4864 per_cu
->offset
.sect_off
,
4865 paddress (gdbarch
, pst
->textlow
),
4866 paddress (gdbarch
, pst
->texthigh
),
4867 pst
->n_global_syms
, pst
->n_static_syms
);
4871 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
4872 Process compilation unit THIS_CU for a psymtab. */
4875 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
4876 int want_partial_unit
)
4878 /* If this compilation unit was already read in, free the
4879 cached copy in order to read it in again. This is
4880 necessary because we skipped some symbols when we first
4881 read in the compilation unit (see load_partial_dies).
4882 This problem could be avoided, but the benefit is unclear. */
4883 if (this_cu
->cu
!= NULL
)
4884 free_one_cached_comp_unit (this_cu
);
4886 gdb_assert (! this_cu
->is_debug_types
);
4887 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0,
4888 process_psymtab_comp_unit_reader
,
4889 &want_partial_unit
);
4891 /* Age out any secondary CUs. */
4892 age_cached_comp_units ();
4896 hash_type_unit_group (const void *item
)
4898 const struct type_unit_group
*tu_group
= item
;
4900 return hash_stmt_list_entry (&tu_group
->hash
);
4904 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
4906 const struct type_unit_group
*lhs
= item_lhs
;
4907 const struct type_unit_group
*rhs
= item_rhs
;
4909 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
4912 /* Allocate a hash table for type unit groups. */
4915 allocate_type_unit_groups_table (void)
4917 return htab_create_alloc_ex (3,
4918 hash_type_unit_group
,
4921 &dwarf2_per_objfile
->objfile
->objfile_obstack
,
4922 hashtab_obstack_allocate
,
4923 dummy_obstack_deallocate
);
4926 /* Type units that don't have DW_AT_stmt_list are grouped into their own
4927 partial symtabs. We combine several TUs per psymtab to not let the size
4928 of any one psymtab grow too big. */
4929 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
4930 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
4932 /* Helper routine for get_type_unit_group.
4933 Create the type_unit_group object used to hold one or more TUs. */
4935 static struct type_unit_group
*
4936 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
4938 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4939 struct dwarf2_per_cu_data
*per_cu
;
4940 struct type_unit_group
*tu_group
;
4942 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4943 struct type_unit_group
);
4944 per_cu
= &tu_group
->per_cu
;
4945 per_cu
->objfile
= objfile
;
4946 per_cu
->is_debug_types
= 1;
4947 per_cu
->s
.type_unit_group
= tu_group
;
4949 if (dwarf2_per_objfile
->using_index
)
4951 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4952 struct dwarf2_per_cu_quick_data
);
4953 tu_group
->t
.first_tu
= cu
->per_cu
;
4957 unsigned int line_offset
= line_offset_struct
.sect_off
;
4958 struct partial_symtab
*pst
;
4961 /* Give the symtab a useful name for debug purposes. */
4962 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
4963 name
= xstrprintf ("<type_units_%d>",
4964 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
4966 name
= xstrprintf ("<type_units_at_0x%x>", line_offset
);
4968 pst
= create_partial_symtab (per_cu
, name
);
4974 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
4975 tu_group
->hash
.line_offset
= line_offset_struct
;
4980 /* Look up the type_unit_group for type unit CU, and create it if necessary.
4981 STMT_LIST is a DW_AT_stmt_list attribute. */
4983 static struct type_unit_group
*
4984 get_type_unit_group (struct dwarf2_cu
*cu
, struct attribute
*stmt_list
)
4986 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
4987 struct type_unit_group
*tu_group
;
4989 unsigned int line_offset
;
4990 struct type_unit_group type_unit_group_for_lookup
;
4992 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
4994 dwarf2_per_objfile
->type_unit_groups
=
4995 allocate_type_unit_groups_table ();
4998 /* Do we need to create a new group, or can we use an existing one? */
5002 line_offset
= DW_UNSND (stmt_list
);
5003 ++tu_stats
->nr_symtab_sharers
;
5007 /* Ugh, no stmt_list. Rare, but we have to handle it.
5008 We can do various things here like create one group per TU or
5009 spread them over multiple groups to split up the expansion work.
5010 To avoid worst case scenarios (too many groups or too large groups)
5011 we, umm, group them in bunches. */
5012 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5013 | (tu_stats
->nr_stmt_less_type_units
5014 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
5015 ++tu_stats
->nr_stmt_less_type_units
;
5018 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
5019 type_unit_group_for_lookup
.hash
.line_offset
.sect_off
= line_offset
;
5020 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
5021 &type_unit_group_for_lookup
, INSERT
);
5025 gdb_assert (tu_group
!= NULL
);
5029 sect_offset line_offset_struct
;
5031 line_offset_struct
.sect_off
= line_offset
;
5032 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
5034 ++tu_stats
->nr_symtabs
;
5040 /* Struct used to sort TUs by their abbreviation table offset. */
5042 struct tu_abbrev_offset
5044 struct signatured_type
*sig_type
;
5045 sect_offset abbrev_offset
;
5048 /* Helper routine for build_type_unit_groups, passed to qsort. */
5051 sort_tu_by_abbrev_offset (const void *ap
, const void *bp
)
5053 const struct tu_abbrev_offset
* const *a
= ap
;
5054 const struct tu_abbrev_offset
* const *b
= bp
;
5055 unsigned int aoff
= (*a
)->abbrev_offset
.sect_off
;
5056 unsigned int boff
= (*b
)->abbrev_offset
.sect_off
;
5058 return (aoff
> boff
) - (aoff
< boff
);
5061 /* A helper function to add a type_unit_group to a table. */
5064 add_type_unit_group_to_table (void **slot
, void *datum
)
5066 struct type_unit_group
*tu_group
= *slot
;
5067 struct type_unit_group
***datap
= datum
;
5075 /* Efficiently read all the type units, calling init_cutu_and_read_dies on
5076 each one passing FUNC,DATA.
5078 The efficiency is because we sort TUs by the abbrev table they use and
5079 only read each abbrev table once. In one program there are 200K TUs
5080 sharing 8K abbrev tables.
5082 The main purpose of this function is to support building the
5083 dwarf2_per_objfile->type_unit_groups table.
5084 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
5085 can collapse the search space by grouping them by stmt_list.
5086 The savings can be significant, in the same program from above the 200K TUs
5087 share 8K stmt_list tables.
5089 FUNC is expected to call get_type_unit_group, which will create the
5090 struct type_unit_group if necessary and add it to
5091 dwarf2_per_objfile->type_unit_groups. */
5094 build_type_unit_groups (die_reader_func_ftype
*func
, void *data
)
5096 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5097 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
5098 struct cleanup
*cleanups
;
5099 struct abbrev_table
*abbrev_table
;
5100 sect_offset abbrev_offset
;
5101 struct tu_abbrev_offset
*sorted_by_abbrev
;
5102 struct type_unit_group
**iter
;
5105 /* It's up to the caller to not call us multiple times. */
5106 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
5108 if (dwarf2_per_objfile
->n_type_units
== 0)
5111 /* TUs typically share abbrev tables, and there can be way more TUs than
5112 abbrev tables. Sort by abbrev table to reduce the number of times we
5113 read each abbrev table in.
5114 Alternatives are to punt or to maintain a cache of abbrev tables.
5115 This is simpler and efficient enough for now.
5117 Later we group TUs by their DW_AT_stmt_list value (as this defines the
5118 symtab to use). Typically TUs with the same abbrev offset have the same
5119 stmt_list value too so in practice this should work well.
5121 The basic algorithm here is:
5123 sort TUs by abbrev table
5124 for each TU with same abbrev table:
5125 read abbrev table if first user
5126 read TU top level DIE
5127 [IWBN if DWO skeletons had DW_AT_stmt_list]
5130 if (dwarf2_read_debug
)
5131 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
5133 /* Sort in a separate table to maintain the order of all_type_units
5134 for .gdb_index: TU indices directly index all_type_units. */
5135 sorted_by_abbrev
= XNEWVEC (struct tu_abbrev_offset
,
5136 dwarf2_per_objfile
->n_type_units
);
5137 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
5139 struct signatured_type
*sig_type
= dwarf2_per_objfile
->all_type_units
[i
];
5141 sorted_by_abbrev
[i
].sig_type
= sig_type
;
5142 sorted_by_abbrev
[i
].abbrev_offset
=
5143 read_abbrev_offset (sig_type
->per_cu
.info_or_types_section
,
5144 sig_type
->per_cu
.offset
);
5146 cleanups
= make_cleanup (xfree
, sorted_by_abbrev
);
5147 qsort (sorted_by_abbrev
, dwarf2_per_objfile
->n_type_units
,
5148 sizeof (struct tu_abbrev_offset
), sort_tu_by_abbrev_offset
);
5150 /* Note: In the .gdb_index case, get_type_unit_group may have already been
5151 called any number of times, so we don't reset tu_stats here. */
5153 abbrev_offset
.sect_off
= ~(unsigned) 0;
5154 abbrev_table
= NULL
;
5155 make_cleanup (abbrev_table_free_cleanup
, &abbrev_table
);
5157 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
5159 const struct tu_abbrev_offset
*tu
= &sorted_by_abbrev
[i
];
5161 /* Switch to the next abbrev table if necessary. */
5162 if (abbrev_table
== NULL
5163 || tu
->abbrev_offset
.sect_off
!= abbrev_offset
.sect_off
)
5165 if (abbrev_table
!= NULL
)
5167 abbrev_table_free (abbrev_table
);
5168 /* Reset to NULL in case abbrev_table_read_table throws
5169 an error: abbrev_table_free_cleanup will get called. */
5170 abbrev_table
= NULL
;
5172 abbrev_offset
= tu
->abbrev_offset
;
5174 abbrev_table_read_table (&dwarf2_per_objfile
->abbrev
,
5176 ++tu_stats
->nr_uniq_abbrev_tables
;
5179 init_cutu_and_read_dies (&tu
->sig_type
->per_cu
, abbrev_table
, 0, 0,
5183 /* Create a vector of pointers to primary type units to make it easy to
5184 iterate over them and CUs. See dw2_get_primary_cu. */
5185 dwarf2_per_objfile
->n_type_unit_groups
=
5186 htab_elements (dwarf2_per_objfile
->type_unit_groups
);
5187 dwarf2_per_objfile
->all_type_unit_groups
=
5188 obstack_alloc (&objfile
->objfile_obstack
,
5189 dwarf2_per_objfile
->n_type_unit_groups
5190 * sizeof (struct type_unit_group
*));
5191 iter
= &dwarf2_per_objfile
->all_type_unit_groups
[0];
5192 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
5193 add_type_unit_group_to_table
, &iter
);
5194 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_unit_groups
[0]
5195 == dwarf2_per_objfile
->n_type_unit_groups
);
5197 do_cleanups (cleanups
);
5199 if (dwarf2_read_debug
)
5201 fprintf_unfiltered (gdb_stdlog
, "Done building type unit groups:\n");
5202 fprintf_unfiltered (gdb_stdlog
, " %d TUs\n",
5203 dwarf2_per_objfile
->n_type_units
);
5204 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
5205 tu_stats
->nr_uniq_abbrev_tables
);
5206 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
5207 tu_stats
->nr_symtabs
);
5208 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
5209 tu_stats
->nr_symtab_sharers
);
5210 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
5211 tu_stats
->nr_stmt_less_type_units
);
5215 /* Reader function for build_type_psymtabs. */
5218 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
5220 struct die_info
*type_unit_die
,
5224 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5225 struct dwarf2_cu
*cu
= reader
->cu
;
5226 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
5227 struct type_unit_group
*tu_group
;
5228 struct attribute
*attr
;
5229 struct partial_die_info
*first_die
;
5230 CORE_ADDR lowpc
, highpc
;
5231 struct partial_symtab
*pst
;
5233 gdb_assert (data
== NULL
);
5238 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
5239 tu_group
= get_type_unit_group (cu
, attr
);
5241 VEC_safe_push (dwarf2_per_cu_ptr
, tu_group
->t
.tus
, per_cu
);
5243 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
5244 cu
->list_in_scope
= &file_symbols
;
5245 pst
= create_partial_symtab (per_cu
, "");
5248 first_die
= load_partial_dies (reader
, info_ptr
, 1);
5250 lowpc
= (CORE_ADDR
) -1;
5251 highpc
= (CORE_ADDR
) 0;
5252 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
5254 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
5255 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
5256 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
5257 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
5258 sort_pst_symbols (pst
);
5261 /* Traversal function for build_type_psymtabs. */
5264 build_type_psymtab_dependencies (void **slot
, void *info
)
5266 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5267 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
5268 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
5269 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
5270 int len
= VEC_length (dwarf2_per_cu_ptr
, tu_group
->t
.tus
);
5271 struct dwarf2_per_cu_data
*iter
;
5274 gdb_assert (len
> 0);
5276 pst
->number_of_dependencies
= len
;
5277 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
5278 len
* sizeof (struct psymtab
*));
5280 VEC_iterate (dwarf2_per_cu_ptr
, tu_group
->t
.tus
, i
, iter
);
5283 pst
->dependencies
[i
] = iter
->v
.psymtab
;
5284 iter
->s
.type_unit_group
= tu_group
;
5287 VEC_free (dwarf2_per_cu_ptr
, tu_group
->t
.tus
);
5292 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
5293 Build partial symbol tables for the .debug_types comp-units. */
5296 build_type_psymtabs (struct objfile
*objfile
)
5298 if (! create_all_type_units (objfile
))
5301 build_type_unit_groups (build_type_psymtabs_reader
, NULL
);
5303 /* Now that all TUs have been processed we can fill in the dependencies. */
5304 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
5305 build_type_psymtab_dependencies
, NULL
);
5308 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
5311 psymtabs_addrmap_cleanup (void *o
)
5313 struct objfile
*objfile
= o
;
5315 objfile
->psymtabs_addrmap
= NULL
;
5318 /* Compute the 'user' field for each psymtab in OBJFILE. */
5321 set_partial_user (struct objfile
*objfile
)
5325 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5327 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
5328 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
5334 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
5336 /* Set the 'user' field only if it is not already set. */
5337 if (pst
->dependencies
[j
]->user
== NULL
)
5338 pst
->dependencies
[j
]->user
= pst
;
5343 /* Build the partial symbol table by doing a quick pass through the
5344 .debug_info and .debug_abbrev sections. */
5347 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
5349 struct cleanup
*back_to
, *addrmap_cleanup
;
5350 struct obstack temp_obstack
;
5353 if (dwarf2_read_debug
)
5355 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
5359 dwarf2_per_objfile
->reading_partial_symbols
= 1;
5361 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
5363 /* Any cached compilation units will be linked by the per-objfile
5364 read_in_chain. Make sure to free them when we're done. */
5365 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
5367 build_type_psymtabs (objfile
);
5369 create_all_comp_units (objfile
);
5371 /* Create a temporary address map on a temporary obstack. We later
5372 copy this to the final obstack. */
5373 obstack_init (&temp_obstack
);
5374 make_cleanup_obstack_free (&temp_obstack
);
5375 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
5376 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
5378 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5380 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
5382 process_psymtab_comp_unit (per_cu
, 0);
5385 set_partial_user (objfile
);
5387 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
5388 &objfile
->objfile_obstack
);
5389 discard_cleanups (addrmap_cleanup
);
5391 do_cleanups (back_to
);
5393 if (dwarf2_read_debug
)
5394 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
5398 /* die_reader_func for load_partial_comp_unit. */
5401 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
5403 struct die_info
*comp_unit_die
,
5407 struct dwarf2_cu
*cu
= reader
->cu
;
5409 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
5411 /* Check if comp unit has_children.
5412 If so, read the rest of the partial symbols from this comp unit.
5413 If not, there's no more debug_info for this comp unit. */
5415 load_partial_dies (reader
, info_ptr
, 0);
5418 /* Load the partial DIEs for a secondary CU into memory.
5419 This is also used when rereading a primary CU with load_all_dies. */
5422 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
5424 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
5425 load_partial_comp_unit_reader
, NULL
);
5429 read_comp_units_from_section (struct objfile
*objfile
,
5430 struct dwarf2_section_info
*section
,
5431 unsigned int is_dwz
,
5434 struct dwarf2_per_cu_data
***all_comp_units
)
5437 bfd
*abfd
= section
->asection
->owner
;
5439 dwarf2_read_section (objfile
, section
);
5441 info_ptr
= section
->buffer
;
5443 while (info_ptr
< section
->buffer
+ section
->size
)
5445 unsigned int length
, initial_length_size
;
5446 struct dwarf2_per_cu_data
*this_cu
;
5449 offset
.sect_off
= info_ptr
- section
->buffer
;
5451 /* Read just enough information to find out where the next
5452 compilation unit is. */
5453 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
5455 /* Save the compilation unit for later lookup. */
5456 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
5457 sizeof (struct dwarf2_per_cu_data
));
5458 memset (this_cu
, 0, sizeof (*this_cu
));
5459 this_cu
->offset
= offset
;
5460 this_cu
->length
= length
+ initial_length_size
;
5461 this_cu
->is_dwz
= is_dwz
;
5462 this_cu
->objfile
= objfile
;
5463 this_cu
->info_or_types_section
= section
;
5465 if (*n_comp_units
== *n_allocated
)
5468 *all_comp_units
= xrealloc (*all_comp_units
,
5470 * sizeof (struct dwarf2_per_cu_data
*));
5472 (*all_comp_units
)[*n_comp_units
] = this_cu
;
5475 info_ptr
= info_ptr
+ this_cu
->length
;
5479 /* Create a list of all compilation units in OBJFILE.
5480 This is only done for -readnow and building partial symtabs. */
5483 create_all_comp_units (struct objfile
*objfile
)
5487 struct dwarf2_per_cu_data
**all_comp_units
;
5491 all_comp_units
= xmalloc (n_allocated
5492 * sizeof (struct dwarf2_per_cu_data
*));
5494 read_comp_units_from_section (objfile
, &dwarf2_per_objfile
->info
, 0,
5495 &n_allocated
, &n_comp_units
, &all_comp_units
);
5497 if (bfd_get_section_by_name (objfile
->obfd
, ".gnu_debugaltlink") != NULL
)
5499 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
5501 read_comp_units_from_section (objfile
, &dwz
->info
, 1,
5502 &n_allocated
, &n_comp_units
,
5506 dwarf2_per_objfile
->all_comp_units
5507 = obstack_alloc (&objfile
->objfile_obstack
,
5508 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
5509 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
5510 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
5511 xfree (all_comp_units
);
5512 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
5515 /* Process all loaded DIEs for compilation unit CU, starting at
5516 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
5517 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
5518 DW_AT_ranges). If NEED_PC is set, then this function will set
5519 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
5520 and record the covered ranges in the addrmap. */
5523 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
5524 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
5526 struct partial_die_info
*pdi
;
5528 /* Now, march along the PDI's, descending into ones which have
5529 interesting children but skipping the children of the other ones,
5530 until we reach the end of the compilation unit. */
5536 fixup_partial_die (pdi
, cu
);
5538 /* Anonymous namespaces or modules have no name but have interesting
5539 children, so we need to look at them. Ditto for anonymous
5542 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
5543 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
5544 || pdi
->tag
== DW_TAG_imported_unit
)
5548 case DW_TAG_subprogram
:
5549 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
5551 case DW_TAG_constant
:
5552 case DW_TAG_variable
:
5553 case DW_TAG_typedef
:
5554 case DW_TAG_union_type
:
5555 if (!pdi
->is_declaration
)
5557 add_partial_symbol (pdi
, cu
);
5560 case DW_TAG_class_type
:
5561 case DW_TAG_interface_type
:
5562 case DW_TAG_structure_type
:
5563 if (!pdi
->is_declaration
)
5565 add_partial_symbol (pdi
, cu
);
5568 case DW_TAG_enumeration_type
:
5569 if (!pdi
->is_declaration
)
5570 add_partial_enumeration (pdi
, cu
);
5572 case DW_TAG_base_type
:
5573 case DW_TAG_subrange_type
:
5574 /* File scope base type definitions are added to the partial
5576 add_partial_symbol (pdi
, cu
);
5578 case DW_TAG_namespace
:
5579 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
5582 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
5584 case DW_TAG_imported_unit
:
5586 struct dwarf2_per_cu_data
*per_cu
;
5588 /* For now we don't handle imported units in type units. */
5589 if (cu
->per_cu
->is_debug_types
)
5591 error (_("Dwarf Error: DW_TAG_imported_unit is not"
5592 " supported in type units [in module %s]"),
5596 per_cu
= dwarf2_find_containing_comp_unit (pdi
->d
.offset
,
5600 /* Go read the partial unit, if needed. */
5601 if (per_cu
->v
.psymtab
== NULL
)
5602 process_psymtab_comp_unit (per_cu
, 1);
5604 VEC_safe_push (dwarf2_per_cu_ptr
,
5605 cu
->per_cu
->s
.imported_symtabs
, per_cu
);
5613 /* If the die has a sibling, skip to the sibling. */
5615 pdi
= pdi
->die_sibling
;
5619 /* Functions used to compute the fully scoped name of a partial DIE.
5621 Normally, this is simple. For C++, the parent DIE's fully scoped
5622 name is concatenated with "::" and the partial DIE's name. For
5623 Java, the same thing occurs except that "." is used instead of "::".
5624 Enumerators are an exception; they use the scope of their parent
5625 enumeration type, i.e. the name of the enumeration type is not
5626 prepended to the enumerator.
5628 There are two complexities. One is DW_AT_specification; in this
5629 case "parent" means the parent of the target of the specification,
5630 instead of the direct parent of the DIE. The other is compilers
5631 which do not emit DW_TAG_namespace; in this case we try to guess
5632 the fully qualified name of structure types from their members'
5633 linkage names. This must be done using the DIE's children rather
5634 than the children of any DW_AT_specification target. We only need
5635 to do this for structures at the top level, i.e. if the target of
5636 any DW_AT_specification (if any; otherwise the DIE itself) does not
5639 /* Compute the scope prefix associated with PDI's parent, in
5640 compilation unit CU. The result will be allocated on CU's
5641 comp_unit_obstack, or a copy of the already allocated PDI->NAME
5642 field. NULL is returned if no prefix is necessary. */
5644 partial_die_parent_scope (struct partial_die_info
*pdi
,
5645 struct dwarf2_cu
*cu
)
5647 char *grandparent_scope
;
5648 struct partial_die_info
*parent
, *real_pdi
;
5650 /* We need to look at our parent DIE; if we have a DW_AT_specification,
5651 then this means the parent of the specification DIE. */
5654 while (real_pdi
->has_specification
)
5655 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
5656 real_pdi
->spec_is_dwz
, cu
);
5658 parent
= real_pdi
->die_parent
;
5662 if (parent
->scope_set
)
5663 return parent
->scope
;
5665 fixup_partial_die (parent
, cu
);
5667 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
5669 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
5670 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
5671 Work around this problem here. */
5672 if (cu
->language
== language_cplus
5673 && parent
->tag
== DW_TAG_namespace
5674 && strcmp (parent
->name
, "::") == 0
5675 && grandparent_scope
== NULL
)
5677 parent
->scope
= NULL
;
5678 parent
->scope_set
= 1;
5682 if (pdi
->tag
== DW_TAG_enumerator
)
5683 /* Enumerators should not get the name of the enumeration as a prefix. */
5684 parent
->scope
= grandparent_scope
;
5685 else if (parent
->tag
== DW_TAG_namespace
5686 || parent
->tag
== DW_TAG_module
5687 || parent
->tag
== DW_TAG_structure_type
5688 || parent
->tag
== DW_TAG_class_type
5689 || parent
->tag
== DW_TAG_interface_type
5690 || parent
->tag
== DW_TAG_union_type
5691 || parent
->tag
== DW_TAG_enumeration_type
)
5693 if (grandparent_scope
== NULL
)
5694 parent
->scope
= parent
->name
;
5696 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
5698 parent
->name
, 0, cu
);
5702 /* FIXME drow/2004-04-01: What should we be doing with
5703 function-local names? For partial symbols, we should probably be
5705 complaint (&symfile_complaints
,
5706 _("unhandled containing DIE tag %d for DIE at %d"),
5707 parent
->tag
, pdi
->offset
.sect_off
);
5708 parent
->scope
= grandparent_scope
;
5711 parent
->scope_set
= 1;
5712 return parent
->scope
;
5715 /* Return the fully scoped name associated with PDI, from compilation unit
5716 CU. The result will be allocated with malloc. */
5719 partial_die_full_name (struct partial_die_info
*pdi
,
5720 struct dwarf2_cu
*cu
)
5724 /* If this is a template instantiation, we can not work out the
5725 template arguments from partial DIEs. So, unfortunately, we have
5726 to go through the full DIEs. At least any work we do building
5727 types here will be reused if full symbols are loaded later. */
5728 if (pdi
->has_template_arguments
)
5730 fixup_partial_die (pdi
, cu
);
5732 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
5734 struct die_info
*die
;
5735 struct attribute attr
;
5736 struct dwarf2_cu
*ref_cu
= cu
;
5738 /* DW_FORM_ref_addr is using section offset. */
5740 attr
.form
= DW_FORM_ref_addr
;
5741 attr
.u
.unsnd
= pdi
->offset
.sect_off
;
5742 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
5744 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
5748 parent_scope
= partial_die_parent_scope (pdi
, cu
);
5749 if (parent_scope
== NULL
)
5752 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
5756 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
5758 struct objfile
*objfile
= cu
->objfile
;
5760 char *actual_name
= NULL
;
5762 int built_actual_name
= 0;
5764 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5766 actual_name
= partial_die_full_name (pdi
, cu
);
5768 built_actual_name
= 1;
5770 if (actual_name
== NULL
)
5771 actual_name
= pdi
->name
;
5775 case DW_TAG_subprogram
:
5776 if (pdi
->is_external
|| cu
->language
== language_ada
)
5778 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
5779 of the global scope. But in Ada, we want to be able to access
5780 nested procedures globally. So all Ada subprograms are stored
5781 in the global scope. */
5782 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
5783 mst_text, objfile); */
5784 add_psymbol_to_list (actual_name
, strlen (actual_name
),
5786 VAR_DOMAIN
, LOC_BLOCK
,
5787 &objfile
->global_psymbols
,
5788 0, pdi
->lowpc
+ baseaddr
,
5789 cu
->language
, objfile
);
5793 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
5794 mst_file_text, objfile); */
5795 add_psymbol_to_list (actual_name
, strlen (actual_name
),
5797 VAR_DOMAIN
, LOC_BLOCK
,
5798 &objfile
->static_psymbols
,
5799 0, pdi
->lowpc
+ baseaddr
,
5800 cu
->language
, objfile
);
5803 case DW_TAG_constant
:
5805 struct psymbol_allocation_list
*list
;
5807 if (pdi
->is_external
)
5808 list
= &objfile
->global_psymbols
;
5810 list
= &objfile
->static_psymbols
;
5811 add_psymbol_to_list (actual_name
, strlen (actual_name
),
5812 built_actual_name
, VAR_DOMAIN
, LOC_STATIC
,
5813 list
, 0, 0, cu
->language
, objfile
);
5816 case DW_TAG_variable
:
5818 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
5822 && !dwarf2_per_objfile
->has_section_at_zero
)
5824 /* A global or static variable may also have been stripped
5825 out by the linker if unused, in which case its address
5826 will be nullified; do not add such variables into partial
5827 symbol table then. */
5829 else if (pdi
->is_external
)
5832 Don't enter into the minimal symbol tables as there is
5833 a minimal symbol table entry from the ELF symbols already.
5834 Enter into partial symbol table if it has a location
5835 descriptor or a type.
5836 If the location descriptor is missing, new_symbol will create
5837 a LOC_UNRESOLVED symbol, the address of the variable will then
5838 be determined from the minimal symbol table whenever the variable
5840 The address for the partial symbol table entry is not
5841 used by GDB, but it comes in handy for debugging partial symbol
5844 if (pdi
->d
.locdesc
|| pdi
->has_type
)
5845 add_psymbol_to_list (actual_name
, strlen (actual_name
),
5847 VAR_DOMAIN
, LOC_STATIC
,
5848 &objfile
->global_psymbols
,
5850 cu
->language
, objfile
);
5854 /* Static Variable. Skip symbols without location descriptors. */
5855 if (pdi
->d
.locdesc
== NULL
)
5857 if (built_actual_name
)
5858 xfree (actual_name
);
5861 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
5862 mst_file_data, objfile); */
5863 add_psymbol_to_list (actual_name
, strlen (actual_name
),
5865 VAR_DOMAIN
, LOC_STATIC
,
5866 &objfile
->static_psymbols
,
5868 cu
->language
, objfile
);
5871 case DW_TAG_typedef
:
5872 case DW_TAG_base_type
:
5873 case DW_TAG_subrange_type
:
5874 add_psymbol_to_list (actual_name
, strlen (actual_name
),
5876 VAR_DOMAIN
, LOC_TYPEDEF
,
5877 &objfile
->static_psymbols
,
5878 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
5880 case DW_TAG_namespace
:
5881 add_psymbol_to_list (actual_name
, strlen (actual_name
),
5883 VAR_DOMAIN
, LOC_TYPEDEF
,
5884 &objfile
->global_psymbols
,
5885 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
5887 case DW_TAG_class_type
:
5888 case DW_TAG_interface_type
:
5889 case DW_TAG_structure_type
:
5890 case DW_TAG_union_type
:
5891 case DW_TAG_enumeration_type
:
5892 /* Skip external references. The DWARF standard says in the section
5893 about "Structure, Union, and Class Type Entries": "An incomplete
5894 structure, union or class type is represented by a structure,
5895 union or class entry that does not have a byte size attribute
5896 and that has a DW_AT_declaration attribute." */
5897 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
5899 if (built_actual_name
)
5900 xfree (actual_name
);
5904 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
5905 static vs. global. */
5906 add_psymbol_to_list (actual_name
, strlen (actual_name
),
5908 STRUCT_DOMAIN
, LOC_TYPEDEF
,
5909 (cu
->language
== language_cplus
5910 || cu
->language
== language_java
)
5911 ? &objfile
->global_psymbols
5912 : &objfile
->static_psymbols
,
5913 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
5916 case DW_TAG_enumerator
:
5917 add_psymbol_to_list (actual_name
, strlen (actual_name
),
5919 VAR_DOMAIN
, LOC_CONST
,
5920 (cu
->language
== language_cplus
5921 || cu
->language
== language_java
)
5922 ? &objfile
->global_psymbols
5923 : &objfile
->static_psymbols
,
5924 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
5930 if (built_actual_name
)
5931 xfree (actual_name
);
5934 /* Read a partial die corresponding to a namespace; also, add a symbol
5935 corresponding to that namespace to the symbol table. NAMESPACE is
5936 the name of the enclosing namespace. */
5939 add_partial_namespace (struct partial_die_info
*pdi
,
5940 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
5941 int need_pc
, struct dwarf2_cu
*cu
)
5943 /* Add a symbol for the namespace. */
5945 add_partial_symbol (pdi
, cu
);
5947 /* Now scan partial symbols in that namespace. */
5949 if (pdi
->has_children
)
5950 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
5953 /* Read a partial die corresponding to a Fortran module. */
5956 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
5957 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
5959 /* Now scan partial symbols in that module. */
5961 if (pdi
->has_children
)
5962 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
5965 /* Read a partial die corresponding to a subprogram and create a partial
5966 symbol for that subprogram. When the CU language allows it, this
5967 routine also defines a partial symbol for each nested subprogram
5968 that this subprogram contains.
5970 DIE my also be a lexical block, in which case we simply search
5971 recursively for suprograms defined inside that lexical block.
5972 Again, this is only performed when the CU language allows this
5973 type of definitions. */
5976 add_partial_subprogram (struct partial_die_info
*pdi
,
5977 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
5978 int need_pc
, struct dwarf2_cu
*cu
)
5980 if (pdi
->tag
== DW_TAG_subprogram
)
5982 if (pdi
->has_pc_info
)
5984 if (pdi
->lowpc
< *lowpc
)
5985 *lowpc
= pdi
->lowpc
;
5986 if (pdi
->highpc
> *highpc
)
5987 *highpc
= pdi
->highpc
;
5991 struct objfile
*objfile
= cu
->objfile
;
5993 baseaddr
= ANOFFSET (objfile
->section_offsets
,
5994 SECT_OFF_TEXT (objfile
));
5995 addrmap_set_empty (objfile
->psymtabs_addrmap
,
5996 pdi
->lowpc
+ baseaddr
,
5997 pdi
->highpc
- 1 + baseaddr
,
5998 cu
->per_cu
->v
.psymtab
);
6002 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
6004 if (!pdi
->is_declaration
)
6005 /* Ignore subprogram DIEs that do not have a name, they are
6006 illegal. Do not emit a complaint at this point, we will
6007 do so when we convert this psymtab into a symtab. */
6009 add_partial_symbol (pdi
, cu
);
6013 if (! pdi
->has_children
)
6016 if (cu
->language
== language_ada
)
6018 pdi
= pdi
->die_child
;
6021 fixup_partial_die (pdi
, cu
);
6022 if (pdi
->tag
== DW_TAG_subprogram
6023 || pdi
->tag
== DW_TAG_lexical_block
)
6024 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
6025 pdi
= pdi
->die_sibling
;
6030 /* Read a partial die corresponding to an enumeration type. */
6033 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
6034 struct dwarf2_cu
*cu
)
6036 struct partial_die_info
*pdi
;
6038 if (enum_pdi
->name
!= NULL
)
6039 add_partial_symbol (enum_pdi
, cu
);
6041 pdi
= enum_pdi
->die_child
;
6044 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
6045 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
6047 add_partial_symbol (pdi
, cu
);
6048 pdi
= pdi
->die_sibling
;
6052 /* Return the initial uleb128 in the die at INFO_PTR. */
6055 peek_abbrev_code (bfd
*abfd
, gdb_byte
*info_ptr
)
6057 unsigned int bytes_read
;
6059 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6062 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
6063 Return the corresponding abbrev, or NULL if the number is zero (indicating
6064 an empty DIE). In either case *BYTES_READ will be set to the length of
6065 the initial number. */
6067 static struct abbrev_info
*
6068 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
6069 struct dwarf2_cu
*cu
)
6071 bfd
*abfd
= cu
->objfile
->obfd
;
6072 unsigned int abbrev_number
;
6073 struct abbrev_info
*abbrev
;
6075 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
6077 if (abbrev_number
== 0)
6080 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
6083 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
6084 abbrev_number
, bfd_get_filename (abfd
));
6090 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
6091 Returns a pointer to the end of a series of DIEs, terminated by an empty
6092 DIE. Any children of the skipped DIEs will also be skipped. */
6095 skip_children (const struct die_reader_specs
*reader
, gdb_byte
*info_ptr
)
6097 struct dwarf2_cu
*cu
= reader
->cu
;
6098 struct abbrev_info
*abbrev
;
6099 unsigned int bytes_read
;
6103 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
6105 return info_ptr
+ bytes_read
;
6107 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
6111 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
6112 INFO_PTR should point just after the initial uleb128 of a DIE, and the
6113 abbrev corresponding to that skipped uleb128 should be passed in
6114 ABBREV. Returns a pointer to this DIE's sibling, skipping any
6118 skip_one_die (const struct die_reader_specs
*reader
, gdb_byte
*info_ptr
,
6119 struct abbrev_info
*abbrev
)
6121 unsigned int bytes_read
;
6122 struct attribute attr
;
6123 bfd
*abfd
= reader
->abfd
;
6124 struct dwarf2_cu
*cu
= reader
->cu
;
6125 gdb_byte
*buffer
= reader
->buffer
;
6126 const gdb_byte
*buffer_end
= reader
->buffer_end
;
6127 gdb_byte
*start_info_ptr
= info_ptr
;
6128 unsigned int form
, i
;
6130 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
6132 /* The only abbrev we care about is DW_AT_sibling. */
6133 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
6135 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
6136 if (attr
.form
== DW_FORM_ref_addr
)
6137 complaint (&symfile_complaints
,
6138 _("ignoring absolute DW_AT_sibling"));
6140 return buffer
+ dwarf2_get_ref_die_offset (&attr
).sect_off
;
6143 /* If it isn't DW_AT_sibling, skip this attribute. */
6144 form
= abbrev
->attrs
[i
].form
;
6148 case DW_FORM_ref_addr
:
6149 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
6150 and later it is offset sized. */
6151 if (cu
->header
.version
== 2)
6152 info_ptr
+= cu
->header
.addr_size
;
6154 info_ptr
+= cu
->header
.offset_size
;
6156 case DW_FORM_GNU_ref_alt
:
6157 info_ptr
+= cu
->header
.offset_size
;
6160 info_ptr
+= cu
->header
.addr_size
;
6167 case DW_FORM_flag_present
:
6179 case DW_FORM_ref_sig8
:
6182 case DW_FORM_string
:
6183 read_direct_string (abfd
, info_ptr
, &bytes_read
);
6184 info_ptr
+= bytes_read
;
6186 case DW_FORM_sec_offset
:
6188 case DW_FORM_GNU_strp_alt
:
6189 info_ptr
+= cu
->header
.offset_size
;
6191 case DW_FORM_exprloc
:
6193 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6194 info_ptr
+= bytes_read
;
6196 case DW_FORM_block1
:
6197 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
6199 case DW_FORM_block2
:
6200 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
6202 case DW_FORM_block4
:
6203 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
6207 case DW_FORM_ref_udata
:
6208 case DW_FORM_GNU_addr_index
:
6209 case DW_FORM_GNU_str_index
:
6210 info_ptr
= (gdb_byte
*) safe_skip_leb128 (info_ptr
, buffer_end
);
6212 case DW_FORM_indirect
:
6213 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6214 info_ptr
+= bytes_read
;
6215 /* We need to continue parsing from here, so just go back to
6217 goto skip_attribute
;
6220 error (_("Dwarf Error: Cannot handle %s "
6221 "in DWARF reader [in module %s]"),
6222 dwarf_form_name (form
),
6223 bfd_get_filename (abfd
));
6227 if (abbrev
->has_children
)
6228 return skip_children (reader
, info_ptr
);
6233 /* Locate ORIG_PDI's sibling.
6234 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
6237 locate_pdi_sibling (const struct die_reader_specs
*reader
,
6238 struct partial_die_info
*orig_pdi
,
6241 /* Do we know the sibling already? */
6243 if (orig_pdi
->sibling
)
6244 return orig_pdi
->sibling
;
6246 /* Are there any children to deal with? */
6248 if (!orig_pdi
->has_children
)
6251 /* Skip the children the long way. */
6253 return skip_children (reader
, info_ptr
);
6256 /* Expand this partial symbol table into a full symbol table. */
6259 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
6265 warning (_("bug: psymtab for %s is already read in."),
6272 printf_filtered (_("Reading in symbols for %s..."),
6274 gdb_flush (gdb_stdout
);
6277 /* Restore our global data. */
6278 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
6279 dwarf2_objfile_data_key
);
6281 /* If this psymtab is constructed from a debug-only objfile, the
6282 has_section_at_zero flag will not necessarily be correct. We
6283 can get the correct value for this flag by looking at the data
6284 associated with the (presumably stripped) associated objfile. */
6285 if (pst
->objfile
->separate_debug_objfile_backlink
)
6287 struct dwarf2_per_objfile
*dpo_backlink
6288 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
6289 dwarf2_objfile_data_key
);
6291 dwarf2_per_objfile
->has_section_at_zero
6292 = dpo_backlink
->has_section_at_zero
;
6295 dwarf2_per_objfile
->reading_partial_symbols
= 0;
6297 psymtab_to_symtab_1 (pst
);
6299 /* Finish up the debug error message. */
6301 printf_filtered (_("done.\n"));
6305 process_cu_includes ();
6308 /* Reading in full CUs. */
6310 /* Add PER_CU to the queue. */
6313 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
6314 enum language pretend_language
)
6316 struct dwarf2_queue_item
*item
;
6319 item
= xmalloc (sizeof (*item
));
6320 item
->per_cu
= per_cu
;
6321 item
->pretend_language
= pretend_language
;
6324 if (dwarf2_queue
== NULL
)
6325 dwarf2_queue
= item
;
6327 dwarf2_queue_tail
->next
= item
;
6329 dwarf2_queue_tail
= item
;
6332 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
6333 unit and add it to our queue.
6334 The result is non-zero if PER_CU was queued, otherwise the result is zero
6335 meaning either PER_CU is already queued or it is already loaded. */
6338 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
6339 struct dwarf2_per_cu_data
*per_cu
,
6340 enum language pretend_language
)
6342 /* We may arrive here during partial symbol reading, if we need full
6343 DIEs to process an unusual case (e.g. template arguments). Do
6344 not queue PER_CU, just tell our caller to load its DIEs. */
6345 if (dwarf2_per_objfile
->reading_partial_symbols
)
6347 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
6352 /* Mark the dependence relation so that we don't flush PER_CU
6354 dwarf2_add_dependence (this_cu
, per_cu
);
6356 /* If it's already on the queue, we have nothing to do. */
6360 /* If the compilation unit is already loaded, just mark it as
6362 if (per_cu
->cu
!= NULL
)
6364 per_cu
->cu
->last_used
= 0;
6368 /* Add it to the queue. */
6369 queue_comp_unit (per_cu
, pretend_language
);
6374 /* Process the queue. */
6377 process_queue (void)
6379 struct dwarf2_queue_item
*item
, *next_item
;
6381 if (dwarf2_read_debug
)
6383 fprintf_unfiltered (gdb_stdlog
,
6384 "Expanding one or more symtabs of objfile %s ...\n",
6385 dwarf2_per_objfile
->objfile
->name
);
6388 /* The queue starts out with one item, but following a DIE reference
6389 may load a new CU, adding it to the end of the queue. */
6390 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
6392 if (dwarf2_per_objfile
->using_index
6393 ? !item
->per_cu
->v
.quick
->symtab
6394 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
6396 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
6398 if (dwarf2_read_debug
)
6400 fprintf_unfiltered (gdb_stdlog
,
6401 "Expanding symtab of %s at offset 0x%x\n",
6402 per_cu
->is_debug_types
? "TU" : "CU",
6403 per_cu
->offset
.sect_off
);
6406 if (per_cu
->is_debug_types
)
6407 process_full_type_unit (per_cu
, item
->pretend_language
);
6409 process_full_comp_unit (per_cu
, item
->pretend_language
);
6411 if (dwarf2_read_debug
)
6413 fprintf_unfiltered (gdb_stdlog
,
6414 "Done expanding %s at offset 0x%x\n",
6415 per_cu
->is_debug_types
? "TU" : "CU",
6416 per_cu
->offset
.sect_off
);
6420 item
->per_cu
->queued
= 0;
6421 next_item
= item
->next
;
6425 dwarf2_queue_tail
= NULL
;
6427 if (dwarf2_read_debug
)
6429 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
6430 dwarf2_per_objfile
->objfile
->name
);
6434 /* Free all allocated queue entries. This function only releases anything if
6435 an error was thrown; if the queue was processed then it would have been
6436 freed as we went along. */
6439 dwarf2_release_queue (void *dummy
)
6441 struct dwarf2_queue_item
*item
, *last
;
6443 item
= dwarf2_queue
;
6446 /* Anything still marked queued is likely to be in an
6447 inconsistent state, so discard it. */
6448 if (item
->per_cu
->queued
)
6450 if (item
->per_cu
->cu
!= NULL
)
6451 free_one_cached_comp_unit (item
->per_cu
);
6452 item
->per_cu
->queued
= 0;
6460 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
6463 /* Read in full symbols for PST, and anything it depends on. */
6466 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
6468 struct dwarf2_per_cu_data
*per_cu
;
6474 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
6475 if (!pst
->dependencies
[i
]->readin
6476 && pst
->dependencies
[i
]->user
== NULL
)
6478 /* Inform about additional files that need to be read in. */
6481 /* FIXME: i18n: Need to make this a single string. */
6482 fputs_filtered (" ", gdb_stdout
);
6484 fputs_filtered ("and ", gdb_stdout
);
6486 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
6487 wrap_here (""); /* Flush output. */
6488 gdb_flush (gdb_stdout
);
6490 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
6493 per_cu
= pst
->read_symtab_private
;
6497 /* It's an include file, no symbols to read for it.
6498 Everything is in the parent symtab. */
6503 dw2_do_instantiate_symtab (per_cu
);
6506 /* Trivial hash function for die_info: the hash value of a DIE
6507 is its offset in .debug_info for this objfile. */
6510 die_hash (const void *item
)
6512 const struct die_info
*die
= item
;
6514 return die
->offset
.sect_off
;
6517 /* Trivial comparison function for die_info structures: two DIEs
6518 are equal if they have the same offset. */
6521 die_eq (const void *item_lhs
, const void *item_rhs
)
6523 const struct die_info
*die_lhs
= item_lhs
;
6524 const struct die_info
*die_rhs
= item_rhs
;
6526 return die_lhs
->offset
.sect_off
== die_rhs
->offset
.sect_off
;
6529 /* die_reader_func for load_full_comp_unit.
6530 This is identical to read_signatured_type_reader,
6531 but is kept separate for now. */
6534 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
6536 struct die_info
*comp_unit_die
,
6540 struct dwarf2_cu
*cu
= reader
->cu
;
6541 enum language
*language_ptr
= data
;
6543 gdb_assert (cu
->die_hash
== NULL
);
6545 htab_create_alloc_ex (cu
->header
.length
/ 12,
6549 &cu
->comp_unit_obstack
,
6550 hashtab_obstack_allocate
,
6551 dummy_obstack_deallocate
);
6554 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
6555 &info_ptr
, comp_unit_die
);
6556 cu
->dies
= comp_unit_die
;
6557 /* comp_unit_die is not stored in die_hash, no need. */
6559 /* We try not to read any attributes in this function, because not
6560 all CUs needed for references have been loaded yet, and symbol
6561 table processing isn't initialized. But we have to set the CU language,
6562 or we won't be able to build types correctly.
6563 Similarly, if we do not read the producer, we can not apply
6564 producer-specific interpretation. */
6565 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
6568 /* Load the DIEs associated with PER_CU into memory. */
6571 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
6572 enum language pretend_language
)
6574 gdb_assert (! this_cu
->is_debug_types
);
6576 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
6577 load_full_comp_unit_reader
, &pretend_language
);
6580 /* Add a DIE to the delayed physname list. */
6583 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
6584 const char *name
, struct die_info
*die
,
6585 struct dwarf2_cu
*cu
)
6587 struct delayed_method_info mi
;
6589 mi
.fnfield_index
= fnfield_index
;
6593 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
6596 /* A cleanup for freeing the delayed method list. */
6599 free_delayed_list (void *ptr
)
6601 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
6602 if (cu
->method_list
!= NULL
)
6604 VEC_free (delayed_method_info
, cu
->method_list
);
6605 cu
->method_list
= NULL
;
6609 /* Compute the physnames of any methods on the CU's method list.
6611 The computation of method physnames is delayed in order to avoid the
6612 (bad) condition that one of the method's formal parameters is of an as yet
6616 compute_delayed_physnames (struct dwarf2_cu
*cu
)
6619 struct delayed_method_info
*mi
;
6620 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
6622 const char *physname
;
6623 struct fn_fieldlist
*fn_flp
6624 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
6625 physname
= dwarf2_physname ((char *) mi
->name
, mi
->die
, cu
);
6626 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
6630 /* Go objects should be embedded in a DW_TAG_module DIE,
6631 and it's not clear if/how imported objects will appear.
6632 To keep Go support simple until that's worked out,
6633 go back through what we've read and create something usable.
6634 We could do this while processing each DIE, and feels kinda cleaner,
6635 but that way is more invasive.
6636 This is to, for example, allow the user to type "p var" or "b main"
6637 without having to specify the package name, and allow lookups
6638 of module.object to work in contexts that use the expression
6642 fixup_go_packaging (struct dwarf2_cu
*cu
)
6644 char *package_name
= NULL
;
6645 struct pending
*list
;
6648 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
6650 for (i
= 0; i
< list
->nsyms
; ++i
)
6652 struct symbol
*sym
= list
->symbol
[i
];
6654 if (SYMBOL_LANGUAGE (sym
) == language_go
6655 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
6657 char *this_package_name
= go_symbol_package_name (sym
);
6659 if (this_package_name
== NULL
)
6661 if (package_name
== NULL
)
6662 package_name
= this_package_name
;
6665 if (strcmp (package_name
, this_package_name
) != 0)
6666 complaint (&symfile_complaints
,
6667 _("Symtab %s has objects from two different Go packages: %s and %s"),
6668 (sym
->symtab
&& sym
->symtab
->filename
6669 ? sym
->symtab
->filename
6670 : cu
->objfile
->name
),
6671 this_package_name
, package_name
);
6672 xfree (this_package_name
);
6678 if (package_name
!= NULL
)
6680 struct objfile
*objfile
= cu
->objfile
;
6681 struct type
*type
= init_type (TYPE_CODE_MODULE
, 0, 0,
6682 package_name
, objfile
);
6685 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
6687 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
6688 SYMBOL_SET_LANGUAGE (sym
, language_go
);
6689 SYMBOL_SET_NAMES (sym
, package_name
, strlen (package_name
), 1, objfile
);
6690 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
6691 e.g., "main" finds the "main" module and not C's main(). */
6692 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6693 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6694 SYMBOL_TYPE (sym
) = type
;
6696 add_symbol_to_list (sym
, &global_symbols
);
6698 xfree (package_name
);
6702 static void compute_symtab_includes (struct dwarf2_per_cu_data
*per_cu
);
6704 /* Return the symtab for PER_CU. This works properly regardless of
6705 whether we're using the index or psymtabs. */
6707 static struct symtab
*
6708 get_symtab (struct dwarf2_per_cu_data
*per_cu
)
6710 return (dwarf2_per_objfile
->using_index
6711 ? per_cu
->v
.quick
->symtab
6712 : per_cu
->v
.psymtab
->symtab
);
6715 /* A helper function for computing the list of all symbol tables
6716 included by PER_CU. */
6719 recursively_compute_inclusions (VEC (dwarf2_per_cu_ptr
) **result
,
6720 htab_t all_children
,
6721 struct dwarf2_per_cu_data
*per_cu
)
6725 struct dwarf2_per_cu_data
*iter
;
6727 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
6730 /* This inclusion and its children have been processed. */
6735 /* Only add a CU if it has a symbol table. */
6736 if (get_symtab (per_cu
) != NULL
)
6737 VEC_safe_push (dwarf2_per_cu_ptr
, *result
, per_cu
);
6740 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->s
.imported_symtabs
, ix
, iter
);
6742 recursively_compute_inclusions (result
, all_children
, iter
);
6745 /* Compute the symtab 'includes' fields for the symtab related to
6749 compute_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
6751 gdb_assert (! per_cu
->is_debug_types
);
6753 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->s
.imported_symtabs
))
6756 struct dwarf2_per_cu_data
*iter
;
6757 VEC (dwarf2_per_cu_ptr
) *result_children
= NULL
;
6758 htab_t all_children
;
6759 struct symtab
*symtab
= get_symtab (per_cu
);
6761 /* If we don't have a symtab, we can just skip this case. */
6765 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
6766 NULL
, xcalloc
, xfree
);
6769 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->s
.imported_symtabs
,
6772 recursively_compute_inclusions (&result_children
, all_children
, iter
);
6774 /* Now we have a transitive closure of all the included CUs, so
6775 we can convert it to a list of symtabs. */
6776 len
= VEC_length (dwarf2_per_cu_ptr
, result_children
);
6778 = obstack_alloc (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
6779 (len
+ 1) * sizeof (struct symtab
*));
6781 VEC_iterate (dwarf2_per_cu_ptr
, result_children
, ix
, iter
);
6783 symtab
->includes
[ix
] = get_symtab (iter
);
6784 symtab
->includes
[len
] = NULL
;
6786 VEC_free (dwarf2_per_cu_ptr
, result_children
);
6787 htab_delete (all_children
);
6791 /* Compute the 'includes' field for the symtabs of all the CUs we just
6795 process_cu_includes (void)
6798 struct dwarf2_per_cu_data
*iter
;
6801 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
6805 if (! iter
->is_debug_types
)
6806 compute_symtab_includes (iter
);
6809 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
6812 /* Generate full symbol information for PER_CU, whose DIEs have
6813 already been loaded into memory. */
6816 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
6817 enum language pretend_language
)
6819 struct dwarf2_cu
*cu
= per_cu
->cu
;
6820 struct objfile
*objfile
= per_cu
->objfile
;
6821 CORE_ADDR lowpc
, highpc
;
6822 struct symtab
*symtab
;
6823 struct cleanup
*back_to
, *delayed_list_cleanup
;
6825 struct block
*static_block
;
6827 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6830 back_to
= make_cleanup (really_free_pendings
, NULL
);
6831 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
6833 cu
->list_in_scope
= &file_symbols
;
6835 cu
->language
= pretend_language
;
6836 cu
->language_defn
= language_def (cu
->language
);
6838 /* Do line number decoding in read_file_scope () */
6839 process_die (cu
->dies
, cu
);
6841 /* For now fudge the Go package. */
6842 if (cu
->language
== language_go
)
6843 fixup_go_packaging (cu
);
6845 /* Now that we have processed all the DIEs in the CU, all the types
6846 should be complete, and it should now be safe to compute all of the
6848 compute_delayed_physnames (cu
);
6849 do_cleanups (delayed_list_cleanup
);
6851 /* Some compilers don't define a DW_AT_high_pc attribute for the
6852 compilation unit. If the DW_AT_high_pc is missing, synthesize
6853 it, by scanning the DIE's below the compilation unit. */
6854 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
6857 = end_symtab_get_static_block (highpc
+ baseaddr
, objfile
, 0,
6858 per_cu
->s
.imported_symtabs
!= NULL
);
6860 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
6861 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
6862 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
6863 addrmap to help ensure it has an accurate map of pc values belonging to
6865 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
6867 symtab
= end_symtab_from_static_block (static_block
, objfile
,
6868 SECT_OFF_TEXT (objfile
), 0);
6872 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
6874 /* Set symtab language to language from DW_AT_language. If the
6875 compilation is from a C file generated by language preprocessors, do
6876 not set the language if it was already deduced by start_subfile. */
6877 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
6878 symtab
->language
= cu
->language
;
6880 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
6881 produce DW_AT_location with location lists but it can be possibly
6882 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
6883 there were bugs in prologue debug info, fixed later in GCC-4.5
6884 by "unwind info for epilogues" patch (which is not directly related).
6886 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
6887 needed, it would be wrong due to missing DW_AT_producer there.
6889 Still one can confuse GDB by using non-standard GCC compilation
6890 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
6892 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
6893 symtab
->locations_valid
= 1;
6895 if (gcc_4_minor
>= 5)
6896 symtab
->epilogue_unwind_valid
= 1;
6898 symtab
->call_site_htab
= cu
->call_site_htab
;
6901 if (dwarf2_per_objfile
->using_index
)
6902 per_cu
->v
.quick
->symtab
= symtab
;
6905 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6906 pst
->symtab
= symtab
;
6910 /* Push it for inclusion processing later. */
6911 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
6913 do_cleanups (back_to
);
6916 /* Generate full symbol information for type unit PER_CU, whose DIEs have
6917 already been loaded into memory. */
6920 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
6921 enum language pretend_language
)
6923 struct dwarf2_cu
*cu
= per_cu
->cu
;
6924 struct objfile
*objfile
= per_cu
->objfile
;
6925 struct symtab
*symtab
;
6926 struct cleanup
*back_to
, *delayed_list_cleanup
;
6929 back_to
= make_cleanup (really_free_pendings
, NULL
);
6930 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
6932 cu
->list_in_scope
= &file_symbols
;
6934 cu
->language
= pretend_language
;
6935 cu
->language_defn
= language_def (cu
->language
);
6937 /* The symbol tables are set up in read_type_unit_scope. */
6938 process_die (cu
->dies
, cu
);
6940 /* For now fudge the Go package. */
6941 if (cu
->language
== language_go
)
6942 fixup_go_packaging (cu
);
6944 /* Now that we have processed all the DIEs in the CU, all the types
6945 should be complete, and it should now be safe to compute all of the
6947 compute_delayed_physnames (cu
);
6948 do_cleanups (delayed_list_cleanup
);
6950 /* TUs share symbol tables.
6951 If this is the first TU to use this symtab, complete the construction
6952 of it with end_expandable_symtab. Otherwise, complete the addition of
6953 this TU's symbols to the existing symtab. */
6954 if (per_cu
->s
.type_unit_group
->primary_symtab
== NULL
)
6956 symtab
= end_expandable_symtab (0, objfile
, SECT_OFF_TEXT (objfile
));
6957 per_cu
->s
.type_unit_group
->primary_symtab
= symtab
;
6961 /* Set symtab language to language from DW_AT_language. If the
6962 compilation is from a C file generated by language preprocessors,
6963 do not set the language if it was already deduced by
6965 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
6966 symtab
->language
= cu
->language
;
6971 augment_type_symtab (objfile
,
6972 per_cu
->s
.type_unit_group
->primary_symtab
);
6973 symtab
= per_cu
->s
.type_unit_group
->primary_symtab
;
6976 if (dwarf2_per_objfile
->using_index
)
6977 per_cu
->v
.quick
->symtab
= symtab
;
6980 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6981 pst
->symtab
= symtab
;
6985 do_cleanups (back_to
);
6988 /* Process an imported unit DIE. */
6991 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
6993 struct attribute
*attr
;
6995 /* For now we don't handle imported units in type units. */
6996 if (cu
->per_cu
->is_debug_types
)
6998 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6999 " supported in type units [in module %s]"),
7003 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
7006 struct dwarf2_per_cu_data
*per_cu
;
7007 struct symtab
*imported_symtab
;
7011 offset
= dwarf2_get_ref_die_offset (attr
);
7012 is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
7013 per_cu
= dwarf2_find_containing_comp_unit (offset
, is_dwz
, cu
->objfile
);
7015 /* Queue the unit, if needed. */
7016 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
7017 load_full_comp_unit (per_cu
, cu
->language
);
7019 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->s
.imported_symtabs
,
7024 /* Process a die and its children. */
7027 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7031 case DW_TAG_padding
:
7033 case DW_TAG_compile_unit
:
7034 case DW_TAG_partial_unit
:
7035 read_file_scope (die
, cu
);
7037 case DW_TAG_type_unit
:
7038 read_type_unit_scope (die
, cu
);
7040 case DW_TAG_subprogram
:
7041 case DW_TAG_inlined_subroutine
:
7042 read_func_scope (die
, cu
);
7044 case DW_TAG_lexical_block
:
7045 case DW_TAG_try_block
:
7046 case DW_TAG_catch_block
:
7047 read_lexical_block_scope (die
, cu
);
7049 case DW_TAG_GNU_call_site
:
7050 read_call_site_scope (die
, cu
);
7052 case DW_TAG_class_type
:
7053 case DW_TAG_interface_type
:
7054 case DW_TAG_structure_type
:
7055 case DW_TAG_union_type
:
7056 process_structure_scope (die
, cu
);
7058 case DW_TAG_enumeration_type
:
7059 process_enumeration_scope (die
, cu
);
7062 /* These dies have a type, but processing them does not create
7063 a symbol or recurse to process the children. Therefore we can
7064 read them on-demand through read_type_die. */
7065 case DW_TAG_subroutine_type
:
7066 case DW_TAG_set_type
:
7067 case DW_TAG_array_type
:
7068 case DW_TAG_pointer_type
:
7069 case DW_TAG_ptr_to_member_type
:
7070 case DW_TAG_reference_type
:
7071 case DW_TAG_string_type
:
7074 case DW_TAG_base_type
:
7075 case DW_TAG_subrange_type
:
7076 case DW_TAG_typedef
:
7077 /* Add a typedef symbol for the type definition, if it has a
7079 new_symbol (die
, read_type_die (die
, cu
), cu
);
7081 case DW_TAG_common_block
:
7082 read_common_block (die
, cu
);
7084 case DW_TAG_common_inclusion
:
7086 case DW_TAG_namespace
:
7087 processing_has_namespace_info
= 1;
7088 read_namespace (die
, cu
);
7091 processing_has_namespace_info
= 1;
7092 read_module (die
, cu
);
7094 case DW_TAG_imported_declaration
:
7095 case DW_TAG_imported_module
:
7096 processing_has_namespace_info
= 1;
7097 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
7098 || cu
->language
!= language_fortran
))
7099 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
7100 dwarf_tag_name (die
->tag
));
7101 read_import_statement (die
, cu
);
7104 case DW_TAG_imported_unit
:
7105 process_imported_unit_die (die
, cu
);
7109 new_symbol (die
, NULL
, cu
);
7114 /* A helper function for dwarf2_compute_name which determines whether DIE
7115 needs to have the name of the scope prepended to the name listed in the
7119 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
7121 struct attribute
*attr
;
7125 case DW_TAG_namespace
:
7126 case DW_TAG_typedef
:
7127 case DW_TAG_class_type
:
7128 case DW_TAG_interface_type
:
7129 case DW_TAG_structure_type
:
7130 case DW_TAG_union_type
:
7131 case DW_TAG_enumeration_type
:
7132 case DW_TAG_enumerator
:
7133 case DW_TAG_subprogram
:
7137 case DW_TAG_variable
:
7138 case DW_TAG_constant
:
7139 /* We only need to prefix "globally" visible variables. These include
7140 any variable marked with DW_AT_external or any variable that
7141 lives in a namespace. [Variables in anonymous namespaces
7142 require prefixing, but they are not DW_AT_external.] */
7144 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
7146 struct dwarf2_cu
*spec_cu
= cu
;
7148 return die_needs_namespace (die_specification (die
, &spec_cu
),
7152 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
7153 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
7154 && die
->parent
->tag
!= DW_TAG_module
)
7156 /* A variable in a lexical block of some kind does not need a
7157 namespace, even though in C++ such variables may be external
7158 and have a mangled name. */
7159 if (die
->parent
->tag
== DW_TAG_lexical_block
7160 || die
->parent
->tag
== DW_TAG_try_block
7161 || die
->parent
->tag
== DW_TAG_catch_block
7162 || die
->parent
->tag
== DW_TAG_subprogram
)
7171 /* Retrieve the last character from a mem_file. */
7174 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
7176 char *last_char_p
= (char *) object
;
7179 *last_char_p
= buffer
[length
- 1];
7182 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
7183 compute the physname for the object, which include a method's:
7184 - formal parameters (C++/Java),
7185 - receiver type (Go),
7186 - return type (Java).
7188 The term "physname" is a bit confusing.
7189 For C++, for example, it is the demangled name.
7190 For Go, for example, it's the mangled name.
7192 For Ada, return the DIE's linkage name rather than the fully qualified
7193 name. PHYSNAME is ignored..
7195 The result is allocated on the objfile_obstack and canonicalized. */
7198 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
7201 struct objfile
*objfile
= cu
->objfile
;
7204 name
= dwarf2_name (die
, cu
);
7206 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
7207 compute it by typename_concat inside GDB. */
7208 if (cu
->language
== language_ada
7209 || (cu
->language
== language_fortran
&& physname
))
7211 /* For Ada unit, we prefer the linkage name over the name, as
7212 the former contains the exported name, which the user expects
7213 to be able to reference. Ideally, we want the user to be able
7214 to reference this entity using either natural or linkage name,
7215 but we haven't started looking at this enhancement yet. */
7216 struct attribute
*attr
;
7218 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
7220 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7221 if (attr
&& DW_STRING (attr
))
7222 return DW_STRING (attr
);
7225 /* These are the only languages we know how to qualify names in. */
7227 && (cu
->language
== language_cplus
|| cu
->language
== language_java
7228 || cu
->language
== language_fortran
))
7230 if (die_needs_namespace (die
, cu
))
7234 struct ui_file
*buf
;
7236 prefix
= determine_prefix (die
, cu
);
7237 buf
= mem_fileopen ();
7238 if (*prefix
!= '\0')
7240 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
7243 fputs_unfiltered (prefixed_name
, buf
);
7244 xfree (prefixed_name
);
7247 fputs_unfiltered (name
, buf
);
7249 /* Template parameters may be specified in the DIE's DW_AT_name, or
7250 as children with DW_TAG_template_type_param or
7251 DW_TAG_value_type_param. If the latter, add them to the name
7252 here. If the name already has template parameters, then
7253 skip this step; some versions of GCC emit both, and
7254 it is more efficient to use the pre-computed name.
7256 Something to keep in mind about this process: it is very
7257 unlikely, or in some cases downright impossible, to produce
7258 something that will match the mangled name of a function.
7259 If the definition of the function has the same debug info,
7260 we should be able to match up with it anyway. But fallbacks
7261 using the minimal symbol, for instance to find a method
7262 implemented in a stripped copy of libstdc++, will not work.
7263 If we do not have debug info for the definition, we will have to
7264 match them up some other way.
7266 When we do name matching there is a related problem with function
7267 templates; two instantiated function templates are allowed to
7268 differ only by their return types, which we do not add here. */
7270 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
7272 struct attribute
*attr
;
7273 struct die_info
*child
;
7276 die
->building_fullname
= 1;
7278 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
7283 struct dwarf2_locexpr_baton
*baton
;
7286 if (child
->tag
!= DW_TAG_template_type_param
7287 && child
->tag
!= DW_TAG_template_value_param
)
7292 fputs_unfiltered ("<", buf
);
7296 fputs_unfiltered (", ", buf
);
7298 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
7301 complaint (&symfile_complaints
,
7302 _("template parameter missing DW_AT_type"));
7303 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
7306 type
= die_type (child
, cu
);
7308 if (child
->tag
== DW_TAG_template_type_param
)
7310 c_print_type (type
, "", buf
, -1, 0);
7314 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
7317 complaint (&symfile_complaints
,
7318 _("template parameter missing "
7319 "DW_AT_const_value"));
7320 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
7324 dwarf2_const_value_attr (attr
, type
, name
,
7325 &cu
->comp_unit_obstack
, cu
,
7326 &value
, &bytes
, &baton
);
7328 if (TYPE_NOSIGN (type
))
7329 /* GDB prints characters as NUMBER 'CHAR'. If that's
7330 changed, this can use value_print instead. */
7331 c_printchar (value
, type
, buf
);
7334 struct value_print_options opts
;
7337 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
7341 else if (bytes
!= NULL
)
7343 v
= allocate_value (type
);
7344 memcpy (value_contents_writeable (v
), bytes
,
7345 TYPE_LENGTH (type
));
7348 v
= value_from_longest (type
, value
);
7350 /* Specify decimal so that we do not depend on
7352 get_formatted_print_options (&opts
, 'd');
7354 value_print (v
, buf
, &opts
);
7360 die
->building_fullname
= 0;
7364 /* Close the argument list, with a space if necessary
7365 (nested templates). */
7366 char last_char
= '\0';
7367 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
7368 if (last_char
== '>')
7369 fputs_unfiltered (" >", buf
);
7371 fputs_unfiltered (">", buf
);
7375 /* For Java and C++ methods, append formal parameter type
7376 information, if PHYSNAME. */
7378 if (physname
&& die
->tag
== DW_TAG_subprogram
7379 && (cu
->language
== language_cplus
7380 || cu
->language
== language_java
))
7382 struct type
*type
= read_type_die (die
, cu
);
7384 c_type_print_args (type
, buf
, 1, cu
->language
);
7386 if (cu
->language
== language_java
)
7388 /* For java, we must append the return type to method
7390 if (die
->tag
== DW_TAG_subprogram
)
7391 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
7394 else if (cu
->language
== language_cplus
)
7396 /* Assume that an artificial first parameter is
7397 "this", but do not crash if it is not. RealView
7398 marks unnamed (and thus unused) parameters as
7399 artificial; there is no way to differentiate
7401 if (TYPE_NFIELDS (type
) > 0
7402 && TYPE_FIELD_ARTIFICIAL (type
, 0)
7403 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
7404 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
7406 fputs_unfiltered (" const", buf
);
7410 name
= ui_file_obsavestring (buf
, &objfile
->objfile_obstack
,
7412 ui_file_delete (buf
);
7414 if (cu
->language
== language_cplus
)
7417 = dwarf2_canonicalize_name (name
, cu
,
7418 &objfile
->objfile_obstack
);
7429 /* Return the fully qualified name of DIE, based on its DW_AT_name.
7430 If scope qualifiers are appropriate they will be added. The result
7431 will be allocated on the objfile_obstack, or NULL if the DIE does
7432 not have a name. NAME may either be from a previous call to
7433 dwarf2_name or NULL.
7435 The output string will be canonicalized (if C++/Java). */
7438 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
7440 return dwarf2_compute_name (name
, die
, cu
, 0);
7443 /* Construct a physname for the given DIE in CU. NAME may either be
7444 from a previous call to dwarf2_name or NULL. The result will be
7445 allocated on the objfile_objstack or NULL if the DIE does not have a
7448 The output string will be canonicalized (if C++/Java). */
7451 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
7453 struct objfile
*objfile
= cu
->objfile
;
7454 struct attribute
*attr
;
7455 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
7456 struct cleanup
*back_to
;
7459 /* In this case dwarf2_compute_name is just a shortcut not building anything
7461 if (!die_needs_namespace (die
, cu
))
7462 return dwarf2_compute_name (name
, die
, cu
, 1);
7464 back_to
= make_cleanup (null_cleanup
, NULL
);
7466 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
7468 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7470 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
7472 if (attr
&& DW_STRING (attr
))
7476 mangled
= DW_STRING (attr
);
7478 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
7479 type. It is easier for GDB users to search for such functions as
7480 `name(params)' than `long name(params)'. In such case the minimal
7481 symbol names do not match the full symbol names but for template
7482 functions there is never a need to look up their definition from their
7483 declaration so the only disadvantage remains the minimal symbol
7484 variant `long name(params)' does not have the proper inferior type.
7487 if (cu
->language
== language_go
)
7489 /* This is a lie, but we already lie to the caller new_symbol_full.
7490 new_symbol_full assumes we return the mangled name.
7491 This just undoes that lie until things are cleaned up. */
7496 demangled
= cplus_demangle (mangled
,
7497 (DMGL_PARAMS
| DMGL_ANSI
7498 | (cu
->language
== language_java
7499 ? DMGL_JAVA
| DMGL_RET_POSTFIX
7504 make_cleanup (xfree
, demangled
);
7514 if (canon
== NULL
|| check_physname
)
7516 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
7518 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
7520 /* It may not mean a bug in GDB. The compiler could also
7521 compute DW_AT_linkage_name incorrectly. But in such case
7522 GDB would need to be bug-to-bug compatible. */
7524 complaint (&symfile_complaints
,
7525 _("Computed physname <%s> does not match demangled <%s> "
7526 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
7527 physname
, canon
, mangled
, die
->offset
.sect_off
, objfile
->name
);
7529 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
7530 is available here - over computed PHYSNAME. It is safer
7531 against both buggy GDB and buggy compilers. */
7545 retval
= obsavestring (retval
, strlen (retval
),
7546 &objfile
->objfile_obstack
);
7548 do_cleanups (back_to
);
7552 /* Read the import statement specified by the given die and record it. */
7555 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
7557 struct objfile
*objfile
= cu
->objfile
;
7558 struct attribute
*import_attr
;
7559 struct die_info
*imported_die
, *child_die
;
7560 struct dwarf2_cu
*imported_cu
;
7561 const char *imported_name
;
7562 const char *imported_name_prefix
;
7563 const char *canonical_name
;
7564 const char *import_alias
;
7565 const char *imported_declaration
= NULL
;
7566 const char *import_prefix
;
7567 VEC (const_char_ptr
) *excludes
= NULL
;
7568 struct cleanup
*cleanups
;
7572 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
7573 if (import_attr
== NULL
)
7575 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
7576 dwarf_tag_name (die
->tag
));
7581 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
7582 imported_name
= dwarf2_name (imported_die
, imported_cu
);
7583 if (imported_name
== NULL
)
7585 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
7587 The import in the following code:
7601 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
7602 <52> DW_AT_decl_file : 1
7603 <53> DW_AT_decl_line : 6
7604 <54> DW_AT_import : <0x75>
7605 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
7607 <5b> DW_AT_decl_file : 1
7608 <5c> DW_AT_decl_line : 2
7609 <5d> DW_AT_type : <0x6e>
7611 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
7612 <76> DW_AT_byte_size : 4
7613 <77> DW_AT_encoding : 5 (signed)
7615 imports the wrong die ( 0x75 instead of 0x58 ).
7616 This case will be ignored until the gcc bug is fixed. */
7620 /* Figure out the local name after import. */
7621 import_alias
= dwarf2_name (die
, cu
);
7623 /* Figure out where the statement is being imported to. */
7624 import_prefix
= determine_prefix (die
, cu
);
7626 /* Figure out what the scope of the imported die is and prepend it
7627 to the name of the imported die. */
7628 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
7630 if (imported_die
->tag
!= DW_TAG_namespace
7631 && imported_die
->tag
!= DW_TAG_module
)
7633 imported_declaration
= imported_name
;
7634 canonical_name
= imported_name_prefix
;
7636 else if (strlen (imported_name_prefix
) > 0)
7638 temp
= alloca (strlen (imported_name_prefix
)
7639 + 2 + strlen (imported_name
) + 1);
7640 strcpy (temp
, imported_name_prefix
);
7641 strcat (temp
, "::");
7642 strcat (temp
, imported_name
);
7643 canonical_name
= temp
;
7646 canonical_name
= imported_name
;
7648 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
7650 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
7651 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
7652 child_die
= sibling_die (child_die
))
7654 /* DWARF-4: A Fortran use statement with a “rename list” may be
7655 represented by an imported module entry with an import attribute
7656 referring to the module and owned entries corresponding to those
7657 entities that are renamed as part of being imported. */
7659 if (child_die
->tag
!= DW_TAG_imported_declaration
)
7661 complaint (&symfile_complaints
,
7662 _("child DW_TAG_imported_declaration expected "
7663 "- DIE at 0x%x [in module %s]"),
7664 child_die
->offset
.sect_off
, objfile
->name
);
7668 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
7669 if (import_attr
== NULL
)
7671 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
7672 dwarf_tag_name (child_die
->tag
));
7677 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
7679 imported_name
= dwarf2_name (imported_die
, imported_cu
);
7680 if (imported_name
== NULL
)
7682 complaint (&symfile_complaints
,
7683 _("child DW_TAG_imported_declaration has unknown "
7684 "imported name - DIE at 0x%x [in module %s]"),
7685 child_die
->offset
.sect_off
, objfile
->name
);
7689 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
7691 process_die (child_die
, cu
);
7694 cp_add_using_directive (import_prefix
,
7697 imported_declaration
,
7699 &objfile
->objfile_obstack
);
7701 do_cleanups (cleanups
);
7704 /* Cleanup function for handle_DW_AT_stmt_list. */
7707 free_cu_line_header (void *arg
)
7709 struct dwarf2_cu
*cu
= arg
;
7711 free_line_header (cu
->line_header
);
7712 cu
->line_header
= NULL
;
7716 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
7717 char **name
, char **comp_dir
)
7719 struct attribute
*attr
;
7724 /* Find the filename. Do not use dwarf2_name here, since the filename
7725 is not a source language identifier. */
7726 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7729 *name
= DW_STRING (attr
);
7732 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
7734 *comp_dir
= DW_STRING (attr
);
7735 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
7737 *comp_dir
= ldirname (*name
);
7738 if (*comp_dir
!= NULL
)
7739 make_cleanup (xfree
, *comp_dir
);
7741 if (*comp_dir
!= NULL
)
7743 /* Irix 6.2 native cc prepends <machine>.: to the compilation
7744 directory, get rid of it. */
7745 char *cp
= strchr (*comp_dir
, ':');
7747 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
7752 *name
= "<unknown>";
7755 /* Handle DW_AT_stmt_list for a compilation unit.
7756 DIE is the DW_TAG_compile_unit die for CU.
7757 COMP_DIR is the compilation directory.
7758 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
7761 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
7762 const char *comp_dir
)
7764 struct attribute
*attr
;
7766 gdb_assert (! cu
->per_cu
->is_debug_types
);
7768 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
7771 unsigned int line_offset
= DW_UNSND (attr
);
7772 struct line_header
*line_header
7773 = dwarf_decode_line_header (line_offset
, cu
);
7777 cu
->line_header
= line_header
;
7778 make_cleanup (free_cu_line_header
, cu
);
7779 dwarf_decode_lines (line_header
, comp_dir
, cu
, NULL
, 1);
7784 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
7787 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7789 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7790 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
7791 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
7792 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
7793 struct attribute
*attr
;
7795 char *comp_dir
= NULL
;
7796 struct die_info
*child_die
;
7797 bfd
*abfd
= objfile
->obfd
;
7800 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7802 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
7804 /* If we didn't find a lowpc, set it to highpc to avoid complaints
7805 from finish_block. */
7806 if (lowpc
== ((CORE_ADDR
) -1))
7811 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
7813 prepare_one_comp_unit (cu
, die
, cu
->language
);
7815 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
7816 standardised yet. As a workaround for the language detection we fall
7817 back to the DW_AT_producer string. */
7818 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
7819 cu
->language
= language_opencl
;
7821 /* Similar hack for Go. */
7822 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
7823 set_cu_language (DW_LANG_Go
, cu
);
7825 dwarf2_start_symtab (cu
, name
, comp_dir
, lowpc
);
7827 /* Decode line number information if present. We do this before
7828 processing child DIEs, so that the line header table is available
7829 for DW_AT_decl_file. */
7830 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
7832 /* Process all dies in compilation unit. */
7833 if (die
->child
!= NULL
)
7835 child_die
= die
->child
;
7836 while (child_die
&& child_die
->tag
)
7838 process_die (child_die
, cu
);
7839 child_die
= sibling_die (child_die
);
7843 /* Decode macro information, if present. Dwarf 2 macro information
7844 refers to information in the line number info statement program
7845 header, so we can only read it if we've read the header
7847 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
7848 if (attr
&& cu
->line_header
)
7850 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
7851 complaint (&symfile_complaints
,
7852 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
7854 dwarf_decode_macros (cu
, DW_UNSND (attr
), comp_dir
, 1);
7858 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
7859 if (attr
&& cu
->line_header
)
7861 unsigned int macro_offset
= DW_UNSND (attr
);
7863 dwarf_decode_macros (cu
, macro_offset
, comp_dir
, 0);
7867 do_cleanups (back_to
);
7870 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
7871 Create the set of symtabs used by this TU, or if this TU is sharing
7872 symtabs with another TU and the symtabs have already been created
7873 then restore those symtabs in the line header.
7874 We don't need the pc/line-number mapping for type units. */
7877 setup_type_unit_groups (struct die_info
*die
, struct dwarf2_cu
*cu
)
7879 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7880 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7881 struct type_unit_group
*tu_group
;
7883 struct line_header
*lh
;
7884 struct attribute
*attr
;
7885 unsigned int i
, line_offset
;
7887 gdb_assert (per_cu
->is_debug_types
);
7889 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
7891 /* If we're using .gdb_index (includes -readnow) then
7892 per_cu->s.type_unit_group may not have been set up yet. */
7893 if (per_cu
->s
.type_unit_group
== NULL
)
7894 per_cu
->s
.type_unit_group
= get_type_unit_group (cu
, attr
);
7895 tu_group
= per_cu
->s
.type_unit_group
;
7897 /* If we've already processed this stmt_list there's no real need to
7898 do it again, we could fake it and just recreate the part we need
7899 (file name,index -> symtab mapping). If data shows this optimization
7900 is useful we can do it then. */
7901 first_time
= tu_group
->primary_symtab
== NULL
;
7903 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
7908 line_offset
= DW_UNSND (attr
);
7909 lh
= dwarf_decode_line_header (line_offset
, cu
);
7914 dwarf2_start_symtab (cu
, "", NULL
, 0);
7917 gdb_assert (tu_group
->symtabs
== NULL
);
7920 /* Note: The primary symtab will get allocated at the end. */
7924 cu
->line_header
= lh
;
7925 make_cleanup (free_cu_line_header
, cu
);
7929 dwarf2_start_symtab (cu
, "", NULL
, 0);
7931 tu_group
->num_symtabs
= lh
->num_file_names
;
7932 tu_group
->symtabs
= XNEWVEC (struct symtab
*, lh
->num_file_names
);
7934 for (i
= 0; i
< lh
->num_file_names
; ++i
)
7937 struct file_entry
*fe
= &lh
->file_names
[i
];
7940 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7941 dwarf2_start_subfile (fe
->name
, dir
, NULL
);
7943 /* Note: We don't have to watch for the main subfile here, type units
7944 don't have DW_AT_name. */
7946 if (current_subfile
->symtab
== NULL
)
7948 /* NOTE: start_subfile will recognize when it's been passed
7949 a file it has already seen. So we can't assume there's a
7950 simple mapping from lh->file_names to subfiles,
7951 lh->file_names may contain dups. */
7952 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
7956 fe
->symtab
= current_subfile
->symtab
;
7957 tu_group
->symtabs
[i
] = fe
->symtab
;
7964 for (i
= 0; i
< lh
->num_file_names
; ++i
)
7966 struct file_entry
*fe
= &lh
->file_names
[i
];
7968 fe
->symtab
= tu_group
->symtabs
[i
];
7972 /* The main symtab is allocated last. Type units don't have DW_AT_name
7973 so they don't have a "real" (so to speak) symtab anyway.
7974 There is later code that will assign the main symtab to all symbols
7975 that don't have one. We need to handle the case of a symbol with a
7976 missing symtab (DW_AT_decl_file) anyway. */
7979 /* Process DW_TAG_type_unit.
7980 For TUs we want to skip the first top level sibling if it's not the
7981 actual type being defined by this TU. In this case the first top
7982 level sibling is there to provide context only. */
7985 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7987 struct die_info
*child_die
;
7989 prepare_one_comp_unit (cu
, die
, language_minimal
);
7991 /* Initialize (or reinitialize) the machinery for building symtabs.
7992 We do this before processing child DIEs, so that the line header table
7993 is available for DW_AT_decl_file. */
7994 setup_type_unit_groups (die
, cu
);
7996 if (die
->child
!= NULL
)
7998 child_die
= die
->child
;
7999 while (child_die
&& child_die
->tag
)
8001 process_die (child_die
, cu
);
8002 child_die
= sibling_die (child_die
);
8010 hash_dwo_file (const void *item
)
8012 const struct dwo_file
*dwo_file
= item
;
8014 return htab_hash_string (dwo_file
->dwo_name
);
8018 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
8020 const struct dwo_file
*lhs
= item_lhs
;
8021 const struct dwo_file
*rhs
= item_rhs
;
8023 return strcmp (lhs
->dwo_name
, rhs
->dwo_name
) == 0;
8026 /* Allocate a hash table for DWO files. */
8029 allocate_dwo_file_hash_table (void)
8031 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8033 return htab_create_alloc_ex (41,
8037 &objfile
->objfile_obstack
,
8038 hashtab_obstack_allocate
,
8039 dummy_obstack_deallocate
);
8043 hash_dwo_unit (const void *item
)
8045 const struct dwo_unit
*dwo_unit
= item
;
8047 /* This drops the top 32 bits of the id, but is ok for a hash. */
8048 return dwo_unit
->signature
;
8052 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
8054 const struct dwo_unit
*lhs
= item_lhs
;
8055 const struct dwo_unit
*rhs
= item_rhs
;
8057 /* The signature is assumed to be unique within the DWO file.
8058 So while object file CU dwo_id's always have the value zero,
8059 that's OK, assuming each object file DWO file has only one CU,
8060 and that's the rule for now. */
8061 return lhs
->signature
== rhs
->signature
;
8064 /* Allocate a hash table for DWO CUs,TUs.
8065 There is one of these tables for each of CUs,TUs for each DWO file. */
8068 allocate_dwo_unit_table (struct objfile
*objfile
)
8070 /* Start out with a pretty small number.
8071 Generally DWO files contain only one CU and maybe some TUs. */
8072 return htab_create_alloc_ex (3,
8076 &objfile
->objfile_obstack
,
8077 hashtab_obstack_allocate
,
8078 dummy_obstack_deallocate
);
8081 /* This function is mapped across the sections and remembers the offset and
8082 size of each of the DWO debugging sections we are interested in. */
8085 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_file_ptr
)
8087 struct dwo_file
*dwo_file
= dwo_file_ptr
;
8088 const struct dwo_section_names
*names
= &dwo_section_names
;
8090 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
8092 dwo_file
->sections
.abbrev
.asection
= sectp
;
8093 dwo_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
8095 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
8097 dwo_file
->sections
.info
.asection
= sectp
;
8098 dwo_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
8100 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
8102 dwo_file
->sections
.line
.asection
= sectp
;
8103 dwo_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
8105 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
8107 dwo_file
->sections
.loc
.asection
= sectp
;
8108 dwo_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
8110 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
8112 dwo_file
->sections
.macinfo
.asection
= sectp
;
8113 dwo_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
8115 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
8117 dwo_file
->sections
.macro
.asection
= sectp
;
8118 dwo_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
8120 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
8122 dwo_file
->sections
.str
.asection
= sectp
;
8123 dwo_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
8125 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
8127 dwo_file
->sections
.str_offsets
.asection
= sectp
;
8128 dwo_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
8130 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
8132 struct dwarf2_section_info type_section
;
8134 memset (&type_section
, 0, sizeof (type_section
));
8135 type_section
.asection
= sectp
;
8136 type_section
.size
= bfd_get_section_size (sectp
);
8137 VEC_safe_push (dwarf2_section_info_def
, dwo_file
->sections
.types
,
8142 /* Structure used to pass data to create_debug_info_hash_table_reader. */
8144 struct create_dwo_info_table_data
8146 struct dwo_file
*dwo_file
;
8150 /* die_reader_func for create_debug_info_hash_table. */
8153 create_debug_info_hash_table_reader (const struct die_reader_specs
*reader
,
8155 struct die_info
*comp_unit_die
,
8159 struct dwarf2_cu
*cu
= reader
->cu
;
8160 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8161 sect_offset offset
= cu
->per_cu
->offset
;
8162 struct dwarf2_section_info
*section
= cu
->per_cu
->info_or_types_section
;
8163 struct create_dwo_info_table_data
*data
= datap
;
8164 struct dwo_file
*dwo_file
= data
->dwo_file
;
8165 htab_t cu_htab
= data
->cu_htab
;
8167 struct attribute
*attr
;
8168 struct dwo_unit
*dwo_unit
;
8170 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
8173 error (_("Dwarf Error: debug entry at offset 0x%x is missing"
8174 " its dwo_id [in module %s]"),
8175 offset
.sect_off
, dwo_file
->dwo_name
);
8179 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
8180 dwo_unit
->dwo_file
= dwo_file
;
8181 dwo_unit
->signature
= DW_UNSND (attr
);
8182 dwo_unit
->info_or_types_section
= section
;
8183 dwo_unit
->offset
= offset
;
8184 dwo_unit
->length
= cu
->per_cu
->length
;
8186 slot
= htab_find_slot (cu_htab
, dwo_unit
, INSERT
);
8187 gdb_assert (slot
!= NULL
);
8190 const struct dwo_unit
*dup_dwo_unit
= *slot
;
8192 complaint (&symfile_complaints
,
8193 _("debug entry at offset 0x%x is duplicate to the entry at"
8194 " offset 0x%x, dwo_id 0x%s [in module %s]"),
8195 offset
.sect_off
, dup_dwo_unit
->offset
.sect_off
,
8196 phex (dwo_unit
->signature
, sizeof (dwo_unit
->signature
)),
8197 dwo_file
->dwo_name
);
8202 if (dwarf2_read_debug
)
8203 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id 0x%s\n",
8205 phex (dwo_unit
->signature
,
8206 sizeof (dwo_unit
->signature
)));
8209 /* Create a hash table to map DWO IDs to their CU entry in .debug_info.dwo. */
8212 create_debug_info_hash_table (struct dwo_file
*dwo_file
)
8214 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8215 struct dwarf2_section_info
*section
= &dwo_file
->sections
.info
;
8218 gdb_byte
*info_ptr
, *end_ptr
;
8219 struct create_dwo_info_table_data create_dwo_info_table_data
;
8221 dwarf2_read_section (objfile
, section
);
8222 info_ptr
= section
->buffer
;
8224 if (info_ptr
== NULL
)
8227 /* We can't set abfd until now because the section may be empty or
8228 not present, in which case section->asection will be NULL. */
8229 abfd
= section
->asection
->owner
;
8231 if (dwarf2_read_debug
)
8232 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_info.dwo for %s:\n",
8233 bfd_get_filename (abfd
));
8235 cu_htab
= allocate_dwo_unit_table (objfile
);
8237 create_dwo_info_table_data
.dwo_file
= dwo_file
;
8238 create_dwo_info_table_data
.cu_htab
= cu_htab
;
8240 end_ptr
= info_ptr
+ section
->size
;
8241 while (info_ptr
< end_ptr
)
8243 struct dwarf2_per_cu_data per_cu
;
8245 memset (&per_cu
, 0, sizeof (per_cu
));
8246 per_cu
.objfile
= objfile
;
8247 per_cu
.is_debug_types
= 0;
8248 per_cu
.offset
.sect_off
= info_ptr
- section
->buffer
;
8249 per_cu
.info_or_types_section
= section
;
8251 init_cutu_and_read_dies_no_follow (&per_cu
,
8252 &dwo_file
->sections
.abbrev
,
8254 create_debug_info_hash_table_reader
,
8255 &create_dwo_info_table_data
);
8257 info_ptr
+= per_cu
.length
;
8263 /* Subroutine of open_dwo_file to simplify it.
8264 Open the file specified by FILE_NAME and hand it off to BFD for
8265 preliminary analysis. Return a newly initialized bfd *, which
8266 includes a canonicalized copy of FILE_NAME.
8267 In case of trouble, return NULL.
8268 NOTE: This function is derived from symfile_bfd_open. */
8271 try_open_dwo_file (const char *file_name
)
8275 char *absolute_name
;
8277 desc
= openp (debug_file_directory
, OPF_TRY_CWD_FIRST
, file_name
,
8278 O_RDONLY
| O_BINARY
, &absolute_name
);
8282 sym_bfd
= gdb_bfd_open (absolute_name
, gnutarget
, desc
);
8285 xfree (absolute_name
);
8288 xfree (absolute_name
);
8289 bfd_set_cacheable (sym_bfd
, 1);
8291 if (!bfd_check_format (sym_bfd
, bfd_object
))
8293 gdb_bfd_unref (sym_bfd
); /* This also closes desc. */
8300 /* Try to open DWO file DWO_NAME.
8301 COMP_DIR is the DW_AT_comp_dir attribute.
8302 The result is the bfd handle of the file.
8303 If there is a problem finding or opening the file, return NULL.
8304 Upon success, the canonicalized path of the file is stored in the bfd,
8305 same as symfile_bfd_open. */
8308 open_dwo_file (const char *dwo_name
, const char *comp_dir
)
8312 if (IS_ABSOLUTE_PATH (dwo_name
))
8313 return try_open_dwo_file (dwo_name
);
8315 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
8317 if (comp_dir
!= NULL
)
8319 char *path_to_try
= concat (comp_dir
, SLASH_STRING
, dwo_name
, NULL
);
8321 /* NOTE: If comp_dir is a relative path, this will also try the
8322 search path, which seems useful. */
8323 abfd
= try_open_dwo_file (path_to_try
);
8324 xfree (path_to_try
);
8329 /* That didn't work, try debug-file-directory, which, despite its name,
8330 is a list of paths. */
8332 if (*debug_file_directory
== '\0')
8335 return try_open_dwo_file (dwo_name
);
8338 /* Initialize the use of the DWO file specified by DWO_NAME. */
8340 static struct dwo_file
*
8341 init_dwo_file (const char *dwo_name
, const char *comp_dir
)
8343 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8344 struct dwo_file
*dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
8347 struct cleanup
*cleanups
;
8349 if (dwarf2_read_debug
)
8350 fprintf_unfiltered (gdb_stdlog
, "Reading DWO file %s:\n", dwo_name
);
8352 abfd
= open_dwo_file (dwo_name
, comp_dir
);
8355 dwo_file
->dwo_name
= dwo_name
;
8356 dwo_file
->dwo_bfd
= abfd
;
8358 cleanups
= make_cleanup (free_dwo_file_cleanup
, dwo_file
);
8360 bfd_map_over_sections (abfd
, dwarf2_locate_dwo_sections
, dwo_file
);
8362 dwo_file
->cus
= create_debug_info_hash_table (dwo_file
);
8364 dwo_file
->tus
= create_debug_types_hash_table (dwo_file
,
8365 dwo_file
->sections
.types
);
8367 discard_cleanups (cleanups
);
8372 /* Lookup DWO file DWO_NAME. */
8374 static struct dwo_file
*
8375 lookup_dwo_file (char *dwo_name
, const char *comp_dir
)
8377 struct dwo_file
*dwo_file
;
8378 struct dwo_file find_entry
;
8381 if (dwarf2_per_objfile
->dwo_files
== NULL
)
8382 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
8384 /* Have we already seen this DWO file? */
8385 find_entry
.dwo_name
= dwo_name
;
8386 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
8388 /* If not, read it in and build a table of the DWOs it contains. */
8390 *slot
= init_dwo_file (dwo_name
, comp_dir
);
8392 /* NOTE: This will be NULL if unable to open the file. */
8398 /* Lookup the DWO CU referenced from THIS_CU in DWO file DWO_NAME.
8399 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
8400 SIGNATURE is the "dwo_id" of the CU (for consistency we use the same
8401 nomenclature as TUs).
8402 The result is a pointer to the dwo_unit object or NULL if we didn't find it
8403 (dwo_id mismatch or couldn't find the DWO file). */
8405 static struct dwo_unit
*
8406 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
8407 char *dwo_name
, const char *comp_dir
,
8410 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8411 struct dwo_file
*dwo_file
;
8413 dwo_file
= lookup_dwo_file (dwo_name
, comp_dir
);
8414 if (dwo_file
== NULL
)
8417 /* Look up the DWO using its signature(dwo_id). */
8419 if (dwo_file
->cus
!= NULL
)
8421 struct dwo_unit find_dwo_cu
, *dwo_cu
;
8423 find_dwo_cu
.signature
= signature
;
8424 dwo_cu
= htab_find (dwo_file
->cus
, &find_dwo_cu
);
8430 /* We didn't find it. This must mean a dwo_id mismatch. */
8432 complaint (&symfile_complaints
,
8433 _("Could not find DWO CU referenced by CU at offset 0x%x"
8435 this_cu
->offset
.sect_off
, objfile
->name
);
8439 /* Lookup the DWO TU referenced from THIS_TU in DWO file DWO_NAME.
8440 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
8441 The result is a pointer to the dwo_unit object or NULL if we didn't find it
8442 (dwo_id mismatch or couldn't find the DWO file). */
8444 static struct dwo_unit
*
8445 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
8446 char *dwo_name
, const char *comp_dir
)
8448 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8449 struct dwo_file
*dwo_file
;
8451 dwo_file
= lookup_dwo_file (dwo_name
, comp_dir
);
8452 if (dwo_file
== NULL
)
8455 /* Look up the DWO using its signature(dwo_id). */
8457 if (dwo_file
->tus
!= NULL
)
8459 struct dwo_unit find_dwo_tu
, *dwo_tu
;
8461 find_dwo_tu
.signature
= this_tu
->signature
;
8462 dwo_tu
= htab_find (dwo_file
->tus
, &find_dwo_tu
);
8468 /* We didn't find it. This must mean a dwo_id mismatch. */
8470 complaint (&symfile_complaints
,
8471 _("Could not find DWO TU referenced by TU at offset 0x%x"
8473 this_tu
->per_cu
.offset
.sect_off
, objfile
->name
);
8477 /* Free all resources associated with DWO_FILE.
8478 Close the DWO file and munmap the sections.
8479 All memory should be on the objfile obstack. */
8482 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
8485 struct dwarf2_section_info
*section
;
8487 gdb_assert (dwo_file
->dwo_bfd
!= objfile
->obfd
);
8488 gdb_bfd_unref (dwo_file
->dwo_bfd
);
8490 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
8493 /* Wrapper for free_dwo_file for use in cleanups. */
8496 free_dwo_file_cleanup (void *arg
)
8498 struct dwo_file
*dwo_file
= (struct dwo_file
*) arg
;
8499 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8501 free_dwo_file (dwo_file
, objfile
);
8504 /* Traversal function for free_dwo_files. */
8507 free_dwo_file_from_slot (void **slot
, void *info
)
8509 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
8510 struct objfile
*objfile
= (struct objfile
*) info
;
8512 free_dwo_file (dwo_file
, objfile
);
8517 /* Free all resources associated with DWO_FILES. */
8520 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
8522 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
8525 /* Read in various DIEs. */
8527 /* qsort helper for inherit_abstract_dies. */
8530 unsigned_int_compar (const void *ap
, const void *bp
)
8532 unsigned int a
= *(unsigned int *) ap
;
8533 unsigned int b
= *(unsigned int *) bp
;
8535 return (a
> b
) - (b
> a
);
8538 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
8539 Inherit only the children of the DW_AT_abstract_origin DIE not being
8540 already referenced by DW_AT_abstract_origin from the children of the
8544 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
8546 struct die_info
*child_die
;
8547 unsigned die_children_count
;
8548 /* CU offsets which were referenced by children of the current DIE. */
8549 sect_offset
*offsets
;
8550 sect_offset
*offsets_end
, *offsetp
;
8551 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
8552 struct die_info
*origin_die
;
8553 /* Iterator of the ORIGIN_DIE children. */
8554 struct die_info
*origin_child_die
;
8555 struct cleanup
*cleanups
;
8556 struct attribute
*attr
;
8557 struct dwarf2_cu
*origin_cu
;
8558 struct pending
**origin_previous_list_in_scope
;
8560 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
8564 /* Note that following die references may follow to a die in a
8568 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
8570 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
8572 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
8573 origin_cu
->list_in_scope
= cu
->list_in_scope
;
8575 if (die
->tag
!= origin_die
->tag
8576 && !(die
->tag
== DW_TAG_inlined_subroutine
8577 && origin_die
->tag
== DW_TAG_subprogram
))
8578 complaint (&symfile_complaints
,
8579 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
8580 die
->offset
.sect_off
, origin_die
->offset
.sect_off
);
8582 child_die
= die
->child
;
8583 die_children_count
= 0;
8584 while (child_die
&& child_die
->tag
)
8586 child_die
= sibling_die (child_die
);
8587 die_children_count
++;
8589 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
8590 cleanups
= make_cleanup (xfree
, offsets
);
8592 offsets_end
= offsets
;
8593 child_die
= die
->child
;
8594 while (child_die
&& child_die
->tag
)
8596 /* For each CHILD_DIE, find the corresponding child of
8597 ORIGIN_DIE. If there is more than one layer of
8598 DW_AT_abstract_origin, follow them all; there shouldn't be,
8599 but GCC versions at least through 4.4 generate this (GCC PR
8601 struct die_info
*child_origin_die
= child_die
;
8602 struct dwarf2_cu
*child_origin_cu
= cu
;
8606 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
8610 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
8614 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
8615 counterpart may exist. */
8616 if (child_origin_die
!= child_die
)
8618 if (child_die
->tag
!= child_origin_die
->tag
8619 && !(child_die
->tag
== DW_TAG_inlined_subroutine
8620 && child_origin_die
->tag
== DW_TAG_subprogram
))
8621 complaint (&symfile_complaints
,
8622 _("Child DIE 0x%x and its abstract origin 0x%x have "
8623 "different tags"), child_die
->offset
.sect_off
,
8624 child_origin_die
->offset
.sect_off
);
8625 if (child_origin_die
->parent
!= origin_die
)
8626 complaint (&symfile_complaints
,
8627 _("Child DIE 0x%x and its abstract origin 0x%x have "
8628 "different parents"), child_die
->offset
.sect_off
,
8629 child_origin_die
->offset
.sect_off
);
8631 *offsets_end
++ = child_origin_die
->offset
;
8633 child_die
= sibling_die (child_die
);
8635 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
8636 unsigned_int_compar
);
8637 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
8638 if (offsetp
[-1].sect_off
== offsetp
->sect_off
)
8639 complaint (&symfile_complaints
,
8640 _("Multiple children of DIE 0x%x refer "
8641 "to DIE 0x%x as their abstract origin"),
8642 die
->offset
.sect_off
, offsetp
->sect_off
);
8645 origin_child_die
= origin_die
->child
;
8646 while (origin_child_die
&& origin_child_die
->tag
)
8648 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
8649 while (offsetp
< offsets_end
8650 && offsetp
->sect_off
< origin_child_die
->offset
.sect_off
)
8652 if (offsetp
>= offsets_end
8653 || offsetp
->sect_off
> origin_child_die
->offset
.sect_off
)
8655 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
8656 process_die (origin_child_die
, origin_cu
);
8658 origin_child_die
= sibling_die (origin_child_die
);
8660 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
8662 do_cleanups (cleanups
);
8666 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
8668 struct objfile
*objfile
= cu
->objfile
;
8669 struct context_stack
*new;
8672 struct die_info
*child_die
;
8673 struct attribute
*attr
, *call_line
, *call_file
;
8676 struct block
*block
;
8677 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
8678 VEC (symbolp
) *template_args
= NULL
;
8679 struct template_symbol
*templ_func
= NULL
;
8683 /* If we do not have call site information, we can't show the
8684 caller of this inlined function. That's too confusing, so
8685 only use the scope for local variables. */
8686 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
8687 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
8688 if (call_line
== NULL
|| call_file
== NULL
)
8690 read_lexical_block_scope (die
, cu
);
8695 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8697 name
= dwarf2_name (die
, cu
);
8699 /* Ignore functions with missing or empty names. These are actually
8700 illegal according to the DWARF standard. */
8703 complaint (&symfile_complaints
,
8704 _("missing name for subprogram DIE at %d"),
8705 die
->offset
.sect_off
);
8709 /* Ignore functions with missing or invalid low and high pc attributes. */
8710 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
8712 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
8713 if (!attr
|| !DW_UNSND (attr
))
8714 complaint (&symfile_complaints
,
8715 _("cannot get low and high bounds "
8716 "for subprogram DIE at %d"),
8717 die
->offset
.sect_off
);
8724 /* If we have any template arguments, then we must allocate a
8725 different sort of symbol. */
8726 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
8728 if (child_die
->tag
== DW_TAG_template_type_param
8729 || child_die
->tag
== DW_TAG_template_value_param
)
8731 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
8732 struct template_symbol
);
8733 templ_func
->base
.is_cplus_template_function
= 1;
8738 new = push_context (0, lowpc
);
8739 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
8740 (struct symbol
*) templ_func
);
8742 /* If there is a location expression for DW_AT_frame_base, record
8744 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
8746 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
8747 expression is being recorded directly in the function's symbol
8748 and not in a separate frame-base object. I guess this hack is
8749 to avoid adding some sort of frame-base adjunct/annex to the
8750 function's symbol :-(. The problem with doing this is that it
8751 results in a function symbol with a location expression that
8752 has nothing to do with the location of the function, ouch! The
8753 relationship should be: a function's symbol has-a frame base; a
8754 frame-base has-a location expression. */
8755 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
8757 cu
->list_in_scope
= &local_symbols
;
8759 if (die
->child
!= NULL
)
8761 child_die
= die
->child
;
8762 while (child_die
&& child_die
->tag
)
8764 if (child_die
->tag
== DW_TAG_template_type_param
8765 || child_die
->tag
== DW_TAG_template_value_param
)
8767 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
8770 VEC_safe_push (symbolp
, template_args
, arg
);
8773 process_die (child_die
, cu
);
8774 child_die
= sibling_die (child_die
);
8778 inherit_abstract_dies (die
, cu
);
8780 /* If we have a DW_AT_specification, we might need to import using
8781 directives from the context of the specification DIE. See the
8782 comment in determine_prefix. */
8783 if (cu
->language
== language_cplus
8784 && dwarf2_attr (die
, DW_AT_specification
, cu
))
8786 struct dwarf2_cu
*spec_cu
= cu
;
8787 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
8791 child_die
= spec_die
->child
;
8792 while (child_die
&& child_die
->tag
)
8794 if (child_die
->tag
== DW_TAG_imported_module
)
8795 process_die (child_die
, spec_cu
);
8796 child_die
= sibling_die (child_die
);
8799 /* In some cases, GCC generates specification DIEs that
8800 themselves contain DW_AT_specification attributes. */
8801 spec_die
= die_specification (spec_die
, &spec_cu
);
8805 new = pop_context ();
8806 /* Make a block for the local symbols within. */
8807 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
8808 lowpc
, highpc
, objfile
);
8810 /* For C++, set the block's scope. */
8811 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
8812 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
8813 determine_prefix (die
, cu
),
8814 processing_has_namespace_info
);
8816 /* If we have address ranges, record them. */
8817 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
8819 /* Attach template arguments to function. */
8820 if (! VEC_empty (symbolp
, template_args
))
8822 gdb_assert (templ_func
!= NULL
);
8824 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
8825 templ_func
->template_arguments
8826 = obstack_alloc (&objfile
->objfile_obstack
,
8827 (templ_func
->n_template_arguments
8828 * sizeof (struct symbol
*)));
8829 memcpy (templ_func
->template_arguments
,
8830 VEC_address (symbolp
, template_args
),
8831 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
8832 VEC_free (symbolp
, template_args
);
8835 /* In C++, we can have functions nested inside functions (e.g., when
8836 a function declares a class that has methods). This means that
8837 when we finish processing a function scope, we may need to go
8838 back to building a containing block's symbol lists. */
8839 local_symbols
= new->locals
;
8840 param_symbols
= new->params
;
8841 using_directives
= new->using_directives
;
8843 /* If we've finished processing a top-level function, subsequent
8844 symbols go in the file symbol list. */
8845 if (outermost_context_p ())
8846 cu
->list_in_scope
= &file_symbols
;
8849 /* Process all the DIES contained within a lexical block scope. Start
8850 a new scope, process the dies, and then close the scope. */
8853 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
8855 struct objfile
*objfile
= cu
->objfile
;
8856 struct context_stack
*new;
8857 CORE_ADDR lowpc
, highpc
;
8858 struct die_info
*child_die
;
8861 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8863 /* Ignore blocks with missing or invalid low and high pc attributes. */
8864 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
8865 as multiple lexical blocks? Handling children in a sane way would
8866 be nasty. Might be easier to properly extend generic blocks to
8868 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
8873 push_context (0, lowpc
);
8874 if (die
->child
!= NULL
)
8876 child_die
= die
->child
;
8877 while (child_die
&& child_die
->tag
)
8879 process_die (child_die
, cu
);
8880 child_die
= sibling_die (child_die
);
8883 new = pop_context ();
8885 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
8888 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
8891 /* Note that recording ranges after traversing children, as we
8892 do here, means that recording a parent's ranges entails
8893 walking across all its children's ranges as they appear in
8894 the address map, which is quadratic behavior.
8896 It would be nicer to record the parent's ranges before
8897 traversing its children, simply overriding whatever you find
8898 there. But since we don't even decide whether to create a
8899 block until after we've traversed its children, that's hard
8901 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
8903 local_symbols
= new->locals
;
8904 using_directives
= new->using_directives
;
8907 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
8910 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
8912 struct objfile
*objfile
= cu
->objfile
;
8913 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8914 CORE_ADDR pc
, baseaddr
;
8915 struct attribute
*attr
;
8916 struct call_site
*call_site
, call_site_local
;
8919 struct die_info
*child_die
;
8921 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8923 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
8926 complaint (&symfile_complaints
,
8927 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
8928 "DIE 0x%x [in module %s]"),
8929 die
->offset
.sect_off
, objfile
->name
);
8932 pc
= DW_ADDR (attr
) + baseaddr
;
8934 if (cu
->call_site_htab
== NULL
)
8935 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
8936 NULL
, &objfile
->objfile_obstack
,
8937 hashtab_obstack_allocate
, NULL
);
8938 call_site_local
.pc
= pc
;
8939 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
8942 complaint (&symfile_complaints
,
8943 _("Duplicate PC %s for DW_TAG_GNU_call_site "
8944 "DIE 0x%x [in module %s]"),
8945 paddress (gdbarch
, pc
), die
->offset
.sect_off
, objfile
->name
);
8949 /* Count parameters at the caller. */
8952 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
8953 child_die
= sibling_die (child_die
))
8955 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
8957 complaint (&symfile_complaints
,
8958 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
8959 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
8960 child_die
->tag
, child_die
->offset
.sect_off
, objfile
->name
);
8967 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
8968 (sizeof (*call_site
)
8969 + (sizeof (*call_site
->parameter
)
8972 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
8975 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
8977 struct die_info
*func_die
;
8979 /* Skip also over DW_TAG_inlined_subroutine. */
8980 for (func_die
= die
->parent
;
8981 func_die
&& func_die
->tag
!= DW_TAG_subprogram
8982 && func_die
->tag
!= DW_TAG_subroutine_type
;
8983 func_die
= func_die
->parent
);
8985 /* DW_AT_GNU_all_call_sites is a superset
8986 of DW_AT_GNU_all_tail_call_sites. */
8988 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
8989 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
8991 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
8992 not complete. But keep CALL_SITE for look ups via call_site_htab,
8993 both the initial caller containing the real return address PC and
8994 the final callee containing the current PC of a chain of tail
8995 calls do not need to have the tail call list complete. But any
8996 function candidate for a virtual tail call frame searched via
8997 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
8998 determined unambiguously. */
9002 struct type
*func_type
= NULL
;
9005 func_type
= get_die_type (func_die
, cu
);
9006 if (func_type
!= NULL
)
9008 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
9010 /* Enlist this call site to the function. */
9011 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
9012 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
9015 complaint (&symfile_complaints
,
9016 _("Cannot find function owning DW_TAG_GNU_call_site "
9017 "DIE 0x%x [in module %s]"),
9018 die
->offset
.sect_off
, objfile
->name
);
9022 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
9024 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
9025 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
9026 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
9027 /* Keep NULL DWARF_BLOCK. */;
9028 else if (attr_form_is_block (attr
))
9030 struct dwarf2_locexpr_baton
*dlbaton
;
9032 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
9033 dlbaton
->data
= DW_BLOCK (attr
)->data
;
9034 dlbaton
->size
= DW_BLOCK (attr
)->size
;
9035 dlbaton
->per_cu
= cu
->per_cu
;
9037 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
9039 else if (is_ref_attr (attr
))
9041 struct dwarf2_cu
*target_cu
= cu
;
9042 struct die_info
*target_die
;
9044 target_die
= follow_die_ref_or_sig (die
, attr
, &target_cu
);
9045 gdb_assert (target_cu
->objfile
== objfile
);
9046 if (die_is_declaration (target_die
, target_cu
))
9048 const char *target_physname
;
9050 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
9051 if (target_physname
== NULL
)
9052 complaint (&symfile_complaints
,
9053 _("DW_AT_GNU_call_site_target target DIE has invalid "
9054 "physname, for referencing DIE 0x%x [in module %s]"),
9055 die
->offset
.sect_off
, objfile
->name
);
9057 SET_FIELD_PHYSNAME (call_site
->target
, (char *) target_physname
);
9063 /* DW_AT_entry_pc should be preferred. */
9064 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
9065 complaint (&symfile_complaints
,
9066 _("DW_AT_GNU_call_site_target target DIE has invalid "
9067 "low pc, for referencing DIE 0x%x [in module %s]"),
9068 die
->offset
.sect_off
, objfile
->name
);
9070 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
+ baseaddr
);
9074 complaint (&symfile_complaints
,
9075 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
9076 "block nor reference, for DIE 0x%x [in module %s]"),
9077 die
->offset
.sect_off
, objfile
->name
);
9079 call_site
->per_cu
= cu
->per_cu
;
9081 for (child_die
= die
->child
;
9082 child_die
&& child_die
->tag
;
9083 child_die
= sibling_die (child_die
))
9085 struct call_site_parameter
*parameter
;
9086 struct attribute
*loc
, *origin
;
9088 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
9090 /* Already printed the complaint above. */
9094 gdb_assert (call_site
->parameter_count
< nparams
);
9095 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
9097 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
9098 specifies DW_TAG_formal_parameter. Value of the data assumed for the
9099 register is contained in DW_AT_GNU_call_site_value. */
9101 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
9102 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
9103 if (loc
== NULL
&& origin
!= NULL
&& is_ref_attr (origin
))
9107 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
9108 offset
= dwarf2_get_ref_die_offset (origin
);
9109 if (!offset_in_cu_p (&cu
->header
, offset
))
9111 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
9112 binding can be done only inside one CU. Such referenced DIE
9113 therefore cannot be even moved to DW_TAG_partial_unit. */
9114 complaint (&symfile_complaints
,
9115 _("DW_AT_abstract_origin offset is not in CU for "
9116 "DW_TAG_GNU_call_site child DIE 0x%x "
9118 child_die
->offset
.sect_off
, objfile
->name
);
9121 parameter
->u
.param_offset
.cu_off
= (offset
.sect_off
9122 - cu
->header
.offset
.sect_off
);
9124 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
9126 complaint (&symfile_complaints
,
9127 _("No DW_FORM_block* DW_AT_location for "
9128 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
9129 child_die
->offset
.sect_off
, objfile
->name
);
9134 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
9135 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
9136 if (parameter
->u
.dwarf_reg
!= -1)
9137 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
9138 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
9139 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
9140 ¶meter
->u
.fb_offset
))
9141 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
9144 complaint (&symfile_complaints
,
9145 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
9146 "for DW_FORM_block* DW_AT_location is supported for "
9147 "DW_TAG_GNU_call_site child DIE 0x%x "
9149 child_die
->offset
.sect_off
, objfile
->name
);
9154 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
9155 if (!attr_form_is_block (attr
))
9157 complaint (&symfile_complaints
,
9158 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
9159 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
9160 child_die
->offset
.sect_off
, objfile
->name
);
9163 parameter
->value
= DW_BLOCK (attr
)->data
;
9164 parameter
->value_size
= DW_BLOCK (attr
)->size
;
9166 /* Parameters are not pre-cleared by memset above. */
9167 parameter
->data_value
= NULL
;
9168 parameter
->data_value_size
= 0;
9169 call_site
->parameter_count
++;
9171 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
9174 if (!attr_form_is_block (attr
))
9175 complaint (&symfile_complaints
,
9176 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
9177 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
9178 child_die
->offset
.sect_off
, objfile
->name
);
9181 parameter
->data_value
= DW_BLOCK (attr
)->data
;
9182 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
9188 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
9189 Return 1 if the attributes are present and valid, otherwise, return 0.
9190 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
9193 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
9194 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
9195 struct partial_symtab
*ranges_pst
)
9197 struct objfile
*objfile
= cu
->objfile
;
9198 struct comp_unit_head
*cu_header
= &cu
->header
;
9199 bfd
*obfd
= objfile
->obfd
;
9200 unsigned int addr_size
= cu_header
->addr_size
;
9201 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
9202 /* Base address selection entry. */
9213 found_base
= cu
->base_known
;
9214 base
= cu
->base_address
;
9216 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
9217 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
9219 complaint (&symfile_complaints
,
9220 _("Offset %d out of bounds for DW_AT_ranges attribute"),
9224 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
9226 /* Read in the largest possible address. */
9227 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
9228 if ((marker
& mask
) == mask
)
9230 /* If we found the largest possible address, then
9231 read the base address. */
9232 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
9233 buffer
+= 2 * addr_size
;
9234 offset
+= 2 * addr_size
;
9240 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9244 CORE_ADDR range_beginning
, range_end
;
9246 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
9247 buffer
+= addr_size
;
9248 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
9249 buffer
+= addr_size
;
9250 offset
+= 2 * addr_size
;
9252 /* An end of list marker is a pair of zero addresses. */
9253 if (range_beginning
== 0 && range_end
== 0)
9254 /* Found the end of list entry. */
9257 /* Each base address selection entry is a pair of 2 values.
9258 The first is the largest possible address, the second is
9259 the base address. Check for a base address here. */
9260 if ((range_beginning
& mask
) == mask
)
9262 /* If we found the largest possible address, then
9263 read the base address. */
9264 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
9271 /* We have no valid base address for the ranges
9273 complaint (&symfile_complaints
,
9274 _("Invalid .debug_ranges data (no base address)"));
9278 if (range_beginning
> range_end
)
9280 /* Inverted range entries are invalid. */
9281 complaint (&symfile_complaints
,
9282 _("Invalid .debug_ranges data (inverted range)"));
9286 /* Empty range entries have no effect. */
9287 if (range_beginning
== range_end
)
9290 range_beginning
+= base
;
9293 /* A not-uncommon case of bad debug info.
9294 Don't pollute the addrmap with bad data. */
9295 if (range_beginning
+ baseaddr
== 0
9296 && !dwarf2_per_objfile
->has_section_at_zero
)
9298 complaint (&symfile_complaints
,
9299 _(".debug_ranges entry has start address of zero"
9300 " [in module %s]"), objfile
->name
);
9304 if (ranges_pst
!= NULL
)
9305 addrmap_set_empty (objfile
->psymtabs_addrmap
,
9306 range_beginning
+ baseaddr
,
9307 range_end
- 1 + baseaddr
,
9310 /* FIXME: This is recording everything as a low-high
9311 segment of consecutive addresses. We should have a
9312 data structure for discontiguous block ranges
9316 low
= range_beginning
;
9322 if (range_beginning
< low
)
9323 low
= range_beginning
;
9324 if (range_end
> high
)
9330 /* If the first entry is an end-of-list marker, the range
9331 describes an empty scope, i.e. no instructions. */
9337 *high_return
= high
;
9341 /* Get low and high pc attributes from a die. Return 1 if the attributes
9342 are present and valid, otherwise, return 0. Return -1 if the range is
9343 discontinuous, i.e. derived from DW_AT_ranges information. */
9346 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
9347 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
9348 struct partial_symtab
*pst
)
9350 struct attribute
*attr
;
9351 struct attribute
*attr_high
;
9356 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
9359 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
9362 low
= DW_ADDR (attr
);
9363 if (attr_high
->form
== DW_FORM_addr
9364 || attr_high
->form
== DW_FORM_GNU_addr_index
)
9365 high
= DW_ADDR (attr_high
);
9367 high
= low
+ DW_UNSND (attr_high
);
9370 /* Found high w/o low attribute. */
9373 /* Found consecutive range of addresses. */
9378 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
9381 unsigned int ranges_offset
= DW_UNSND (attr
) + cu
->ranges_base
;
9383 /* Value of the DW_AT_ranges attribute is the offset in the
9384 .debug_ranges section. */
9385 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
9387 /* Found discontinuous range of addresses. */
9392 /* read_partial_die has also the strict LOW < HIGH requirement. */
9396 /* When using the GNU linker, .gnu.linkonce. sections are used to
9397 eliminate duplicate copies of functions and vtables and such.
9398 The linker will arbitrarily choose one and discard the others.
9399 The AT_*_pc values for such functions refer to local labels in
9400 these sections. If the section from that file was discarded, the
9401 labels are not in the output, so the relocs get a value of 0.
9402 If this is a discarded function, mark the pc bounds as invalid,
9403 so that GDB will ignore it. */
9404 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
9413 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
9414 its low and high PC addresses. Do nothing if these addresses could not
9415 be determined. Otherwise, set LOWPC to the low address if it is smaller,
9416 and HIGHPC to the high address if greater than HIGHPC. */
9419 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
9420 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9421 struct dwarf2_cu
*cu
)
9423 CORE_ADDR low
, high
;
9424 struct die_info
*child
= die
->child
;
9426 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
9428 *lowpc
= min (*lowpc
, low
);
9429 *highpc
= max (*highpc
, high
);
9432 /* If the language does not allow nested subprograms (either inside
9433 subprograms or lexical blocks), we're done. */
9434 if (cu
->language
!= language_ada
)
9437 /* Check all the children of the given DIE. If it contains nested
9438 subprograms, then check their pc bounds. Likewise, we need to
9439 check lexical blocks as well, as they may also contain subprogram
9441 while (child
&& child
->tag
)
9443 if (child
->tag
== DW_TAG_subprogram
9444 || child
->tag
== DW_TAG_lexical_block
)
9445 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
9446 child
= sibling_die (child
);
9450 /* Get the low and high pc's represented by the scope DIE, and store
9451 them in *LOWPC and *HIGHPC. If the correct values can't be
9452 determined, set *LOWPC to -1 and *HIGHPC to 0. */
9455 get_scope_pc_bounds (struct die_info
*die
,
9456 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9457 struct dwarf2_cu
*cu
)
9459 CORE_ADDR best_low
= (CORE_ADDR
) -1;
9460 CORE_ADDR best_high
= (CORE_ADDR
) 0;
9461 CORE_ADDR current_low
, current_high
;
9463 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
9465 best_low
= current_low
;
9466 best_high
= current_high
;
9470 struct die_info
*child
= die
->child
;
9472 while (child
&& child
->tag
)
9474 switch (child
->tag
) {
9475 case DW_TAG_subprogram
:
9476 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
9478 case DW_TAG_namespace
:
9480 /* FIXME: carlton/2004-01-16: Should we do this for
9481 DW_TAG_class_type/DW_TAG_structure_type, too? I think
9482 that current GCC's always emit the DIEs corresponding
9483 to definitions of methods of classes as children of a
9484 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
9485 the DIEs giving the declarations, which could be
9486 anywhere). But I don't see any reason why the
9487 standards says that they have to be there. */
9488 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
9490 if (current_low
!= ((CORE_ADDR
) -1))
9492 best_low
= min (best_low
, current_low
);
9493 best_high
= max (best_high
, current_high
);
9501 child
= sibling_die (child
);
9506 *highpc
= best_high
;
9509 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
9513 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
9514 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
9516 struct objfile
*objfile
= cu
->objfile
;
9517 struct attribute
*attr
;
9518 struct attribute
*attr_high
;
9520 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
9523 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
9526 CORE_ADDR low
= DW_ADDR (attr
);
9528 if (attr_high
->form
== DW_FORM_addr
9529 || attr_high
->form
== DW_FORM_GNU_addr_index
)
9530 high
= DW_ADDR (attr_high
);
9532 high
= low
+ DW_UNSND (attr_high
);
9534 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
9538 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
9541 bfd
*obfd
= objfile
->obfd
;
9543 /* The value of the DW_AT_ranges attribute is the offset of the
9544 address range list in the .debug_ranges section. */
9545 unsigned long offset
= DW_UNSND (attr
) + cu
->ranges_base
;
9546 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
9548 /* For some target architectures, but not others, the
9549 read_address function sign-extends the addresses it returns.
9550 To recognize base address selection entries, we need a
9552 unsigned int addr_size
= cu
->header
.addr_size
;
9553 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
9555 /* The base address, to which the next pair is relative. Note
9556 that this 'base' is a DWARF concept: most entries in a range
9557 list are relative, to reduce the number of relocs against the
9558 debugging information. This is separate from this function's
9559 'baseaddr' argument, which GDB uses to relocate debugging
9560 information from a shared library based on the address at
9561 which the library was loaded. */
9562 CORE_ADDR base
= cu
->base_address
;
9563 int base_known
= cu
->base_known
;
9565 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
9566 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
9568 complaint (&symfile_complaints
,
9569 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
9576 unsigned int bytes_read
;
9577 CORE_ADDR start
, end
;
9579 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
9580 buffer
+= bytes_read
;
9581 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
9582 buffer
+= bytes_read
;
9584 /* Did we find the end of the range list? */
9585 if (start
== 0 && end
== 0)
9588 /* Did we find a base address selection entry? */
9589 else if ((start
& base_select_mask
) == base_select_mask
)
9595 /* We found an ordinary address range. */
9600 complaint (&symfile_complaints
,
9601 _("Invalid .debug_ranges data "
9602 "(no base address)"));
9608 /* Inverted range entries are invalid. */
9609 complaint (&symfile_complaints
,
9610 _("Invalid .debug_ranges data "
9611 "(inverted range)"));
9615 /* Empty range entries have no effect. */
9619 start
+= base
+ baseaddr
;
9620 end
+= base
+ baseaddr
;
9622 /* A not-uncommon case of bad debug info.
9623 Don't pollute the addrmap with bad data. */
9624 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
9626 complaint (&symfile_complaints
,
9627 _(".debug_ranges entry has start address of zero"
9628 " [in module %s]"), objfile
->name
);
9632 record_block_range (block
, start
, end
- 1);
9638 /* Check whether the producer field indicates either of GCC < 4.6, or the
9639 Intel C/C++ compiler, and cache the result in CU. */
9642 check_producer (struct dwarf2_cu
*cu
)
9645 int major
, minor
, release
;
9647 if (cu
->producer
== NULL
)
9649 /* For unknown compilers expect their behavior is DWARF version
9652 GCC started to support .debug_types sections by -gdwarf-4 since
9653 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
9654 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
9655 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
9656 interpreted incorrectly by GDB now - GCC PR debug/48229. */
9658 else if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) == 0)
9660 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
9662 cs
= &cu
->producer
[strlen ("GNU ")];
9663 while (*cs
&& !isdigit (*cs
))
9665 if (sscanf (cs
, "%d.%d.%d", &major
, &minor
, &release
) != 3)
9667 /* Not recognized as GCC. */
9670 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
9672 else if (strncmp (cu
->producer
, "Intel(R) C", strlen ("Intel(R) C")) == 0)
9673 cu
->producer_is_icc
= 1;
9676 /* For other non-GCC compilers, expect their behavior is DWARF version
9680 cu
->checked_producer
= 1;
9683 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
9684 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
9685 during 4.6.0 experimental. */
9688 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
9690 if (!cu
->checked_producer
)
9691 check_producer (cu
);
9693 return cu
->producer_is_gxx_lt_4_6
;
9696 /* Return the default accessibility type if it is not overriden by
9697 DW_AT_accessibility. */
9699 static enum dwarf_access_attribute
9700 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
9702 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
9704 /* The default DWARF 2 accessibility for members is public, the default
9705 accessibility for inheritance is private. */
9707 if (die
->tag
!= DW_TAG_inheritance
)
9708 return DW_ACCESS_public
;
9710 return DW_ACCESS_private
;
9714 /* DWARF 3+ defines the default accessibility a different way. The same
9715 rules apply now for DW_TAG_inheritance as for the members and it only
9716 depends on the container kind. */
9718 if (die
->parent
->tag
== DW_TAG_class_type
)
9719 return DW_ACCESS_private
;
9721 return DW_ACCESS_public
;
9725 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
9726 offset. If the attribute was not found return 0, otherwise return
9727 1. If it was found but could not properly be handled, set *OFFSET
9731 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
9734 struct attribute
*attr
;
9736 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
9741 /* Note that we do not check for a section offset first here.
9742 This is because DW_AT_data_member_location is new in DWARF 4,
9743 so if we see it, we can assume that a constant form is really
9744 a constant and not a section offset. */
9745 if (attr_form_is_constant (attr
))
9746 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
9747 else if (attr_form_is_section_offset (attr
))
9748 dwarf2_complex_location_expr_complaint ();
9749 else if (attr_form_is_block (attr
))
9750 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
9752 dwarf2_complex_location_expr_complaint ();
9760 /* Add an aggregate field to the field list. */
9763 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
9764 struct dwarf2_cu
*cu
)
9766 struct objfile
*objfile
= cu
->objfile
;
9767 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9768 struct nextfield
*new_field
;
9769 struct attribute
*attr
;
9771 char *fieldname
= "";
9773 /* Allocate a new field list entry and link it in. */
9774 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
9775 make_cleanup (xfree
, new_field
);
9776 memset (new_field
, 0, sizeof (struct nextfield
));
9778 if (die
->tag
== DW_TAG_inheritance
)
9780 new_field
->next
= fip
->baseclasses
;
9781 fip
->baseclasses
= new_field
;
9785 new_field
->next
= fip
->fields
;
9786 fip
->fields
= new_field
;
9790 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
9792 new_field
->accessibility
= DW_UNSND (attr
);
9794 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
9795 if (new_field
->accessibility
!= DW_ACCESS_public
)
9796 fip
->non_public_fields
= 1;
9798 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
9800 new_field
->virtuality
= DW_UNSND (attr
);
9802 new_field
->virtuality
= DW_VIRTUALITY_none
;
9804 fp
= &new_field
->field
;
9806 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
9810 /* Data member other than a C++ static data member. */
9812 /* Get type of field. */
9813 fp
->type
= die_type (die
, cu
);
9815 SET_FIELD_BITPOS (*fp
, 0);
9817 /* Get bit size of field (zero if none). */
9818 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
9821 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
9825 FIELD_BITSIZE (*fp
) = 0;
9828 /* Get bit offset of field. */
9829 if (handle_data_member_location (die
, cu
, &offset
))
9830 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
9831 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
9834 if (gdbarch_bits_big_endian (gdbarch
))
9836 /* For big endian bits, the DW_AT_bit_offset gives the
9837 additional bit offset from the MSB of the containing
9838 anonymous object to the MSB of the field. We don't
9839 have to do anything special since we don't need to
9840 know the size of the anonymous object. */
9841 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
9845 /* For little endian bits, compute the bit offset to the
9846 MSB of the anonymous object, subtract off the number of
9847 bits from the MSB of the field to the MSB of the
9848 object, and then subtract off the number of bits of
9849 the field itself. The result is the bit offset of
9850 the LSB of the field. */
9852 int bit_offset
= DW_UNSND (attr
);
9854 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
9857 /* The size of the anonymous object containing
9858 the bit field is explicit, so use the
9859 indicated size (in bytes). */
9860 anonymous_size
= DW_UNSND (attr
);
9864 /* The size of the anonymous object containing
9865 the bit field must be inferred from the type
9866 attribute of the data member containing the
9868 anonymous_size
= TYPE_LENGTH (fp
->type
);
9870 SET_FIELD_BITPOS (*fp
,
9872 + anonymous_size
* bits_per_byte
9873 - bit_offset
- FIELD_BITSIZE (*fp
)));
9877 /* Get name of field. */
9878 fieldname
= dwarf2_name (die
, cu
);
9879 if (fieldname
== NULL
)
9882 /* The name is already allocated along with this objfile, so we don't
9883 need to duplicate it for the type. */
9884 fp
->name
= fieldname
;
9886 /* Change accessibility for artificial fields (e.g. virtual table
9887 pointer or virtual base class pointer) to private. */
9888 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
9890 FIELD_ARTIFICIAL (*fp
) = 1;
9891 new_field
->accessibility
= DW_ACCESS_private
;
9892 fip
->non_public_fields
= 1;
9895 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
9897 /* C++ static member. */
9899 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
9900 is a declaration, but all versions of G++ as of this writing
9901 (so through at least 3.2.1) incorrectly generate
9902 DW_TAG_variable tags. */
9904 const char *physname
;
9906 /* Get name of field. */
9907 fieldname
= dwarf2_name (die
, cu
);
9908 if (fieldname
== NULL
)
9911 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
9913 /* Only create a symbol if this is an external value.
9914 new_symbol checks this and puts the value in the global symbol
9915 table, which we want. If it is not external, new_symbol
9916 will try to put the value in cu->list_in_scope which is wrong. */
9917 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
9919 /* A static const member, not much different than an enum as far as
9920 we're concerned, except that we can support more types. */
9921 new_symbol (die
, NULL
, cu
);
9924 /* Get physical name. */
9925 physname
= dwarf2_physname (fieldname
, die
, cu
);
9927 /* The name is already allocated along with this objfile, so we don't
9928 need to duplicate it for the type. */
9929 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
9930 FIELD_TYPE (*fp
) = die_type (die
, cu
);
9931 FIELD_NAME (*fp
) = fieldname
;
9933 else if (die
->tag
== DW_TAG_inheritance
)
9937 /* C++ base class field. */
9938 if (handle_data_member_location (die
, cu
, &offset
))
9939 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
9940 FIELD_BITSIZE (*fp
) = 0;
9941 FIELD_TYPE (*fp
) = die_type (die
, cu
);
9942 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
9943 fip
->nbaseclasses
++;
9947 /* Add a typedef defined in the scope of the FIP's class. */
9950 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
9951 struct dwarf2_cu
*cu
)
9953 struct objfile
*objfile
= cu
->objfile
;
9954 struct typedef_field_list
*new_field
;
9955 struct attribute
*attr
;
9956 struct typedef_field
*fp
;
9957 char *fieldname
= "";
9959 /* Allocate a new field list entry and link it in. */
9960 new_field
= xzalloc (sizeof (*new_field
));
9961 make_cleanup (xfree
, new_field
);
9963 gdb_assert (die
->tag
== DW_TAG_typedef
);
9965 fp
= &new_field
->field
;
9967 /* Get name of field. */
9968 fp
->name
= dwarf2_name (die
, cu
);
9969 if (fp
->name
== NULL
)
9972 fp
->type
= read_type_die (die
, cu
);
9974 new_field
->next
= fip
->typedef_field_list
;
9975 fip
->typedef_field_list
= new_field
;
9976 fip
->typedef_field_list_count
++;
9979 /* Create the vector of fields, and attach it to the type. */
9982 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
9983 struct dwarf2_cu
*cu
)
9985 int nfields
= fip
->nfields
;
9987 /* Record the field count, allocate space for the array of fields,
9988 and create blank accessibility bitfields if necessary. */
9989 TYPE_NFIELDS (type
) = nfields
;
9990 TYPE_FIELDS (type
) = (struct field
*)
9991 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
9992 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
9994 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
9996 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
9998 TYPE_FIELD_PRIVATE_BITS (type
) =
9999 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
10000 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
10002 TYPE_FIELD_PROTECTED_BITS (type
) =
10003 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
10004 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
10006 TYPE_FIELD_IGNORE_BITS (type
) =
10007 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
10008 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
10011 /* If the type has baseclasses, allocate and clear a bit vector for
10012 TYPE_FIELD_VIRTUAL_BITS. */
10013 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
10015 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
10016 unsigned char *pointer
;
10018 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
10019 pointer
= TYPE_ALLOC (type
, num_bytes
);
10020 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
10021 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
10022 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
10025 /* Copy the saved-up fields into the field vector. Start from the head of
10026 the list, adding to the tail of the field array, so that they end up in
10027 the same order in the array in which they were added to the list. */
10028 while (nfields
-- > 0)
10030 struct nextfield
*fieldp
;
10034 fieldp
= fip
->fields
;
10035 fip
->fields
= fieldp
->next
;
10039 fieldp
= fip
->baseclasses
;
10040 fip
->baseclasses
= fieldp
->next
;
10043 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
10044 switch (fieldp
->accessibility
)
10046 case DW_ACCESS_private
:
10047 if (cu
->language
!= language_ada
)
10048 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
10051 case DW_ACCESS_protected
:
10052 if (cu
->language
!= language_ada
)
10053 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
10056 case DW_ACCESS_public
:
10060 /* Unknown accessibility. Complain and treat it as public. */
10062 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
10063 fieldp
->accessibility
);
10067 if (nfields
< fip
->nbaseclasses
)
10069 switch (fieldp
->virtuality
)
10071 case DW_VIRTUALITY_virtual
:
10072 case DW_VIRTUALITY_pure_virtual
:
10073 if (cu
->language
== language_ada
)
10074 error (_("unexpected virtuality in component of Ada type"));
10075 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
10082 /* Add a member function to the proper fieldlist. */
10085 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
10086 struct type
*type
, struct dwarf2_cu
*cu
)
10088 struct objfile
*objfile
= cu
->objfile
;
10089 struct attribute
*attr
;
10090 struct fnfieldlist
*flp
;
10092 struct fn_field
*fnp
;
10094 struct nextfnfield
*new_fnfield
;
10095 struct type
*this_type
;
10096 enum dwarf_access_attribute accessibility
;
10098 if (cu
->language
== language_ada
)
10099 error (_("unexpected member function in Ada type"));
10101 /* Get name of member function. */
10102 fieldname
= dwarf2_name (die
, cu
);
10103 if (fieldname
== NULL
)
10106 /* Look up member function name in fieldlist. */
10107 for (i
= 0; i
< fip
->nfnfields
; i
++)
10109 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
10113 /* Create new list element if necessary. */
10114 if (i
< fip
->nfnfields
)
10115 flp
= &fip
->fnfieldlists
[i
];
10118 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
10120 fip
->fnfieldlists
= (struct fnfieldlist
*)
10121 xrealloc (fip
->fnfieldlists
,
10122 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
10123 * sizeof (struct fnfieldlist
));
10124 if (fip
->nfnfields
== 0)
10125 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
10127 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
10128 flp
->name
= fieldname
;
10131 i
= fip
->nfnfields
++;
10134 /* Create a new member function field and chain it to the field list
10136 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
10137 make_cleanup (xfree
, new_fnfield
);
10138 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
10139 new_fnfield
->next
= flp
->head
;
10140 flp
->head
= new_fnfield
;
10143 /* Fill in the member function field info. */
10144 fnp
= &new_fnfield
->fnfield
;
10146 /* Delay processing of the physname until later. */
10147 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
10149 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
10154 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
10155 fnp
->physname
= physname
? physname
: "";
10158 fnp
->type
= alloc_type (objfile
);
10159 this_type
= read_type_die (die
, cu
);
10160 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
10162 int nparams
= TYPE_NFIELDS (this_type
);
10164 /* TYPE is the domain of this method, and THIS_TYPE is the type
10165 of the method itself (TYPE_CODE_METHOD). */
10166 smash_to_method_type (fnp
->type
, type
,
10167 TYPE_TARGET_TYPE (this_type
),
10168 TYPE_FIELDS (this_type
),
10169 TYPE_NFIELDS (this_type
),
10170 TYPE_VARARGS (this_type
));
10172 /* Handle static member functions.
10173 Dwarf2 has no clean way to discern C++ static and non-static
10174 member functions. G++ helps GDB by marking the first
10175 parameter for non-static member functions (which is the this
10176 pointer) as artificial. We obtain this information from
10177 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
10178 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
10179 fnp
->voffset
= VOFFSET_STATIC
;
10182 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
10183 dwarf2_full_name (fieldname
, die
, cu
));
10185 /* Get fcontext from DW_AT_containing_type if present. */
10186 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
10187 fnp
->fcontext
= die_containing_type (die
, cu
);
10189 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
10190 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
10192 /* Get accessibility. */
10193 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
10195 accessibility
= DW_UNSND (attr
);
10197 accessibility
= dwarf2_default_access_attribute (die
, cu
);
10198 switch (accessibility
)
10200 case DW_ACCESS_private
:
10201 fnp
->is_private
= 1;
10203 case DW_ACCESS_protected
:
10204 fnp
->is_protected
= 1;
10208 /* Check for artificial methods. */
10209 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
10210 if (attr
&& DW_UNSND (attr
) != 0)
10211 fnp
->is_artificial
= 1;
10213 /* Get index in virtual function table if it is a virtual member
10214 function. For older versions of GCC, this is an offset in the
10215 appropriate virtual table, as specified by DW_AT_containing_type.
10216 For everyone else, it is an expression to be evaluated relative
10217 to the object address. */
10219 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
10222 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
10224 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
10226 /* Old-style GCC. */
10227 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
10229 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
10230 || (DW_BLOCK (attr
)->size
> 1
10231 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
10232 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
10234 struct dwarf_block blk
;
10237 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
10239 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
10240 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
10241 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
10242 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
10243 dwarf2_complex_location_expr_complaint ();
10245 fnp
->voffset
/= cu
->header
.addr_size
;
10249 dwarf2_complex_location_expr_complaint ();
10251 if (!fnp
->fcontext
)
10252 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
10254 else if (attr_form_is_section_offset (attr
))
10256 dwarf2_complex_location_expr_complaint ();
10260 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
10266 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
10267 if (attr
&& DW_UNSND (attr
))
10269 /* GCC does this, as of 2008-08-25; PR debug/37237. */
10270 complaint (&symfile_complaints
,
10271 _("Member function \"%s\" (offset %d) is virtual "
10272 "but the vtable offset is not specified"),
10273 fieldname
, die
->offset
.sect_off
);
10274 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
10275 TYPE_CPLUS_DYNAMIC (type
) = 1;
10280 /* Create the vector of member function fields, and attach it to the type. */
10283 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
10284 struct dwarf2_cu
*cu
)
10286 struct fnfieldlist
*flp
;
10289 if (cu
->language
== language_ada
)
10290 error (_("unexpected member functions in Ada type"));
10292 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
10293 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
10294 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
10296 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
10298 struct nextfnfield
*nfp
= flp
->head
;
10299 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
10302 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
10303 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
10304 fn_flp
->fn_fields
= (struct fn_field
*)
10305 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
10306 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
10307 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
10310 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
10313 /* Returns non-zero if NAME is the name of a vtable member in CU's
10314 language, zero otherwise. */
10316 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
10318 static const char vptr
[] = "_vptr";
10319 static const char vtable
[] = "vtable";
10321 /* Look for the C++ and Java forms of the vtable. */
10322 if ((cu
->language
== language_java
10323 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
10324 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
10325 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
10331 /* GCC outputs unnamed structures that are really pointers to member
10332 functions, with the ABI-specified layout. If TYPE describes
10333 such a structure, smash it into a member function type.
10335 GCC shouldn't do this; it should just output pointer to member DIEs.
10336 This is GCC PR debug/28767. */
10339 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
10341 struct type
*pfn_type
, *domain_type
, *new_type
;
10343 /* Check for a structure with no name and two children. */
10344 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
10347 /* Check for __pfn and __delta members. */
10348 if (TYPE_FIELD_NAME (type
, 0) == NULL
10349 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
10350 || TYPE_FIELD_NAME (type
, 1) == NULL
10351 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
10354 /* Find the type of the method. */
10355 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
10356 if (pfn_type
== NULL
10357 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
10358 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
10361 /* Look for the "this" argument. */
10362 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
10363 if (TYPE_NFIELDS (pfn_type
) == 0
10364 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
10365 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
10368 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
10369 new_type
= alloc_type (objfile
);
10370 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
10371 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
10372 TYPE_VARARGS (pfn_type
));
10373 smash_to_methodptr_type (type
, new_type
);
10376 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
10380 producer_is_icc (struct dwarf2_cu
*cu
)
10382 if (!cu
->checked_producer
)
10383 check_producer (cu
);
10385 return cu
->producer_is_icc
;
10388 /* Called when we find the DIE that starts a structure or union scope
10389 (definition) to create a type for the structure or union. Fill in
10390 the type's name and general properties; the members will not be
10391 processed until process_structure_type.
10393 NOTE: we need to call these functions regardless of whether or not the
10394 DIE has a DW_AT_name attribute, since it might be an anonymous
10395 structure or union. This gets the type entered into our set of
10396 user defined types.
10398 However, if the structure is incomplete (an opaque struct/union)
10399 then suppress creating a symbol table entry for it since gdb only
10400 wants to find the one with the complete definition. Note that if
10401 it is complete, we just call new_symbol, which does it's own
10402 checking about whether the struct/union is anonymous or not (and
10403 suppresses creating a symbol table entry itself). */
10405 static struct type
*
10406 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10408 struct objfile
*objfile
= cu
->objfile
;
10410 struct attribute
*attr
;
10413 /* If the definition of this type lives in .debug_types, read that type.
10414 Don't follow DW_AT_specification though, that will take us back up
10415 the chain and we want to go down. */
10416 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
10419 struct dwarf2_cu
*type_cu
= cu
;
10420 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
10422 /* We could just recurse on read_structure_type, but we need to call
10423 get_die_type to ensure only one type for this DIE is created.
10424 This is important, for example, because for c++ classes we need
10425 TYPE_NAME set which is only done by new_symbol. Blech. */
10426 type
= read_type_die (type_die
, type_cu
);
10428 /* TYPE_CU may not be the same as CU.
10429 Ensure TYPE is recorded in CU's type_hash table. */
10430 return set_die_type (die
, type
, cu
);
10433 type
= alloc_type (objfile
);
10434 INIT_CPLUS_SPECIFIC (type
);
10436 name
= dwarf2_name (die
, cu
);
10439 if (cu
->language
== language_cplus
10440 || cu
->language
== language_java
)
10442 char *full_name
= (char *) dwarf2_full_name (name
, die
, cu
);
10444 /* dwarf2_full_name might have already finished building the DIE's
10445 type. If so, there is no need to continue. */
10446 if (get_die_type (die
, cu
) != NULL
)
10447 return get_die_type (die
, cu
);
10449 TYPE_TAG_NAME (type
) = full_name
;
10450 if (die
->tag
== DW_TAG_structure_type
10451 || die
->tag
== DW_TAG_class_type
)
10452 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
10456 /* The name is already allocated along with this objfile, so
10457 we don't need to duplicate it for the type. */
10458 TYPE_TAG_NAME (type
) = (char *) name
;
10459 if (die
->tag
== DW_TAG_class_type
)
10460 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
10464 if (die
->tag
== DW_TAG_structure_type
)
10466 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10468 else if (die
->tag
== DW_TAG_union_type
)
10470 TYPE_CODE (type
) = TYPE_CODE_UNION
;
10474 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
10477 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
10478 TYPE_DECLARED_CLASS (type
) = 1;
10480 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
10483 TYPE_LENGTH (type
) = DW_UNSND (attr
);
10487 TYPE_LENGTH (type
) = 0;
10490 if (producer_is_icc (cu
))
10492 /* ICC does not output the required DW_AT_declaration
10493 on incomplete types, but gives them a size of zero. */
10496 TYPE_STUB_SUPPORTED (type
) = 1;
10498 if (die_is_declaration (die
, cu
))
10499 TYPE_STUB (type
) = 1;
10500 else if (attr
== NULL
&& die
->child
== NULL
10501 && producer_is_realview (cu
->producer
))
10502 /* RealView does not output the required DW_AT_declaration
10503 on incomplete types. */
10504 TYPE_STUB (type
) = 1;
10506 /* We need to add the type field to the die immediately so we don't
10507 infinitely recurse when dealing with pointers to the structure
10508 type within the structure itself. */
10509 set_die_type (die
, type
, cu
);
10511 /* set_die_type should be already done. */
10512 set_descriptive_type (type
, die
, cu
);
10517 /* Finish creating a structure or union type, including filling in
10518 its members and creating a symbol for it. */
10521 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10523 struct objfile
*objfile
= cu
->objfile
;
10524 struct die_info
*child_die
= die
->child
;
10527 type
= get_die_type (die
, cu
);
10529 type
= read_structure_type (die
, cu
);
10531 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
10533 struct field_info fi
;
10534 struct die_info
*child_die
;
10535 VEC (symbolp
) *template_args
= NULL
;
10536 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
10538 memset (&fi
, 0, sizeof (struct field_info
));
10540 child_die
= die
->child
;
10542 while (child_die
&& child_die
->tag
)
10544 if (child_die
->tag
== DW_TAG_member
10545 || child_die
->tag
== DW_TAG_variable
)
10547 /* NOTE: carlton/2002-11-05: A C++ static data member
10548 should be a DW_TAG_member that is a declaration, but
10549 all versions of G++ as of this writing (so through at
10550 least 3.2.1) incorrectly generate DW_TAG_variable
10551 tags for them instead. */
10552 dwarf2_add_field (&fi
, child_die
, cu
);
10554 else if (child_die
->tag
== DW_TAG_subprogram
)
10556 /* C++ member function. */
10557 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
10559 else if (child_die
->tag
== DW_TAG_inheritance
)
10561 /* C++ base class field. */
10562 dwarf2_add_field (&fi
, child_die
, cu
);
10564 else if (child_die
->tag
== DW_TAG_typedef
)
10565 dwarf2_add_typedef (&fi
, child_die
, cu
);
10566 else if (child_die
->tag
== DW_TAG_template_type_param
10567 || child_die
->tag
== DW_TAG_template_value_param
)
10569 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
10572 VEC_safe_push (symbolp
, template_args
, arg
);
10575 child_die
= sibling_die (child_die
);
10578 /* Attach template arguments to type. */
10579 if (! VEC_empty (symbolp
, template_args
))
10581 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
10582 TYPE_N_TEMPLATE_ARGUMENTS (type
)
10583 = VEC_length (symbolp
, template_args
);
10584 TYPE_TEMPLATE_ARGUMENTS (type
)
10585 = obstack_alloc (&objfile
->objfile_obstack
,
10586 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
10587 * sizeof (struct symbol
*)));
10588 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
10589 VEC_address (symbolp
, template_args
),
10590 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
10591 * sizeof (struct symbol
*)));
10592 VEC_free (symbolp
, template_args
);
10595 /* Attach fields and member functions to the type. */
10597 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
10600 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
10602 /* Get the type which refers to the base class (possibly this
10603 class itself) which contains the vtable pointer for the current
10604 class from the DW_AT_containing_type attribute. This use of
10605 DW_AT_containing_type is a GNU extension. */
10607 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
10609 struct type
*t
= die_containing_type (die
, cu
);
10611 TYPE_VPTR_BASETYPE (type
) = t
;
10616 /* Our own class provides vtbl ptr. */
10617 for (i
= TYPE_NFIELDS (t
) - 1;
10618 i
>= TYPE_N_BASECLASSES (t
);
10621 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
10623 if (is_vtable_name (fieldname
, cu
))
10625 TYPE_VPTR_FIELDNO (type
) = i
;
10630 /* Complain if virtual function table field not found. */
10631 if (i
< TYPE_N_BASECLASSES (t
))
10632 complaint (&symfile_complaints
,
10633 _("virtual function table pointer "
10634 "not found when defining class '%s'"),
10635 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
10640 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
10643 else if (cu
->producer
10644 && strncmp (cu
->producer
,
10645 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
10647 /* The IBM XLC compiler does not provide direct indication
10648 of the containing type, but the vtable pointer is
10649 always named __vfp. */
10653 for (i
= TYPE_NFIELDS (type
) - 1;
10654 i
>= TYPE_N_BASECLASSES (type
);
10657 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
10659 TYPE_VPTR_FIELDNO (type
) = i
;
10660 TYPE_VPTR_BASETYPE (type
) = type
;
10667 /* Copy fi.typedef_field_list linked list elements content into the
10668 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
10669 if (fi
.typedef_field_list
)
10671 int i
= fi
.typedef_field_list_count
;
10673 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
10674 TYPE_TYPEDEF_FIELD_ARRAY (type
)
10675 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
10676 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
10678 /* Reverse the list order to keep the debug info elements order. */
10681 struct typedef_field
*dest
, *src
;
10683 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
10684 src
= &fi
.typedef_field_list
->field
;
10685 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
10690 do_cleanups (back_to
);
10692 if (HAVE_CPLUS_STRUCT (type
))
10693 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
10696 quirk_gcc_member_function_pointer (type
, objfile
);
10698 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
10699 snapshots) has been known to create a die giving a declaration
10700 for a class that has, as a child, a die giving a definition for a
10701 nested class. So we have to process our children even if the
10702 current die is a declaration. Normally, of course, a declaration
10703 won't have any children at all. */
10705 while (child_die
!= NULL
&& child_die
->tag
)
10707 if (child_die
->tag
== DW_TAG_member
10708 || child_die
->tag
== DW_TAG_variable
10709 || child_die
->tag
== DW_TAG_inheritance
10710 || child_die
->tag
== DW_TAG_template_value_param
10711 || child_die
->tag
== DW_TAG_template_type_param
)
10716 process_die (child_die
, cu
);
10718 child_die
= sibling_die (child_die
);
10721 /* Do not consider external references. According to the DWARF standard,
10722 these DIEs are identified by the fact that they have no byte_size
10723 attribute, and a declaration attribute. */
10724 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
10725 || !die_is_declaration (die
, cu
))
10726 new_symbol (die
, type
, cu
);
10729 /* Given a DW_AT_enumeration_type die, set its type. We do not
10730 complete the type's fields yet, or create any symbols. */
10732 static struct type
*
10733 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10735 struct objfile
*objfile
= cu
->objfile
;
10737 struct attribute
*attr
;
10740 /* If the definition of this type lives in .debug_types, read that type.
10741 Don't follow DW_AT_specification though, that will take us back up
10742 the chain and we want to go down. */
10743 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
10746 struct dwarf2_cu
*type_cu
= cu
;
10747 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
10749 type
= read_type_die (type_die
, type_cu
);
10751 /* TYPE_CU may not be the same as CU.
10752 Ensure TYPE is recorded in CU's type_hash table. */
10753 return set_die_type (die
, type
, cu
);
10756 type
= alloc_type (objfile
);
10758 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
10759 name
= dwarf2_full_name (NULL
, die
, cu
);
10761 TYPE_TAG_NAME (type
) = (char *) name
;
10763 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
10766 TYPE_LENGTH (type
) = DW_UNSND (attr
);
10770 TYPE_LENGTH (type
) = 0;
10773 /* The enumeration DIE can be incomplete. In Ada, any type can be
10774 declared as private in the package spec, and then defined only
10775 inside the package body. Such types are known as Taft Amendment
10776 Types. When another package uses such a type, an incomplete DIE
10777 may be generated by the compiler. */
10778 if (die_is_declaration (die
, cu
))
10779 TYPE_STUB (type
) = 1;
10781 return set_die_type (die
, type
, cu
);
10784 /* Given a pointer to a die which begins an enumeration, process all
10785 the dies that define the members of the enumeration, and create the
10786 symbol for the enumeration type.
10788 NOTE: We reverse the order of the element list. */
10791 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10793 struct type
*this_type
;
10795 this_type
= get_die_type (die
, cu
);
10796 if (this_type
== NULL
)
10797 this_type
= read_enumeration_type (die
, cu
);
10799 if (die
->child
!= NULL
)
10801 struct die_info
*child_die
;
10802 struct symbol
*sym
;
10803 struct field
*fields
= NULL
;
10804 int num_fields
= 0;
10805 int unsigned_enum
= 1;
10810 child_die
= die
->child
;
10811 while (child_die
&& child_die
->tag
)
10813 if (child_die
->tag
!= DW_TAG_enumerator
)
10815 process_die (child_die
, cu
);
10819 name
= dwarf2_name (child_die
, cu
);
10822 sym
= new_symbol (child_die
, this_type
, cu
);
10823 if (SYMBOL_VALUE (sym
) < 0)
10828 else if ((mask
& SYMBOL_VALUE (sym
)) != 0)
10831 mask
|= SYMBOL_VALUE (sym
);
10833 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
10835 fields
= (struct field
*)
10837 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
10838 * sizeof (struct field
));
10841 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
10842 FIELD_TYPE (fields
[num_fields
]) = NULL
;
10843 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
10844 FIELD_BITSIZE (fields
[num_fields
]) = 0;
10850 child_die
= sibling_die (child_die
);
10855 TYPE_NFIELDS (this_type
) = num_fields
;
10856 TYPE_FIELDS (this_type
) = (struct field
*)
10857 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
10858 memcpy (TYPE_FIELDS (this_type
), fields
,
10859 sizeof (struct field
) * num_fields
);
10863 TYPE_UNSIGNED (this_type
) = 1;
10865 TYPE_FLAG_ENUM (this_type
) = 1;
10868 /* If we are reading an enum from a .debug_types unit, and the enum
10869 is a declaration, and the enum is not the signatured type in the
10870 unit, then we do not want to add a symbol for it. Adding a
10871 symbol would in some cases obscure the true definition of the
10872 enum, giving users an incomplete type when the definition is
10873 actually available. Note that we do not want to do this for all
10874 enums which are just declarations, because C++0x allows forward
10875 enum declarations. */
10876 if (cu
->per_cu
->is_debug_types
10877 && die_is_declaration (die
, cu
))
10879 struct signatured_type
*sig_type
;
10882 = lookup_signatured_type_at_offset (dwarf2_per_objfile
->objfile
,
10883 cu
->per_cu
->info_or_types_section
,
10884 cu
->per_cu
->offset
);
10885 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
10886 if (sig_type
->type_offset_in_section
.sect_off
!= die
->offset
.sect_off
)
10890 new_symbol (die
, this_type
, cu
);
10893 /* Extract all information from a DW_TAG_array_type DIE and put it in
10894 the DIE's type field. For now, this only handles one dimensional
10897 static struct type
*
10898 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10900 struct objfile
*objfile
= cu
->objfile
;
10901 struct die_info
*child_die
;
10903 struct type
*element_type
, *range_type
, *index_type
;
10904 struct type
**range_types
= NULL
;
10905 struct attribute
*attr
;
10907 struct cleanup
*back_to
;
10910 element_type
= die_type (die
, cu
);
10912 /* The die_type call above may have already set the type for this DIE. */
10913 type
= get_die_type (die
, cu
);
10917 /* Irix 6.2 native cc creates array types without children for
10918 arrays with unspecified length. */
10919 if (die
->child
== NULL
)
10921 index_type
= objfile_type (objfile
)->builtin_int
;
10922 range_type
= create_range_type (NULL
, index_type
, 0, -1);
10923 type
= create_array_type (NULL
, element_type
, range_type
);
10924 return set_die_type (die
, type
, cu
);
10927 back_to
= make_cleanup (null_cleanup
, NULL
);
10928 child_die
= die
->child
;
10929 while (child_die
&& child_die
->tag
)
10931 if (child_die
->tag
== DW_TAG_subrange_type
)
10933 struct type
*child_type
= read_type_die (child_die
, cu
);
10935 if (child_type
!= NULL
)
10937 /* The range type was succesfully read. Save it for the
10938 array type creation. */
10939 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
10941 range_types
= (struct type
**)
10942 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
10943 * sizeof (struct type
*));
10945 make_cleanup (free_current_contents
, &range_types
);
10947 range_types
[ndim
++] = child_type
;
10950 child_die
= sibling_die (child_die
);
10953 /* Dwarf2 dimensions are output from left to right, create the
10954 necessary array types in backwards order. */
10956 type
= element_type
;
10958 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
10963 type
= create_array_type (NULL
, type
, range_types
[i
++]);
10968 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
10971 /* Understand Dwarf2 support for vector types (like they occur on
10972 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
10973 array type. This is not part of the Dwarf2/3 standard yet, but a
10974 custom vendor extension. The main difference between a regular
10975 array and the vector variant is that vectors are passed by value
10977 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
10979 make_vector_type (type
);
10981 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
10982 implementation may choose to implement triple vectors using this
10984 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
10987 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
10988 TYPE_LENGTH (type
) = DW_UNSND (attr
);
10990 complaint (&symfile_complaints
,
10991 _("DW_AT_byte_size for array type smaller "
10992 "than the total size of elements"));
10995 name
= dwarf2_name (die
, cu
);
10997 TYPE_NAME (type
) = name
;
10999 /* Install the type in the die. */
11000 set_die_type (die
, type
, cu
);
11002 /* set_die_type should be already done. */
11003 set_descriptive_type (type
, die
, cu
);
11005 do_cleanups (back_to
);
11010 static enum dwarf_array_dim_ordering
11011 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
11013 struct attribute
*attr
;
11015 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
11017 if (attr
) return DW_SND (attr
);
11019 /* GNU F77 is a special case, as at 08/2004 array type info is the
11020 opposite order to the dwarf2 specification, but data is still
11021 laid out as per normal fortran.
11023 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
11024 version checking. */
11026 if (cu
->language
== language_fortran
11027 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
11029 return DW_ORD_row_major
;
11032 switch (cu
->language_defn
->la_array_ordering
)
11034 case array_column_major
:
11035 return DW_ORD_col_major
;
11036 case array_row_major
:
11038 return DW_ORD_row_major
;
11042 /* Extract all information from a DW_TAG_set_type DIE and put it in
11043 the DIE's type field. */
11045 static struct type
*
11046 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11048 struct type
*domain_type
, *set_type
;
11049 struct attribute
*attr
;
11051 domain_type
= die_type (die
, cu
);
11053 /* The die_type call above may have already set the type for this DIE. */
11054 set_type
= get_die_type (die
, cu
);
11058 set_type
= create_set_type (NULL
, domain_type
);
11060 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
11062 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
11064 return set_die_type (die
, set_type
, cu
);
11067 /* First cut: install each common block member as a global variable. */
11070 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
11072 struct die_info
*child_die
;
11073 struct attribute
*attr
;
11074 struct symbol
*sym
;
11075 CORE_ADDR base
= (CORE_ADDR
) 0;
11077 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11080 /* Support the .debug_loc offsets. */
11081 if (attr_form_is_block (attr
))
11083 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
11085 else if (attr_form_is_section_offset (attr
))
11087 dwarf2_complex_location_expr_complaint ();
11091 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
11092 "common block member");
11095 if (die
->child
!= NULL
)
11097 child_die
= die
->child
;
11098 while (child_die
&& child_die
->tag
)
11102 sym
= new_symbol (child_die
, NULL
, cu
);
11104 && handle_data_member_location (child_die
, cu
, &offset
))
11106 SYMBOL_VALUE_ADDRESS (sym
) = base
+ offset
;
11107 add_symbol_to_list (sym
, &global_symbols
);
11109 child_die
= sibling_die (child_die
);
11114 /* Create a type for a C++ namespace. */
11116 static struct type
*
11117 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11119 struct objfile
*objfile
= cu
->objfile
;
11120 const char *previous_prefix
, *name
;
11124 /* For extensions, reuse the type of the original namespace. */
11125 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
11127 struct die_info
*ext_die
;
11128 struct dwarf2_cu
*ext_cu
= cu
;
11130 ext_die
= dwarf2_extension (die
, &ext_cu
);
11131 type
= read_type_die (ext_die
, ext_cu
);
11133 /* EXT_CU may not be the same as CU.
11134 Ensure TYPE is recorded in CU's type_hash table. */
11135 return set_die_type (die
, type
, cu
);
11138 name
= namespace_name (die
, &is_anonymous
, cu
);
11140 /* Now build the name of the current namespace. */
11142 previous_prefix
= determine_prefix (die
, cu
);
11143 if (previous_prefix
[0] != '\0')
11144 name
= typename_concat (&objfile
->objfile_obstack
,
11145 previous_prefix
, name
, 0, cu
);
11147 /* Create the type. */
11148 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
11150 TYPE_NAME (type
) = (char *) name
;
11151 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
11153 return set_die_type (die
, type
, cu
);
11156 /* Read a C++ namespace. */
11159 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
11161 struct objfile
*objfile
= cu
->objfile
;
11164 /* Add a symbol associated to this if we haven't seen the namespace
11165 before. Also, add a using directive if it's an anonymous
11168 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
11172 type
= read_type_die (die
, cu
);
11173 new_symbol (die
, type
, cu
);
11175 namespace_name (die
, &is_anonymous
, cu
);
11178 const char *previous_prefix
= determine_prefix (die
, cu
);
11180 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
11181 NULL
, NULL
, &objfile
->objfile_obstack
);
11185 if (die
->child
!= NULL
)
11187 struct die_info
*child_die
= die
->child
;
11189 while (child_die
&& child_die
->tag
)
11191 process_die (child_die
, cu
);
11192 child_die
= sibling_die (child_die
);
11197 /* Read a Fortran module as type. This DIE can be only a declaration used for
11198 imported module. Still we need that type as local Fortran "use ... only"
11199 declaration imports depend on the created type in determine_prefix. */
11201 static struct type
*
11202 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11204 struct objfile
*objfile
= cu
->objfile
;
11208 module_name
= dwarf2_name (die
, cu
);
11210 complaint (&symfile_complaints
,
11211 _("DW_TAG_module has no name, offset 0x%x"),
11212 die
->offset
.sect_off
);
11213 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
11215 /* determine_prefix uses TYPE_TAG_NAME. */
11216 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
11218 return set_die_type (die
, type
, cu
);
11221 /* Read a Fortran module. */
11224 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
11226 struct die_info
*child_die
= die
->child
;
11228 while (child_die
&& child_die
->tag
)
11230 process_die (child_die
, cu
);
11231 child_die
= sibling_die (child_die
);
11235 /* Return the name of the namespace represented by DIE. Set
11236 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
11239 static const char *
11240 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
11242 struct die_info
*current_die
;
11243 const char *name
= NULL
;
11245 /* Loop through the extensions until we find a name. */
11247 for (current_die
= die
;
11248 current_die
!= NULL
;
11249 current_die
= dwarf2_extension (die
, &cu
))
11251 name
= dwarf2_name (current_die
, cu
);
11256 /* Is it an anonymous namespace? */
11258 *is_anonymous
= (name
== NULL
);
11260 name
= CP_ANONYMOUS_NAMESPACE_STR
;
11265 /* Extract all information from a DW_TAG_pointer_type DIE and add to
11266 the user defined type vector. */
11268 static struct type
*
11269 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11271 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
11272 struct comp_unit_head
*cu_header
= &cu
->header
;
11274 struct attribute
*attr_byte_size
;
11275 struct attribute
*attr_address_class
;
11276 int byte_size
, addr_class
;
11277 struct type
*target_type
;
11279 target_type
= die_type (die
, cu
);
11281 /* The die_type call above may have already set the type for this DIE. */
11282 type
= get_die_type (die
, cu
);
11286 type
= lookup_pointer_type (target_type
);
11288 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
11289 if (attr_byte_size
)
11290 byte_size
= DW_UNSND (attr_byte_size
);
11292 byte_size
= cu_header
->addr_size
;
11294 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
11295 if (attr_address_class
)
11296 addr_class
= DW_UNSND (attr_address_class
);
11298 addr_class
= DW_ADDR_none
;
11300 /* If the pointer size or address class is different than the
11301 default, create a type variant marked as such and set the
11302 length accordingly. */
11303 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
11305 if (gdbarch_address_class_type_flags_p (gdbarch
))
11309 type_flags
= gdbarch_address_class_type_flags
11310 (gdbarch
, byte_size
, addr_class
);
11311 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
11313 type
= make_type_with_address_space (type
, type_flags
);
11315 else if (TYPE_LENGTH (type
) != byte_size
)
11317 complaint (&symfile_complaints
,
11318 _("invalid pointer size %d"), byte_size
);
11322 /* Should we also complain about unhandled address classes? */
11326 TYPE_LENGTH (type
) = byte_size
;
11327 return set_die_type (die
, type
, cu
);
11330 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
11331 the user defined type vector. */
11333 static struct type
*
11334 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11337 struct type
*to_type
;
11338 struct type
*domain
;
11340 to_type
= die_type (die
, cu
);
11341 domain
= die_containing_type (die
, cu
);
11343 /* The calls above may have already set the type for this DIE. */
11344 type
= get_die_type (die
, cu
);
11348 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
11349 type
= lookup_methodptr_type (to_type
);
11351 type
= lookup_memberptr_type (to_type
, domain
);
11353 return set_die_type (die
, type
, cu
);
11356 /* Extract all information from a DW_TAG_reference_type DIE and add to
11357 the user defined type vector. */
11359 static struct type
*
11360 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11362 struct comp_unit_head
*cu_header
= &cu
->header
;
11363 struct type
*type
, *target_type
;
11364 struct attribute
*attr
;
11366 target_type
= die_type (die
, cu
);
11368 /* The die_type call above may have already set the type for this DIE. */
11369 type
= get_die_type (die
, cu
);
11373 type
= lookup_reference_type (target_type
);
11374 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
11377 TYPE_LENGTH (type
) = DW_UNSND (attr
);
11381 TYPE_LENGTH (type
) = cu_header
->addr_size
;
11383 return set_die_type (die
, type
, cu
);
11386 static struct type
*
11387 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11389 struct type
*base_type
, *cv_type
;
11391 base_type
= die_type (die
, cu
);
11393 /* The die_type call above may have already set the type for this DIE. */
11394 cv_type
= get_die_type (die
, cu
);
11398 /* In case the const qualifier is applied to an array type, the element type
11399 is so qualified, not the array type (section 6.7.3 of C99). */
11400 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
11402 struct type
*el_type
, *inner_array
;
11404 base_type
= copy_type (base_type
);
11405 inner_array
= base_type
;
11407 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
11409 TYPE_TARGET_TYPE (inner_array
) =
11410 copy_type (TYPE_TARGET_TYPE (inner_array
));
11411 inner_array
= TYPE_TARGET_TYPE (inner_array
);
11414 el_type
= TYPE_TARGET_TYPE (inner_array
);
11415 TYPE_TARGET_TYPE (inner_array
) =
11416 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
11418 return set_die_type (die
, base_type
, cu
);
11421 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
11422 return set_die_type (die
, cv_type
, cu
);
11425 static struct type
*
11426 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11428 struct type
*base_type
, *cv_type
;
11430 base_type
= die_type (die
, cu
);
11432 /* The die_type call above may have already set the type for this DIE. */
11433 cv_type
= get_die_type (die
, cu
);
11437 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
11438 return set_die_type (die
, cv_type
, cu
);
11441 /* Extract all information from a DW_TAG_string_type DIE and add to
11442 the user defined type vector. It isn't really a user defined type,
11443 but it behaves like one, with other DIE's using an AT_user_def_type
11444 attribute to reference it. */
11446 static struct type
*
11447 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11449 struct objfile
*objfile
= cu
->objfile
;
11450 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11451 struct type
*type
, *range_type
, *index_type
, *char_type
;
11452 struct attribute
*attr
;
11453 unsigned int length
;
11455 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
11458 length
= DW_UNSND (attr
);
11462 /* Check for the DW_AT_byte_size attribute. */
11463 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
11466 length
= DW_UNSND (attr
);
11474 index_type
= objfile_type (objfile
)->builtin_int
;
11475 range_type
= create_range_type (NULL
, index_type
, 1, length
);
11476 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
11477 type
= create_string_type (NULL
, char_type
, range_type
);
11479 return set_die_type (die
, type
, cu
);
11482 /* Handle DIES due to C code like:
11486 int (*funcp)(int a, long l);
11490 ('funcp' generates a DW_TAG_subroutine_type DIE). */
11492 static struct type
*
11493 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11495 struct objfile
*objfile
= cu
->objfile
;
11496 struct type
*type
; /* Type that this function returns. */
11497 struct type
*ftype
; /* Function that returns above type. */
11498 struct attribute
*attr
;
11500 type
= die_type (die
, cu
);
11502 /* The die_type call above may have already set the type for this DIE. */
11503 ftype
= get_die_type (die
, cu
);
11507 ftype
= lookup_function_type (type
);
11509 /* All functions in C++, Pascal and Java have prototypes. */
11510 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
11511 if ((attr
&& (DW_UNSND (attr
) != 0))
11512 || cu
->language
== language_cplus
11513 || cu
->language
== language_java
11514 || cu
->language
== language_pascal
)
11515 TYPE_PROTOTYPED (ftype
) = 1;
11516 else if (producer_is_realview (cu
->producer
))
11517 /* RealView does not emit DW_AT_prototyped. We can not
11518 distinguish prototyped and unprototyped functions; default to
11519 prototyped, since that is more common in modern code (and
11520 RealView warns about unprototyped functions). */
11521 TYPE_PROTOTYPED (ftype
) = 1;
11523 /* Store the calling convention in the type if it's available in
11524 the subroutine die. Otherwise set the calling convention to
11525 the default value DW_CC_normal. */
11526 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
11528 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
11529 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
11530 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
11532 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
11534 /* We need to add the subroutine type to the die immediately so
11535 we don't infinitely recurse when dealing with parameters
11536 declared as the same subroutine type. */
11537 set_die_type (die
, ftype
, cu
);
11539 if (die
->child
!= NULL
)
11541 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
11542 struct die_info
*child_die
;
11543 int nparams
, iparams
;
11545 /* Count the number of parameters.
11546 FIXME: GDB currently ignores vararg functions, but knows about
11547 vararg member functions. */
11549 child_die
= die
->child
;
11550 while (child_die
&& child_die
->tag
)
11552 if (child_die
->tag
== DW_TAG_formal_parameter
)
11554 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
11555 TYPE_VARARGS (ftype
) = 1;
11556 child_die
= sibling_die (child_die
);
11559 /* Allocate storage for parameters and fill them in. */
11560 TYPE_NFIELDS (ftype
) = nparams
;
11561 TYPE_FIELDS (ftype
) = (struct field
*)
11562 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
11564 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
11565 even if we error out during the parameters reading below. */
11566 for (iparams
= 0; iparams
< nparams
; iparams
++)
11567 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
11570 child_die
= die
->child
;
11571 while (child_die
&& child_die
->tag
)
11573 if (child_die
->tag
== DW_TAG_formal_parameter
)
11575 struct type
*arg_type
;
11577 /* DWARF version 2 has no clean way to discern C++
11578 static and non-static member functions. G++ helps
11579 GDB by marking the first parameter for non-static
11580 member functions (which is the this pointer) as
11581 artificial. We pass this information to
11582 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
11584 DWARF version 3 added DW_AT_object_pointer, which GCC
11585 4.5 does not yet generate. */
11586 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
11588 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
11591 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
11593 /* GCC/43521: In java, the formal parameter
11594 "this" is sometimes not marked with DW_AT_artificial. */
11595 if (cu
->language
== language_java
)
11597 const char *name
= dwarf2_name (child_die
, cu
);
11599 if (name
&& !strcmp (name
, "this"))
11600 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
11603 arg_type
= die_type (child_die
, cu
);
11605 /* RealView does not mark THIS as const, which the testsuite
11606 expects. GCC marks THIS as const in method definitions,
11607 but not in the class specifications (GCC PR 43053). */
11608 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
11609 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
11612 struct dwarf2_cu
*arg_cu
= cu
;
11613 const char *name
= dwarf2_name (child_die
, cu
);
11615 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
11618 /* If the compiler emits this, use it. */
11619 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
11622 else if (name
&& strcmp (name
, "this") == 0)
11623 /* Function definitions will have the argument names. */
11625 else if (name
== NULL
&& iparams
== 0)
11626 /* Declarations may not have the names, so like
11627 elsewhere in GDB, assume an artificial first
11628 argument is "this". */
11632 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
11636 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
11639 child_die
= sibling_die (child_die
);
11646 static struct type
*
11647 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
11649 struct objfile
*objfile
= cu
->objfile
;
11650 const char *name
= NULL
;
11651 struct type
*this_type
, *target_type
;
11653 name
= dwarf2_full_name (NULL
, die
, cu
);
11654 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
11655 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
11656 TYPE_NAME (this_type
) = (char *) name
;
11657 set_die_type (die
, this_type
, cu
);
11658 target_type
= die_type (die
, cu
);
11659 if (target_type
!= this_type
)
11660 TYPE_TARGET_TYPE (this_type
) = target_type
;
11663 /* Self-referential typedefs are, it seems, not allowed by the DWARF
11664 spec and cause infinite loops in GDB. */
11665 complaint (&symfile_complaints
,
11666 _("Self-referential DW_TAG_typedef "
11667 "- DIE at 0x%x [in module %s]"),
11668 die
->offset
.sect_off
, objfile
->name
);
11669 TYPE_TARGET_TYPE (this_type
) = NULL
;
11674 /* Find a representation of a given base type and install
11675 it in the TYPE field of the die. */
11677 static struct type
*
11678 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11680 struct objfile
*objfile
= cu
->objfile
;
11682 struct attribute
*attr
;
11683 int encoding
= 0, size
= 0;
11685 enum type_code code
= TYPE_CODE_INT
;
11686 int type_flags
= 0;
11687 struct type
*target_type
= NULL
;
11689 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
11692 encoding
= DW_UNSND (attr
);
11694 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
11697 size
= DW_UNSND (attr
);
11699 name
= dwarf2_name (die
, cu
);
11702 complaint (&symfile_complaints
,
11703 _("DW_AT_name missing from DW_TAG_base_type"));
11708 case DW_ATE_address
:
11709 /* Turn DW_ATE_address into a void * pointer. */
11710 code
= TYPE_CODE_PTR
;
11711 type_flags
|= TYPE_FLAG_UNSIGNED
;
11712 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
11714 case DW_ATE_boolean
:
11715 code
= TYPE_CODE_BOOL
;
11716 type_flags
|= TYPE_FLAG_UNSIGNED
;
11718 case DW_ATE_complex_float
:
11719 code
= TYPE_CODE_COMPLEX
;
11720 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
11722 case DW_ATE_decimal_float
:
11723 code
= TYPE_CODE_DECFLOAT
;
11726 code
= TYPE_CODE_FLT
;
11728 case DW_ATE_signed
:
11730 case DW_ATE_unsigned
:
11731 type_flags
|= TYPE_FLAG_UNSIGNED
;
11732 if (cu
->language
== language_fortran
11734 && strncmp (name
, "character(", sizeof ("character(") - 1) == 0)
11735 code
= TYPE_CODE_CHAR
;
11737 case DW_ATE_signed_char
:
11738 if (cu
->language
== language_ada
|| cu
->language
== language_m2
11739 || cu
->language
== language_pascal
11740 || cu
->language
== language_fortran
)
11741 code
= TYPE_CODE_CHAR
;
11743 case DW_ATE_unsigned_char
:
11744 if (cu
->language
== language_ada
|| cu
->language
== language_m2
11745 || cu
->language
== language_pascal
11746 || cu
->language
== language_fortran
)
11747 code
= TYPE_CODE_CHAR
;
11748 type_flags
|= TYPE_FLAG_UNSIGNED
;
11751 /* We just treat this as an integer and then recognize the
11752 type by name elsewhere. */
11756 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
11757 dwarf_type_encoding_name (encoding
));
11761 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
11762 TYPE_NAME (type
) = name
;
11763 TYPE_TARGET_TYPE (type
) = target_type
;
11765 if (name
&& strcmp (name
, "char") == 0)
11766 TYPE_NOSIGN (type
) = 1;
11768 return set_die_type (die
, type
, cu
);
11771 /* Read the given DW_AT_subrange DIE. */
11773 static struct type
*
11774 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11776 struct type
*base_type
;
11777 struct type
*range_type
;
11778 struct attribute
*attr
;
11780 int low_default_is_valid
;
11782 LONGEST negative_mask
;
11784 base_type
= die_type (die
, cu
);
11785 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
11786 check_typedef (base_type
);
11788 /* The die_type call above may have already set the type for this DIE. */
11789 range_type
= get_die_type (die
, cu
);
11793 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
11794 omitting DW_AT_lower_bound. */
11795 switch (cu
->language
)
11798 case language_cplus
:
11800 low_default_is_valid
= 1;
11802 case language_fortran
:
11804 low_default_is_valid
= 1;
11807 case language_java
:
11808 case language_objc
:
11810 low_default_is_valid
= (cu
->header
.version
>= 4);
11814 case language_pascal
:
11816 low_default_is_valid
= (cu
->header
.version
>= 4);
11820 low_default_is_valid
= 0;
11824 /* FIXME: For variable sized arrays either of these could be
11825 a variable rather than a constant value. We'll allow it,
11826 but we don't know how to handle it. */
11827 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
11829 low
= dwarf2_get_attr_constant_value (attr
, low
);
11830 else if (!low_default_is_valid
)
11831 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
11832 "- DIE at 0x%x [in module %s]"),
11833 die
->offset
.sect_off
, cu
->objfile
->name
);
11835 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
11838 if (attr_form_is_block (attr
) || is_ref_attr (attr
))
11840 /* GCC encodes arrays with unspecified or dynamic length
11841 with a DW_FORM_block1 attribute or a reference attribute.
11842 FIXME: GDB does not yet know how to handle dynamic
11843 arrays properly, treat them as arrays with unspecified
11846 FIXME: jimb/2003-09-22: GDB does not really know
11847 how to handle arrays of unspecified length
11848 either; we just represent them as zero-length
11849 arrays. Choose an appropriate upper bound given
11850 the lower bound we've computed above. */
11854 high
= dwarf2_get_attr_constant_value (attr
, 1);
11858 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
11861 int count
= dwarf2_get_attr_constant_value (attr
, 1);
11862 high
= low
+ count
- 1;
11866 /* Unspecified array length. */
11871 /* Dwarf-2 specifications explicitly allows to create subrange types
11872 without specifying a base type.
11873 In that case, the base type must be set to the type of
11874 the lower bound, upper bound or count, in that order, if any of these
11875 three attributes references an object that has a type.
11876 If no base type is found, the Dwarf-2 specifications say that
11877 a signed integer type of size equal to the size of an address should
11879 For the following C code: `extern char gdb_int [];'
11880 GCC produces an empty range DIE.
11881 FIXME: muller/2010-05-28: Possible references to object for low bound,
11882 high bound or count are not yet handled by this code. */
11883 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
11885 struct objfile
*objfile
= cu
->objfile
;
11886 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11887 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
11888 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
11890 /* Test "int", "long int", and "long long int" objfile types,
11891 and select the first one having a size above or equal to the
11892 architecture address size. */
11893 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
11894 base_type
= int_type
;
11897 int_type
= objfile_type (objfile
)->builtin_long
;
11898 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
11899 base_type
= int_type
;
11902 int_type
= objfile_type (objfile
)->builtin_long_long
;
11903 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
11904 base_type
= int_type
;
11910 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
11911 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
11912 low
|= negative_mask
;
11913 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
11914 high
|= negative_mask
;
11916 range_type
= create_range_type (NULL
, base_type
, low
, high
);
11918 /* Mark arrays with dynamic length at least as an array of unspecified
11919 length. GDB could check the boundary but before it gets implemented at
11920 least allow accessing the array elements. */
11921 if (attr
&& attr_form_is_block (attr
))
11922 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
11924 /* Ada expects an empty array on no boundary attributes. */
11925 if (attr
== NULL
&& cu
->language
!= language_ada
)
11926 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
11928 name
= dwarf2_name (die
, cu
);
11930 TYPE_NAME (range_type
) = name
;
11932 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
11934 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
11936 set_die_type (die
, range_type
, cu
);
11938 /* set_die_type should be already done. */
11939 set_descriptive_type (range_type
, die
, cu
);
11944 static struct type
*
11945 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11949 /* For now, we only support the C meaning of an unspecified type: void. */
11951 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
11952 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
11954 return set_die_type (die
, type
, cu
);
11957 /* Read a single die and all its descendents. Set the die's sibling
11958 field to NULL; set other fields in the die correctly, and set all
11959 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
11960 location of the info_ptr after reading all of those dies. PARENT
11961 is the parent of the die in question. */
11963 static struct die_info
*
11964 read_die_and_children (const struct die_reader_specs
*reader
,
11965 gdb_byte
*info_ptr
,
11966 gdb_byte
**new_info_ptr
,
11967 struct die_info
*parent
)
11969 struct die_info
*die
;
11973 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
11976 *new_info_ptr
= cur_ptr
;
11979 store_in_ref_table (die
, reader
->cu
);
11982 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
11986 *new_info_ptr
= cur_ptr
;
11989 die
->sibling
= NULL
;
11990 die
->parent
= parent
;
11994 /* Read a die, all of its descendents, and all of its siblings; set
11995 all of the fields of all of the dies correctly. Arguments are as
11996 in read_die_and_children. */
11998 static struct die_info
*
11999 read_die_and_siblings (const struct die_reader_specs
*reader
,
12000 gdb_byte
*info_ptr
,
12001 gdb_byte
**new_info_ptr
,
12002 struct die_info
*parent
)
12004 struct die_info
*first_die
, *last_sibling
;
12007 cur_ptr
= info_ptr
;
12008 first_die
= last_sibling
= NULL
;
12012 struct die_info
*die
12013 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
12017 *new_info_ptr
= cur_ptr
;
12024 last_sibling
->sibling
= die
;
12026 last_sibling
= die
;
12030 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
12032 The caller is responsible for filling in the extra attributes
12033 and updating (*DIEP)->num_attrs.
12034 Set DIEP to point to a newly allocated die with its information,
12035 except for its child, sibling, and parent fields.
12036 Set HAS_CHILDREN to tell whether the die has children or not. */
12039 read_full_die_1 (const struct die_reader_specs
*reader
,
12040 struct die_info
**diep
, gdb_byte
*info_ptr
,
12041 int *has_children
, int num_extra_attrs
)
12043 unsigned int abbrev_number
, bytes_read
, i
;
12044 sect_offset offset
;
12045 struct abbrev_info
*abbrev
;
12046 struct die_info
*die
;
12047 struct dwarf2_cu
*cu
= reader
->cu
;
12048 bfd
*abfd
= reader
->abfd
;
12050 offset
.sect_off
= info_ptr
- reader
->buffer
;
12051 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
12052 info_ptr
+= bytes_read
;
12053 if (!abbrev_number
)
12060 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
12062 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
12064 bfd_get_filename (abfd
));
12066 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
12067 die
->offset
= offset
;
12068 die
->tag
= abbrev
->tag
;
12069 die
->abbrev
= abbrev_number
;
12071 /* Make the result usable.
12072 The caller needs to update num_attrs after adding the extra
12074 die
->num_attrs
= abbrev
->num_attrs
;
12076 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
12077 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
12081 *has_children
= abbrev
->has_children
;
12085 /* Read a die and all its attributes.
12086 Set DIEP to point to a newly allocated die with its information,
12087 except for its child, sibling, and parent fields.
12088 Set HAS_CHILDREN to tell whether the die has children or not. */
12091 read_full_die (const struct die_reader_specs
*reader
,
12092 struct die_info
**diep
, gdb_byte
*info_ptr
,
12095 return read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
12098 /* Abbreviation tables.
12100 In DWARF version 2, the description of the debugging information is
12101 stored in a separate .debug_abbrev section. Before we read any
12102 dies from a section we read in all abbreviations and install them
12103 in a hash table. */
12105 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
12107 static struct abbrev_info
*
12108 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
12110 struct abbrev_info
*abbrev
;
12112 abbrev
= (struct abbrev_info
*)
12113 obstack_alloc (&abbrev_table
->abbrev_obstack
, sizeof (struct abbrev_info
));
12114 memset (abbrev
, 0, sizeof (struct abbrev_info
));
12118 /* Add an abbreviation to the table. */
12121 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
12122 unsigned int abbrev_number
,
12123 struct abbrev_info
*abbrev
)
12125 unsigned int hash_number
;
12127 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
12128 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
12129 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
12132 /* Look up an abbrev in the table.
12133 Returns NULL if the abbrev is not found. */
12135 static struct abbrev_info
*
12136 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
12137 unsigned int abbrev_number
)
12139 unsigned int hash_number
;
12140 struct abbrev_info
*abbrev
;
12142 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
12143 abbrev
= abbrev_table
->abbrevs
[hash_number
];
12147 if (abbrev
->number
== abbrev_number
)
12149 abbrev
= abbrev
->next
;
12154 /* Read in an abbrev table. */
12156 static struct abbrev_table
*
12157 abbrev_table_read_table (struct dwarf2_section_info
*section
,
12158 sect_offset offset
)
12160 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12161 bfd
*abfd
= section
->asection
->owner
;
12162 struct abbrev_table
*abbrev_table
;
12163 gdb_byte
*abbrev_ptr
;
12164 struct abbrev_info
*cur_abbrev
;
12165 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
12166 unsigned int abbrev_form
;
12167 struct attr_abbrev
*cur_attrs
;
12168 unsigned int allocated_attrs
;
12170 abbrev_table
= XMALLOC (struct abbrev_table
);
12171 abbrev_table
->offset
= offset
;
12172 obstack_init (&abbrev_table
->abbrev_obstack
);
12173 abbrev_table
->abbrevs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
12175 * sizeof (struct abbrev_info
*)));
12176 memset (abbrev_table
->abbrevs
, 0,
12177 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
12179 dwarf2_read_section (objfile
, section
);
12180 abbrev_ptr
= section
->buffer
+ offset
.sect_off
;
12181 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
12182 abbrev_ptr
+= bytes_read
;
12184 allocated_attrs
= ATTR_ALLOC_CHUNK
;
12185 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
12187 /* Loop until we reach an abbrev number of 0. */
12188 while (abbrev_number
)
12190 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
12192 /* read in abbrev header */
12193 cur_abbrev
->number
= abbrev_number
;
12194 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
12195 abbrev_ptr
+= bytes_read
;
12196 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
12199 /* now read in declarations */
12200 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
12201 abbrev_ptr
+= bytes_read
;
12202 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
12203 abbrev_ptr
+= bytes_read
;
12204 while (abbrev_name
)
12206 if (cur_abbrev
->num_attrs
== allocated_attrs
)
12208 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
12210 = xrealloc (cur_attrs
, (allocated_attrs
12211 * sizeof (struct attr_abbrev
)));
12214 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
12215 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
12216 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
12217 abbrev_ptr
+= bytes_read
;
12218 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
12219 abbrev_ptr
+= bytes_read
;
12222 cur_abbrev
->attrs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
12223 (cur_abbrev
->num_attrs
12224 * sizeof (struct attr_abbrev
)));
12225 memcpy (cur_abbrev
->attrs
, cur_attrs
,
12226 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
12228 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
12230 /* Get next abbreviation.
12231 Under Irix6 the abbreviations for a compilation unit are not
12232 always properly terminated with an abbrev number of 0.
12233 Exit loop if we encounter an abbreviation which we have
12234 already read (which means we are about to read the abbreviations
12235 for the next compile unit) or if the end of the abbreviation
12236 table is reached. */
12237 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
12239 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
12240 abbrev_ptr
+= bytes_read
;
12241 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
12246 return abbrev_table
;
12249 /* Free the resources held by ABBREV_TABLE. */
12252 abbrev_table_free (struct abbrev_table
*abbrev_table
)
12254 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
12255 xfree (abbrev_table
);
12258 /* Same as abbrev_table_free but as a cleanup.
12259 We pass in a pointer to the pointer to the table so that we can
12260 set the pointer to NULL when we're done. It also simplifies
12261 build_type_unit_groups. */
12264 abbrev_table_free_cleanup (void *table_ptr
)
12266 struct abbrev_table
**abbrev_table_ptr
= table_ptr
;
12268 if (*abbrev_table_ptr
!= NULL
)
12269 abbrev_table_free (*abbrev_table_ptr
);
12270 *abbrev_table_ptr
= NULL
;
12273 /* Read the abbrev table for CU from ABBREV_SECTION. */
12276 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
12277 struct dwarf2_section_info
*abbrev_section
)
12280 abbrev_table_read_table (abbrev_section
, cu
->header
.abbrev_offset
);
12283 /* Release the memory used by the abbrev table for a compilation unit. */
12286 dwarf2_free_abbrev_table (void *ptr_to_cu
)
12288 struct dwarf2_cu
*cu
= ptr_to_cu
;
12290 abbrev_table_free (cu
->abbrev_table
);
12291 /* Set this to NULL so that we SEGV if we try to read it later,
12292 and also because free_comp_unit verifies this is NULL. */
12293 cu
->abbrev_table
= NULL
;
12296 /* Returns nonzero if TAG represents a type that we might generate a partial
12300 is_type_tag_for_partial (int tag
)
12305 /* Some types that would be reasonable to generate partial symbols for,
12306 that we don't at present. */
12307 case DW_TAG_array_type
:
12308 case DW_TAG_file_type
:
12309 case DW_TAG_ptr_to_member_type
:
12310 case DW_TAG_set_type
:
12311 case DW_TAG_string_type
:
12312 case DW_TAG_subroutine_type
:
12314 case DW_TAG_base_type
:
12315 case DW_TAG_class_type
:
12316 case DW_TAG_interface_type
:
12317 case DW_TAG_enumeration_type
:
12318 case DW_TAG_structure_type
:
12319 case DW_TAG_subrange_type
:
12320 case DW_TAG_typedef
:
12321 case DW_TAG_union_type
:
12328 /* Load all DIEs that are interesting for partial symbols into memory. */
12330 static struct partial_die_info
*
12331 load_partial_dies (const struct die_reader_specs
*reader
,
12332 gdb_byte
*info_ptr
, int building_psymtab
)
12334 struct dwarf2_cu
*cu
= reader
->cu
;
12335 struct objfile
*objfile
= cu
->objfile
;
12336 struct partial_die_info
*part_die
;
12337 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
12338 struct abbrev_info
*abbrev
;
12339 unsigned int bytes_read
;
12340 unsigned int load_all
= 0;
12341 int nesting_level
= 1;
12346 gdb_assert (cu
->per_cu
!= NULL
);
12347 if (cu
->per_cu
->load_all_dies
)
12351 = htab_create_alloc_ex (cu
->header
.length
/ 12,
12355 &cu
->comp_unit_obstack
,
12356 hashtab_obstack_allocate
,
12357 dummy_obstack_deallocate
);
12359 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
12360 sizeof (struct partial_die_info
));
12364 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
12366 /* A NULL abbrev means the end of a series of children. */
12367 if (abbrev
== NULL
)
12369 if (--nesting_level
== 0)
12371 /* PART_DIE was probably the last thing allocated on the
12372 comp_unit_obstack, so we could call obstack_free
12373 here. We don't do that because the waste is small,
12374 and will be cleaned up when we're done with this
12375 compilation unit. This way, we're also more robust
12376 against other users of the comp_unit_obstack. */
12379 info_ptr
+= bytes_read
;
12380 last_die
= parent_die
;
12381 parent_die
= parent_die
->die_parent
;
12385 /* Check for template arguments. We never save these; if
12386 they're seen, we just mark the parent, and go on our way. */
12387 if (parent_die
!= NULL
12388 && cu
->language
== language_cplus
12389 && (abbrev
->tag
== DW_TAG_template_type_param
12390 || abbrev
->tag
== DW_TAG_template_value_param
))
12392 parent_die
->has_template_arguments
= 1;
12396 /* We don't need a partial DIE for the template argument. */
12397 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
12402 /* We only recurse into c++ subprograms looking for template arguments.
12403 Skip their other children. */
12405 && cu
->language
== language_cplus
12406 && parent_die
!= NULL
12407 && parent_die
->tag
== DW_TAG_subprogram
)
12409 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
12413 /* Check whether this DIE is interesting enough to save. Normally
12414 we would not be interested in members here, but there may be
12415 later variables referencing them via DW_AT_specification (for
12416 static members). */
12418 && !is_type_tag_for_partial (abbrev
->tag
)
12419 && abbrev
->tag
!= DW_TAG_constant
12420 && abbrev
->tag
!= DW_TAG_enumerator
12421 && abbrev
->tag
!= DW_TAG_subprogram
12422 && abbrev
->tag
!= DW_TAG_lexical_block
12423 && abbrev
->tag
!= DW_TAG_variable
12424 && abbrev
->tag
!= DW_TAG_namespace
12425 && abbrev
->tag
!= DW_TAG_module
12426 && abbrev
->tag
!= DW_TAG_member
12427 && abbrev
->tag
!= DW_TAG_imported_unit
)
12429 /* Otherwise we skip to the next sibling, if any. */
12430 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
12434 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
12437 /* This two-pass algorithm for processing partial symbols has a
12438 high cost in cache pressure. Thus, handle some simple cases
12439 here which cover the majority of C partial symbols. DIEs
12440 which neither have specification tags in them, nor could have
12441 specification tags elsewhere pointing at them, can simply be
12442 processed and discarded.
12444 This segment is also optional; scan_partial_symbols and
12445 add_partial_symbol will handle these DIEs if we chain
12446 them in normally. When compilers which do not emit large
12447 quantities of duplicate debug information are more common,
12448 this code can probably be removed. */
12450 /* Any complete simple types at the top level (pretty much all
12451 of them, for a language without namespaces), can be processed
12453 if (parent_die
== NULL
12454 && part_die
->has_specification
== 0
12455 && part_die
->is_declaration
== 0
12456 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
12457 || part_die
->tag
== DW_TAG_base_type
12458 || part_die
->tag
== DW_TAG_subrange_type
))
12460 if (building_psymtab
&& part_die
->name
!= NULL
)
12461 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
12462 VAR_DOMAIN
, LOC_TYPEDEF
,
12463 &objfile
->static_psymbols
,
12464 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
12465 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
12469 /* The exception for DW_TAG_typedef with has_children above is
12470 a workaround of GCC PR debug/47510. In the case of this complaint
12471 type_name_no_tag_or_error will error on such types later.
12473 GDB skipped children of DW_TAG_typedef by the shortcut above and then
12474 it could not find the child DIEs referenced later, this is checked
12475 above. In correct DWARF DW_TAG_typedef should have no children. */
12477 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
12478 complaint (&symfile_complaints
,
12479 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
12480 "- DIE at 0x%x [in module %s]"),
12481 part_die
->offset
.sect_off
, objfile
->name
);
12483 /* If we're at the second level, and we're an enumerator, and
12484 our parent has no specification (meaning possibly lives in a
12485 namespace elsewhere), then we can add the partial symbol now
12486 instead of queueing it. */
12487 if (part_die
->tag
== DW_TAG_enumerator
12488 && parent_die
!= NULL
12489 && parent_die
->die_parent
== NULL
12490 && parent_die
->tag
== DW_TAG_enumeration_type
12491 && parent_die
->has_specification
== 0)
12493 if (part_die
->name
== NULL
)
12494 complaint (&symfile_complaints
,
12495 _("malformed enumerator DIE ignored"));
12496 else if (building_psymtab
)
12497 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
12498 VAR_DOMAIN
, LOC_CONST
,
12499 (cu
->language
== language_cplus
12500 || cu
->language
== language_java
)
12501 ? &objfile
->global_psymbols
12502 : &objfile
->static_psymbols
,
12503 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
12505 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
12509 /* We'll save this DIE so link it in. */
12510 part_die
->die_parent
= parent_die
;
12511 part_die
->die_sibling
= NULL
;
12512 part_die
->die_child
= NULL
;
12514 if (last_die
&& last_die
== parent_die
)
12515 last_die
->die_child
= part_die
;
12517 last_die
->die_sibling
= part_die
;
12519 last_die
= part_die
;
12521 if (first_die
== NULL
)
12522 first_die
= part_die
;
12524 /* Maybe add the DIE to the hash table. Not all DIEs that we
12525 find interesting need to be in the hash table, because we
12526 also have the parent/sibling/child chains; only those that we
12527 might refer to by offset later during partial symbol reading.
12529 For now this means things that might have be the target of a
12530 DW_AT_specification, DW_AT_abstract_origin, or
12531 DW_AT_extension. DW_AT_extension will refer only to
12532 namespaces; DW_AT_abstract_origin refers to functions (and
12533 many things under the function DIE, but we do not recurse
12534 into function DIEs during partial symbol reading) and
12535 possibly variables as well; DW_AT_specification refers to
12536 declarations. Declarations ought to have the DW_AT_declaration
12537 flag. It happens that GCC forgets to put it in sometimes, but
12538 only for functions, not for types.
12540 Adding more things than necessary to the hash table is harmless
12541 except for the performance cost. Adding too few will result in
12542 wasted time in find_partial_die, when we reread the compilation
12543 unit with load_all_dies set. */
12546 || abbrev
->tag
== DW_TAG_constant
12547 || abbrev
->tag
== DW_TAG_subprogram
12548 || abbrev
->tag
== DW_TAG_variable
12549 || abbrev
->tag
== DW_TAG_namespace
12550 || part_die
->is_declaration
)
12554 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
12555 part_die
->offset
.sect_off
, INSERT
);
12559 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
12560 sizeof (struct partial_die_info
));
12562 /* For some DIEs we want to follow their children (if any). For C
12563 we have no reason to follow the children of structures; for other
12564 languages we have to, so that we can get at method physnames
12565 to infer fully qualified class names, for DW_AT_specification,
12566 and for C++ template arguments. For C++, we also look one level
12567 inside functions to find template arguments (if the name of the
12568 function does not already contain the template arguments).
12570 For Ada, we need to scan the children of subprograms and lexical
12571 blocks as well because Ada allows the definition of nested
12572 entities that could be interesting for the debugger, such as
12573 nested subprograms for instance. */
12574 if (last_die
->has_children
12576 || last_die
->tag
== DW_TAG_namespace
12577 || last_die
->tag
== DW_TAG_module
12578 || last_die
->tag
== DW_TAG_enumeration_type
12579 || (cu
->language
== language_cplus
12580 && last_die
->tag
== DW_TAG_subprogram
12581 && (last_die
->name
== NULL
12582 || strchr (last_die
->name
, '<') == NULL
))
12583 || (cu
->language
!= language_c
12584 && (last_die
->tag
== DW_TAG_class_type
12585 || last_die
->tag
== DW_TAG_interface_type
12586 || last_die
->tag
== DW_TAG_structure_type
12587 || last_die
->tag
== DW_TAG_union_type
))
12588 || (cu
->language
== language_ada
12589 && (last_die
->tag
== DW_TAG_subprogram
12590 || last_die
->tag
== DW_TAG_lexical_block
))))
12593 parent_die
= last_die
;
12597 /* Otherwise we skip to the next sibling, if any. */
12598 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
12600 /* Back to the top, do it again. */
12604 /* Read a minimal amount of information into the minimal die structure. */
12607 read_partial_die (const struct die_reader_specs
*reader
,
12608 struct partial_die_info
*part_die
,
12609 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
12610 gdb_byte
*info_ptr
)
12612 struct dwarf2_cu
*cu
= reader
->cu
;
12613 struct objfile
*objfile
= cu
->objfile
;
12614 gdb_byte
*buffer
= reader
->buffer
;
12616 struct attribute attr
;
12617 int has_low_pc_attr
= 0;
12618 int has_high_pc_attr
= 0;
12619 int high_pc_relative
= 0;
12621 memset (part_die
, 0, sizeof (struct partial_die_info
));
12623 part_die
->offset
.sect_off
= info_ptr
- buffer
;
12625 info_ptr
+= abbrev_len
;
12627 if (abbrev
== NULL
)
12630 part_die
->tag
= abbrev
->tag
;
12631 part_die
->has_children
= abbrev
->has_children
;
12633 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
12635 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
12637 /* Store the data if it is of an attribute we want to keep in a
12638 partial symbol table. */
12642 switch (part_die
->tag
)
12644 case DW_TAG_compile_unit
:
12645 case DW_TAG_partial_unit
:
12646 case DW_TAG_type_unit
:
12647 /* Compilation units have a DW_AT_name that is a filename, not
12648 a source language identifier. */
12649 case DW_TAG_enumeration_type
:
12650 case DW_TAG_enumerator
:
12651 /* These tags always have simple identifiers already; no need
12652 to canonicalize them. */
12653 part_die
->name
= DW_STRING (&attr
);
12657 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
12658 &objfile
->objfile_obstack
);
12662 case DW_AT_linkage_name
:
12663 case DW_AT_MIPS_linkage_name
:
12664 /* Note that both forms of linkage name might appear. We
12665 assume they will be the same, and we only store the last
12667 if (cu
->language
== language_ada
)
12668 part_die
->name
= DW_STRING (&attr
);
12669 part_die
->linkage_name
= DW_STRING (&attr
);
12672 has_low_pc_attr
= 1;
12673 part_die
->lowpc
= DW_ADDR (&attr
);
12675 case DW_AT_high_pc
:
12676 has_high_pc_attr
= 1;
12677 if (attr
.form
== DW_FORM_addr
12678 || attr
.form
== DW_FORM_GNU_addr_index
)
12679 part_die
->highpc
= DW_ADDR (&attr
);
12682 high_pc_relative
= 1;
12683 part_die
->highpc
= DW_UNSND (&attr
);
12686 case DW_AT_location
:
12687 /* Support the .debug_loc offsets. */
12688 if (attr_form_is_block (&attr
))
12690 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
12692 else if (attr_form_is_section_offset (&attr
))
12694 dwarf2_complex_location_expr_complaint ();
12698 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
12699 "partial symbol information");
12702 case DW_AT_external
:
12703 part_die
->is_external
= DW_UNSND (&attr
);
12705 case DW_AT_declaration
:
12706 part_die
->is_declaration
= DW_UNSND (&attr
);
12709 part_die
->has_type
= 1;
12711 case DW_AT_abstract_origin
:
12712 case DW_AT_specification
:
12713 case DW_AT_extension
:
12714 part_die
->has_specification
= 1;
12715 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
12716 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
12717 || cu
->per_cu
->is_dwz
);
12719 case DW_AT_sibling
:
12720 /* Ignore absolute siblings, they might point outside of
12721 the current compile unit. */
12722 if (attr
.form
== DW_FORM_ref_addr
)
12723 complaint (&symfile_complaints
,
12724 _("ignoring absolute DW_AT_sibling"));
12726 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
).sect_off
;
12728 case DW_AT_byte_size
:
12729 part_die
->has_byte_size
= 1;
12731 case DW_AT_calling_convention
:
12732 /* DWARF doesn't provide a way to identify a program's source-level
12733 entry point. DW_AT_calling_convention attributes are only meant
12734 to describe functions' calling conventions.
12736 However, because it's a necessary piece of information in
12737 Fortran, and because DW_CC_program is the only piece of debugging
12738 information whose definition refers to a 'main program' at all,
12739 several compilers have begun marking Fortran main programs with
12740 DW_CC_program --- even when those functions use the standard
12741 calling conventions.
12743 So until DWARF specifies a way to provide this information and
12744 compilers pick up the new representation, we'll support this
12746 if (DW_UNSND (&attr
) == DW_CC_program
12747 && cu
->language
== language_fortran
)
12749 set_main_name (part_die
->name
);
12751 /* As this DIE has a static linkage the name would be difficult
12752 to look up later. */
12753 language_of_main
= language_fortran
;
12757 if (DW_UNSND (&attr
) == DW_INL_inlined
12758 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
12759 part_die
->may_be_inlined
= 1;
12763 if (part_die
->tag
== DW_TAG_imported_unit
)
12765 part_die
->d
.offset
= dwarf2_get_ref_die_offset (&attr
);
12766 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
12767 || cu
->per_cu
->is_dwz
);
12776 if (high_pc_relative
)
12777 part_die
->highpc
+= part_die
->lowpc
;
12779 if (has_low_pc_attr
&& has_high_pc_attr
)
12781 /* When using the GNU linker, .gnu.linkonce. sections are used to
12782 eliminate duplicate copies of functions and vtables and such.
12783 The linker will arbitrarily choose one and discard the others.
12784 The AT_*_pc values for such functions refer to local labels in
12785 these sections. If the section from that file was discarded, the
12786 labels are not in the output, so the relocs get a value of 0.
12787 If this is a discarded function, mark the pc bounds as invalid,
12788 so that GDB will ignore it. */
12789 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12791 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12793 complaint (&symfile_complaints
,
12794 _("DW_AT_low_pc %s is zero "
12795 "for DIE at 0x%x [in module %s]"),
12796 paddress (gdbarch
, part_die
->lowpc
),
12797 part_die
->offset
.sect_off
, objfile
->name
);
12799 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
12800 else if (part_die
->lowpc
>= part_die
->highpc
)
12802 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12804 complaint (&symfile_complaints
,
12805 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
12806 "for DIE at 0x%x [in module %s]"),
12807 paddress (gdbarch
, part_die
->lowpc
),
12808 paddress (gdbarch
, part_die
->highpc
),
12809 part_die
->offset
.sect_off
, objfile
->name
);
12812 part_die
->has_pc_info
= 1;
12818 /* Find a cached partial DIE at OFFSET in CU. */
12820 static struct partial_die_info
*
12821 find_partial_die_in_comp_unit (sect_offset offset
, struct dwarf2_cu
*cu
)
12823 struct partial_die_info
*lookup_die
= NULL
;
12824 struct partial_die_info part_die
;
12826 part_die
.offset
= offset
;
12827 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
,
12833 /* Find a partial DIE at OFFSET, which may or may not be in CU,
12834 except in the case of .debug_types DIEs which do not reference
12835 outside their CU (they do however referencing other types via
12836 DW_FORM_ref_sig8). */
12838 static struct partial_die_info
*
12839 find_partial_die (sect_offset offset
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
12841 struct objfile
*objfile
= cu
->objfile
;
12842 struct dwarf2_per_cu_data
*per_cu
= NULL
;
12843 struct partial_die_info
*pd
= NULL
;
12845 if (offset_in_dwz
== cu
->per_cu
->is_dwz
12846 && offset_in_cu_p (&cu
->header
, offset
))
12848 pd
= find_partial_die_in_comp_unit (offset
, cu
);
12851 /* We missed recording what we needed.
12852 Load all dies and try again. */
12853 per_cu
= cu
->per_cu
;
12857 /* TUs don't reference other CUs/TUs (except via type signatures). */
12858 if (cu
->per_cu
->is_debug_types
)
12860 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
12861 " external reference to offset 0x%lx [in module %s].\n"),
12862 (long) cu
->header
.offset
.sect_off
, (long) offset
.sect_off
,
12863 bfd_get_filename (objfile
->obfd
));
12865 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
12868 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
12869 load_partial_comp_unit (per_cu
);
12871 per_cu
->cu
->last_used
= 0;
12872 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
12875 /* If we didn't find it, and not all dies have been loaded,
12876 load them all and try again. */
12878 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
12880 per_cu
->load_all_dies
= 1;
12882 /* This is nasty. When we reread the DIEs, somewhere up the call chain
12883 THIS_CU->cu may already be in use. So we can't just free it and
12884 replace its DIEs with the ones we read in. Instead, we leave those
12885 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
12886 and clobber THIS_CU->cu->partial_dies with the hash table for the new
12888 load_partial_comp_unit (per_cu
);
12890 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
12894 internal_error (__FILE__
, __LINE__
,
12895 _("could not find partial DIE 0x%x "
12896 "in cache [from module %s]\n"),
12897 offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
12901 /* See if we can figure out if the class lives in a namespace. We do
12902 this by looking for a member function; its demangled name will
12903 contain namespace info, if there is any. */
12906 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
12907 struct dwarf2_cu
*cu
)
12909 /* NOTE: carlton/2003-10-07: Getting the info this way changes
12910 what template types look like, because the demangler
12911 frequently doesn't give the same name as the debug info. We
12912 could fix this by only using the demangled name to get the
12913 prefix (but see comment in read_structure_type). */
12915 struct partial_die_info
*real_pdi
;
12916 struct partial_die_info
*child_pdi
;
12918 /* If this DIE (this DIE's specification, if any) has a parent, then
12919 we should not do this. We'll prepend the parent's fully qualified
12920 name when we create the partial symbol. */
12922 real_pdi
= struct_pdi
;
12923 while (real_pdi
->has_specification
)
12924 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
12925 real_pdi
->spec_is_dwz
, cu
);
12927 if (real_pdi
->die_parent
!= NULL
)
12930 for (child_pdi
= struct_pdi
->die_child
;
12932 child_pdi
= child_pdi
->die_sibling
)
12934 if (child_pdi
->tag
== DW_TAG_subprogram
12935 && child_pdi
->linkage_name
!= NULL
)
12937 char *actual_class_name
12938 = language_class_name_from_physname (cu
->language_defn
,
12939 child_pdi
->linkage_name
);
12940 if (actual_class_name
!= NULL
)
12943 = obsavestring (actual_class_name
,
12944 strlen (actual_class_name
),
12945 &cu
->objfile
->objfile_obstack
);
12946 xfree (actual_class_name
);
12953 /* Adjust PART_DIE before generating a symbol for it. This function
12954 may set the is_external flag or change the DIE's name. */
12957 fixup_partial_die (struct partial_die_info
*part_die
,
12958 struct dwarf2_cu
*cu
)
12960 /* Once we've fixed up a die, there's no point in doing so again.
12961 This also avoids a memory leak if we were to call
12962 guess_partial_die_structure_name multiple times. */
12963 if (part_die
->fixup_called
)
12966 /* If we found a reference attribute and the DIE has no name, try
12967 to find a name in the referred to DIE. */
12969 if (part_die
->name
== NULL
&& part_die
->has_specification
)
12971 struct partial_die_info
*spec_die
;
12973 spec_die
= find_partial_die (part_die
->spec_offset
,
12974 part_die
->spec_is_dwz
, cu
);
12976 fixup_partial_die (spec_die
, cu
);
12978 if (spec_die
->name
)
12980 part_die
->name
= spec_die
->name
;
12982 /* Copy DW_AT_external attribute if it is set. */
12983 if (spec_die
->is_external
)
12984 part_die
->is_external
= spec_die
->is_external
;
12988 /* Set default names for some unnamed DIEs. */
12990 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
12991 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
12993 /* If there is no parent die to provide a namespace, and there are
12994 children, see if we can determine the namespace from their linkage
12996 if (cu
->language
== language_cplus
12997 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
12998 && part_die
->die_parent
== NULL
12999 && part_die
->has_children
13000 && (part_die
->tag
== DW_TAG_class_type
13001 || part_die
->tag
== DW_TAG_structure_type
13002 || part_die
->tag
== DW_TAG_union_type
))
13003 guess_partial_die_structure_name (part_die
, cu
);
13005 /* GCC might emit a nameless struct or union that has a linkage
13006 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
13007 if (part_die
->name
== NULL
13008 && (part_die
->tag
== DW_TAG_class_type
13009 || part_die
->tag
== DW_TAG_interface_type
13010 || part_die
->tag
== DW_TAG_structure_type
13011 || part_die
->tag
== DW_TAG_union_type
)
13012 && part_die
->linkage_name
!= NULL
)
13016 demangled
= cplus_demangle (part_die
->linkage_name
, DMGL_TYPES
);
13021 /* Strip any leading namespaces/classes, keep only the base name.
13022 DW_AT_name for named DIEs does not contain the prefixes. */
13023 base
= strrchr (demangled
, ':');
13024 if (base
&& base
> demangled
&& base
[-1] == ':')
13029 part_die
->name
= obsavestring (base
, strlen (base
),
13030 &cu
->objfile
->objfile_obstack
);
13035 part_die
->fixup_called
= 1;
13038 /* Read an attribute value described by an attribute form. */
13041 read_attribute_value (const struct die_reader_specs
*reader
,
13042 struct attribute
*attr
, unsigned form
,
13043 gdb_byte
*info_ptr
)
13045 struct dwarf2_cu
*cu
= reader
->cu
;
13046 bfd
*abfd
= reader
->abfd
;
13047 struct comp_unit_head
*cu_header
= &cu
->header
;
13048 unsigned int bytes_read
;
13049 struct dwarf_block
*blk
;
13054 case DW_FORM_ref_addr
:
13055 if (cu
->header
.version
== 2)
13056 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
13058 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
13059 &cu
->header
, &bytes_read
);
13060 info_ptr
+= bytes_read
;
13062 case DW_FORM_GNU_ref_alt
:
13063 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
13064 info_ptr
+= bytes_read
;
13067 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
13068 info_ptr
+= bytes_read
;
13070 case DW_FORM_block2
:
13071 blk
= dwarf_alloc_block (cu
);
13072 blk
->size
= read_2_bytes (abfd
, info_ptr
);
13074 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
13075 info_ptr
+= blk
->size
;
13076 DW_BLOCK (attr
) = blk
;
13078 case DW_FORM_block4
:
13079 blk
= dwarf_alloc_block (cu
);
13080 blk
->size
= read_4_bytes (abfd
, info_ptr
);
13082 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
13083 info_ptr
+= blk
->size
;
13084 DW_BLOCK (attr
) = blk
;
13086 case DW_FORM_data2
:
13087 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
13090 case DW_FORM_data4
:
13091 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
13094 case DW_FORM_data8
:
13095 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
13098 case DW_FORM_sec_offset
:
13099 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
13100 info_ptr
+= bytes_read
;
13102 case DW_FORM_string
:
13103 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
13104 DW_STRING_IS_CANONICAL (attr
) = 0;
13105 info_ptr
+= bytes_read
;
13108 if (!cu
->per_cu
->is_dwz
)
13110 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
13112 DW_STRING_IS_CANONICAL (attr
) = 0;
13113 info_ptr
+= bytes_read
;
13117 case DW_FORM_GNU_strp_alt
:
13119 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
13120 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
13123 DW_STRING (attr
) = read_indirect_string_from_dwz (dwz
, str_offset
);
13124 DW_STRING_IS_CANONICAL (attr
) = 0;
13125 info_ptr
+= bytes_read
;
13128 case DW_FORM_exprloc
:
13129 case DW_FORM_block
:
13130 blk
= dwarf_alloc_block (cu
);
13131 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
13132 info_ptr
+= bytes_read
;
13133 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
13134 info_ptr
+= blk
->size
;
13135 DW_BLOCK (attr
) = blk
;
13137 case DW_FORM_block1
:
13138 blk
= dwarf_alloc_block (cu
);
13139 blk
->size
= read_1_byte (abfd
, info_ptr
);
13141 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
13142 info_ptr
+= blk
->size
;
13143 DW_BLOCK (attr
) = blk
;
13145 case DW_FORM_data1
:
13146 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
13150 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
13153 case DW_FORM_flag_present
:
13154 DW_UNSND (attr
) = 1;
13156 case DW_FORM_sdata
:
13157 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
13158 info_ptr
+= bytes_read
;
13160 case DW_FORM_udata
:
13161 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
13162 info_ptr
+= bytes_read
;
13165 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
13166 + read_1_byte (abfd
, info_ptr
));
13170 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
13171 + read_2_bytes (abfd
, info_ptr
));
13175 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
13176 + read_4_bytes (abfd
, info_ptr
));
13180 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
13181 + read_8_bytes (abfd
, info_ptr
));
13184 case DW_FORM_ref_sig8
:
13185 /* Convert the signature to something we can record in DW_UNSND
13187 NOTE: This is NULL if the type wasn't found. */
13188 DW_SIGNATURED_TYPE (attr
) =
13189 lookup_signatured_type (read_8_bytes (abfd
, info_ptr
));
13192 case DW_FORM_ref_udata
:
13193 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
13194 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
13195 info_ptr
+= bytes_read
;
13197 case DW_FORM_indirect
:
13198 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
13199 info_ptr
+= bytes_read
;
13200 info_ptr
= read_attribute_value (reader
, attr
, form
, info_ptr
);
13202 case DW_FORM_GNU_addr_index
:
13203 if (reader
->dwo_file
== NULL
)
13205 /* For now flag a hard error.
13206 Later we can turn this into a complaint. */
13207 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
13208 dwarf_form_name (form
),
13209 bfd_get_filename (abfd
));
13211 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
13212 info_ptr
+= bytes_read
;
13214 case DW_FORM_GNU_str_index
:
13215 if (reader
->dwo_file
== NULL
)
13217 /* For now flag a hard error.
13218 Later we can turn this into a complaint if warranted. */
13219 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
13220 dwarf_form_name (form
),
13221 bfd_get_filename (abfd
));
13224 ULONGEST str_index
=
13225 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
13227 DW_STRING (attr
) = read_str_index (reader
, cu
, str_index
);
13228 DW_STRING_IS_CANONICAL (attr
) = 0;
13229 info_ptr
+= bytes_read
;
13233 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
13234 dwarf_form_name (form
),
13235 bfd_get_filename (abfd
));
13239 if (cu
->per_cu
->is_dwz
&& is_ref_attr (attr
))
13240 attr
->form
= DW_FORM_GNU_ref_alt
;
13242 /* We have seen instances where the compiler tried to emit a byte
13243 size attribute of -1 which ended up being encoded as an unsigned
13244 0xffffffff. Although 0xffffffff is technically a valid size value,
13245 an object of this size seems pretty unlikely so we can relatively
13246 safely treat these cases as if the size attribute was invalid and
13247 treat them as zero by default. */
13248 if (attr
->name
== DW_AT_byte_size
13249 && form
== DW_FORM_data4
13250 && DW_UNSND (attr
) >= 0xffffffff)
13253 (&symfile_complaints
,
13254 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
13255 hex_string (DW_UNSND (attr
)));
13256 DW_UNSND (attr
) = 0;
13262 /* Read an attribute described by an abbreviated attribute. */
13265 read_attribute (const struct die_reader_specs
*reader
,
13266 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
13267 gdb_byte
*info_ptr
)
13269 attr
->name
= abbrev
->name
;
13270 return read_attribute_value (reader
, attr
, abbrev
->form
, info_ptr
);
13273 /* Read dwarf information from a buffer. */
13275 static unsigned int
13276 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
13278 return bfd_get_8 (abfd
, buf
);
13282 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
13284 return bfd_get_signed_8 (abfd
, buf
);
13287 static unsigned int
13288 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
13290 return bfd_get_16 (abfd
, buf
);
13294 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
13296 return bfd_get_signed_16 (abfd
, buf
);
13299 static unsigned int
13300 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
13302 return bfd_get_32 (abfd
, buf
);
13306 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
13308 return bfd_get_signed_32 (abfd
, buf
);
13312 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
13314 return bfd_get_64 (abfd
, buf
);
13318 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
13319 unsigned int *bytes_read
)
13321 struct comp_unit_head
*cu_header
= &cu
->header
;
13322 CORE_ADDR retval
= 0;
13324 if (cu_header
->signed_addr_p
)
13326 switch (cu_header
->addr_size
)
13329 retval
= bfd_get_signed_16 (abfd
, buf
);
13332 retval
= bfd_get_signed_32 (abfd
, buf
);
13335 retval
= bfd_get_signed_64 (abfd
, buf
);
13338 internal_error (__FILE__
, __LINE__
,
13339 _("read_address: bad switch, signed [in module %s]"),
13340 bfd_get_filename (abfd
));
13345 switch (cu_header
->addr_size
)
13348 retval
= bfd_get_16 (abfd
, buf
);
13351 retval
= bfd_get_32 (abfd
, buf
);
13354 retval
= bfd_get_64 (abfd
, buf
);
13357 internal_error (__FILE__
, __LINE__
,
13358 _("read_address: bad switch, "
13359 "unsigned [in module %s]"),
13360 bfd_get_filename (abfd
));
13364 *bytes_read
= cu_header
->addr_size
;
13368 /* Read the initial length from a section. The (draft) DWARF 3
13369 specification allows the initial length to take up either 4 bytes
13370 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
13371 bytes describe the length and all offsets will be 8 bytes in length
13374 An older, non-standard 64-bit format is also handled by this
13375 function. The older format in question stores the initial length
13376 as an 8-byte quantity without an escape value. Lengths greater
13377 than 2^32 aren't very common which means that the initial 4 bytes
13378 is almost always zero. Since a length value of zero doesn't make
13379 sense for the 32-bit format, this initial zero can be considered to
13380 be an escape value which indicates the presence of the older 64-bit
13381 format. As written, the code can't detect (old format) lengths
13382 greater than 4GB. If it becomes necessary to handle lengths
13383 somewhat larger than 4GB, we could allow other small values (such
13384 as the non-sensical values of 1, 2, and 3) to also be used as
13385 escape values indicating the presence of the old format.
13387 The value returned via bytes_read should be used to increment the
13388 relevant pointer after calling read_initial_length().
13390 [ Note: read_initial_length() and read_offset() are based on the
13391 document entitled "DWARF Debugging Information Format", revision
13392 3, draft 8, dated November 19, 2001. This document was obtained
13395 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
13397 This document is only a draft and is subject to change. (So beware.)
13399 Details regarding the older, non-standard 64-bit format were
13400 determined empirically by examining 64-bit ELF files produced by
13401 the SGI toolchain on an IRIX 6.5 machine.
13403 - Kevin, July 16, 2002
13407 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
13409 LONGEST length
= bfd_get_32 (abfd
, buf
);
13411 if (length
== 0xffffffff)
13413 length
= bfd_get_64 (abfd
, buf
+ 4);
13416 else if (length
== 0)
13418 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
13419 length
= bfd_get_64 (abfd
, buf
);
13430 /* Cover function for read_initial_length.
13431 Returns the length of the object at BUF, and stores the size of the
13432 initial length in *BYTES_READ and stores the size that offsets will be in
13434 If the initial length size is not equivalent to that specified in
13435 CU_HEADER then issue a complaint.
13436 This is useful when reading non-comp-unit headers. */
13439 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
13440 const struct comp_unit_head
*cu_header
,
13441 unsigned int *bytes_read
,
13442 unsigned int *offset_size
)
13444 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
13446 gdb_assert (cu_header
->initial_length_size
== 4
13447 || cu_header
->initial_length_size
== 8
13448 || cu_header
->initial_length_size
== 12);
13450 if (cu_header
->initial_length_size
!= *bytes_read
)
13451 complaint (&symfile_complaints
,
13452 _("intermixed 32-bit and 64-bit DWARF sections"));
13454 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
13458 /* Read an offset from the data stream. The size of the offset is
13459 given by cu_header->offset_size. */
13462 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
13463 unsigned int *bytes_read
)
13465 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
13467 *bytes_read
= cu_header
->offset_size
;
13471 /* Read an offset from the data stream. */
13474 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
13476 LONGEST retval
= 0;
13478 switch (offset_size
)
13481 retval
= bfd_get_32 (abfd
, buf
);
13484 retval
= bfd_get_64 (abfd
, buf
);
13487 internal_error (__FILE__
, __LINE__
,
13488 _("read_offset_1: bad switch [in module %s]"),
13489 bfd_get_filename (abfd
));
13496 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
13498 /* If the size of a host char is 8 bits, we can return a pointer
13499 to the buffer, otherwise we have to copy the data to a buffer
13500 allocated on the temporary obstack. */
13501 gdb_assert (HOST_CHAR_BIT
== 8);
13506 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
13508 /* If the size of a host char is 8 bits, we can return a pointer
13509 to the string, otherwise we have to copy the string to a buffer
13510 allocated on the temporary obstack. */
13511 gdb_assert (HOST_CHAR_BIT
== 8);
13514 *bytes_read_ptr
= 1;
13517 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
13518 return (char *) buf
;
13522 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
13524 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
13525 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
13526 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
13527 bfd_get_filename (abfd
));
13528 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
13529 error (_("DW_FORM_strp pointing outside of "
13530 ".debug_str section [in module %s]"),
13531 bfd_get_filename (abfd
));
13532 gdb_assert (HOST_CHAR_BIT
== 8);
13533 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
13535 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
13538 /* Read a string at offset STR_OFFSET in the .debug_str section from
13539 the .dwz file DWZ. Throw an error if the offset is too large. If
13540 the string consists of a single NUL byte, return NULL; otherwise
13541 return a pointer to the string. */
13544 read_indirect_string_from_dwz (struct dwz_file
*dwz
, LONGEST str_offset
)
13546 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwz
->str
);
13548 if (dwz
->str
.buffer
== NULL
)
13549 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
13550 "section [in module %s]"),
13551 bfd_get_filename (dwz
->dwz_bfd
));
13552 if (str_offset
>= dwz
->str
.size
)
13553 error (_("DW_FORM_GNU_strp_alt pointing outside of "
13554 ".debug_str section [in module %s]"),
13555 bfd_get_filename (dwz
->dwz_bfd
));
13556 gdb_assert (HOST_CHAR_BIT
== 8);
13557 if (dwz
->str
.buffer
[str_offset
] == '\0')
13559 return (char *) (dwz
->str
.buffer
+ str_offset
);
13563 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
13564 const struct comp_unit_head
*cu_header
,
13565 unsigned int *bytes_read_ptr
)
13567 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
13569 return read_indirect_string_at_offset (abfd
, str_offset
);
13573 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
13576 unsigned int num_read
;
13578 unsigned char byte
;
13586 byte
= bfd_get_8 (abfd
, buf
);
13589 result
|= ((ULONGEST
) (byte
& 127) << shift
);
13590 if ((byte
& 128) == 0)
13596 *bytes_read_ptr
= num_read
;
13601 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
13604 int i
, shift
, num_read
;
13605 unsigned char byte
;
13613 byte
= bfd_get_8 (abfd
, buf
);
13616 result
|= ((LONGEST
) (byte
& 127) << shift
);
13618 if ((byte
& 128) == 0)
13623 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
13624 result
|= -(((LONGEST
) 1) << shift
);
13625 *bytes_read_ptr
= num_read
;
13629 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
13630 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
13631 ADDR_SIZE is the size of addresses from the CU header. */
13634 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
13636 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13637 bfd
*abfd
= objfile
->obfd
;
13638 const gdb_byte
*info_ptr
;
13640 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
13641 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
13642 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
13644 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
13645 error (_("DW_FORM_addr_index pointing outside of "
13646 ".debug_addr section [in module %s]"),
13648 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
13649 + addr_base
+ addr_index
* addr_size
);
13650 if (addr_size
== 4)
13651 return bfd_get_32 (abfd
, info_ptr
);
13653 return bfd_get_64 (abfd
, info_ptr
);
13656 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
13659 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
13661 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
13664 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
13667 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, gdb_byte
*info_ptr
,
13668 unsigned int *bytes_read
)
13670 bfd
*abfd
= cu
->objfile
->obfd
;
13671 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
13673 return read_addr_index (cu
, addr_index
);
13676 /* Data structure to pass results from dwarf2_read_addr_index_reader
13677 back to dwarf2_read_addr_index. */
13679 struct dwarf2_read_addr_index_data
13681 ULONGEST addr_base
;
13685 /* die_reader_func for dwarf2_read_addr_index. */
13688 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
13689 gdb_byte
*info_ptr
,
13690 struct die_info
*comp_unit_die
,
13694 struct dwarf2_cu
*cu
= reader
->cu
;
13695 struct dwarf2_read_addr_index_data
*aidata
=
13696 (struct dwarf2_read_addr_index_data
*) data
;
13698 aidata
->addr_base
= cu
->addr_base
;
13699 aidata
->addr_size
= cu
->header
.addr_size
;
13702 /* Given an index in .debug_addr, fetch the value.
13703 NOTE: This can be called during dwarf expression evaluation,
13704 long after the debug information has been read, and thus per_cu->cu
13705 may no longer exist. */
13708 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
13709 unsigned int addr_index
)
13711 struct objfile
*objfile
= per_cu
->objfile
;
13712 struct dwarf2_cu
*cu
= per_cu
->cu
;
13713 ULONGEST addr_base
;
13716 /* This is intended to be called from outside this file. */
13717 dw2_setup (objfile
);
13719 /* We need addr_base and addr_size.
13720 If we don't have PER_CU->cu, we have to get it.
13721 Nasty, but the alternative is storing the needed info in PER_CU,
13722 which at this point doesn't seem justified: it's not clear how frequently
13723 it would get used and it would increase the size of every PER_CU.
13724 Entry points like dwarf2_per_cu_addr_size do a similar thing
13725 so we're not in uncharted territory here.
13726 Alas we need to be a bit more complicated as addr_base is contained
13729 We don't need to read the entire CU(/TU).
13730 We just need the header and top level die.
13731 IWBN to use the aging mechanism to let us lazily later discard the CU.
13732 See however init_cutu_and_read_dies_simple. */
13736 addr_base
= cu
->addr_base
;
13737 addr_size
= cu
->header
.addr_size
;
13741 struct dwarf2_read_addr_index_data aidata
;
13743 init_cutu_and_read_dies_simple (per_cu
, dwarf2_read_addr_index_reader
,
13745 addr_base
= aidata
.addr_base
;
13746 addr_size
= aidata
.addr_size
;
13749 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
13752 /* Given a DW_AT_str_index, fetch the string. */
13755 read_str_index (const struct die_reader_specs
*reader
,
13756 struct dwarf2_cu
*cu
, ULONGEST str_index
)
13758 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13759 const char *dwo_name
= objfile
->name
;
13760 bfd
*abfd
= objfile
->obfd
;
13761 struct dwo_sections
*sections
= &reader
->dwo_file
->sections
;
13762 gdb_byte
*info_ptr
;
13763 ULONGEST str_offset
;
13765 dwarf2_read_section (objfile
, §ions
->str
);
13766 dwarf2_read_section (objfile
, §ions
->str_offsets
);
13767 if (sections
->str
.buffer
== NULL
)
13768 error (_("DW_FORM_str_index used without .debug_str.dwo section"
13769 " in CU at offset 0x%lx [in module %s]"),
13770 (long) cu
->header
.offset
.sect_off
, dwo_name
);
13771 if (sections
->str_offsets
.buffer
== NULL
)
13772 error (_("DW_FORM_str_index used without .debug_str_offsets.dwo section"
13773 " in CU at offset 0x%lx [in module %s]"),
13774 (long) cu
->header
.offset
.sect_off
, dwo_name
);
13775 if (str_index
* cu
->header
.offset_size
>= sections
->str_offsets
.size
)
13776 error (_("DW_FORM_str_index pointing outside of .debug_str_offsets.dwo"
13777 " section in CU at offset 0x%lx [in module %s]"),
13778 (long) cu
->header
.offset
.sect_off
, dwo_name
);
13779 info_ptr
= (sections
->str_offsets
.buffer
13780 + str_index
* cu
->header
.offset_size
);
13781 if (cu
->header
.offset_size
== 4)
13782 str_offset
= bfd_get_32 (abfd
, info_ptr
);
13784 str_offset
= bfd_get_64 (abfd
, info_ptr
);
13785 if (str_offset
>= sections
->str
.size
)
13786 error (_("Offset from DW_FORM_str_index pointing outside of"
13787 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
13788 (long) cu
->header
.offset
.sect_off
, dwo_name
);
13789 return (char *) (sections
->str
.buffer
+ str_offset
);
13792 /* Return the length of an LEB128 number in BUF. */
13795 leb128_size (const gdb_byte
*buf
)
13797 const gdb_byte
*begin
= buf
;
13803 if ((byte
& 128) == 0)
13804 return buf
- begin
;
13809 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
13816 cu
->language
= language_c
;
13818 case DW_LANG_C_plus_plus
:
13819 cu
->language
= language_cplus
;
13822 cu
->language
= language_d
;
13824 case DW_LANG_Fortran77
:
13825 case DW_LANG_Fortran90
:
13826 case DW_LANG_Fortran95
:
13827 cu
->language
= language_fortran
;
13830 cu
->language
= language_go
;
13832 case DW_LANG_Mips_Assembler
:
13833 cu
->language
= language_asm
;
13836 cu
->language
= language_java
;
13838 case DW_LANG_Ada83
:
13839 case DW_LANG_Ada95
:
13840 cu
->language
= language_ada
;
13842 case DW_LANG_Modula2
:
13843 cu
->language
= language_m2
;
13845 case DW_LANG_Pascal83
:
13846 cu
->language
= language_pascal
;
13849 cu
->language
= language_objc
;
13851 case DW_LANG_Cobol74
:
13852 case DW_LANG_Cobol85
:
13854 cu
->language
= language_minimal
;
13857 cu
->language_defn
= language_def (cu
->language
);
13860 /* Return the named attribute or NULL if not there. */
13862 static struct attribute
*
13863 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
13868 struct attribute
*spec
= NULL
;
13870 for (i
= 0; i
< die
->num_attrs
; ++i
)
13872 if (die
->attrs
[i
].name
== name
)
13873 return &die
->attrs
[i
];
13874 if (die
->attrs
[i
].name
== DW_AT_specification
13875 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
13876 spec
= &die
->attrs
[i
];
13882 die
= follow_die_ref (die
, spec
, &cu
);
13888 /* Return the named attribute or NULL if not there,
13889 but do not follow DW_AT_specification, etc.
13890 This is for use in contexts where we're reading .debug_types dies.
13891 Following DW_AT_specification, DW_AT_abstract_origin will take us
13892 back up the chain, and we want to go down. */
13894 static struct attribute
*
13895 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
13899 for (i
= 0; i
< die
->num_attrs
; ++i
)
13900 if (die
->attrs
[i
].name
== name
)
13901 return &die
->attrs
[i
];
13906 /* Return non-zero iff the attribute NAME is defined for the given DIE,
13907 and holds a non-zero value. This function should only be used for
13908 DW_FORM_flag or DW_FORM_flag_present attributes. */
13911 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
13913 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
13915 return (attr
&& DW_UNSND (attr
));
13919 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
13921 /* A DIE is a declaration if it has a DW_AT_declaration attribute
13922 which value is non-zero. However, we have to be careful with
13923 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
13924 (via dwarf2_flag_true_p) follows this attribute. So we may
13925 end up accidently finding a declaration attribute that belongs
13926 to a different DIE referenced by the specification attribute,
13927 even though the given DIE does not have a declaration attribute. */
13928 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
13929 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
13932 /* Return the die giving the specification for DIE, if there is
13933 one. *SPEC_CU is the CU containing DIE on input, and the CU
13934 containing the return value on output. If there is no
13935 specification, but there is an abstract origin, that is
13938 static struct die_info
*
13939 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
13941 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
13944 if (spec_attr
== NULL
)
13945 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
13947 if (spec_attr
== NULL
)
13950 return follow_die_ref (die
, spec_attr
, spec_cu
);
13953 /* Free the line_header structure *LH, and any arrays and strings it
13955 NOTE: This is also used as a "cleanup" function. */
13958 free_line_header (struct line_header
*lh
)
13960 if (lh
->standard_opcode_lengths
)
13961 xfree (lh
->standard_opcode_lengths
);
13963 /* Remember that all the lh->file_names[i].name pointers are
13964 pointers into debug_line_buffer, and don't need to be freed. */
13965 if (lh
->file_names
)
13966 xfree (lh
->file_names
);
13968 /* Similarly for the include directory names. */
13969 if (lh
->include_dirs
)
13970 xfree (lh
->include_dirs
);
13975 /* Add an entry to LH's include directory table. */
13978 add_include_dir (struct line_header
*lh
, char *include_dir
)
13980 /* Grow the array if necessary. */
13981 if (lh
->include_dirs_size
== 0)
13983 lh
->include_dirs_size
= 1; /* for testing */
13984 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
13985 * sizeof (*lh
->include_dirs
));
13987 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
13989 lh
->include_dirs_size
*= 2;
13990 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
13991 (lh
->include_dirs_size
13992 * sizeof (*lh
->include_dirs
)));
13995 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
13998 /* Add an entry to LH's file name table. */
14001 add_file_name (struct line_header
*lh
,
14003 unsigned int dir_index
,
14004 unsigned int mod_time
,
14005 unsigned int length
)
14007 struct file_entry
*fe
;
14009 /* Grow the array if necessary. */
14010 if (lh
->file_names_size
== 0)
14012 lh
->file_names_size
= 1; /* for testing */
14013 lh
->file_names
= xmalloc (lh
->file_names_size
14014 * sizeof (*lh
->file_names
));
14016 else if (lh
->num_file_names
>= lh
->file_names_size
)
14018 lh
->file_names_size
*= 2;
14019 lh
->file_names
= xrealloc (lh
->file_names
,
14020 (lh
->file_names_size
14021 * sizeof (*lh
->file_names
)));
14024 fe
= &lh
->file_names
[lh
->num_file_names
++];
14026 fe
->dir_index
= dir_index
;
14027 fe
->mod_time
= mod_time
;
14028 fe
->length
= length
;
14029 fe
->included_p
= 0;
14033 /* A convenience function to find the proper .debug_line section for a
14036 static struct dwarf2_section_info
*
14037 get_debug_line_section (struct dwarf2_cu
*cu
)
14039 struct dwarf2_section_info
*section
;
14041 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
14043 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
14044 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
14045 else if (cu
->per_cu
->is_dwz
)
14047 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
14049 section
= &dwz
->line
;
14052 section
= &dwarf2_per_objfile
->line
;
14057 /* Read the statement program header starting at OFFSET in
14058 .debug_line, or .debug_line.dwo. Return a pointer
14059 to a struct line_header, allocated using xmalloc.
14061 NOTE: the strings in the include directory and file name tables of
14062 the returned object point into the dwarf line section buffer,
14063 and must not be freed. */
14065 static struct line_header
*
14066 dwarf_decode_line_header (unsigned int offset
, struct dwarf2_cu
*cu
)
14068 struct cleanup
*back_to
;
14069 struct line_header
*lh
;
14070 gdb_byte
*line_ptr
;
14071 unsigned int bytes_read
, offset_size
;
14073 char *cur_dir
, *cur_file
;
14074 struct dwarf2_section_info
*section
;
14077 section
= get_debug_line_section (cu
);
14078 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
14079 if (section
->buffer
== NULL
)
14081 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
14082 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
14084 complaint (&symfile_complaints
, _("missing .debug_line section"));
14088 /* We can't do this until we know the section is non-empty.
14089 Only then do we know we have such a section. */
14090 abfd
= section
->asection
->owner
;
14092 /* Make sure that at least there's room for the total_length field.
14093 That could be 12 bytes long, but we're just going to fudge that. */
14094 if (offset
+ 4 >= section
->size
)
14096 dwarf2_statement_list_fits_in_line_number_section_complaint ();
14100 lh
= xmalloc (sizeof (*lh
));
14101 memset (lh
, 0, sizeof (*lh
));
14102 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
14105 line_ptr
= section
->buffer
+ offset
;
14107 /* Read in the header. */
14109 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
14110 &bytes_read
, &offset_size
);
14111 line_ptr
+= bytes_read
;
14112 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
14114 dwarf2_statement_list_fits_in_line_number_section_complaint ();
14117 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
14118 lh
->version
= read_2_bytes (abfd
, line_ptr
);
14120 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
14121 line_ptr
+= offset_size
;
14122 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
14124 if (lh
->version
>= 4)
14126 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
14130 lh
->maximum_ops_per_instruction
= 1;
14132 if (lh
->maximum_ops_per_instruction
== 0)
14134 lh
->maximum_ops_per_instruction
= 1;
14135 complaint (&symfile_complaints
,
14136 _("invalid maximum_ops_per_instruction "
14137 "in `.debug_line' section"));
14140 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
14142 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
14144 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
14146 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
14148 lh
->standard_opcode_lengths
14149 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
14151 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
14152 for (i
= 1; i
< lh
->opcode_base
; ++i
)
14154 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
14158 /* Read directory table. */
14159 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
14161 line_ptr
+= bytes_read
;
14162 add_include_dir (lh
, cur_dir
);
14164 line_ptr
+= bytes_read
;
14166 /* Read file name table. */
14167 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
14169 unsigned int dir_index
, mod_time
, length
;
14171 line_ptr
+= bytes_read
;
14172 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14173 line_ptr
+= bytes_read
;
14174 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14175 line_ptr
+= bytes_read
;
14176 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14177 line_ptr
+= bytes_read
;
14179 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
14181 line_ptr
+= bytes_read
;
14182 lh
->statement_program_start
= line_ptr
;
14184 if (line_ptr
> (section
->buffer
+ section
->size
))
14185 complaint (&symfile_complaints
,
14186 _("line number info header doesn't "
14187 "fit in `.debug_line' section"));
14189 discard_cleanups (back_to
);
14193 /* Subroutine of dwarf_decode_lines to simplify it.
14194 Return the file name of the psymtab for included file FILE_INDEX
14195 in line header LH of PST.
14196 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
14197 If space for the result is malloc'd, it will be freed by a cleanup.
14198 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
14201 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
14202 const struct partial_symtab
*pst
,
14203 const char *comp_dir
)
14205 const struct file_entry fe
= lh
->file_names
[file_index
];
14206 char *include_name
= fe
.name
;
14207 char *include_name_to_compare
= include_name
;
14208 char *dir_name
= NULL
;
14209 const char *pst_filename
;
14210 char *copied_name
= NULL
;
14214 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
14216 if (!IS_ABSOLUTE_PATH (include_name
)
14217 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
14219 /* Avoid creating a duplicate psymtab for PST.
14220 We do this by comparing INCLUDE_NAME and PST_FILENAME.
14221 Before we do the comparison, however, we need to account
14222 for DIR_NAME and COMP_DIR.
14223 First prepend dir_name (if non-NULL). If we still don't
14224 have an absolute path prepend comp_dir (if non-NULL).
14225 However, the directory we record in the include-file's
14226 psymtab does not contain COMP_DIR (to match the
14227 corresponding symtab(s)).
14232 bash$ gcc -g ./hello.c
14233 include_name = "hello.c"
14235 DW_AT_comp_dir = comp_dir = "/tmp"
14236 DW_AT_name = "./hello.c" */
14238 if (dir_name
!= NULL
)
14240 include_name
= concat (dir_name
, SLASH_STRING
,
14241 include_name
, (char *)NULL
);
14242 include_name_to_compare
= include_name
;
14243 make_cleanup (xfree
, include_name
);
14245 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
14247 include_name_to_compare
= concat (comp_dir
, SLASH_STRING
,
14248 include_name
, (char *)NULL
);
14252 pst_filename
= pst
->filename
;
14253 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
14255 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
14256 pst_filename
, (char *)NULL
);
14257 pst_filename
= copied_name
;
14260 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
14262 if (include_name_to_compare
!= include_name
)
14263 xfree (include_name_to_compare
);
14264 if (copied_name
!= NULL
)
14265 xfree (copied_name
);
14269 return include_name
;
14272 /* Ignore this record_line request. */
14275 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
14280 /* Subroutine of dwarf_decode_lines to simplify it.
14281 Process the line number information in LH. */
14284 dwarf_decode_lines_1 (struct line_header
*lh
, const char *comp_dir
,
14285 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
14287 gdb_byte
*line_ptr
, *extended_end
;
14288 gdb_byte
*line_end
;
14289 unsigned int bytes_read
, extended_len
;
14290 unsigned char op_code
, extended_op
, adj_opcode
;
14291 CORE_ADDR baseaddr
;
14292 struct objfile
*objfile
= cu
->objfile
;
14293 bfd
*abfd
= objfile
->obfd
;
14294 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14295 const int decode_for_pst_p
= (pst
!= NULL
);
14296 struct subfile
*last_subfile
= NULL
;
14297 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
14300 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14302 line_ptr
= lh
->statement_program_start
;
14303 line_end
= lh
->statement_program_end
;
14305 /* Read the statement sequences until there's nothing left. */
14306 while (line_ptr
< line_end
)
14308 /* state machine registers */
14309 CORE_ADDR address
= 0;
14310 unsigned int file
= 1;
14311 unsigned int line
= 1;
14312 unsigned int column
= 0;
14313 int is_stmt
= lh
->default_is_stmt
;
14314 int basic_block
= 0;
14315 int end_sequence
= 0;
14317 unsigned char op_index
= 0;
14319 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
14321 /* Start a subfile for the current file of the state machine. */
14322 /* lh->include_dirs and lh->file_names are 0-based, but the
14323 directory and file name numbers in the statement program
14325 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
14329 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
14331 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
14334 /* Decode the table. */
14335 while (!end_sequence
)
14337 op_code
= read_1_byte (abfd
, line_ptr
);
14339 if (line_ptr
> line_end
)
14341 dwarf2_debug_line_missing_end_sequence_complaint ();
14345 if (op_code
>= lh
->opcode_base
)
14347 /* Special operand. */
14348 adj_opcode
= op_code
- lh
->opcode_base
;
14349 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
14350 / lh
->maximum_ops_per_instruction
)
14351 * lh
->minimum_instruction_length
);
14352 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
14353 % lh
->maximum_ops_per_instruction
);
14354 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
14355 if (lh
->num_file_names
< file
|| file
== 0)
14356 dwarf2_debug_line_missing_file_complaint ();
14357 /* For now we ignore lines not starting on an
14358 instruction boundary. */
14359 else if (op_index
== 0)
14361 lh
->file_names
[file
- 1].included_p
= 1;
14362 if (!decode_for_pst_p
&& is_stmt
)
14364 if (last_subfile
!= current_subfile
)
14366 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
14368 (*p_record_line
) (last_subfile
, 0, addr
);
14369 last_subfile
= current_subfile
;
14371 /* Append row to matrix using current values. */
14372 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
14373 (*p_record_line
) (current_subfile
, line
, addr
);
14378 else switch (op_code
)
14380 case DW_LNS_extended_op
:
14381 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
14383 line_ptr
+= bytes_read
;
14384 extended_end
= line_ptr
+ extended_len
;
14385 extended_op
= read_1_byte (abfd
, line_ptr
);
14387 switch (extended_op
)
14389 case DW_LNE_end_sequence
:
14390 p_record_line
= record_line
;
14393 case DW_LNE_set_address
:
14394 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
14396 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
14398 /* This line table is for a function which has been
14399 GCd by the linker. Ignore it. PR gdb/12528 */
14402 = line_ptr
- get_debug_line_section (cu
)->buffer
;
14404 complaint (&symfile_complaints
,
14405 _(".debug_line address at offset 0x%lx is 0 "
14407 line_offset
, objfile
->name
);
14408 p_record_line
= noop_record_line
;
14412 line_ptr
+= bytes_read
;
14413 address
+= baseaddr
;
14415 case DW_LNE_define_file
:
14418 unsigned int dir_index
, mod_time
, length
;
14420 cur_file
= read_direct_string (abfd
, line_ptr
,
14422 line_ptr
+= bytes_read
;
14424 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14425 line_ptr
+= bytes_read
;
14427 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14428 line_ptr
+= bytes_read
;
14430 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14431 line_ptr
+= bytes_read
;
14432 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
14435 case DW_LNE_set_discriminator
:
14436 /* The discriminator is not interesting to the debugger;
14438 line_ptr
= extended_end
;
14441 complaint (&symfile_complaints
,
14442 _("mangled .debug_line section"));
14445 /* Make sure that we parsed the extended op correctly. If e.g.
14446 we expected a different address size than the producer used,
14447 we may have read the wrong number of bytes. */
14448 if (line_ptr
!= extended_end
)
14450 complaint (&symfile_complaints
,
14451 _("mangled .debug_line section"));
14456 if (lh
->num_file_names
< file
|| file
== 0)
14457 dwarf2_debug_line_missing_file_complaint ();
14460 lh
->file_names
[file
- 1].included_p
= 1;
14461 if (!decode_for_pst_p
&& is_stmt
)
14463 if (last_subfile
!= current_subfile
)
14465 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
14467 (*p_record_line
) (last_subfile
, 0, addr
);
14468 last_subfile
= current_subfile
;
14470 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
14471 (*p_record_line
) (current_subfile
, line
, addr
);
14476 case DW_LNS_advance_pc
:
14479 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14481 address
+= (((op_index
+ adjust
)
14482 / lh
->maximum_ops_per_instruction
)
14483 * lh
->minimum_instruction_length
);
14484 op_index
= ((op_index
+ adjust
)
14485 % lh
->maximum_ops_per_instruction
);
14486 line_ptr
+= bytes_read
;
14489 case DW_LNS_advance_line
:
14490 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
14491 line_ptr
+= bytes_read
;
14493 case DW_LNS_set_file
:
14495 /* The arrays lh->include_dirs and lh->file_names are
14496 0-based, but the directory and file name numbers in
14497 the statement program are 1-based. */
14498 struct file_entry
*fe
;
14501 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14502 line_ptr
+= bytes_read
;
14503 if (lh
->num_file_names
< file
|| file
== 0)
14504 dwarf2_debug_line_missing_file_complaint ();
14507 fe
= &lh
->file_names
[file
- 1];
14509 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
14510 if (!decode_for_pst_p
)
14512 last_subfile
= current_subfile
;
14513 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
14518 case DW_LNS_set_column
:
14519 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14520 line_ptr
+= bytes_read
;
14522 case DW_LNS_negate_stmt
:
14523 is_stmt
= (!is_stmt
);
14525 case DW_LNS_set_basic_block
:
14528 /* Add to the address register of the state machine the
14529 address increment value corresponding to special opcode
14530 255. I.e., this value is scaled by the minimum
14531 instruction length since special opcode 255 would have
14532 scaled the increment. */
14533 case DW_LNS_const_add_pc
:
14535 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
14537 address
+= (((op_index
+ adjust
)
14538 / lh
->maximum_ops_per_instruction
)
14539 * lh
->minimum_instruction_length
);
14540 op_index
= ((op_index
+ adjust
)
14541 % lh
->maximum_ops_per_instruction
);
14544 case DW_LNS_fixed_advance_pc
:
14545 address
+= read_2_bytes (abfd
, line_ptr
);
14551 /* Unknown standard opcode, ignore it. */
14554 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
14556 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
14557 line_ptr
+= bytes_read
;
14562 if (lh
->num_file_names
< file
|| file
== 0)
14563 dwarf2_debug_line_missing_file_complaint ();
14566 lh
->file_names
[file
- 1].included_p
= 1;
14567 if (!decode_for_pst_p
)
14569 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
14570 (*p_record_line
) (current_subfile
, 0, addr
);
14576 /* Decode the Line Number Program (LNP) for the given line_header
14577 structure and CU. The actual information extracted and the type
14578 of structures created from the LNP depends on the value of PST.
14580 1. If PST is NULL, then this procedure uses the data from the program
14581 to create all necessary symbol tables, and their linetables.
14583 2. If PST is not NULL, this procedure reads the program to determine
14584 the list of files included by the unit represented by PST, and
14585 builds all the associated partial symbol tables.
14587 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
14588 It is used for relative paths in the line table.
14589 NOTE: When processing partial symtabs (pst != NULL),
14590 comp_dir == pst->dirname.
14592 NOTE: It is important that psymtabs have the same file name (via strcmp)
14593 as the corresponding symtab. Since COMP_DIR is not used in the name of the
14594 symtab we don't use it in the name of the psymtabs we create.
14595 E.g. expand_line_sal requires this when finding psymtabs to expand.
14596 A good testcase for this is mb-inline.exp. */
14599 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
14600 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
14601 int want_line_info
)
14603 struct objfile
*objfile
= cu
->objfile
;
14604 const int decode_for_pst_p
= (pst
!= NULL
);
14605 struct subfile
*first_subfile
= current_subfile
;
14607 if (want_line_info
)
14608 dwarf_decode_lines_1 (lh
, comp_dir
, cu
, pst
);
14610 if (decode_for_pst_p
)
14614 /* Now that we're done scanning the Line Header Program, we can
14615 create the psymtab of each included file. */
14616 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
14617 if (lh
->file_names
[file_index
].included_p
== 1)
14619 char *include_name
=
14620 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
14621 if (include_name
!= NULL
)
14622 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
14627 /* Make sure a symtab is created for every file, even files
14628 which contain only variables (i.e. no code with associated
14632 for (i
= 0; i
< lh
->num_file_names
; i
++)
14635 struct file_entry
*fe
;
14637 fe
= &lh
->file_names
[i
];
14639 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
14640 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
14642 /* Skip the main file; we don't need it, and it must be
14643 allocated last, so that it will show up before the
14644 non-primary symtabs in the objfile's symtab list. */
14645 if (current_subfile
== first_subfile
)
14648 if (current_subfile
->symtab
== NULL
)
14649 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
14651 fe
->symtab
= current_subfile
->symtab
;
14656 /* Start a subfile for DWARF. FILENAME is the name of the file and
14657 DIRNAME the name of the source directory which contains FILENAME
14658 or NULL if not known. COMP_DIR is the compilation directory for the
14659 linetable's compilation unit or NULL if not known.
14660 This routine tries to keep line numbers from identical absolute and
14661 relative file names in a common subfile.
14663 Using the `list' example from the GDB testsuite, which resides in
14664 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
14665 of /srcdir/list0.c yields the following debugging information for list0.c:
14667 DW_AT_name: /srcdir/list0.c
14668 DW_AT_comp_dir: /compdir
14669 files.files[0].name: list0.h
14670 files.files[0].dir: /srcdir
14671 files.files[1].name: list0.c
14672 files.files[1].dir: /srcdir
14674 The line number information for list0.c has to end up in a single
14675 subfile, so that `break /srcdir/list0.c:1' works as expected.
14676 start_subfile will ensure that this happens provided that we pass the
14677 concatenation of files.files[1].dir and files.files[1].name as the
14681 dwarf2_start_subfile (char *filename
, const char *dirname
,
14682 const char *comp_dir
)
14686 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
14687 `start_symtab' will always pass the contents of DW_AT_comp_dir as
14688 second argument to start_subfile. To be consistent, we do the
14689 same here. In order not to lose the line information directory,
14690 we concatenate it to the filename when it makes sense.
14691 Note that the Dwarf3 standard says (speaking of filenames in line
14692 information): ``The directory index is ignored for file names
14693 that represent full path names''. Thus ignoring dirname in the
14694 `else' branch below isn't an issue. */
14696 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
14697 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
14699 fullname
= filename
;
14701 start_subfile (fullname
, comp_dir
);
14703 if (fullname
!= filename
)
14707 /* Start a symtab for DWARF.
14708 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
14711 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
14712 char *name
, char *comp_dir
, CORE_ADDR low_pc
)
14714 start_symtab (name
, comp_dir
, low_pc
);
14715 record_debugformat ("DWARF 2");
14716 record_producer (cu
->producer
);
14718 /* We assume that we're processing GCC output. */
14719 processing_gcc_compilation
= 2;
14721 processing_has_namespace_info
= 0;
14725 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
14726 struct dwarf2_cu
*cu
)
14728 struct objfile
*objfile
= cu
->objfile
;
14729 struct comp_unit_head
*cu_header
= &cu
->header
;
14731 /* NOTE drow/2003-01-30: There used to be a comment and some special
14732 code here to turn a symbol with DW_AT_external and a
14733 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
14734 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
14735 with some versions of binutils) where shared libraries could have
14736 relocations against symbols in their debug information - the
14737 minimal symbol would have the right address, but the debug info
14738 would not. It's no longer necessary, because we will explicitly
14739 apply relocations when we read in the debug information now. */
14741 /* A DW_AT_location attribute with no contents indicates that a
14742 variable has been optimized away. */
14743 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
14745 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
14749 /* Handle one degenerate form of location expression specially, to
14750 preserve GDB's previous behavior when section offsets are
14751 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
14752 then mark this symbol as LOC_STATIC. */
14754 if (attr_form_is_block (attr
)
14755 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
14756 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
14757 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
14758 && (DW_BLOCK (attr
)->size
14759 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
14761 unsigned int dummy
;
14763 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
14764 SYMBOL_VALUE_ADDRESS (sym
) =
14765 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
14767 SYMBOL_VALUE_ADDRESS (sym
) =
14768 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
14769 SYMBOL_CLASS (sym
) = LOC_STATIC
;
14770 fixup_symbol_section (sym
, objfile
);
14771 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
14772 SYMBOL_SECTION (sym
));
14776 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
14777 expression evaluator, and use LOC_COMPUTED only when necessary
14778 (i.e. when the value of a register or memory location is
14779 referenced, or a thread-local block, etc.). Then again, it might
14780 not be worthwhile. I'm assuming that it isn't unless performance
14781 or memory numbers show me otherwise. */
14783 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
14784 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
14786 if (SYMBOL_COMPUTED_OPS (sym
) == &dwarf2_loclist_funcs
)
14787 cu
->has_loclist
= 1;
14790 /* Given a pointer to a DWARF information entry, figure out if we need
14791 to make a symbol table entry for it, and if so, create a new entry
14792 and return a pointer to it.
14793 If TYPE is NULL, determine symbol type from the die, otherwise
14794 used the passed type.
14795 If SPACE is not NULL, use it to hold the new symbol. If it is
14796 NULL, allocate a new symbol on the objfile's obstack. */
14798 static struct symbol
*
14799 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
14800 struct symbol
*space
)
14802 struct objfile
*objfile
= cu
->objfile
;
14803 struct symbol
*sym
= NULL
;
14805 struct attribute
*attr
= NULL
;
14806 struct attribute
*attr2
= NULL
;
14807 CORE_ADDR baseaddr
;
14808 struct pending
**list_to_add
= NULL
;
14810 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
14812 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14814 name
= dwarf2_name (die
, cu
);
14817 const char *linkagename
;
14818 int suppress_add
= 0;
14823 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
14824 OBJSTAT (objfile
, n_syms
++);
14826 /* Cache this symbol's name and the name's demangled form (if any). */
14827 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
14828 linkagename
= dwarf2_physname (name
, die
, cu
);
14829 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
14831 /* Fortran does not have mangling standard and the mangling does differ
14832 between gfortran, iFort etc. */
14833 if (cu
->language
== language_fortran
14834 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
14835 symbol_set_demangled_name (&(sym
->ginfo
),
14836 (char *) dwarf2_full_name (name
, die
, cu
),
14839 /* Default assumptions.
14840 Use the passed type or decode it from the die. */
14841 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
14842 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
14844 SYMBOL_TYPE (sym
) = type
;
14846 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
14847 attr
= dwarf2_attr (die
,
14848 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
14852 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
14855 attr
= dwarf2_attr (die
,
14856 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
14860 int file_index
= DW_UNSND (attr
);
14862 if (cu
->line_header
== NULL
14863 || file_index
> cu
->line_header
->num_file_names
)
14864 complaint (&symfile_complaints
,
14865 _("file index out of range"));
14866 else if (file_index
> 0)
14868 struct file_entry
*fe
;
14870 fe
= &cu
->line_header
->file_names
[file_index
- 1];
14871 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
14878 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14881 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
14883 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
14884 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
14885 SYMBOL_CLASS (sym
) = LOC_LABEL
;
14886 add_symbol_to_list (sym
, cu
->list_in_scope
);
14888 case DW_TAG_subprogram
:
14889 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
14891 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
14892 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
14893 if ((attr2
&& (DW_UNSND (attr2
) != 0))
14894 || cu
->language
== language_ada
)
14896 /* Subprograms marked external are stored as a global symbol.
14897 Ada subprograms, whether marked external or not, are always
14898 stored as a global symbol, because we want to be able to
14899 access them globally. For instance, we want to be able
14900 to break on a nested subprogram without having to
14901 specify the context. */
14902 list_to_add
= &global_symbols
;
14906 list_to_add
= cu
->list_in_scope
;
14909 case DW_TAG_inlined_subroutine
:
14910 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
14912 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
14913 SYMBOL_INLINED (sym
) = 1;
14914 list_to_add
= cu
->list_in_scope
;
14916 case DW_TAG_template_value_param
:
14918 /* Fall through. */
14919 case DW_TAG_constant
:
14920 case DW_TAG_variable
:
14921 case DW_TAG_member
:
14922 /* Compilation with minimal debug info may result in
14923 variables with missing type entries. Change the
14924 misleading `void' type to something sensible. */
14925 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
14927 = objfile_type (objfile
)->nodebug_data_symbol
;
14929 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
14930 /* In the case of DW_TAG_member, we should only be called for
14931 static const members. */
14932 if (die
->tag
== DW_TAG_member
)
14934 /* dwarf2_add_field uses die_is_declaration,
14935 so we do the same. */
14936 gdb_assert (die_is_declaration (die
, cu
));
14941 dwarf2_const_value (attr
, sym
, cu
);
14942 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
14945 if (attr2
&& (DW_UNSND (attr2
) != 0))
14946 list_to_add
= &global_symbols
;
14948 list_to_add
= cu
->list_in_scope
;
14952 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
14955 var_decode_location (attr
, sym
, cu
);
14956 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
14957 if (SYMBOL_CLASS (sym
) == LOC_STATIC
14958 && SYMBOL_VALUE_ADDRESS (sym
) == 0
14959 && !dwarf2_per_objfile
->has_section_at_zero
)
14961 /* When a static variable is eliminated by the linker,
14962 the corresponding debug information is not stripped
14963 out, but the variable address is set to null;
14964 do not add such variables into symbol table. */
14966 else if (attr2
&& (DW_UNSND (attr2
) != 0))
14968 /* Workaround gfortran PR debug/40040 - it uses
14969 DW_AT_location for variables in -fPIC libraries which may
14970 get overriden by other libraries/executable and get
14971 a different address. Resolve it by the minimal symbol
14972 which may come from inferior's executable using copy
14973 relocation. Make this workaround only for gfortran as for
14974 other compilers GDB cannot guess the minimal symbol
14975 Fortran mangling kind. */
14976 if (cu
->language
== language_fortran
&& die
->parent
14977 && die
->parent
->tag
== DW_TAG_module
14979 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
14980 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
14982 /* A variable with DW_AT_external is never static,
14983 but it may be block-scoped. */
14984 list_to_add
= (cu
->list_in_scope
== &file_symbols
14985 ? &global_symbols
: cu
->list_in_scope
);
14988 list_to_add
= cu
->list_in_scope
;
14992 /* We do not know the address of this symbol.
14993 If it is an external symbol and we have type information
14994 for it, enter the symbol as a LOC_UNRESOLVED symbol.
14995 The address of the variable will then be determined from
14996 the minimal symbol table whenever the variable is
14998 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
14999 if (attr2
&& (DW_UNSND (attr2
) != 0)
15000 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
15002 /* A variable with DW_AT_external is never static, but it
15003 may be block-scoped. */
15004 list_to_add
= (cu
->list_in_scope
== &file_symbols
15005 ? &global_symbols
: cu
->list_in_scope
);
15007 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
15009 else if (!die_is_declaration (die
, cu
))
15011 /* Use the default LOC_OPTIMIZED_OUT class. */
15012 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
15014 list_to_add
= cu
->list_in_scope
;
15018 case DW_TAG_formal_parameter
:
15019 /* If we are inside a function, mark this as an argument. If
15020 not, we might be looking at an argument to an inlined function
15021 when we do not have enough information to show inlined frames;
15022 pretend it's a local variable in that case so that the user can
15024 if (context_stack_depth
> 0
15025 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
15026 SYMBOL_IS_ARGUMENT (sym
) = 1;
15027 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
15030 var_decode_location (attr
, sym
, cu
);
15032 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15035 dwarf2_const_value (attr
, sym
, cu
);
15038 list_to_add
= cu
->list_in_scope
;
15040 case DW_TAG_unspecified_parameters
:
15041 /* From varargs functions; gdb doesn't seem to have any
15042 interest in this information, so just ignore it for now.
15045 case DW_TAG_template_type_param
:
15047 /* Fall through. */
15048 case DW_TAG_class_type
:
15049 case DW_TAG_interface_type
:
15050 case DW_TAG_structure_type
:
15051 case DW_TAG_union_type
:
15052 case DW_TAG_set_type
:
15053 case DW_TAG_enumeration_type
:
15054 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
15055 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
15058 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
15059 really ever be static objects: otherwise, if you try
15060 to, say, break of a class's method and you're in a file
15061 which doesn't mention that class, it won't work unless
15062 the check for all static symbols in lookup_symbol_aux
15063 saves you. See the OtherFileClass tests in
15064 gdb.c++/namespace.exp. */
15068 list_to_add
= (cu
->list_in_scope
== &file_symbols
15069 && (cu
->language
== language_cplus
15070 || cu
->language
== language_java
)
15071 ? &global_symbols
: cu
->list_in_scope
);
15073 /* The semantics of C++ state that "struct foo {
15074 ... }" also defines a typedef for "foo". A Java
15075 class declaration also defines a typedef for the
15077 if (cu
->language
== language_cplus
15078 || cu
->language
== language_java
15079 || cu
->language
== language_ada
)
15081 /* The symbol's name is already allocated along
15082 with this objfile, so we don't need to
15083 duplicate it for the type. */
15084 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
15085 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
15090 case DW_TAG_typedef
:
15091 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
15092 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
15093 list_to_add
= cu
->list_in_scope
;
15095 case DW_TAG_base_type
:
15096 case DW_TAG_subrange_type
:
15097 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
15098 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
15099 list_to_add
= cu
->list_in_scope
;
15101 case DW_TAG_enumerator
:
15102 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15105 dwarf2_const_value (attr
, sym
, cu
);
15108 /* NOTE: carlton/2003-11-10: See comment above in the
15109 DW_TAG_class_type, etc. block. */
15111 list_to_add
= (cu
->list_in_scope
== &file_symbols
15112 && (cu
->language
== language_cplus
15113 || cu
->language
== language_java
)
15114 ? &global_symbols
: cu
->list_in_scope
);
15117 case DW_TAG_namespace
:
15118 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
15119 list_to_add
= &global_symbols
;
15122 /* Not a tag we recognize. Hopefully we aren't processing
15123 trash data, but since we must specifically ignore things
15124 we don't recognize, there is nothing else we should do at
15126 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
15127 dwarf_tag_name (die
->tag
));
15133 sym
->hash_next
= objfile
->template_symbols
;
15134 objfile
->template_symbols
= sym
;
15135 list_to_add
= NULL
;
15138 if (list_to_add
!= NULL
)
15139 add_symbol_to_list (sym
, list_to_add
);
15141 /* For the benefit of old versions of GCC, check for anonymous
15142 namespaces based on the demangled name. */
15143 if (!processing_has_namespace_info
15144 && cu
->language
== language_cplus
)
15145 cp_scan_for_anonymous_namespaces (sym
, objfile
);
15150 /* A wrapper for new_symbol_full that always allocates a new symbol. */
15152 static struct symbol
*
15153 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
15155 return new_symbol_full (die
, type
, cu
, NULL
);
15158 /* Given an attr with a DW_FORM_dataN value in host byte order,
15159 zero-extend it as appropriate for the symbol's type. The DWARF
15160 standard (v4) is not entirely clear about the meaning of using
15161 DW_FORM_dataN for a constant with a signed type, where the type is
15162 wider than the data. The conclusion of a discussion on the DWARF
15163 list was that this is unspecified. We choose to always zero-extend
15164 because that is the interpretation long in use by GCC. */
15167 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
15168 const char *name
, struct obstack
*obstack
,
15169 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
15171 struct objfile
*objfile
= cu
->objfile
;
15172 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
15173 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
15174 LONGEST l
= DW_UNSND (attr
);
15176 if (bits
< sizeof (*value
) * 8)
15178 l
&= ((LONGEST
) 1 << bits
) - 1;
15181 else if (bits
== sizeof (*value
) * 8)
15185 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
15186 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
15193 /* Read a constant value from an attribute. Either set *VALUE, or if
15194 the value does not fit in *VALUE, set *BYTES - either already
15195 allocated on the objfile obstack, or newly allocated on OBSTACK,
15196 or, set *BATON, if we translated the constant to a location
15200 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
15201 const char *name
, struct obstack
*obstack
,
15202 struct dwarf2_cu
*cu
,
15203 LONGEST
*value
, gdb_byte
**bytes
,
15204 struct dwarf2_locexpr_baton
**baton
)
15206 struct objfile
*objfile
= cu
->objfile
;
15207 struct comp_unit_head
*cu_header
= &cu
->header
;
15208 struct dwarf_block
*blk
;
15209 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
15210 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
15216 switch (attr
->form
)
15219 case DW_FORM_GNU_addr_index
:
15223 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
15224 dwarf2_const_value_length_mismatch_complaint (name
,
15225 cu_header
->addr_size
,
15226 TYPE_LENGTH (type
));
15227 /* Symbols of this form are reasonably rare, so we just
15228 piggyback on the existing location code rather than writing
15229 a new implementation of symbol_computed_ops. */
15230 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
15231 sizeof (struct dwarf2_locexpr_baton
));
15232 (*baton
)->per_cu
= cu
->per_cu
;
15233 gdb_assert ((*baton
)->per_cu
);
15235 (*baton
)->size
= 2 + cu_header
->addr_size
;
15236 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
15237 (*baton
)->data
= data
;
15239 data
[0] = DW_OP_addr
;
15240 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
15241 byte_order
, DW_ADDR (attr
));
15242 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
15245 case DW_FORM_string
:
15247 case DW_FORM_GNU_str_index
:
15248 case DW_FORM_GNU_strp_alt
:
15249 /* DW_STRING is already allocated on the objfile obstack, point
15251 *bytes
= (gdb_byte
*) DW_STRING (attr
);
15253 case DW_FORM_block1
:
15254 case DW_FORM_block2
:
15255 case DW_FORM_block4
:
15256 case DW_FORM_block
:
15257 case DW_FORM_exprloc
:
15258 blk
= DW_BLOCK (attr
);
15259 if (TYPE_LENGTH (type
) != blk
->size
)
15260 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
15261 TYPE_LENGTH (type
));
15262 *bytes
= blk
->data
;
15265 /* The DW_AT_const_value attributes are supposed to carry the
15266 symbol's value "represented as it would be on the target
15267 architecture." By the time we get here, it's already been
15268 converted to host endianness, so we just need to sign- or
15269 zero-extend it as appropriate. */
15270 case DW_FORM_data1
:
15271 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
15272 obstack
, cu
, value
, 8);
15274 case DW_FORM_data2
:
15275 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
15276 obstack
, cu
, value
, 16);
15278 case DW_FORM_data4
:
15279 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
15280 obstack
, cu
, value
, 32);
15282 case DW_FORM_data8
:
15283 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
15284 obstack
, cu
, value
, 64);
15287 case DW_FORM_sdata
:
15288 *value
= DW_SND (attr
);
15291 case DW_FORM_udata
:
15292 *value
= DW_UNSND (attr
);
15296 complaint (&symfile_complaints
,
15297 _("unsupported const value attribute form: '%s'"),
15298 dwarf_form_name (attr
->form
));
15305 /* Copy constant value from an attribute to a symbol. */
15308 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
15309 struct dwarf2_cu
*cu
)
15311 struct objfile
*objfile
= cu
->objfile
;
15312 struct comp_unit_head
*cu_header
= &cu
->header
;
15315 struct dwarf2_locexpr_baton
*baton
;
15317 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
15318 SYMBOL_PRINT_NAME (sym
),
15319 &objfile
->objfile_obstack
, cu
,
15320 &value
, &bytes
, &baton
);
15324 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
15325 SYMBOL_LOCATION_BATON (sym
) = baton
;
15326 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
15328 else if (bytes
!= NULL
)
15330 SYMBOL_VALUE_BYTES (sym
) = bytes
;
15331 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
15335 SYMBOL_VALUE (sym
) = value
;
15336 SYMBOL_CLASS (sym
) = LOC_CONST
;
15340 /* Return the type of the die in question using its DW_AT_type attribute. */
15342 static struct type
*
15343 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15345 struct attribute
*type_attr
;
15347 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
15350 /* A missing DW_AT_type represents a void type. */
15351 return objfile_type (cu
->objfile
)->builtin_void
;
15354 return lookup_die_type (die
, type_attr
, cu
);
15357 /* True iff CU's producer generates GNAT Ada auxiliary information
15358 that allows to find parallel types through that information instead
15359 of having to do expensive parallel lookups by type name. */
15362 need_gnat_info (struct dwarf2_cu
*cu
)
15364 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
15365 of GNAT produces this auxiliary information, without any indication
15366 that it is produced. Part of enhancing the FSF version of GNAT
15367 to produce that information will be to put in place an indicator
15368 that we can use in order to determine whether the descriptive type
15369 info is available or not. One suggestion that has been made is
15370 to use a new attribute, attached to the CU die. For now, assume
15371 that the descriptive type info is not available. */
15375 /* Return the auxiliary type of the die in question using its
15376 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
15377 attribute is not present. */
15379 static struct type
*
15380 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15382 struct attribute
*type_attr
;
15384 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
15388 return lookup_die_type (die
, type_attr
, cu
);
15391 /* If DIE has a descriptive_type attribute, then set the TYPE's
15392 descriptive type accordingly. */
15395 set_descriptive_type (struct type
*type
, struct die_info
*die
,
15396 struct dwarf2_cu
*cu
)
15398 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
15400 if (descriptive_type
)
15402 ALLOCATE_GNAT_AUX_TYPE (type
);
15403 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
15407 /* Return the containing type of the die in question using its
15408 DW_AT_containing_type attribute. */
15410 static struct type
*
15411 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15413 struct attribute
*type_attr
;
15415 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
15417 error (_("Dwarf Error: Problem turning containing type into gdb type "
15418 "[in module %s]"), cu
->objfile
->name
);
15420 return lookup_die_type (die
, type_attr
, cu
);
15423 /* Look up the type of DIE in CU using its type attribute ATTR.
15424 If there is no type substitute an error marker. */
15426 static struct type
*
15427 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
15428 struct dwarf2_cu
*cu
)
15430 struct objfile
*objfile
= cu
->objfile
;
15431 struct type
*this_type
;
15433 /* First see if we have it cached. */
15435 if (attr
->form
== DW_FORM_GNU_ref_alt
)
15437 struct dwarf2_per_cu_data
*per_cu
;
15438 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
15440 per_cu
= dwarf2_find_containing_comp_unit (offset
, 1, cu
->objfile
);
15441 this_type
= get_die_type_at_offset (offset
, per_cu
);
15443 else if (is_ref_attr (attr
))
15445 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
15447 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
15449 else if (attr
->form
== DW_FORM_ref_sig8
)
15451 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
15453 /* sig_type will be NULL if the signatured type is missing from
15455 if (sig_type
== NULL
)
15456 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
15457 "at 0x%x [in module %s]"),
15458 die
->offset
.sect_off
, objfile
->name
);
15460 gdb_assert (sig_type
->per_cu
.is_debug_types
);
15461 /* If we haven't filled in type_offset_in_section yet, then we
15462 haven't read the type in yet. */
15464 if (sig_type
->type_offset_in_section
.sect_off
!= 0)
15467 get_die_type_at_offset (sig_type
->type_offset_in_section
,
15468 &sig_type
->per_cu
);
15473 dump_die_for_error (die
);
15474 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
15475 dwarf_attr_name (attr
->name
), objfile
->name
);
15478 /* If not cached we need to read it in. */
15480 if (this_type
== NULL
)
15482 struct die_info
*type_die
;
15483 struct dwarf2_cu
*type_cu
= cu
;
15485 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
15486 /* If we found the type now, it's probably because the type came
15487 from an inter-CU reference and the type's CU got expanded before
15489 this_type
= get_die_type (type_die
, type_cu
);
15490 if (this_type
== NULL
)
15491 this_type
= read_type_die_1 (type_die
, type_cu
);
15494 /* If we still don't have a type use an error marker. */
15496 if (this_type
== NULL
)
15498 char *message
, *saved
;
15500 /* read_type_die already issued a complaint. */
15501 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
15503 cu
->header
.offset
.sect_off
,
15504 die
->offset
.sect_off
);
15505 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
15506 message
, strlen (message
));
15509 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
15515 /* Return the type in DIE, CU.
15516 Returns NULL for invalid types.
15518 This first does a lookup in the appropriate type_hash table,
15519 and only reads the die in if necessary.
15521 NOTE: This can be called when reading in partial or full symbols. */
15523 static struct type
*
15524 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
15526 struct type
*this_type
;
15528 this_type
= get_die_type (die
, cu
);
15532 return read_type_die_1 (die
, cu
);
15535 /* Read the type in DIE, CU.
15536 Returns NULL for invalid types. */
15538 static struct type
*
15539 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
15541 struct type
*this_type
= NULL
;
15545 case DW_TAG_class_type
:
15546 case DW_TAG_interface_type
:
15547 case DW_TAG_structure_type
:
15548 case DW_TAG_union_type
:
15549 this_type
= read_structure_type (die
, cu
);
15551 case DW_TAG_enumeration_type
:
15552 this_type
= read_enumeration_type (die
, cu
);
15554 case DW_TAG_subprogram
:
15555 case DW_TAG_subroutine_type
:
15556 case DW_TAG_inlined_subroutine
:
15557 this_type
= read_subroutine_type (die
, cu
);
15559 case DW_TAG_array_type
:
15560 this_type
= read_array_type (die
, cu
);
15562 case DW_TAG_set_type
:
15563 this_type
= read_set_type (die
, cu
);
15565 case DW_TAG_pointer_type
:
15566 this_type
= read_tag_pointer_type (die
, cu
);
15568 case DW_TAG_ptr_to_member_type
:
15569 this_type
= read_tag_ptr_to_member_type (die
, cu
);
15571 case DW_TAG_reference_type
:
15572 this_type
= read_tag_reference_type (die
, cu
);
15574 case DW_TAG_const_type
:
15575 this_type
= read_tag_const_type (die
, cu
);
15577 case DW_TAG_volatile_type
:
15578 this_type
= read_tag_volatile_type (die
, cu
);
15580 case DW_TAG_string_type
:
15581 this_type
= read_tag_string_type (die
, cu
);
15583 case DW_TAG_typedef
:
15584 this_type
= read_typedef (die
, cu
);
15586 case DW_TAG_subrange_type
:
15587 this_type
= read_subrange_type (die
, cu
);
15589 case DW_TAG_base_type
:
15590 this_type
= read_base_type (die
, cu
);
15592 case DW_TAG_unspecified_type
:
15593 this_type
= read_unspecified_type (die
, cu
);
15595 case DW_TAG_namespace
:
15596 this_type
= read_namespace_type (die
, cu
);
15598 case DW_TAG_module
:
15599 this_type
= read_module_type (die
, cu
);
15602 complaint (&symfile_complaints
,
15603 _("unexpected tag in read_type_die: '%s'"),
15604 dwarf_tag_name (die
->tag
));
15611 /* See if we can figure out if the class lives in a namespace. We do
15612 this by looking for a member function; its demangled name will
15613 contain namespace info, if there is any.
15614 Return the computed name or NULL.
15615 Space for the result is allocated on the objfile's obstack.
15616 This is the full-die version of guess_partial_die_structure_name.
15617 In this case we know DIE has no useful parent. */
15620 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
15622 struct die_info
*spec_die
;
15623 struct dwarf2_cu
*spec_cu
;
15624 struct die_info
*child
;
15627 spec_die
= die_specification (die
, &spec_cu
);
15628 if (spec_die
!= NULL
)
15634 for (child
= die
->child
;
15636 child
= child
->sibling
)
15638 if (child
->tag
== DW_TAG_subprogram
)
15640 struct attribute
*attr
;
15642 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
15644 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
15648 = language_class_name_from_physname (cu
->language_defn
,
15652 if (actual_name
!= NULL
)
15654 char *die_name
= dwarf2_name (die
, cu
);
15656 if (die_name
!= NULL
15657 && strcmp (die_name
, actual_name
) != 0)
15659 /* Strip off the class name from the full name.
15660 We want the prefix. */
15661 int die_name_len
= strlen (die_name
);
15662 int actual_name_len
= strlen (actual_name
);
15664 /* Test for '::' as a sanity check. */
15665 if (actual_name_len
> die_name_len
+ 2
15666 && actual_name
[actual_name_len
15667 - die_name_len
- 1] == ':')
15669 obsavestring (actual_name
,
15670 actual_name_len
- die_name_len
- 2,
15671 &cu
->objfile
->objfile_obstack
);
15674 xfree (actual_name
);
15683 /* GCC might emit a nameless typedef that has a linkage name. Determine the
15684 prefix part in such case. See
15685 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
15688 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
15690 struct attribute
*attr
;
15693 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
15694 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
15697 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
15698 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
15701 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
15703 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
15704 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
15707 /* dwarf2_name had to be already called. */
15708 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
15710 /* Strip the base name, keep any leading namespaces/classes. */
15711 base
= strrchr (DW_STRING (attr
), ':');
15712 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
15715 return obsavestring (DW_STRING (attr
), &base
[-1] - DW_STRING (attr
),
15716 &cu
->objfile
->objfile_obstack
);
15719 /* Return the name of the namespace/class that DIE is defined within,
15720 or "" if we can't tell. The caller should not xfree the result.
15722 For example, if we're within the method foo() in the following
15732 then determine_prefix on foo's die will return "N::C". */
15734 static const char *
15735 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
15737 struct die_info
*parent
, *spec_die
;
15738 struct dwarf2_cu
*spec_cu
;
15739 struct type
*parent_type
;
15742 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
15743 && cu
->language
!= language_fortran
)
15746 retval
= anonymous_struct_prefix (die
, cu
);
15750 /* We have to be careful in the presence of DW_AT_specification.
15751 For example, with GCC 3.4, given the code
15755 // Definition of N::foo.
15759 then we'll have a tree of DIEs like this:
15761 1: DW_TAG_compile_unit
15762 2: DW_TAG_namespace // N
15763 3: DW_TAG_subprogram // declaration of N::foo
15764 4: DW_TAG_subprogram // definition of N::foo
15765 DW_AT_specification // refers to die #3
15767 Thus, when processing die #4, we have to pretend that we're in
15768 the context of its DW_AT_specification, namely the contex of die
15771 spec_die
= die_specification (die
, &spec_cu
);
15772 if (spec_die
== NULL
)
15773 parent
= die
->parent
;
15776 parent
= spec_die
->parent
;
15780 if (parent
== NULL
)
15782 else if (parent
->building_fullname
)
15785 const char *parent_name
;
15787 /* It has been seen on RealView 2.2 built binaries,
15788 DW_TAG_template_type_param types actually _defined_ as
15789 children of the parent class:
15792 template class <class Enum> Class{};
15793 Class<enum E> class_e;
15795 1: DW_TAG_class_type (Class)
15796 2: DW_TAG_enumeration_type (E)
15797 3: DW_TAG_enumerator (enum1:0)
15798 3: DW_TAG_enumerator (enum2:1)
15800 2: DW_TAG_template_type_param
15801 DW_AT_type DW_FORM_ref_udata (E)
15803 Besides being broken debug info, it can put GDB into an
15804 infinite loop. Consider:
15806 When we're building the full name for Class<E>, we'll start
15807 at Class, and go look over its template type parameters,
15808 finding E. We'll then try to build the full name of E, and
15809 reach here. We're now trying to build the full name of E,
15810 and look over the parent DIE for containing scope. In the
15811 broken case, if we followed the parent DIE of E, we'd again
15812 find Class, and once again go look at its template type
15813 arguments, etc., etc. Simply don't consider such parent die
15814 as source-level parent of this die (it can't be, the language
15815 doesn't allow it), and break the loop here. */
15816 name
= dwarf2_name (die
, cu
);
15817 parent_name
= dwarf2_name (parent
, cu
);
15818 complaint (&symfile_complaints
,
15819 _("template param type '%s' defined within parent '%s'"),
15820 name
? name
: "<unknown>",
15821 parent_name
? parent_name
: "<unknown>");
15825 switch (parent
->tag
)
15827 case DW_TAG_namespace
:
15828 parent_type
= read_type_die (parent
, cu
);
15829 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
15830 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
15831 Work around this problem here. */
15832 if (cu
->language
== language_cplus
15833 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
15835 /* We give a name to even anonymous namespaces. */
15836 return TYPE_TAG_NAME (parent_type
);
15837 case DW_TAG_class_type
:
15838 case DW_TAG_interface_type
:
15839 case DW_TAG_structure_type
:
15840 case DW_TAG_union_type
:
15841 case DW_TAG_module
:
15842 parent_type
= read_type_die (parent
, cu
);
15843 if (TYPE_TAG_NAME (parent_type
) != NULL
)
15844 return TYPE_TAG_NAME (parent_type
);
15846 /* An anonymous structure is only allowed non-static data
15847 members; no typedefs, no member functions, et cetera.
15848 So it does not need a prefix. */
15850 case DW_TAG_compile_unit
:
15851 case DW_TAG_partial_unit
:
15852 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
15853 if (cu
->language
== language_cplus
15854 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
15855 && die
->child
!= NULL
15856 && (die
->tag
== DW_TAG_class_type
15857 || die
->tag
== DW_TAG_structure_type
15858 || die
->tag
== DW_TAG_union_type
))
15860 char *name
= guess_full_die_structure_name (die
, cu
);
15866 return determine_prefix (parent
, cu
);
15870 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
15871 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
15872 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
15873 an obconcat, otherwise allocate storage for the result. The CU argument is
15874 used to determine the language and hence, the appropriate separator. */
15876 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
15879 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
15880 int physname
, struct dwarf2_cu
*cu
)
15882 const char *lead
= "";
15885 if (suffix
== NULL
|| suffix
[0] == '\0'
15886 || prefix
== NULL
|| prefix
[0] == '\0')
15888 else if (cu
->language
== language_java
)
15890 else if (cu
->language
== language_fortran
&& physname
)
15892 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
15893 DW_AT_MIPS_linkage_name is preferred and used instead. */
15901 if (prefix
== NULL
)
15903 if (suffix
== NULL
)
15909 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
15911 strcpy (retval
, lead
);
15912 strcat (retval
, prefix
);
15913 strcat (retval
, sep
);
15914 strcat (retval
, suffix
);
15919 /* We have an obstack. */
15920 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
15924 /* Return sibling of die, NULL if no sibling. */
15926 static struct die_info
*
15927 sibling_die (struct die_info
*die
)
15929 return die
->sibling
;
15932 /* Get name of a die, return NULL if not found. */
15935 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
15936 struct obstack
*obstack
)
15938 if (name
&& cu
->language
== language_cplus
)
15940 char *canon_name
= cp_canonicalize_string (name
);
15942 if (canon_name
!= NULL
)
15944 if (strcmp (canon_name
, name
) != 0)
15945 name
= obsavestring (canon_name
, strlen (canon_name
),
15947 xfree (canon_name
);
15954 /* Get name of a die, return NULL if not found. */
15957 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
15959 struct attribute
*attr
;
15961 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
15962 if ((!attr
|| !DW_STRING (attr
))
15963 && die
->tag
!= DW_TAG_class_type
15964 && die
->tag
!= DW_TAG_interface_type
15965 && die
->tag
!= DW_TAG_structure_type
15966 && die
->tag
!= DW_TAG_union_type
)
15971 case DW_TAG_compile_unit
:
15972 case DW_TAG_partial_unit
:
15973 /* Compilation units have a DW_AT_name that is a filename, not
15974 a source language identifier. */
15975 case DW_TAG_enumeration_type
:
15976 case DW_TAG_enumerator
:
15977 /* These tags always have simple identifiers already; no need
15978 to canonicalize them. */
15979 return DW_STRING (attr
);
15981 case DW_TAG_subprogram
:
15982 /* Java constructors will all be named "<init>", so return
15983 the class name when we see this special case. */
15984 if (cu
->language
== language_java
15985 && DW_STRING (attr
) != NULL
15986 && strcmp (DW_STRING (attr
), "<init>") == 0)
15988 struct dwarf2_cu
*spec_cu
= cu
;
15989 struct die_info
*spec_die
;
15991 /* GCJ will output '<init>' for Java constructor names.
15992 For this special case, return the name of the parent class. */
15994 /* GCJ may output suprogram DIEs with AT_specification set.
15995 If so, use the name of the specified DIE. */
15996 spec_die
= die_specification (die
, &spec_cu
);
15997 if (spec_die
!= NULL
)
15998 return dwarf2_name (spec_die
, spec_cu
);
16003 if (die
->tag
== DW_TAG_class_type
)
16004 return dwarf2_name (die
, cu
);
16006 while (die
->tag
!= DW_TAG_compile_unit
16007 && die
->tag
!= DW_TAG_partial_unit
);
16011 case DW_TAG_class_type
:
16012 case DW_TAG_interface_type
:
16013 case DW_TAG_structure_type
:
16014 case DW_TAG_union_type
:
16015 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
16016 structures or unions. These were of the form "._%d" in GCC 4.1,
16017 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
16018 and GCC 4.4. We work around this problem by ignoring these. */
16019 if (attr
&& DW_STRING (attr
)
16020 && (strncmp (DW_STRING (attr
), "._", 2) == 0
16021 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
16024 /* GCC might emit a nameless typedef that has a linkage name. See
16025 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
16026 if (!attr
|| DW_STRING (attr
) == NULL
)
16028 char *demangled
= NULL
;
16030 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
16032 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
16034 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
16037 /* Avoid demangling DW_STRING (attr) the second time on a second
16038 call for the same DIE. */
16039 if (!DW_STRING_IS_CANONICAL (attr
))
16040 demangled
= cplus_demangle (DW_STRING (attr
), DMGL_TYPES
);
16046 /* FIXME: we already did this for the partial symbol... */
16047 DW_STRING (attr
) = obsavestring (demangled
, strlen (demangled
),
16048 &cu
->objfile
->objfile_obstack
);
16049 DW_STRING_IS_CANONICAL (attr
) = 1;
16052 /* Strip any leading namespaces/classes, keep only the base name.
16053 DW_AT_name for named DIEs does not contain the prefixes. */
16054 base
= strrchr (DW_STRING (attr
), ':');
16055 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
16058 return DW_STRING (attr
);
16067 if (!DW_STRING_IS_CANONICAL (attr
))
16070 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
16071 &cu
->objfile
->objfile_obstack
);
16072 DW_STRING_IS_CANONICAL (attr
) = 1;
16074 return DW_STRING (attr
);
16077 /* Return the die that this die in an extension of, or NULL if there
16078 is none. *EXT_CU is the CU containing DIE on input, and the CU
16079 containing the return value on output. */
16081 static struct die_info
*
16082 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
16084 struct attribute
*attr
;
16086 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
16090 return follow_die_ref (die
, attr
, ext_cu
);
16093 /* Convert a DIE tag into its string name. */
16095 static const char *
16096 dwarf_tag_name (unsigned tag
)
16098 const char *name
= get_DW_TAG_name (tag
);
16101 return "DW_TAG_<unknown>";
16106 /* Convert a DWARF attribute code into its string name. */
16108 static const char *
16109 dwarf_attr_name (unsigned attr
)
16113 #ifdef MIPS /* collides with DW_AT_HP_block_index */
16114 if (attr
== DW_AT_MIPS_fde
)
16115 return "DW_AT_MIPS_fde";
16117 if (attr
== DW_AT_HP_block_index
)
16118 return "DW_AT_HP_block_index";
16121 name
= get_DW_AT_name (attr
);
16124 return "DW_AT_<unknown>";
16129 /* Convert a DWARF value form code into its string name. */
16131 static const char *
16132 dwarf_form_name (unsigned form
)
16134 const char *name
= get_DW_FORM_name (form
);
16137 return "DW_FORM_<unknown>";
16143 dwarf_bool_name (unsigned mybool
)
16151 /* Convert a DWARF type code into its string name. */
16153 static const char *
16154 dwarf_type_encoding_name (unsigned enc
)
16156 const char *name
= get_DW_ATE_name (enc
);
16159 return "DW_ATE_<unknown>";
16165 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
16169 print_spaces (indent
, f
);
16170 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
16171 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
.sect_off
);
16173 if (die
->parent
!= NULL
)
16175 print_spaces (indent
, f
);
16176 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
16177 die
->parent
->offset
.sect_off
);
16180 print_spaces (indent
, f
);
16181 fprintf_unfiltered (f
, " has children: %s\n",
16182 dwarf_bool_name (die
->child
!= NULL
));
16184 print_spaces (indent
, f
);
16185 fprintf_unfiltered (f
, " attributes:\n");
16187 for (i
= 0; i
< die
->num_attrs
; ++i
)
16189 print_spaces (indent
, f
);
16190 fprintf_unfiltered (f
, " %s (%s) ",
16191 dwarf_attr_name (die
->attrs
[i
].name
),
16192 dwarf_form_name (die
->attrs
[i
].form
));
16194 switch (die
->attrs
[i
].form
)
16197 case DW_FORM_GNU_addr_index
:
16198 fprintf_unfiltered (f
, "address: ");
16199 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
16201 case DW_FORM_block2
:
16202 case DW_FORM_block4
:
16203 case DW_FORM_block
:
16204 case DW_FORM_block1
:
16205 fprintf_unfiltered (f
, "block: size %s",
16206 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
16208 case DW_FORM_exprloc
:
16209 fprintf_unfiltered (f
, "expression: size %s",
16210 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
16212 case DW_FORM_ref_addr
:
16213 fprintf_unfiltered (f
, "ref address: ");
16214 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
16216 case DW_FORM_GNU_ref_alt
:
16217 fprintf_unfiltered (f
, "alt ref address: ");
16218 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
16224 case DW_FORM_ref_udata
:
16225 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
16226 (long) (DW_UNSND (&die
->attrs
[i
])));
16228 case DW_FORM_data1
:
16229 case DW_FORM_data2
:
16230 case DW_FORM_data4
:
16231 case DW_FORM_data8
:
16232 case DW_FORM_udata
:
16233 case DW_FORM_sdata
:
16234 fprintf_unfiltered (f
, "constant: %s",
16235 pulongest (DW_UNSND (&die
->attrs
[i
])));
16237 case DW_FORM_sec_offset
:
16238 fprintf_unfiltered (f
, "section offset: %s",
16239 pulongest (DW_UNSND (&die
->attrs
[i
])));
16241 case DW_FORM_ref_sig8
:
16242 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
16243 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
16244 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->per_cu
.offset
.sect_off
);
16246 fprintf_unfiltered (f
, "signatured type, offset: unknown");
16248 case DW_FORM_string
:
16250 case DW_FORM_GNU_str_index
:
16251 case DW_FORM_GNU_strp_alt
:
16252 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
16253 DW_STRING (&die
->attrs
[i
])
16254 ? DW_STRING (&die
->attrs
[i
]) : "",
16255 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
16258 if (DW_UNSND (&die
->attrs
[i
]))
16259 fprintf_unfiltered (f
, "flag: TRUE");
16261 fprintf_unfiltered (f
, "flag: FALSE");
16263 case DW_FORM_flag_present
:
16264 fprintf_unfiltered (f
, "flag: TRUE");
16266 case DW_FORM_indirect
:
16267 /* The reader will have reduced the indirect form to
16268 the "base form" so this form should not occur. */
16269 fprintf_unfiltered (f
,
16270 "unexpected attribute form: DW_FORM_indirect");
16273 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
16274 die
->attrs
[i
].form
);
16277 fprintf_unfiltered (f
, "\n");
16282 dump_die_for_error (struct die_info
*die
)
16284 dump_die_shallow (gdb_stderr
, 0, die
);
16288 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
16290 int indent
= level
* 4;
16292 gdb_assert (die
!= NULL
);
16294 if (level
>= max_level
)
16297 dump_die_shallow (f
, indent
, die
);
16299 if (die
->child
!= NULL
)
16301 print_spaces (indent
, f
);
16302 fprintf_unfiltered (f
, " Children:");
16303 if (level
+ 1 < max_level
)
16305 fprintf_unfiltered (f
, "\n");
16306 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
16310 fprintf_unfiltered (f
,
16311 " [not printed, max nesting level reached]\n");
16315 if (die
->sibling
!= NULL
&& level
> 0)
16317 dump_die_1 (f
, level
, max_level
, die
->sibling
);
16321 /* This is called from the pdie macro in gdbinit.in.
16322 It's not static so gcc will keep a copy callable from gdb. */
16325 dump_die (struct die_info
*die
, int max_level
)
16327 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
16331 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
16335 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
.sect_off
,
16341 /* DW_ADDR is always stored already as sect_offset; despite for the forms
16342 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
16345 is_ref_attr (struct attribute
*attr
)
16347 switch (attr
->form
)
16349 case DW_FORM_ref_addr
:
16354 case DW_FORM_ref_udata
:
16355 case DW_FORM_GNU_ref_alt
:
16362 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
16366 dwarf2_get_ref_die_offset (struct attribute
*attr
)
16368 sect_offset retval
= { DW_UNSND (attr
) };
16370 if (is_ref_attr (attr
))
16373 retval
.sect_off
= 0;
16374 complaint (&symfile_complaints
,
16375 _("unsupported die ref attribute form: '%s'"),
16376 dwarf_form_name (attr
->form
));
16380 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
16381 * the value held by the attribute is not constant. */
16384 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
16386 if (attr
->form
== DW_FORM_sdata
)
16387 return DW_SND (attr
);
16388 else if (attr
->form
== DW_FORM_udata
16389 || attr
->form
== DW_FORM_data1
16390 || attr
->form
== DW_FORM_data2
16391 || attr
->form
== DW_FORM_data4
16392 || attr
->form
== DW_FORM_data8
)
16393 return DW_UNSND (attr
);
16396 complaint (&symfile_complaints
,
16397 _("Attribute value is not a constant (%s)"),
16398 dwarf_form_name (attr
->form
));
16399 return default_value
;
16403 /* Follow reference or signature attribute ATTR of SRC_DIE.
16404 On entry *REF_CU is the CU of SRC_DIE.
16405 On exit *REF_CU is the CU of the result. */
16407 static struct die_info
*
16408 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
16409 struct dwarf2_cu
**ref_cu
)
16411 struct die_info
*die
;
16413 if (is_ref_attr (attr
))
16414 die
= follow_die_ref (src_die
, attr
, ref_cu
);
16415 else if (attr
->form
== DW_FORM_ref_sig8
)
16416 die
= follow_die_sig (src_die
, attr
, ref_cu
);
16419 dump_die_for_error (src_die
);
16420 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
16421 (*ref_cu
)->objfile
->name
);
16427 /* Follow reference OFFSET.
16428 On entry *REF_CU is the CU of the source die referencing OFFSET.
16429 On exit *REF_CU is the CU of the result.
16430 Returns NULL if OFFSET is invalid. */
16432 static struct die_info
*
16433 follow_die_offset (sect_offset offset
, int offset_in_dwz
,
16434 struct dwarf2_cu
**ref_cu
)
16436 struct die_info temp_die
;
16437 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
16439 gdb_assert (cu
->per_cu
!= NULL
);
16443 if (cu
->per_cu
->is_debug_types
)
16445 /* .debug_types CUs cannot reference anything outside their CU.
16446 If they need to, they have to reference a signatured type via
16447 DW_FORM_ref_sig8. */
16448 if (! offset_in_cu_p (&cu
->header
, offset
))
16451 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
16452 || ! offset_in_cu_p (&cu
->header
, offset
))
16454 struct dwarf2_per_cu_data
*per_cu
;
16456 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
16459 /* If necessary, add it to the queue and load its DIEs. */
16460 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
16461 load_full_comp_unit (per_cu
, cu
->language
);
16463 target_cu
= per_cu
->cu
;
16465 else if (cu
->dies
== NULL
)
16467 /* We're loading full DIEs during partial symbol reading. */
16468 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
16469 load_full_comp_unit (cu
->per_cu
, language_minimal
);
16472 *ref_cu
= target_cu
;
16473 temp_die
.offset
= offset
;
16474 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
.sect_off
);
16477 /* Follow reference attribute ATTR of SRC_DIE.
16478 On entry *REF_CU is the CU of SRC_DIE.
16479 On exit *REF_CU is the CU of the result. */
16481 static struct die_info
*
16482 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
16483 struct dwarf2_cu
**ref_cu
)
16485 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
16486 struct dwarf2_cu
*cu
= *ref_cu
;
16487 struct die_info
*die
;
16489 die
= follow_die_offset (offset
,
16490 (attr
->form
== DW_FORM_GNU_ref_alt
16491 || cu
->per_cu
->is_dwz
),
16494 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
16495 "at 0x%x [in module %s]"),
16496 offset
.sect_off
, src_die
->offset
.sect_off
, cu
->objfile
->name
);
16501 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
16502 Returned value is intended for DW_OP_call*. Returned
16503 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
16505 struct dwarf2_locexpr_baton
16506 dwarf2_fetch_die_location_block (cu_offset offset_in_cu
,
16507 struct dwarf2_per_cu_data
*per_cu
,
16508 CORE_ADDR (*get_frame_pc
) (void *baton
),
16511 sect_offset offset
= { per_cu
->offset
.sect_off
+ offset_in_cu
.cu_off
};
16512 struct dwarf2_cu
*cu
;
16513 struct die_info
*die
;
16514 struct attribute
*attr
;
16515 struct dwarf2_locexpr_baton retval
;
16517 dw2_setup (per_cu
->objfile
);
16519 if (per_cu
->cu
== NULL
)
16523 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
16525 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
16526 offset
.sect_off
, per_cu
->objfile
->name
);
16528 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16531 /* DWARF: "If there is no such attribute, then there is no effect.".
16532 DATA is ignored if SIZE is 0. */
16534 retval
.data
= NULL
;
16537 else if (attr_form_is_section_offset (attr
))
16539 struct dwarf2_loclist_baton loclist_baton
;
16540 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
16543 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
16545 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
16547 retval
.size
= size
;
16551 if (!attr_form_is_block (attr
))
16552 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
16553 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
16554 offset
.sect_off
, per_cu
->objfile
->name
);
16556 retval
.data
= DW_BLOCK (attr
)->data
;
16557 retval
.size
= DW_BLOCK (attr
)->size
;
16559 retval
.per_cu
= cu
->per_cu
;
16561 age_cached_comp_units ();
16566 /* Return the type of the DIE at DIE_OFFSET in the CU named by
16570 dwarf2_get_die_type (cu_offset die_offset
,
16571 struct dwarf2_per_cu_data
*per_cu
)
16573 sect_offset die_offset_sect
;
16575 dw2_setup (per_cu
->objfile
);
16577 die_offset_sect
.sect_off
= per_cu
->offset
.sect_off
+ die_offset
.cu_off
;
16578 return get_die_type_at_offset (die_offset_sect
, per_cu
);
16581 /* Follow the signature attribute ATTR in SRC_DIE.
16582 On entry *REF_CU is the CU of SRC_DIE.
16583 On exit *REF_CU is the CU of the result. */
16585 static struct die_info
*
16586 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
16587 struct dwarf2_cu
**ref_cu
)
16589 struct objfile
*objfile
= (*ref_cu
)->objfile
;
16590 struct die_info temp_die
;
16591 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
16592 struct dwarf2_cu
*sig_cu
;
16593 struct die_info
*die
;
16595 /* sig_type will be NULL if the signatured type is missing from
16597 if (sig_type
== NULL
)
16598 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
16599 "at 0x%x [in module %s]"),
16600 src_die
->offset
.sect_off
, objfile
->name
);
16602 /* If necessary, add it to the queue and load its DIEs. */
16604 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
16605 read_signatured_type (sig_type
);
16607 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
16609 sig_cu
= sig_type
->per_cu
.cu
;
16610 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
16611 temp_die
.offset
= sig_type
->type_offset_in_section
;
16612 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
16613 temp_die
.offset
.sect_off
);
16620 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
16621 "from DIE at 0x%x [in module %s]"),
16622 temp_die
.offset
.sect_off
, src_die
->offset
.sect_off
, objfile
->name
);
16625 /* Given an offset of a signatured type, return its signatured_type. */
16627 static struct signatured_type
*
16628 lookup_signatured_type_at_offset (struct objfile
*objfile
,
16629 struct dwarf2_section_info
*section
,
16630 sect_offset offset
)
16632 gdb_byte
*info_ptr
= section
->buffer
+ offset
.sect_off
;
16633 unsigned int length
, initial_length_size
;
16634 unsigned int sig_offset
;
16635 struct signatured_type find_entry
, *sig_type
;
16637 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
16638 sig_offset
= (initial_length_size
16640 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
16641 + 1 /*address_size*/);
16642 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
16643 sig_type
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
16645 /* This is only used to lookup previously recorded types.
16646 If we didn't find it, it's our bug. */
16647 gdb_assert (sig_type
!= NULL
);
16648 gdb_assert (offset
.sect_off
== sig_type
->per_cu
.offset
.sect_off
);
16653 /* Load the DIEs associated with type unit PER_CU into memory. */
16656 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
16658 struct signatured_type
*sig_type
;
16660 /* Caller is responsible for ensuring type_unit_groups don't get here. */
16661 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
16663 /* We have the per_cu, but we need the signatured_type.
16664 Fortunately this is an easy translation. */
16665 gdb_assert (per_cu
->is_debug_types
);
16666 sig_type
= (struct signatured_type
*) per_cu
;
16668 gdb_assert (per_cu
->cu
== NULL
);
16670 read_signatured_type (sig_type
);
16672 gdb_assert (per_cu
->cu
!= NULL
);
16675 /* die_reader_func for read_signatured_type.
16676 This is identical to load_full_comp_unit_reader,
16677 but is kept separate for now. */
16680 read_signatured_type_reader (const struct die_reader_specs
*reader
,
16681 gdb_byte
*info_ptr
,
16682 struct die_info
*comp_unit_die
,
16686 struct dwarf2_cu
*cu
= reader
->cu
;
16688 gdb_assert (cu
->die_hash
== NULL
);
16690 htab_create_alloc_ex (cu
->header
.length
/ 12,
16694 &cu
->comp_unit_obstack
,
16695 hashtab_obstack_allocate
,
16696 dummy_obstack_deallocate
);
16699 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
16700 &info_ptr
, comp_unit_die
);
16701 cu
->dies
= comp_unit_die
;
16702 /* comp_unit_die is not stored in die_hash, no need. */
16704 /* We try not to read any attributes in this function, because not
16705 all CUs needed for references have been loaded yet, and symbol
16706 table processing isn't initialized. But we have to set the CU language,
16707 or we won't be able to build types correctly.
16708 Similarly, if we do not read the producer, we can not apply
16709 producer-specific interpretation. */
16710 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
16713 /* Read in a signatured type and build its CU and DIEs.
16714 If the type is a stub for the real type in a DWO file,
16715 read in the real type from the DWO file as well. */
16718 read_signatured_type (struct signatured_type
*sig_type
)
16720 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
16722 gdb_assert (per_cu
->is_debug_types
);
16723 gdb_assert (per_cu
->cu
== NULL
);
16725 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
16726 read_signatured_type_reader
, NULL
);
16729 /* Decode simple location descriptions.
16730 Given a pointer to a dwarf block that defines a location, compute
16731 the location and return the value.
16733 NOTE drow/2003-11-18: This function is called in two situations
16734 now: for the address of static or global variables (partial symbols
16735 only) and for offsets into structures which are expected to be
16736 (more or less) constant. The partial symbol case should go away,
16737 and only the constant case should remain. That will let this
16738 function complain more accurately. A few special modes are allowed
16739 without complaint for global variables (for instance, global
16740 register values and thread-local values).
16742 A location description containing no operations indicates that the
16743 object is optimized out. The return value is 0 for that case.
16744 FIXME drow/2003-11-16: No callers check for this case any more; soon all
16745 callers will only want a very basic result and this can become a
16748 Note that stack[0] is unused except as a default error return. */
16751 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
16753 struct objfile
*objfile
= cu
->objfile
;
16755 size_t size
= blk
->size
;
16756 gdb_byte
*data
= blk
->data
;
16757 CORE_ADDR stack
[64];
16759 unsigned int bytes_read
, unsnd
;
16765 stack
[++stacki
] = 0;
16804 stack
[++stacki
] = op
- DW_OP_lit0
;
16839 stack
[++stacki
] = op
- DW_OP_reg0
;
16841 dwarf2_complex_location_expr_complaint ();
16845 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
16847 stack
[++stacki
] = unsnd
;
16849 dwarf2_complex_location_expr_complaint ();
16853 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
16858 case DW_OP_const1u
:
16859 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
16863 case DW_OP_const1s
:
16864 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
16868 case DW_OP_const2u
:
16869 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
16873 case DW_OP_const2s
:
16874 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
16878 case DW_OP_const4u
:
16879 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
16883 case DW_OP_const4s
:
16884 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
16888 case DW_OP_const8u
:
16889 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
16894 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
16900 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
16905 stack
[stacki
+ 1] = stack
[stacki
];
16910 stack
[stacki
- 1] += stack
[stacki
];
16914 case DW_OP_plus_uconst
:
16915 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
16921 stack
[stacki
- 1] -= stack
[stacki
];
16926 /* If we're not the last op, then we definitely can't encode
16927 this using GDB's address_class enum. This is valid for partial
16928 global symbols, although the variable's address will be bogus
16931 dwarf2_complex_location_expr_complaint ();
16934 case DW_OP_GNU_push_tls_address
:
16935 /* The top of the stack has the offset from the beginning
16936 of the thread control block at which the variable is located. */
16937 /* Nothing should follow this operator, so the top of stack would
16939 /* This is valid for partial global symbols, but the variable's
16940 address will be bogus in the psymtab. Make it always at least
16941 non-zero to not look as a variable garbage collected by linker
16942 which have DW_OP_addr 0. */
16944 dwarf2_complex_location_expr_complaint ();
16948 case DW_OP_GNU_uninit
:
16951 case DW_OP_GNU_addr_index
:
16952 case DW_OP_GNU_const_index
:
16953 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
16960 const char *name
= get_DW_OP_name (op
);
16963 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
16966 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
16970 return (stack
[stacki
]);
16973 /* Enforce maximum stack depth of SIZE-1 to avoid writing
16974 outside of the allocated space. Also enforce minimum>0. */
16975 if (stacki
>= ARRAY_SIZE (stack
) - 1)
16977 complaint (&symfile_complaints
,
16978 _("location description stack overflow"));
16984 complaint (&symfile_complaints
,
16985 _("location description stack underflow"));
16989 return (stack
[stacki
]);
16992 /* memory allocation interface */
16994 static struct dwarf_block
*
16995 dwarf_alloc_block (struct dwarf2_cu
*cu
)
16997 struct dwarf_block
*blk
;
16999 blk
= (struct dwarf_block
*)
17000 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
17004 static struct die_info
*
17005 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
17007 struct die_info
*die
;
17008 size_t size
= sizeof (struct die_info
);
17011 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
17013 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
17014 memset (die
, 0, sizeof (struct die_info
));
17019 /* Macro support. */
17021 /* Return the full name of file number I in *LH's file name table.
17022 Use COMP_DIR as the name of the current directory of the
17023 compilation. The result is allocated using xmalloc; the caller is
17024 responsible for freeing it. */
17026 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
17028 /* Is the file number a valid index into the line header's file name
17029 table? Remember that file numbers start with one, not zero. */
17030 if (1 <= file
&& file
<= lh
->num_file_names
)
17032 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
17034 if (IS_ABSOLUTE_PATH (fe
->name
))
17035 return xstrdup (fe
->name
);
17043 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17049 dir_len
= strlen (dir
);
17050 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
17051 strcpy (full_name
, dir
);
17052 full_name
[dir_len
] = '/';
17053 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
17057 return xstrdup (fe
->name
);
17062 /* The compiler produced a bogus file number. We can at least
17063 record the macro definitions made in the file, even if we
17064 won't be able to find the file by name. */
17065 char fake_name
[80];
17067 sprintf (fake_name
, "<bad macro file number %d>", file
);
17069 complaint (&symfile_complaints
,
17070 _("bad file number in macro information (%d)"),
17073 return xstrdup (fake_name
);
17078 static struct macro_source_file
*
17079 macro_start_file (int file
, int line
,
17080 struct macro_source_file
*current_file
,
17081 const char *comp_dir
,
17082 struct line_header
*lh
, struct objfile
*objfile
)
17084 /* The full name of this source file. */
17085 char *full_name
= file_full_name (file
, lh
, comp_dir
);
17087 /* We don't create a macro table for this compilation unit
17088 at all until we actually get a filename. */
17089 if (! pending_macros
)
17090 pending_macros
= new_macro_table (&objfile
->per_bfd
->storage_obstack
,
17091 objfile
->per_bfd
->macro_cache
);
17093 if (! current_file
)
17095 /* If we have no current file, then this must be the start_file
17096 directive for the compilation unit's main source file. */
17097 current_file
= macro_set_main (pending_macros
, full_name
);
17098 macro_define_special (pending_macros
);
17101 current_file
= macro_include (current_file
, line
, full_name
);
17105 return current_file
;
17109 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
17110 followed by a null byte. */
17112 copy_string (const char *buf
, int len
)
17114 char *s
= xmalloc (len
+ 1);
17116 memcpy (s
, buf
, len
);
17122 static const char *
17123 consume_improper_spaces (const char *p
, const char *body
)
17127 complaint (&symfile_complaints
,
17128 _("macro definition contains spaces "
17129 "in formal argument list:\n`%s'"),
17141 parse_macro_definition (struct macro_source_file
*file
, int line
,
17146 /* The body string takes one of two forms. For object-like macro
17147 definitions, it should be:
17149 <macro name> " " <definition>
17151 For function-like macro definitions, it should be:
17153 <macro name> "() " <definition>
17155 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
17157 Spaces may appear only where explicitly indicated, and in the
17160 The Dwarf 2 spec says that an object-like macro's name is always
17161 followed by a space, but versions of GCC around March 2002 omit
17162 the space when the macro's definition is the empty string.
17164 The Dwarf 2 spec says that there should be no spaces between the
17165 formal arguments in a function-like macro's formal argument list,
17166 but versions of GCC around March 2002 include spaces after the
17170 /* Find the extent of the macro name. The macro name is terminated
17171 by either a space or null character (for an object-like macro) or
17172 an opening paren (for a function-like macro). */
17173 for (p
= body
; *p
; p
++)
17174 if (*p
== ' ' || *p
== '(')
17177 if (*p
== ' ' || *p
== '\0')
17179 /* It's an object-like macro. */
17180 int name_len
= p
- body
;
17181 char *name
= copy_string (body
, name_len
);
17182 const char *replacement
;
17185 replacement
= body
+ name_len
+ 1;
17188 dwarf2_macro_malformed_definition_complaint (body
);
17189 replacement
= body
+ name_len
;
17192 macro_define_object (file
, line
, name
, replacement
);
17196 else if (*p
== '(')
17198 /* It's a function-like macro. */
17199 char *name
= copy_string (body
, p
- body
);
17202 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
17206 p
= consume_improper_spaces (p
, body
);
17208 /* Parse the formal argument list. */
17209 while (*p
&& *p
!= ')')
17211 /* Find the extent of the current argument name. */
17212 const char *arg_start
= p
;
17214 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
17217 if (! *p
|| p
== arg_start
)
17218 dwarf2_macro_malformed_definition_complaint (body
);
17221 /* Make sure argv has room for the new argument. */
17222 if (argc
>= argv_size
)
17225 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
17228 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
17231 p
= consume_improper_spaces (p
, body
);
17233 /* Consume the comma, if present. */
17238 p
= consume_improper_spaces (p
, body
);
17247 /* Perfectly formed definition, no complaints. */
17248 macro_define_function (file
, line
, name
,
17249 argc
, (const char **) argv
,
17251 else if (*p
== '\0')
17253 /* Complain, but do define it. */
17254 dwarf2_macro_malformed_definition_complaint (body
);
17255 macro_define_function (file
, line
, name
,
17256 argc
, (const char **) argv
,
17260 /* Just complain. */
17261 dwarf2_macro_malformed_definition_complaint (body
);
17264 /* Just complain. */
17265 dwarf2_macro_malformed_definition_complaint (body
);
17271 for (i
= 0; i
< argc
; i
++)
17277 dwarf2_macro_malformed_definition_complaint (body
);
17280 /* Skip some bytes from BYTES according to the form given in FORM.
17281 Returns the new pointer. */
17284 skip_form_bytes (bfd
*abfd
, gdb_byte
*bytes
, gdb_byte
*buffer_end
,
17285 enum dwarf_form form
,
17286 unsigned int offset_size
,
17287 struct dwarf2_section_info
*section
)
17289 unsigned int bytes_read
;
17293 case DW_FORM_data1
:
17298 case DW_FORM_data2
:
17302 case DW_FORM_data4
:
17306 case DW_FORM_data8
:
17310 case DW_FORM_string
:
17311 read_direct_string (abfd
, bytes
, &bytes_read
);
17312 bytes
+= bytes_read
;
17315 case DW_FORM_sec_offset
:
17317 case DW_FORM_GNU_strp_alt
:
17318 bytes
+= offset_size
;
17321 case DW_FORM_block
:
17322 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
17323 bytes
+= bytes_read
;
17326 case DW_FORM_block1
:
17327 bytes
+= 1 + read_1_byte (abfd
, bytes
);
17329 case DW_FORM_block2
:
17330 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
17332 case DW_FORM_block4
:
17333 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
17336 case DW_FORM_sdata
:
17337 case DW_FORM_udata
:
17338 case DW_FORM_GNU_addr_index
:
17339 case DW_FORM_GNU_str_index
:
17340 bytes
= (gdb_byte
*) gdb_skip_leb128 (bytes
, buffer_end
);
17343 dwarf2_section_buffer_overflow_complaint (section
);
17351 complaint (&symfile_complaints
,
17352 _("invalid form 0x%x in `%s'"),
17354 section
->asection
->name
);
17362 /* A helper for dwarf_decode_macros that handles skipping an unknown
17363 opcode. Returns an updated pointer to the macro data buffer; or,
17364 on error, issues a complaint and returns NULL. */
17367 skip_unknown_opcode (unsigned int opcode
,
17368 gdb_byte
**opcode_definitions
,
17369 gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
17371 unsigned int offset_size
,
17372 struct dwarf2_section_info
*section
)
17374 unsigned int bytes_read
, i
;
17378 if (opcode_definitions
[opcode
] == NULL
)
17380 complaint (&symfile_complaints
,
17381 _("unrecognized DW_MACFINO opcode 0x%x"),
17386 defn
= opcode_definitions
[opcode
];
17387 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
17388 defn
+= bytes_read
;
17390 for (i
= 0; i
< arg
; ++i
)
17392 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
, defn
[i
], offset_size
,
17394 if (mac_ptr
== NULL
)
17396 /* skip_form_bytes already issued the complaint. */
17404 /* A helper function which parses the header of a macro section.
17405 If the macro section is the extended (for now called "GNU") type,
17406 then this updates *OFFSET_SIZE. Returns a pointer to just after
17407 the header, or issues a complaint and returns NULL on error. */
17410 dwarf_parse_macro_header (gdb_byte
**opcode_definitions
,
17413 unsigned int *offset_size
,
17414 int section_is_gnu
)
17416 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
17418 if (section_is_gnu
)
17420 unsigned int version
, flags
;
17422 version
= read_2_bytes (abfd
, mac_ptr
);
17425 complaint (&symfile_complaints
,
17426 _("unrecognized version `%d' in .debug_macro section"),
17432 flags
= read_1_byte (abfd
, mac_ptr
);
17434 *offset_size
= (flags
& 1) ? 8 : 4;
17436 if ((flags
& 2) != 0)
17437 /* We don't need the line table offset. */
17438 mac_ptr
+= *offset_size
;
17440 /* Vendor opcode descriptions. */
17441 if ((flags
& 4) != 0)
17443 unsigned int i
, count
;
17445 count
= read_1_byte (abfd
, mac_ptr
);
17447 for (i
= 0; i
< count
; ++i
)
17449 unsigned int opcode
, bytes_read
;
17452 opcode
= read_1_byte (abfd
, mac_ptr
);
17454 opcode_definitions
[opcode
] = mac_ptr
;
17455 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17456 mac_ptr
+= bytes_read
;
17465 /* A helper for dwarf_decode_macros that handles the GNU extensions,
17466 including DW_MACRO_GNU_transparent_include. */
17469 dwarf_decode_macro_bytes (bfd
*abfd
, gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
17470 struct macro_source_file
*current_file
,
17471 struct line_header
*lh
, char *comp_dir
,
17472 struct dwarf2_section_info
*section
,
17473 int section_is_gnu
, int section_is_dwz
,
17474 unsigned int offset_size
,
17475 struct objfile
*objfile
,
17476 htab_t include_hash
)
17478 enum dwarf_macro_record_type macinfo_type
;
17479 int at_commandline
;
17480 gdb_byte
*opcode_definitions
[256];
17482 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
17483 &offset_size
, section_is_gnu
);
17484 if (mac_ptr
== NULL
)
17486 /* We already issued a complaint. */
17490 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
17491 GDB is still reading the definitions from command line. First
17492 DW_MACINFO_start_file will need to be ignored as it was already executed
17493 to create CURRENT_FILE for the main source holding also the command line
17494 definitions. On first met DW_MACINFO_start_file this flag is reset to
17495 normally execute all the remaining DW_MACINFO_start_file macinfos. */
17497 at_commandline
= 1;
17501 /* Do we at least have room for a macinfo type byte? */
17502 if (mac_ptr
>= mac_end
)
17504 dwarf2_section_buffer_overflow_complaint (section
);
17508 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
17511 /* Note that we rely on the fact that the corresponding GNU and
17512 DWARF constants are the same. */
17513 switch (macinfo_type
)
17515 /* A zero macinfo type indicates the end of the macro
17520 case DW_MACRO_GNU_define
:
17521 case DW_MACRO_GNU_undef
:
17522 case DW_MACRO_GNU_define_indirect
:
17523 case DW_MACRO_GNU_undef_indirect
:
17524 case DW_MACRO_GNU_define_indirect_alt
:
17525 case DW_MACRO_GNU_undef_indirect_alt
:
17527 unsigned int bytes_read
;
17532 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17533 mac_ptr
+= bytes_read
;
17535 if (macinfo_type
== DW_MACRO_GNU_define
17536 || macinfo_type
== DW_MACRO_GNU_undef
)
17538 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
17539 mac_ptr
+= bytes_read
;
17543 LONGEST str_offset
;
17545 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
17546 mac_ptr
+= offset_size
;
17548 if (macinfo_type
== DW_MACRO_GNU_define_indirect_alt
17549 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
17552 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
17554 body
= read_indirect_string_from_dwz (dwz
, str_offset
);
17557 body
= read_indirect_string_at_offset (abfd
, str_offset
);
17560 is_define
= (macinfo_type
== DW_MACRO_GNU_define
17561 || macinfo_type
== DW_MACRO_GNU_define_indirect
17562 || macinfo_type
== DW_MACRO_GNU_define_indirect_alt
);
17563 if (! current_file
)
17565 /* DWARF violation as no main source is present. */
17566 complaint (&symfile_complaints
,
17567 _("debug info with no main source gives macro %s "
17569 is_define
? _("definition") : _("undefinition"),
17573 if ((line
== 0 && !at_commandline
)
17574 || (line
!= 0 && at_commandline
))
17575 complaint (&symfile_complaints
,
17576 _("debug info gives %s macro %s with %s line %d: %s"),
17577 at_commandline
? _("command-line") : _("in-file"),
17578 is_define
? _("definition") : _("undefinition"),
17579 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
17582 parse_macro_definition (current_file
, line
, body
);
17585 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
17586 || macinfo_type
== DW_MACRO_GNU_undef_indirect
17587 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
);
17588 macro_undef (current_file
, line
, body
);
17593 case DW_MACRO_GNU_start_file
:
17595 unsigned int bytes_read
;
17598 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17599 mac_ptr
+= bytes_read
;
17600 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17601 mac_ptr
+= bytes_read
;
17603 if ((line
== 0 && !at_commandline
)
17604 || (line
!= 0 && at_commandline
))
17605 complaint (&symfile_complaints
,
17606 _("debug info gives source %d included "
17607 "from %s at %s line %d"),
17608 file
, at_commandline
? _("command-line") : _("file"),
17609 line
== 0 ? _("zero") : _("non-zero"), line
);
17611 if (at_commandline
)
17613 /* This DW_MACRO_GNU_start_file was executed in the
17615 at_commandline
= 0;
17618 current_file
= macro_start_file (file
, line
,
17619 current_file
, comp_dir
,
17624 case DW_MACRO_GNU_end_file
:
17625 if (! current_file
)
17626 complaint (&symfile_complaints
,
17627 _("macro debug info has an unmatched "
17628 "`close_file' directive"));
17631 current_file
= current_file
->included_by
;
17632 if (! current_file
)
17634 enum dwarf_macro_record_type next_type
;
17636 /* GCC circa March 2002 doesn't produce the zero
17637 type byte marking the end of the compilation
17638 unit. Complain if it's not there, but exit no
17641 /* Do we at least have room for a macinfo type byte? */
17642 if (mac_ptr
>= mac_end
)
17644 dwarf2_section_buffer_overflow_complaint (section
);
17648 /* We don't increment mac_ptr here, so this is just
17650 next_type
= read_1_byte (abfd
, mac_ptr
);
17651 if (next_type
!= 0)
17652 complaint (&symfile_complaints
,
17653 _("no terminating 0-type entry for "
17654 "macros in `.debug_macinfo' section"));
17661 case DW_MACRO_GNU_transparent_include
:
17662 case DW_MACRO_GNU_transparent_include_alt
:
17666 bfd
*include_bfd
= abfd
;
17667 struct dwarf2_section_info
*include_section
= section
;
17668 struct dwarf2_section_info alt_section
;
17669 gdb_byte
*include_mac_end
= mac_end
;
17670 int is_dwz
= section_is_dwz
;
17671 gdb_byte
*new_mac_ptr
;
17673 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
17674 mac_ptr
+= offset_size
;
17676 if (macinfo_type
== DW_MACRO_GNU_transparent_include_alt
)
17678 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
17680 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
17683 include_bfd
= dwz
->macro
.asection
->owner
;
17684 include_section
= &dwz
->macro
;
17685 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
17689 new_mac_ptr
= include_section
->buffer
+ offset
;
17690 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
17694 /* This has actually happened; see
17695 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
17696 complaint (&symfile_complaints
,
17697 _("recursive DW_MACRO_GNU_transparent_include in "
17698 ".debug_macro section"));
17702 *slot
= new_mac_ptr
;
17704 dwarf_decode_macro_bytes (include_bfd
, new_mac_ptr
,
17705 include_mac_end
, current_file
,
17707 section
, section_is_gnu
, is_dwz
,
17708 offset_size
, objfile
, include_hash
);
17710 htab_remove_elt (include_hash
, new_mac_ptr
);
17715 case DW_MACINFO_vendor_ext
:
17716 if (!section_is_gnu
)
17718 unsigned int bytes_read
;
17721 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17722 mac_ptr
+= bytes_read
;
17723 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
17724 mac_ptr
+= bytes_read
;
17726 /* We don't recognize any vendor extensions. */
17732 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
17733 mac_ptr
, mac_end
, abfd
, offset_size
,
17735 if (mac_ptr
== NULL
)
17739 } while (macinfo_type
!= 0);
17743 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
17744 char *comp_dir
, int section_is_gnu
)
17746 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
17747 struct line_header
*lh
= cu
->line_header
;
17749 gdb_byte
*mac_ptr
, *mac_end
;
17750 struct macro_source_file
*current_file
= 0;
17751 enum dwarf_macro_record_type macinfo_type
;
17752 unsigned int offset_size
= cu
->header
.offset_size
;
17753 gdb_byte
*opcode_definitions
[256];
17754 struct cleanup
*cleanup
;
17755 htab_t include_hash
;
17757 struct dwarf2_section_info
*section
;
17758 const char *section_name
;
17760 if (cu
->dwo_unit
!= NULL
)
17762 if (section_is_gnu
)
17764 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
17765 section_name
= ".debug_macro.dwo";
17769 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
17770 section_name
= ".debug_macinfo.dwo";
17775 if (section_is_gnu
)
17777 section
= &dwarf2_per_objfile
->macro
;
17778 section_name
= ".debug_macro";
17782 section
= &dwarf2_per_objfile
->macinfo
;
17783 section_name
= ".debug_macinfo";
17787 dwarf2_read_section (objfile
, section
);
17788 if (section
->buffer
== NULL
)
17790 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
17793 abfd
= section
->asection
->owner
;
17795 /* First pass: Find the name of the base filename.
17796 This filename is needed in order to process all macros whose definition
17797 (or undefinition) comes from the command line. These macros are defined
17798 before the first DW_MACINFO_start_file entry, and yet still need to be
17799 associated to the base file.
17801 To determine the base file name, we scan the macro definitions until we
17802 reach the first DW_MACINFO_start_file entry. We then initialize
17803 CURRENT_FILE accordingly so that any macro definition found before the
17804 first DW_MACINFO_start_file can still be associated to the base file. */
17806 mac_ptr
= section
->buffer
+ offset
;
17807 mac_end
= section
->buffer
+ section
->size
;
17809 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
17810 &offset_size
, section_is_gnu
);
17811 if (mac_ptr
== NULL
)
17813 /* We already issued a complaint. */
17819 /* Do we at least have room for a macinfo type byte? */
17820 if (mac_ptr
>= mac_end
)
17822 /* Complaint is printed during the second pass as GDB will probably
17823 stop the first pass earlier upon finding
17824 DW_MACINFO_start_file. */
17828 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
17831 /* Note that we rely on the fact that the corresponding GNU and
17832 DWARF constants are the same. */
17833 switch (macinfo_type
)
17835 /* A zero macinfo type indicates the end of the macro
17840 case DW_MACRO_GNU_define
:
17841 case DW_MACRO_GNU_undef
:
17842 /* Only skip the data by MAC_PTR. */
17844 unsigned int bytes_read
;
17846 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17847 mac_ptr
+= bytes_read
;
17848 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
17849 mac_ptr
+= bytes_read
;
17853 case DW_MACRO_GNU_start_file
:
17855 unsigned int bytes_read
;
17858 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17859 mac_ptr
+= bytes_read
;
17860 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17861 mac_ptr
+= bytes_read
;
17863 current_file
= macro_start_file (file
, line
, current_file
,
17864 comp_dir
, lh
, objfile
);
17868 case DW_MACRO_GNU_end_file
:
17869 /* No data to skip by MAC_PTR. */
17872 case DW_MACRO_GNU_define_indirect
:
17873 case DW_MACRO_GNU_undef_indirect
:
17874 case DW_MACRO_GNU_define_indirect_alt
:
17875 case DW_MACRO_GNU_undef_indirect_alt
:
17877 unsigned int bytes_read
;
17879 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17880 mac_ptr
+= bytes_read
;
17881 mac_ptr
+= offset_size
;
17885 case DW_MACRO_GNU_transparent_include
:
17886 case DW_MACRO_GNU_transparent_include_alt
:
17887 /* Note that, according to the spec, a transparent include
17888 chain cannot call DW_MACRO_GNU_start_file. So, we can just
17889 skip this opcode. */
17890 mac_ptr
+= offset_size
;
17893 case DW_MACINFO_vendor_ext
:
17894 /* Only skip the data by MAC_PTR. */
17895 if (!section_is_gnu
)
17897 unsigned int bytes_read
;
17899 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
17900 mac_ptr
+= bytes_read
;
17901 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
17902 mac_ptr
+= bytes_read
;
17907 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
17908 mac_ptr
, mac_end
, abfd
, offset_size
,
17910 if (mac_ptr
== NULL
)
17914 } while (macinfo_type
!= 0 && current_file
== NULL
);
17916 /* Second pass: Process all entries.
17918 Use the AT_COMMAND_LINE flag to determine whether we are still processing
17919 command-line macro definitions/undefinitions. This flag is unset when we
17920 reach the first DW_MACINFO_start_file entry. */
17922 include_hash
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
17923 NULL
, xcalloc
, xfree
);
17924 cleanup
= make_cleanup_htab_delete (include_hash
);
17925 mac_ptr
= section
->buffer
+ offset
;
17926 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
17928 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
17929 current_file
, lh
, comp_dir
, section
,
17931 offset_size
, objfile
, include_hash
);
17932 do_cleanups (cleanup
);
17935 /* Check if the attribute's form is a DW_FORM_block*
17936 if so return true else false. */
17939 attr_form_is_block (struct attribute
*attr
)
17941 return (attr
== NULL
? 0 :
17942 attr
->form
== DW_FORM_block1
17943 || attr
->form
== DW_FORM_block2
17944 || attr
->form
== DW_FORM_block4
17945 || attr
->form
== DW_FORM_block
17946 || attr
->form
== DW_FORM_exprloc
);
17949 /* Return non-zero if ATTR's value is a section offset --- classes
17950 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
17951 You may use DW_UNSND (attr) to retrieve such offsets.
17953 Section 7.5.4, "Attribute Encodings", explains that no attribute
17954 may have a value that belongs to more than one of these classes; it
17955 would be ambiguous if we did, because we use the same forms for all
17959 attr_form_is_section_offset (struct attribute
*attr
)
17961 return (attr
->form
== DW_FORM_data4
17962 || attr
->form
== DW_FORM_data8
17963 || attr
->form
== DW_FORM_sec_offset
);
17966 /* Return non-zero if ATTR's value falls in the 'constant' class, or
17967 zero otherwise. When this function returns true, you can apply
17968 dwarf2_get_attr_constant_value to it.
17970 However, note that for some attributes you must check
17971 attr_form_is_section_offset before using this test. DW_FORM_data4
17972 and DW_FORM_data8 are members of both the constant class, and of
17973 the classes that contain offsets into other debug sections
17974 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
17975 that, if an attribute's can be either a constant or one of the
17976 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
17977 taken as section offsets, not constants. */
17980 attr_form_is_constant (struct attribute
*attr
)
17982 switch (attr
->form
)
17984 case DW_FORM_sdata
:
17985 case DW_FORM_udata
:
17986 case DW_FORM_data1
:
17987 case DW_FORM_data2
:
17988 case DW_FORM_data4
:
17989 case DW_FORM_data8
:
17996 /* Return the .debug_loc section to use for CU.
17997 For DWO files use .debug_loc.dwo. */
17999 static struct dwarf2_section_info
*
18000 cu_debug_loc_section (struct dwarf2_cu
*cu
)
18003 return &cu
->dwo_unit
->dwo_file
->sections
.loc
;
18004 return &dwarf2_per_objfile
->loc
;
18007 /* A helper function that fills in a dwarf2_loclist_baton. */
18010 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
18011 struct dwarf2_loclist_baton
*baton
,
18012 struct attribute
*attr
)
18014 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
18016 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
18018 baton
->per_cu
= cu
->per_cu
;
18019 gdb_assert (baton
->per_cu
);
18020 /* We don't know how long the location list is, but make sure we
18021 don't run off the edge of the section. */
18022 baton
->size
= section
->size
- DW_UNSND (attr
);
18023 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
18024 baton
->base_address
= cu
->base_address
;
18025 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
18029 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
18030 struct dwarf2_cu
*cu
)
18032 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18033 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
18035 if (attr_form_is_section_offset (attr
)
18036 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
18037 the section. If so, fall through to the complaint in the
18039 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
18041 struct dwarf2_loclist_baton
*baton
;
18043 baton
= obstack_alloc (&objfile
->objfile_obstack
,
18044 sizeof (struct dwarf2_loclist_baton
));
18046 fill_in_loclist_baton (cu
, baton
, attr
);
18048 if (cu
->base_known
== 0)
18049 complaint (&symfile_complaints
,
18050 _("Location list used without "
18051 "specifying the CU base address."));
18053 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
18054 SYMBOL_LOCATION_BATON (sym
) = baton
;
18058 struct dwarf2_locexpr_baton
*baton
;
18060 baton
= obstack_alloc (&objfile
->objfile_obstack
,
18061 sizeof (struct dwarf2_locexpr_baton
));
18062 baton
->per_cu
= cu
->per_cu
;
18063 gdb_assert (baton
->per_cu
);
18065 if (attr_form_is_block (attr
))
18067 /* Note that we're just copying the block's data pointer
18068 here, not the actual data. We're still pointing into the
18069 info_buffer for SYM's objfile; right now we never release
18070 that buffer, but when we do clean up properly this may
18072 baton
->size
= DW_BLOCK (attr
)->size
;
18073 baton
->data
= DW_BLOCK (attr
)->data
;
18077 dwarf2_invalid_attrib_class_complaint ("location description",
18078 SYMBOL_NATURAL_NAME (sym
));
18082 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
18083 SYMBOL_LOCATION_BATON (sym
) = baton
;
18087 /* Return the OBJFILE associated with the compilation unit CU. If CU
18088 came from a separate debuginfo file, then the master objfile is
18092 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
18094 struct objfile
*objfile
= per_cu
->objfile
;
18096 /* Return the master objfile, so that we can report and look up the
18097 correct file containing this variable. */
18098 if (objfile
->separate_debug_objfile_backlink
)
18099 objfile
= objfile
->separate_debug_objfile_backlink
;
18104 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
18105 (CU_HEADERP is unused in such case) or prepare a temporary copy at
18106 CU_HEADERP first. */
18108 static const struct comp_unit_head
*
18109 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
18110 struct dwarf2_per_cu_data
*per_cu
)
18112 gdb_byte
*info_ptr
;
18115 return &per_cu
->cu
->header
;
18117 info_ptr
= per_cu
->info_or_types_section
->buffer
+ per_cu
->offset
.sect_off
;
18119 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
18120 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->objfile
->obfd
);
18125 /* Return the address size given in the compilation unit header for CU. */
18128 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
18130 struct comp_unit_head cu_header_local
;
18131 const struct comp_unit_head
*cu_headerp
;
18133 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
18135 return cu_headerp
->addr_size
;
18138 /* Return the offset size given in the compilation unit header for CU. */
18141 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
18143 struct comp_unit_head cu_header_local
;
18144 const struct comp_unit_head
*cu_headerp
;
18146 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
18148 return cu_headerp
->offset_size
;
18151 /* See its dwarf2loc.h declaration. */
18154 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
18156 struct comp_unit_head cu_header_local
;
18157 const struct comp_unit_head
*cu_headerp
;
18159 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
18161 if (cu_headerp
->version
== 2)
18162 return cu_headerp
->addr_size
;
18164 return cu_headerp
->offset_size
;
18167 /* Return the text offset of the CU. The returned offset comes from
18168 this CU's objfile. If this objfile came from a separate debuginfo
18169 file, then the offset may be different from the corresponding
18170 offset in the parent objfile. */
18173 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
18175 struct objfile
*objfile
= per_cu
->objfile
;
18177 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
18180 /* Locate the .debug_info compilation unit from CU's objfile which contains
18181 the DIE at OFFSET. Raises an error on failure. */
18183 static struct dwarf2_per_cu_data
*
18184 dwarf2_find_containing_comp_unit (sect_offset offset
,
18185 unsigned int offset_in_dwz
,
18186 struct objfile
*objfile
)
18188 struct dwarf2_per_cu_data
*this_cu
;
18190 const sect_offset
*cu_off
;
18193 high
= dwarf2_per_objfile
->n_comp_units
- 1;
18196 struct dwarf2_per_cu_data
*mid_cu
;
18197 int mid
= low
+ (high
- low
) / 2;
18199 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
18200 cu_off
= &mid_cu
->offset
;
18201 if (mid_cu
->is_dwz
> offset_in_dwz
18202 || (mid_cu
->is_dwz
== offset_in_dwz
18203 && cu_off
->sect_off
>= offset
.sect_off
))
18208 gdb_assert (low
== high
);
18209 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
18210 cu_off
= &this_cu
->offset
;
18211 if (this_cu
->is_dwz
!= offset_in_dwz
|| cu_off
->sect_off
> offset
.sect_off
)
18213 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
18214 error (_("Dwarf Error: could not find partial DIE containing "
18215 "offset 0x%lx [in module %s]"),
18216 (long) offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
18218 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
.sect_off
18219 <= offset
.sect_off
);
18220 return dwarf2_per_objfile
->all_comp_units
[low
-1];
18224 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
18225 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
18226 && offset
.sect_off
>= this_cu
->offset
.sect_off
+ this_cu
->length
)
18227 error (_("invalid dwarf2 offset %u"), offset
.sect_off
);
18228 gdb_assert (offset
.sect_off
< this_cu
->offset
.sect_off
+ this_cu
->length
);
18233 /* Initialize dwarf2_cu CU, owned by PER_CU. */
18236 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
18238 memset (cu
, 0, sizeof (*cu
));
18240 cu
->per_cu
= per_cu
;
18241 cu
->objfile
= per_cu
->objfile
;
18242 obstack_init (&cu
->comp_unit_obstack
);
18245 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
18248 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
18249 enum language pretend_language
)
18251 struct attribute
*attr
;
18253 /* Set the language we're debugging. */
18254 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
18256 set_cu_language (DW_UNSND (attr
), cu
);
18259 cu
->language
= pretend_language
;
18260 cu
->language_defn
= language_def (cu
->language
);
18263 attr
= dwarf2_attr (comp_unit_die
, DW_AT_producer
, cu
);
18265 cu
->producer
= DW_STRING (attr
);
18268 /* Release one cached compilation unit, CU. We unlink it from the tree
18269 of compilation units, but we don't remove it from the read_in_chain;
18270 the caller is responsible for that.
18271 NOTE: DATA is a void * because this function is also used as a
18272 cleanup routine. */
18275 free_heap_comp_unit (void *data
)
18277 struct dwarf2_cu
*cu
= data
;
18279 gdb_assert (cu
->per_cu
!= NULL
);
18280 cu
->per_cu
->cu
= NULL
;
18283 obstack_free (&cu
->comp_unit_obstack
, NULL
);
18288 /* This cleanup function is passed the address of a dwarf2_cu on the stack
18289 when we're finished with it. We can't free the pointer itself, but be
18290 sure to unlink it from the cache. Also release any associated storage. */
18293 free_stack_comp_unit (void *data
)
18295 struct dwarf2_cu
*cu
= data
;
18297 gdb_assert (cu
->per_cu
!= NULL
);
18298 cu
->per_cu
->cu
= NULL
;
18301 obstack_free (&cu
->comp_unit_obstack
, NULL
);
18302 cu
->partial_dies
= NULL
;
18305 /* Free all cached compilation units. */
18308 free_cached_comp_units (void *data
)
18310 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
18312 per_cu
= dwarf2_per_objfile
->read_in_chain
;
18313 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
18314 while (per_cu
!= NULL
)
18316 struct dwarf2_per_cu_data
*next_cu
;
18318 next_cu
= per_cu
->cu
->read_in_chain
;
18320 free_heap_comp_unit (per_cu
->cu
);
18321 *last_chain
= next_cu
;
18327 /* Increase the age counter on each cached compilation unit, and free
18328 any that are too old. */
18331 age_cached_comp_units (void)
18333 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
18335 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
18336 per_cu
= dwarf2_per_objfile
->read_in_chain
;
18337 while (per_cu
!= NULL
)
18339 per_cu
->cu
->last_used
++;
18340 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
18341 dwarf2_mark (per_cu
->cu
);
18342 per_cu
= per_cu
->cu
->read_in_chain
;
18345 per_cu
= dwarf2_per_objfile
->read_in_chain
;
18346 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
18347 while (per_cu
!= NULL
)
18349 struct dwarf2_per_cu_data
*next_cu
;
18351 next_cu
= per_cu
->cu
->read_in_chain
;
18353 if (!per_cu
->cu
->mark
)
18355 free_heap_comp_unit (per_cu
->cu
);
18356 *last_chain
= next_cu
;
18359 last_chain
= &per_cu
->cu
->read_in_chain
;
18365 /* Remove a single compilation unit from the cache. */
18368 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
18370 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
18372 per_cu
= dwarf2_per_objfile
->read_in_chain
;
18373 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
18374 while (per_cu
!= NULL
)
18376 struct dwarf2_per_cu_data
*next_cu
;
18378 next_cu
= per_cu
->cu
->read_in_chain
;
18380 if (per_cu
== target_per_cu
)
18382 free_heap_comp_unit (per_cu
->cu
);
18384 *last_chain
= next_cu
;
18388 last_chain
= &per_cu
->cu
->read_in_chain
;
18394 /* Release all extra memory associated with OBJFILE. */
18397 dwarf2_free_objfile (struct objfile
*objfile
)
18399 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
18401 if (dwarf2_per_objfile
== NULL
)
18404 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
18405 free_cached_comp_units (NULL
);
18407 if (dwarf2_per_objfile
->quick_file_names_table
)
18408 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
18410 /* Everything else should be on the objfile obstack. */
18413 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
18414 We store these in a hash table separate from the DIEs, and preserve them
18415 when the DIEs are flushed out of cache.
18417 The CU "per_cu" pointer is needed because offset alone is not enough to
18418 uniquely identify the type. A file may have multiple .debug_types sections,
18419 or the type may come from a DWO file. We have to use something in
18420 dwarf2_per_cu_data (or the pointer to it) because we can enter the lookup
18421 routine, get_die_type_at_offset, from outside this file, and thus won't
18422 necessarily have PER_CU->cu. Fortunately, PER_CU is stable for the life
18425 struct dwarf2_per_cu_offset_and_type
18427 const struct dwarf2_per_cu_data
*per_cu
;
18428 sect_offset offset
;
18432 /* Hash function for a dwarf2_per_cu_offset_and_type. */
18435 per_cu_offset_and_type_hash (const void *item
)
18437 const struct dwarf2_per_cu_offset_and_type
*ofs
= item
;
18439 return (uintptr_t) ofs
->per_cu
+ ofs
->offset
.sect_off
;
18442 /* Equality function for a dwarf2_per_cu_offset_and_type. */
18445 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
18447 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
= item_lhs
;
18448 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
= item_rhs
;
18450 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
18451 && ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
);
18454 /* Set the type associated with DIE to TYPE. Save it in CU's hash
18455 table if necessary. For convenience, return TYPE.
18457 The DIEs reading must have careful ordering to:
18458 * Not cause infite loops trying to read in DIEs as a prerequisite for
18459 reading current DIE.
18460 * Not trying to dereference contents of still incompletely read in types
18461 while reading in other DIEs.
18462 * Enable referencing still incompletely read in types just by a pointer to
18463 the type without accessing its fields.
18465 Therefore caller should follow these rules:
18466 * Try to fetch any prerequisite types we may need to build this DIE type
18467 before building the type and calling set_die_type.
18468 * After building type call set_die_type for current DIE as soon as
18469 possible before fetching more types to complete the current type.
18470 * Make the type as complete as possible before fetching more types. */
18472 static struct type
*
18473 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
18475 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
18476 struct objfile
*objfile
= cu
->objfile
;
18478 /* For Ada types, make sure that the gnat-specific data is always
18479 initialized (if not already set). There are a few types where
18480 we should not be doing so, because the type-specific area is
18481 already used to hold some other piece of info (eg: TYPE_CODE_FLT
18482 where the type-specific area is used to store the floatformat).
18483 But this is not a problem, because the gnat-specific information
18484 is actually not needed for these types. */
18485 if (need_gnat_info (cu
)
18486 && TYPE_CODE (type
) != TYPE_CODE_FUNC
18487 && TYPE_CODE (type
) != TYPE_CODE_FLT
18488 && !HAVE_GNAT_AUX_INFO (type
))
18489 INIT_GNAT_SPECIFIC (type
);
18491 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
18493 dwarf2_per_objfile
->die_type_hash
=
18494 htab_create_alloc_ex (127,
18495 per_cu_offset_and_type_hash
,
18496 per_cu_offset_and_type_eq
,
18498 &objfile
->objfile_obstack
,
18499 hashtab_obstack_allocate
,
18500 dummy_obstack_deallocate
);
18503 ofs
.per_cu
= cu
->per_cu
;
18504 ofs
.offset
= die
->offset
;
18506 slot
= (struct dwarf2_per_cu_offset_and_type
**)
18507 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
18509 complaint (&symfile_complaints
,
18510 _("A problem internal to GDB: DIE 0x%x has type already set"),
18511 die
->offset
.sect_off
);
18512 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
18517 /* Look up the type for the die at OFFSET in the appropriate type_hash
18518 table, or return NULL if the die does not have a saved type. */
18520 static struct type
*
18521 get_die_type_at_offset (sect_offset offset
,
18522 struct dwarf2_per_cu_data
*per_cu
)
18524 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
18526 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
18529 ofs
.per_cu
= per_cu
;
18530 ofs
.offset
= offset
;
18531 slot
= htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
);
18538 /* Look up the type for DIE in the appropriate type_hash table,
18539 or return NULL if DIE does not have a saved type. */
18541 static struct type
*
18542 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18544 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
18547 /* Add a dependence relationship from CU to REF_PER_CU. */
18550 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
18551 struct dwarf2_per_cu_data
*ref_per_cu
)
18555 if (cu
->dependencies
== NULL
)
18557 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
18558 NULL
, &cu
->comp_unit_obstack
,
18559 hashtab_obstack_allocate
,
18560 dummy_obstack_deallocate
);
18562 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
18564 *slot
= ref_per_cu
;
18567 /* Subroutine of dwarf2_mark to pass to htab_traverse.
18568 Set the mark field in every compilation unit in the
18569 cache that we must keep because we are keeping CU. */
18572 dwarf2_mark_helper (void **slot
, void *data
)
18574 struct dwarf2_per_cu_data
*per_cu
;
18576 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
18578 /* cu->dependencies references may not yet have been ever read if QUIT aborts
18579 reading of the chain. As such dependencies remain valid it is not much
18580 useful to track and undo them during QUIT cleanups. */
18581 if (per_cu
->cu
== NULL
)
18584 if (per_cu
->cu
->mark
)
18586 per_cu
->cu
->mark
= 1;
18588 if (per_cu
->cu
->dependencies
!= NULL
)
18589 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
18594 /* Set the mark field in CU and in every other compilation unit in the
18595 cache that we must keep because we are keeping CU. */
18598 dwarf2_mark (struct dwarf2_cu
*cu
)
18603 if (cu
->dependencies
!= NULL
)
18604 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
18608 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
18612 per_cu
->cu
->mark
= 0;
18613 per_cu
= per_cu
->cu
->read_in_chain
;
18617 /* Trivial hash function for partial_die_info: the hash value of a DIE
18618 is its offset in .debug_info for this objfile. */
18621 partial_die_hash (const void *item
)
18623 const struct partial_die_info
*part_die
= item
;
18625 return part_die
->offset
.sect_off
;
18628 /* Trivial comparison function for partial_die_info structures: two DIEs
18629 are equal if they have the same offset. */
18632 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
18634 const struct partial_die_info
*part_die_lhs
= item_lhs
;
18635 const struct partial_die_info
*part_die_rhs
= item_rhs
;
18637 return part_die_lhs
->offset
.sect_off
== part_die_rhs
->offset
.sect_off
;
18640 static struct cmd_list_element
*set_dwarf2_cmdlist
;
18641 static struct cmd_list_element
*show_dwarf2_cmdlist
;
18644 set_dwarf2_cmd (char *args
, int from_tty
)
18646 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
18650 show_dwarf2_cmd (char *args
, int from_tty
)
18652 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
18655 /* Free data associated with OBJFILE, if necessary. */
18658 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
18660 struct dwarf2_per_objfile
*data
= d
;
18663 for (ix
= 0; ix
< dwarf2_per_objfile
->n_comp_units
; ++ix
)
18664 VEC_free (dwarf2_per_cu_ptr
,
18665 dwarf2_per_objfile
->all_comp_units
[ix
]->s
.imported_symtabs
);
18667 VEC_free (dwarf2_section_info_def
, data
->types
);
18669 if (data
->dwo_files
)
18670 free_dwo_files (data
->dwo_files
, objfile
);
18672 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
18673 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
18677 /* The "save gdb-index" command. */
18679 /* The contents of the hash table we create when building the string
18681 struct strtab_entry
18683 offset_type offset
;
18687 /* Hash function for a strtab_entry.
18689 Function is used only during write_hash_table so no index format backward
18690 compatibility is needed. */
18693 hash_strtab_entry (const void *e
)
18695 const struct strtab_entry
*entry
= e
;
18696 return mapped_index_string_hash (INT_MAX
, entry
->str
);
18699 /* Equality function for a strtab_entry. */
18702 eq_strtab_entry (const void *a
, const void *b
)
18704 const struct strtab_entry
*ea
= a
;
18705 const struct strtab_entry
*eb
= b
;
18706 return !strcmp (ea
->str
, eb
->str
);
18709 /* Create a strtab_entry hash table. */
18712 create_strtab (void)
18714 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
18715 xfree
, xcalloc
, xfree
);
18718 /* Add a string to the constant pool. Return the string's offset in
18722 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
18725 struct strtab_entry entry
;
18726 struct strtab_entry
*result
;
18729 slot
= htab_find_slot (table
, &entry
, INSERT
);
18734 result
= XNEW (struct strtab_entry
);
18735 result
->offset
= obstack_object_size (cpool
);
18737 obstack_grow_str0 (cpool
, str
);
18740 return result
->offset
;
18743 /* An entry in the symbol table. */
18744 struct symtab_index_entry
18746 /* The name of the symbol. */
18748 /* The offset of the name in the constant pool. */
18749 offset_type index_offset
;
18750 /* A sorted vector of the indices of all the CUs that hold an object
18752 VEC (offset_type
) *cu_indices
;
18755 /* The symbol table. This is a power-of-2-sized hash table. */
18756 struct mapped_symtab
18758 offset_type n_elements
;
18760 struct symtab_index_entry
**data
;
18763 /* Hash function for a symtab_index_entry. */
18766 hash_symtab_entry (const void *e
)
18768 const struct symtab_index_entry
*entry
= e
;
18769 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
18770 sizeof (offset_type
) * VEC_length (offset_type
,
18771 entry
->cu_indices
),
18775 /* Equality function for a symtab_index_entry. */
18778 eq_symtab_entry (const void *a
, const void *b
)
18780 const struct symtab_index_entry
*ea
= a
;
18781 const struct symtab_index_entry
*eb
= b
;
18782 int len
= VEC_length (offset_type
, ea
->cu_indices
);
18783 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
18785 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
18786 VEC_address (offset_type
, eb
->cu_indices
),
18787 sizeof (offset_type
) * len
);
18790 /* Destroy a symtab_index_entry. */
18793 delete_symtab_entry (void *p
)
18795 struct symtab_index_entry
*entry
= p
;
18796 VEC_free (offset_type
, entry
->cu_indices
);
18800 /* Create a hash table holding symtab_index_entry objects. */
18803 create_symbol_hash_table (void)
18805 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
18806 delete_symtab_entry
, xcalloc
, xfree
);
18809 /* Create a new mapped symtab object. */
18811 static struct mapped_symtab
*
18812 create_mapped_symtab (void)
18814 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
18815 symtab
->n_elements
= 0;
18816 symtab
->size
= 1024;
18817 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
18821 /* Destroy a mapped_symtab. */
18824 cleanup_mapped_symtab (void *p
)
18826 struct mapped_symtab
*symtab
= p
;
18827 /* The contents of the array are freed when the other hash table is
18829 xfree (symtab
->data
);
18833 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
18836 Function is used only during write_hash_table so no index format backward
18837 compatibility is needed. */
18839 static struct symtab_index_entry
**
18840 find_slot (struct mapped_symtab
*symtab
, const char *name
)
18842 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
18844 index
= hash
& (symtab
->size
- 1);
18845 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
18849 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
18850 return &symtab
->data
[index
];
18851 index
= (index
+ step
) & (symtab
->size
- 1);
18855 /* Expand SYMTAB's hash table. */
18858 hash_expand (struct mapped_symtab
*symtab
)
18860 offset_type old_size
= symtab
->size
;
18862 struct symtab_index_entry
**old_entries
= symtab
->data
;
18865 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
18867 for (i
= 0; i
< old_size
; ++i
)
18869 if (old_entries
[i
])
18871 struct symtab_index_entry
**slot
= find_slot (symtab
,
18872 old_entries
[i
]->name
);
18873 *slot
= old_entries
[i
];
18877 xfree (old_entries
);
18880 /* Add an entry to SYMTAB. NAME is the name of the symbol.
18881 CU_INDEX is the index of the CU in which the symbol appears.
18882 IS_STATIC is one if the symbol is static, otherwise zero (global). */
18885 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
18886 int is_static
, gdb_index_symbol_kind kind
,
18887 offset_type cu_index
)
18889 struct symtab_index_entry
**slot
;
18890 offset_type cu_index_and_attrs
;
18892 ++symtab
->n_elements
;
18893 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
18894 hash_expand (symtab
);
18896 slot
= find_slot (symtab
, name
);
18899 *slot
= XNEW (struct symtab_index_entry
);
18900 (*slot
)->name
= name
;
18901 /* index_offset is set later. */
18902 (*slot
)->cu_indices
= NULL
;
18905 cu_index_and_attrs
= 0;
18906 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
18907 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
18908 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
18910 /* We don't want to record an index value twice as we want to avoid the
18912 We process all global symbols and then all static symbols
18913 (which would allow us to avoid the duplication by only having to check
18914 the last entry pushed), but a symbol could have multiple kinds in one CU.
18915 To keep things simple we don't worry about the duplication here and
18916 sort and uniqufy the list after we've processed all symbols. */
18917 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index_and_attrs
);
18920 /* qsort helper routine for uniquify_cu_indices. */
18923 offset_type_compare (const void *ap
, const void *bp
)
18925 offset_type a
= *(offset_type
*) ap
;
18926 offset_type b
= *(offset_type
*) bp
;
18928 return (a
> b
) - (b
> a
);
18931 /* Sort and remove duplicates of all symbols' cu_indices lists. */
18934 uniquify_cu_indices (struct mapped_symtab
*symtab
)
18938 for (i
= 0; i
< symtab
->size
; ++i
)
18940 struct symtab_index_entry
*entry
= symtab
->data
[i
];
18943 && entry
->cu_indices
!= NULL
)
18945 unsigned int next_to_insert
, next_to_check
;
18946 offset_type last_value
;
18948 qsort (VEC_address (offset_type
, entry
->cu_indices
),
18949 VEC_length (offset_type
, entry
->cu_indices
),
18950 sizeof (offset_type
), offset_type_compare
);
18952 last_value
= VEC_index (offset_type
, entry
->cu_indices
, 0);
18953 next_to_insert
= 1;
18954 for (next_to_check
= 1;
18955 next_to_check
< VEC_length (offset_type
, entry
->cu_indices
);
18958 if (VEC_index (offset_type
, entry
->cu_indices
, next_to_check
)
18961 last_value
= VEC_index (offset_type
, entry
->cu_indices
,
18963 VEC_replace (offset_type
, entry
->cu_indices
, next_to_insert
,
18968 VEC_truncate (offset_type
, entry
->cu_indices
, next_to_insert
);
18973 /* Add a vector of indices to the constant pool. */
18976 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
18977 struct symtab_index_entry
*entry
)
18981 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
18984 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
18985 offset_type val
= MAYBE_SWAP (len
);
18990 entry
->index_offset
= obstack_object_size (cpool
);
18992 obstack_grow (cpool
, &val
, sizeof (val
));
18994 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
18997 val
= MAYBE_SWAP (iter
);
18998 obstack_grow (cpool
, &val
, sizeof (val
));
19003 struct symtab_index_entry
*old_entry
= *slot
;
19004 entry
->index_offset
= old_entry
->index_offset
;
19007 return entry
->index_offset
;
19010 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
19011 constant pool entries going into the obstack CPOOL. */
19014 write_hash_table (struct mapped_symtab
*symtab
,
19015 struct obstack
*output
, struct obstack
*cpool
)
19018 htab_t symbol_hash_table
;
19021 symbol_hash_table
= create_symbol_hash_table ();
19022 str_table
= create_strtab ();
19024 /* We add all the index vectors to the constant pool first, to
19025 ensure alignment is ok. */
19026 for (i
= 0; i
< symtab
->size
; ++i
)
19028 if (symtab
->data
[i
])
19029 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
19032 /* Now write out the hash table. */
19033 for (i
= 0; i
< symtab
->size
; ++i
)
19035 offset_type str_off
, vec_off
;
19037 if (symtab
->data
[i
])
19039 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
19040 vec_off
= symtab
->data
[i
]->index_offset
;
19044 /* While 0 is a valid constant pool index, it is not valid
19045 to have 0 for both offsets. */
19050 str_off
= MAYBE_SWAP (str_off
);
19051 vec_off
= MAYBE_SWAP (vec_off
);
19053 obstack_grow (output
, &str_off
, sizeof (str_off
));
19054 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
19057 htab_delete (str_table
);
19058 htab_delete (symbol_hash_table
);
19061 /* Struct to map psymtab to CU index in the index file. */
19062 struct psymtab_cu_index_map
19064 struct partial_symtab
*psymtab
;
19065 unsigned int cu_index
;
19069 hash_psymtab_cu_index (const void *item
)
19071 const struct psymtab_cu_index_map
*map
= item
;
19073 return htab_hash_pointer (map
->psymtab
);
19077 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
19079 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
19080 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
19082 return lhs
->psymtab
== rhs
->psymtab
;
19085 /* Helper struct for building the address table. */
19086 struct addrmap_index_data
19088 struct objfile
*objfile
;
19089 struct obstack
*addr_obstack
;
19090 htab_t cu_index_htab
;
19092 /* Non-zero if the previous_* fields are valid.
19093 We can't write an entry until we see the next entry (since it is only then
19094 that we know the end of the entry). */
19095 int previous_valid
;
19096 /* Index of the CU in the table of all CUs in the index file. */
19097 unsigned int previous_cu_index
;
19098 /* Start address of the CU. */
19099 CORE_ADDR previous_cu_start
;
19102 /* Write an address entry to OBSTACK. */
19105 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
19106 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
19108 offset_type cu_index_to_write
;
19110 CORE_ADDR baseaddr
;
19112 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
19114 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
19115 obstack_grow (obstack
, addr
, 8);
19116 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
19117 obstack_grow (obstack
, addr
, 8);
19118 cu_index_to_write
= MAYBE_SWAP (cu_index
);
19119 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
19122 /* Worker function for traversing an addrmap to build the address table. */
19125 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
19127 struct addrmap_index_data
*data
= datap
;
19128 struct partial_symtab
*pst
= obj
;
19130 if (data
->previous_valid
)
19131 add_address_entry (data
->objfile
, data
->addr_obstack
,
19132 data
->previous_cu_start
, start_addr
,
19133 data
->previous_cu_index
);
19135 data
->previous_cu_start
= start_addr
;
19138 struct psymtab_cu_index_map find_map
, *map
;
19139 find_map
.psymtab
= pst
;
19140 map
= htab_find (data
->cu_index_htab
, &find_map
);
19141 gdb_assert (map
!= NULL
);
19142 data
->previous_cu_index
= map
->cu_index
;
19143 data
->previous_valid
= 1;
19146 data
->previous_valid
= 0;
19151 /* Write OBJFILE's address map to OBSTACK.
19152 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
19153 in the index file. */
19156 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
19157 htab_t cu_index_htab
)
19159 struct addrmap_index_data addrmap_index_data
;
19161 /* When writing the address table, we have to cope with the fact that
19162 the addrmap iterator only provides the start of a region; we have to
19163 wait until the next invocation to get the start of the next region. */
19165 addrmap_index_data
.objfile
= objfile
;
19166 addrmap_index_data
.addr_obstack
= obstack
;
19167 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
19168 addrmap_index_data
.previous_valid
= 0;
19170 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
19171 &addrmap_index_data
);
19173 /* It's highly unlikely the last entry (end address = 0xff...ff)
19174 is valid, but we should still handle it.
19175 The end address is recorded as the start of the next region, but that
19176 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
19178 if (addrmap_index_data
.previous_valid
)
19179 add_address_entry (objfile
, obstack
,
19180 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
19181 addrmap_index_data
.previous_cu_index
);
19184 /* Return the symbol kind of PSYM. */
19186 static gdb_index_symbol_kind
19187 symbol_kind (struct partial_symbol
*psym
)
19189 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
19190 enum address_class aclass
= PSYMBOL_CLASS (psym
);
19198 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
19200 return GDB_INDEX_SYMBOL_KIND_TYPE
;
19202 case LOC_CONST_BYTES
:
19203 case LOC_OPTIMIZED_OUT
:
19205 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
19207 /* Note: It's currently impossible to recognize psyms as enum values
19208 short of reading the type info. For now punt. */
19209 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
19211 /* There are other LOC_FOO values that one might want to classify
19212 as variables, but dwarf2read.c doesn't currently use them. */
19213 return GDB_INDEX_SYMBOL_KIND_OTHER
;
19215 case STRUCT_DOMAIN
:
19216 return GDB_INDEX_SYMBOL_KIND_TYPE
;
19218 return GDB_INDEX_SYMBOL_KIND_OTHER
;
19222 /* Add a list of partial symbols to SYMTAB. */
19225 write_psymbols (struct mapped_symtab
*symtab
,
19227 struct partial_symbol
**psymp
,
19229 offset_type cu_index
,
19232 for (; count
-- > 0; ++psymp
)
19234 struct partial_symbol
*psym
= *psymp
;
19237 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
19238 error (_("Ada is not currently supported by the index"));
19240 /* Only add a given psymbol once. */
19241 slot
= htab_find_slot (psyms_seen
, psym
, INSERT
);
19244 gdb_index_symbol_kind kind
= symbol_kind (psym
);
19247 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
19248 is_static
, kind
, cu_index
);
19253 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
19254 exception if there is an error. */
19257 write_obstack (FILE *file
, struct obstack
*obstack
)
19259 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
19261 != obstack_object_size (obstack
))
19262 error (_("couldn't data write to file"));
19265 /* Unlink a file if the argument is not NULL. */
19268 unlink_if_set (void *p
)
19270 char **filename
= p
;
19272 unlink (*filename
);
19275 /* A helper struct used when iterating over debug_types. */
19276 struct signatured_type_index_data
19278 struct objfile
*objfile
;
19279 struct mapped_symtab
*symtab
;
19280 struct obstack
*types_list
;
19285 /* A helper function that writes a single signatured_type to an
19289 write_one_signatured_type (void **slot
, void *d
)
19291 struct signatured_type_index_data
*info
= d
;
19292 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
19293 struct dwarf2_per_cu_data
*per_cu
= &entry
->per_cu
;
19294 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
19297 write_psymbols (info
->symtab
,
19299 info
->objfile
->global_psymbols
.list
19300 + psymtab
->globals_offset
,
19301 psymtab
->n_global_syms
, info
->cu_index
,
19303 write_psymbols (info
->symtab
,
19305 info
->objfile
->static_psymbols
.list
19306 + psymtab
->statics_offset
,
19307 psymtab
->n_static_syms
, info
->cu_index
,
19310 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
19311 entry
->per_cu
.offset
.sect_off
);
19312 obstack_grow (info
->types_list
, val
, 8);
19313 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
19314 entry
->type_offset_in_tu
.cu_off
);
19315 obstack_grow (info
->types_list
, val
, 8);
19316 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
19317 obstack_grow (info
->types_list
, val
, 8);
19324 /* Recurse into all "included" dependencies and write their symbols as
19325 if they appeared in this psymtab. */
19328 recursively_write_psymbols (struct objfile
*objfile
,
19329 struct partial_symtab
*psymtab
,
19330 struct mapped_symtab
*symtab
,
19332 offset_type cu_index
)
19336 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
19337 if (psymtab
->dependencies
[i
]->user
!= NULL
)
19338 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
19339 symtab
, psyms_seen
, cu_index
);
19341 write_psymbols (symtab
,
19343 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
19344 psymtab
->n_global_syms
, cu_index
,
19346 write_psymbols (symtab
,
19348 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
19349 psymtab
->n_static_syms
, cu_index
,
19353 /* Create an index file for OBJFILE in the directory DIR. */
19356 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
19358 struct cleanup
*cleanup
;
19359 char *filename
, *cleanup_filename
;
19360 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
19361 struct obstack cu_list
, types_cu_list
;
19364 struct mapped_symtab
*symtab
;
19365 offset_type val
, size_of_contents
, total_len
;
19368 htab_t cu_index_htab
;
19369 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
19371 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
19374 if (dwarf2_per_objfile
->using_index
)
19375 error (_("Cannot use an index to create the index"));
19377 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
19378 error (_("Cannot make an index when the file has multiple .debug_types sections"));
19380 if (stat (objfile
->name
, &st
) < 0)
19381 perror_with_name (objfile
->name
);
19383 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
19384 INDEX_SUFFIX
, (char *) NULL
);
19385 cleanup
= make_cleanup (xfree
, filename
);
19387 out_file
= fopen (filename
, "wb");
19389 error (_("Can't open `%s' for writing"), filename
);
19391 cleanup_filename
= filename
;
19392 make_cleanup (unlink_if_set
, &cleanup_filename
);
19394 symtab
= create_mapped_symtab ();
19395 make_cleanup (cleanup_mapped_symtab
, symtab
);
19397 obstack_init (&addr_obstack
);
19398 make_cleanup_obstack_free (&addr_obstack
);
19400 obstack_init (&cu_list
);
19401 make_cleanup_obstack_free (&cu_list
);
19403 obstack_init (&types_cu_list
);
19404 make_cleanup_obstack_free (&types_cu_list
);
19406 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
19407 NULL
, xcalloc
, xfree
);
19408 make_cleanup_htab_delete (psyms_seen
);
19410 /* While we're scanning CU's create a table that maps a psymtab pointer
19411 (which is what addrmap records) to its index (which is what is recorded
19412 in the index file). This will later be needed to write the address
19414 cu_index_htab
= htab_create_alloc (100,
19415 hash_psymtab_cu_index
,
19416 eq_psymtab_cu_index
,
19417 NULL
, xcalloc
, xfree
);
19418 make_cleanup_htab_delete (cu_index_htab
);
19419 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
19420 xmalloc (sizeof (struct psymtab_cu_index_map
)
19421 * dwarf2_per_objfile
->n_comp_units
);
19422 make_cleanup (xfree
, psymtab_cu_index_map
);
19424 /* The CU list is already sorted, so we don't need to do additional
19425 work here. Also, the debug_types entries do not appear in
19426 all_comp_units, but only in their own hash table. */
19427 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
19429 struct dwarf2_per_cu_data
*per_cu
19430 = dwarf2_per_objfile
->all_comp_units
[i
];
19431 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
19433 struct psymtab_cu_index_map
*map
;
19436 if (psymtab
->user
== NULL
)
19437 recursively_write_psymbols (objfile
, psymtab
, symtab
, psyms_seen
, i
);
19439 map
= &psymtab_cu_index_map
[i
];
19440 map
->psymtab
= psymtab
;
19442 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
19443 gdb_assert (slot
!= NULL
);
19444 gdb_assert (*slot
== NULL
);
19447 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
19448 per_cu
->offset
.sect_off
);
19449 obstack_grow (&cu_list
, val
, 8);
19450 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
19451 obstack_grow (&cu_list
, val
, 8);
19454 /* Dump the address map. */
19455 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
19457 /* Write out the .debug_type entries, if any. */
19458 if (dwarf2_per_objfile
->signatured_types
)
19460 struct signatured_type_index_data sig_data
;
19462 sig_data
.objfile
= objfile
;
19463 sig_data
.symtab
= symtab
;
19464 sig_data
.types_list
= &types_cu_list
;
19465 sig_data
.psyms_seen
= psyms_seen
;
19466 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
19467 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
19468 write_one_signatured_type
, &sig_data
);
19471 /* Now that we've processed all symbols we can shrink their cu_indices
19473 uniquify_cu_indices (symtab
);
19475 obstack_init (&constant_pool
);
19476 make_cleanup_obstack_free (&constant_pool
);
19477 obstack_init (&symtab_obstack
);
19478 make_cleanup_obstack_free (&symtab_obstack
);
19479 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
19481 obstack_init (&contents
);
19482 make_cleanup_obstack_free (&contents
);
19483 size_of_contents
= 6 * sizeof (offset_type
);
19484 total_len
= size_of_contents
;
19486 /* The version number. */
19487 val
= MAYBE_SWAP (7);
19488 obstack_grow (&contents
, &val
, sizeof (val
));
19490 /* The offset of the CU list from the start of the file. */
19491 val
= MAYBE_SWAP (total_len
);
19492 obstack_grow (&contents
, &val
, sizeof (val
));
19493 total_len
+= obstack_object_size (&cu_list
);
19495 /* The offset of the types CU list from the start of the file. */
19496 val
= MAYBE_SWAP (total_len
);
19497 obstack_grow (&contents
, &val
, sizeof (val
));
19498 total_len
+= obstack_object_size (&types_cu_list
);
19500 /* The offset of the address table from the start of the file. */
19501 val
= MAYBE_SWAP (total_len
);
19502 obstack_grow (&contents
, &val
, sizeof (val
));
19503 total_len
+= obstack_object_size (&addr_obstack
);
19505 /* The offset of the symbol table from the start of the file. */
19506 val
= MAYBE_SWAP (total_len
);
19507 obstack_grow (&contents
, &val
, sizeof (val
));
19508 total_len
+= obstack_object_size (&symtab_obstack
);
19510 /* The offset of the constant pool from the start of the file. */
19511 val
= MAYBE_SWAP (total_len
);
19512 obstack_grow (&contents
, &val
, sizeof (val
));
19513 total_len
+= obstack_object_size (&constant_pool
);
19515 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
19517 write_obstack (out_file
, &contents
);
19518 write_obstack (out_file
, &cu_list
);
19519 write_obstack (out_file
, &types_cu_list
);
19520 write_obstack (out_file
, &addr_obstack
);
19521 write_obstack (out_file
, &symtab_obstack
);
19522 write_obstack (out_file
, &constant_pool
);
19526 /* We want to keep the file, so we set cleanup_filename to NULL
19527 here. See unlink_if_set. */
19528 cleanup_filename
= NULL
;
19530 do_cleanups (cleanup
);
19533 /* Implementation of the `save gdb-index' command.
19535 Note that the file format used by this command is documented in the
19536 GDB manual. Any changes here must be documented there. */
19539 save_gdb_index_command (char *arg
, int from_tty
)
19541 struct objfile
*objfile
;
19544 error (_("usage: save gdb-index DIRECTORY"));
19546 ALL_OBJFILES (objfile
)
19550 /* If the objfile does not correspond to an actual file, skip it. */
19551 if (stat (objfile
->name
, &st
) < 0)
19554 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
19555 if (dwarf2_per_objfile
)
19557 volatile struct gdb_exception except
;
19559 TRY_CATCH (except
, RETURN_MASK_ERROR
)
19561 write_psymtabs_to_index (objfile
, arg
);
19563 if (except
.reason
< 0)
19564 exception_fprintf (gdb_stderr
, except
,
19565 _("Error while writing index for `%s': "),
19573 int dwarf2_always_disassemble
;
19576 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
19577 struct cmd_list_element
*c
, const char *value
)
19579 fprintf_filtered (file
,
19580 _("Whether to always disassemble "
19581 "DWARF expressions is %s.\n"),
19586 show_check_physname (struct ui_file
*file
, int from_tty
,
19587 struct cmd_list_element
*c
, const char *value
)
19589 fprintf_filtered (file
,
19590 _("Whether to check \"physname\" is %s.\n"),
19594 void _initialize_dwarf2_read (void);
19597 _initialize_dwarf2_read (void)
19599 struct cmd_list_element
*c
;
19601 dwarf2_objfile_data_key
19602 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
19604 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
19605 Set DWARF 2 specific variables.\n\
19606 Configure DWARF 2 variables such as the cache size"),
19607 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
19608 0/*allow-unknown*/, &maintenance_set_cmdlist
);
19610 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
19611 Show DWARF 2 specific variables\n\
19612 Show DWARF 2 variables such as the cache size"),
19613 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
19614 0/*allow-unknown*/, &maintenance_show_cmdlist
);
19616 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
19617 &dwarf2_max_cache_age
, _("\
19618 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
19619 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
19620 A higher limit means that cached compilation units will be stored\n\
19621 in memory longer, and more total memory will be used. Zero disables\n\
19622 caching, which can slow down startup."),
19624 show_dwarf2_max_cache_age
,
19625 &set_dwarf2_cmdlist
,
19626 &show_dwarf2_cmdlist
);
19628 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
19629 &dwarf2_always_disassemble
, _("\
19630 Set whether `info address' always disassembles DWARF expressions."), _("\
19631 Show whether `info address' always disassembles DWARF expressions."), _("\
19632 When enabled, DWARF expressions are always printed in an assembly-like\n\
19633 syntax. When disabled, expressions will be printed in a more\n\
19634 conversational style, when possible."),
19636 show_dwarf2_always_disassemble
,
19637 &set_dwarf2_cmdlist
,
19638 &show_dwarf2_cmdlist
);
19640 add_setshow_boolean_cmd ("dwarf2-read", no_class
, &dwarf2_read_debug
, _("\
19641 Set debugging of the dwarf2 reader."), _("\
19642 Show debugging of the dwarf2 reader."), _("\
19643 When enabled, debugging messages are printed during dwarf2 reading\n\
19644 and symtab expansion."),
19647 &setdebuglist
, &showdebuglist
);
19649 add_setshow_zuinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
19650 Set debugging of the dwarf2 DIE reader."), _("\
19651 Show debugging of the dwarf2 DIE reader."), _("\
19652 When enabled (non-zero), DIEs are dumped after they are read in.\n\
19653 The value is the maximum depth to print."),
19656 &setdebuglist
, &showdebuglist
);
19658 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
19659 Set cross-checking of \"physname\" code against demangler."), _("\
19660 Show cross-checking of \"physname\" code against demangler."), _("\
19661 When enabled, GDB's internal \"physname\" code is checked against\n\
19663 NULL
, show_check_physname
,
19664 &setdebuglist
, &showdebuglist
);
19666 add_setshow_boolean_cmd ("use-deprecated-index-sections",
19667 no_class
, &use_deprecated_index_sections
, _("\
19668 Set whether to use deprecated gdb_index sections."), _("\
19669 Show whether to use deprecated gdb_index sections."), _("\
19670 When enabled, deprecated .gdb_index sections are used anyway.\n\
19671 Normally they are ignored either because of a missing feature or\n\
19672 performance issue.\n\
19673 Warning: This option must be enabled before gdb reads the file."),
19676 &setlist
, &showlist
);
19678 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
19680 Save a gdb-index file.\n\
19681 Usage: save gdb-index DIRECTORY"),
19683 set_cmd_completer (c
, filename_completer
);