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 */
68 #include "gdb_string.h"
69 #include "gdb_assert.h"
70 #include <sys/types.h>
77 #define MAP_FAILED ((void *) -1)
81 typedef struct symbol
*symbolp
;
84 /* When non-zero, dump DIEs after they are read in. */
85 static int dwarf2_die_debug
= 0;
87 /* When non-zero, cross-check physname against demangler. */
88 static int check_physname
= 0;
90 /* When non-zero, do not reject deprecated .gdb_index sections. */
91 int use_deprecated_index_sections
= 0;
95 /* When set, the file that we're processing is known to have debugging
96 info for C++ namespaces. GCC 3.3.x did not produce this information,
97 but later versions do. */
99 static int processing_has_namespace_info
;
101 static const struct objfile_data
*dwarf2_objfile_data_key
;
103 struct dwarf2_section_info
108 /* Not NULL if the section was actually mmapped. */
110 /* Page aligned size of mmapped area. */
111 bfd_size_type map_len
;
112 /* True if we have tried to read this section. */
116 typedef struct dwarf2_section_info dwarf2_section_info_def
;
117 DEF_VEC_O (dwarf2_section_info_def
);
119 /* All offsets in the index are of this type. It must be
120 architecture-independent. */
121 typedef uint32_t offset_type
;
123 DEF_VEC_I (offset_type
);
125 /* A description of the mapped index. The file format is described in
126 a comment by the code that writes the index. */
129 /* Index data format version. */
132 /* The total length of the buffer. */
135 /* A pointer to the address table data. */
136 const gdb_byte
*address_table
;
138 /* Size of the address table data in bytes. */
139 offset_type address_table_size
;
141 /* The symbol table, implemented as a hash table. */
142 const offset_type
*symbol_table
;
144 /* Size in slots, each slot is 2 offset_types. */
145 offset_type symbol_table_slots
;
147 /* A pointer to the constant pool. */
148 const char *constant_pool
;
151 typedef struct dwarf2_per_cu_data
*dwarf2_per_cu_ptr
;
152 DEF_VEC_P (dwarf2_per_cu_ptr
);
154 /* Collection of data recorded per objfile.
155 This hangs off of dwarf2_objfile_data_key. */
157 struct dwarf2_per_objfile
159 struct dwarf2_section_info info
;
160 struct dwarf2_section_info abbrev
;
161 struct dwarf2_section_info line
;
162 struct dwarf2_section_info loc
;
163 struct dwarf2_section_info macinfo
;
164 struct dwarf2_section_info macro
;
165 struct dwarf2_section_info str
;
166 struct dwarf2_section_info ranges
;
167 struct dwarf2_section_info addr
;
168 struct dwarf2_section_info frame
;
169 struct dwarf2_section_info eh_frame
;
170 struct dwarf2_section_info gdb_index
;
172 VEC (dwarf2_section_info_def
) *types
;
175 struct objfile
*objfile
;
177 /* Table of all the compilation units. This is used to locate
178 the target compilation unit of a particular reference. */
179 struct dwarf2_per_cu_data
**all_comp_units
;
181 /* The number of compilation units in ALL_COMP_UNITS. */
184 /* The number of .debug_types-related CUs. */
187 /* The .debug_types-related CUs (TUs). */
188 struct dwarf2_per_cu_data
**all_type_units
;
190 /* A chain of compilation units that are currently read in, so that
191 they can be freed later. */
192 struct dwarf2_per_cu_data
*read_in_chain
;
194 /* A table mapping .debug_types signatures to its signatured_type entry.
195 This is NULL if the .debug_types section hasn't been read in yet. */
196 htab_t signatured_types
;
198 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
199 This is NULL if the table hasn't been allocated yet. */
202 /* A flag indicating wether this objfile has a section loaded at a
204 int has_section_at_zero
;
206 /* True if we are using the mapped index,
207 or we are faking it for OBJF_READNOW's sake. */
208 unsigned char using_index
;
210 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
211 struct mapped_index
*index_table
;
213 /* When using index_table, this keeps track of all quick_file_names entries.
214 TUs can share line table entries with CUs or other TUs, and there can be
215 a lot more TUs than unique line tables, so we maintain a separate table
216 of all line table entries to support the sharing. */
217 htab_t quick_file_names_table
;
219 /* Set during partial symbol reading, to prevent queueing of full
221 int reading_partial_symbols
;
223 /* Table mapping type DIEs to their struct type *.
224 This is NULL if not allocated yet.
225 The mapping is done via (CU/TU signature + DIE offset) -> type. */
226 htab_t die_type_hash
;
228 /* The CUs we recently read. */
229 VEC (dwarf2_per_cu_ptr
) *just_read_cus
;
232 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
234 /* Default names of the debugging sections. */
236 /* Note that if the debugging section has been compressed, it might
237 have a name like .zdebug_info. */
239 static const struct dwarf2_debug_sections dwarf2_elf_names
=
241 { ".debug_info", ".zdebug_info" },
242 { ".debug_abbrev", ".zdebug_abbrev" },
243 { ".debug_line", ".zdebug_line" },
244 { ".debug_loc", ".zdebug_loc" },
245 { ".debug_macinfo", ".zdebug_macinfo" },
246 { ".debug_macro", ".zdebug_macro" },
247 { ".debug_str", ".zdebug_str" },
248 { ".debug_ranges", ".zdebug_ranges" },
249 { ".debug_types", ".zdebug_types" },
250 { ".debug_addr", ".zdebug_addr" },
251 { ".debug_frame", ".zdebug_frame" },
252 { ".eh_frame", NULL
},
253 { ".gdb_index", ".zgdb_index" },
257 /* List of DWO sections. */
259 static const struct dwo_section_names
261 struct dwarf2_section_names abbrev_dwo
;
262 struct dwarf2_section_names info_dwo
;
263 struct dwarf2_section_names line_dwo
;
264 struct dwarf2_section_names loc_dwo
;
265 struct dwarf2_section_names str_dwo
;
266 struct dwarf2_section_names str_offsets_dwo
;
267 struct dwarf2_section_names types_dwo
;
271 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
272 { ".debug_info.dwo", ".zdebug_info.dwo" },
273 { ".debug_line.dwo", ".zdebug_line.dwo" },
274 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
275 { ".debug_str.dwo", ".zdebug_str.dwo" },
276 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
277 { ".debug_types.dwo", ".zdebug_types.dwo" },
280 /* local data types */
282 /* We hold several abbreviation tables in memory at the same time. */
283 #ifndef ABBREV_HASH_SIZE
284 #define ABBREV_HASH_SIZE 121
287 /* The data in a compilation unit header, after target2host
288 translation, looks like this. */
289 struct comp_unit_head
293 unsigned char addr_size
;
294 unsigned char signed_addr_p
;
295 sect_offset abbrev_offset
;
297 /* Size of file offsets; either 4 or 8. */
298 unsigned int offset_size
;
300 /* Size of the length field; either 4 or 12. */
301 unsigned int initial_length_size
;
303 /* Offset to the first byte of this compilation unit header in the
304 .debug_info section, for resolving relative reference dies. */
307 /* Offset to first die in this cu from the start of the cu.
308 This will be the first byte following the compilation unit header. */
309 cu_offset first_die_offset
;
312 /* Type used for delaying computation of method physnames.
313 See comments for compute_delayed_physnames. */
314 struct delayed_method_info
316 /* The type to which the method is attached, i.e., its parent class. */
319 /* The index of the method in the type's function fieldlists. */
322 /* The index of the method in the fieldlist. */
325 /* The name of the DIE. */
328 /* The DIE associated with this method. */
329 struct die_info
*die
;
332 typedef struct delayed_method_info delayed_method_info
;
333 DEF_VEC_O (delayed_method_info
);
335 /* Internal state when decoding a particular compilation unit. */
338 /* The objfile containing this compilation unit. */
339 struct objfile
*objfile
;
341 /* The header of the compilation unit. */
342 struct comp_unit_head header
;
344 /* Base address of this compilation unit. */
345 CORE_ADDR base_address
;
347 /* Non-zero if base_address has been set. */
350 /* The language we are debugging. */
351 enum language language
;
352 const struct language_defn
*language_defn
;
354 const char *producer
;
356 /* The generic symbol table building routines have separate lists for
357 file scope symbols and all all other scopes (local scopes). So
358 we need to select the right one to pass to add_symbol_to_list().
359 We do it by keeping a pointer to the correct list in list_in_scope.
361 FIXME: The original dwarf code just treated the file scope as the
362 first local scope, and all other local scopes as nested local
363 scopes, and worked fine. Check to see if we really need to
364 distinguish these in buildsym.c. */
365 struct pending
**list_in_scope
;
367 /* DWARF abbreviation table associated with this compilation unit. */
368 struct abbrev_info
**dwarf2_abbrevs
;
370 /* Storage for the abbrev table. */
371 struct obstack abbrev_obstack
;
373 /* Hash table holding all the loaded partial DIEs
374 with partial_die->offset.SECT_OFF as hash. */
377 /* Storage for things with the same lifetime as this read-in compilation
378 unit, including partial DIEs. */
379 struct obstack comp_unit_obstack
;
381 /* When multiple dwarf2_cu structures are living in memory, this field
382 chains them all together, so that they can be released efficiently.
383 We will probably also want a generation counter so that most-recently-used
384 compilation units are cached... */
385 struct dwarf2_per_cu_data
*read_in_chain
;
387 /* Backchain to our per_cu entry if the tree has been built. */
388 struct dwarf2_per_cu_data
*per_cu
;
390 /* How many compilation units ago was this CU last referenced? */
393 /* A hash table of DIE cu_offset for following references with
394 die_info->offset.sect_off as hash. */
397 /* Full DIEs if read in. */
398 struct die_info
*dies
;
400 /* A set of pointers to dwarf2_per_cu_data objects for compilation
401 units referenced by this one. Only set during full symbol processing;
402 partial symbol tables do not have dependencies. */
405 /* Header data from the line table, during full symbol processing. */
406 struct line_header
*line_header
;
408 /* A list of methods which need to have physnames computed
409 after all type information has been read. */
410 VEC (delayed_method_info
) *method_list
;
412 /* To be copied to symtab->call_site_htab. */
413 htab_t call_site_htab
;
415 /* Non-NULL if this CU came from a DWO file.
416 There is an invariant here that is important to remember:
417 Except for attributes copied from the top level DIE in the "main"
418 (or "stub") file in preparation for reading the DWO file
419 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
420 Either there isn't a DWO file (in which case this is NULL and the point
421 is moot), or there is and either we're not going to read it (in which
422 case this is NULL) or there is and we are reading it (in which case this
424 struct dwo_unit
*dwo_unit
;
426 /* The DW_AT_addr_base attribute if present, zero otherwise
427 (zero is a valid value though).
428 Note this value comes from the stub CU/TU's DIE. */
431 /* Mark used when releasing cached dies. */
432 unsigned int mark
: 1;
434 /* This CU references .debug_loc. See the symtab->locations_valid field.
435 This test is imperfect as there may exist optimized debug code not using
436 any location list and still facing inlining issues if handled as
437 unoptimized code. For a future better test see GCC PR other/32998. */
438 unsigned int has_loclist
: 1;
440 /* These cache the results for producer_is_gxx_lt_4_6 and producer_is_icc.
441 CHECKED_PRODUCER is set if both PRODUCER_IS_GXX_LT_4_6 and PRODUCER_IS_ICC
442 are valid. This information is cached because profiling CU expansion
443 showed excessive time spent in producer_is_gxx_lt_4_6. */
444 unsigned int checked_producer
: 1;
445 unsigned int producer_is_gxx_lt_4_6
: 1;
446 unsigned int producer_is_icc
: 1;
448 /* Non-zero if DW_AT_addr_base was found.
449 Used when processing DWO files. */
450 unsigned int have_addr_base
: 1;
453 /* Persistent data held for a compilation unit, even when not
454 processing it. We put a pointer to this structure in the
455 read_symtab_private field of the psymtab. */
457 struct dwarf2_per_cu_data
459 /* The start offset and length of this compilation unit. 2**29-1
460 bytes should suffice to store the length of any compilation unit
461 - if it doesn't, GDB will fall over anyway.
462 NOTE: Unlike comp_unit_head.length, this length includes
464 If the DIE refers to a DWO file, this is always of the original die,
467 unsigned int length
: 29;
469 /* Flag indicating this compilation unit will be read in before
470 any of the current compilation units are processed. */
471 unsigned int queued
: 1;
473 /* This flag will be set when reading partial DIEs if we need to load
474 absolutely all DIEs for this compilation unit, instead of just the ones
475 we think are interesting. It gets set if we look for a DIE in the
476 hash table and don't find it. */
477 unsigned int load_all_dies
: 1;
479 /* Non-zero if this CU is from .debug_types. */
480 unsigned int is_debug_types
: 1;
482 /* The section this CU/TU lives in.
483 If the DIE refers to a DWO file, this is always the original die,
485 struct dwarf2_section_info
*info_or_types_section
;
487 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
488 of the CU cache it gets reset to NULL again. */
489 struct dwarf2_cu
*cu
;
491 /* The corresponding objfile.
492 Normally we can get the objfile from dwarf2_per_objfile.
493 However we can enter this file with just a "per_cu" handle. */
494 struct objfile
*objfile
;
496 /* When using partial symbol tables, the 'psymtab' field is active.
497 Otherwise the 'quick' field is active. */
500 /* The partial symbol table associated with this compilation unit,
501 or NULL for unread partial units. */
502 struct partial_symtab
*psymtab
;
504 /* Data needed by the "quick" functions. */
505 struct dwarf2_per_cu_quick_data
*quick
;
508 /* The CUs we import using DW_TAG_imported_unit. This is filled in
509 while reading psymtabs, used to compute the psymtab dependencies,
510 and then cleared. Then it is filled in again while reading full
511 symbols, and only deleted when the objfile is destroyed. */
512 VEC (dwarf2_per_cu_ptr
) *imported_symtabs
;
515 /* Entry in the signatured_types hash table. */
517 struct signatured_type
519 /* The type's signature. */
522 /* Offset in the TU of the type's DIE, as read from the TU header.
523 If the definition lives in a DWO file, this value is unusable. */
524 cu_offset type_offset_in_tu
;
526 /* Offset in the section of the type's DIE.
527 If the definition lives in a DWO file, this is the offset in the
528 .debug_types.dwo section.
529 The value is zero until the actual value is known.
530 Zero is otherwise not a valid section offset. */
531 sect_offset type_offset_in_section
;
533 /* The CU(/TU) of this type. */
534 struct dwarf2_per_cu_data per_cu
;
537 /* These sections are what may appear in a "dwo" file. */
541 struct dwarf2_section_info abbrev
;
542 struct dwarf2_section_info info
;
543 struct dwarf2_section_info line
;
544 struct dwarf2_section_info loc
;
545 struct dwarf2_section_info str
;
546 struct dwarf2_section_info str_offsets
;
547 VEC (dwarf2_section_info_def
) *types
;
550 /* Common bits of DWO CUs/TUs. */
554 /* Backlink to the containing struct dwo_file. */
555 struct dwo_file
*dwo_file
;
557 /* The "id" that distinguishes this CU/TU.
558 .debug_info calls this "dwo_id", .debug_types calls this "signature".
559 Since signatures came first, we stick with it for consistency. */
562 /* The section this CU/TU lives in, in the DWO file. */
563 struct dwarf2_section_info
*info_or_types_section
;
565 /* Same as dwarf2_per_cu_data:{offset,length} but for the DWO section. */
569 /* For types, offset in the type's DIE of the type defined by this TU. */
570 cu_offset type_offset_in_tu
;
573 /* Data for one DWO file. */
577 /* The DW_AT_GNU_dwo_name attribute.
578 We don't manage space for this, it's an attribute. */
579 const char *dwo_name
;
581 /* The bfd, when the file is open. Otherwise this is NULL. */
584 /* Section info for this file. */
585 struct dwo_sections sections
;
587 /* Table of CUs in the file.
588 Each element is a struct dwo_unit. */
591 /* Table of TUs in the file.
592 Each element is a struct dwo_unit. */
596 /* Struct used to pass misc. parameters to read_die_and_children, et
597 al. which are used for both .debug_info and .debug_types dies.
598 All parameters here are unchanging for the life of the call. This
599 struct exists to abstract away the constant parameters of die reading. */
601 struct die_reader_specs
603 /* die_section->asection->owner. */
606 /* The CU of the DIE we are parsing. */
607 struct dwarf2_cu
*cu
;
609 /* Non-NULL if reading a DWO file. */
610 struct dwo_file
*dwo_file
;
612 /* The section the die comes from.
613 This is either .debug_info or .debug_types, or the .dwo variants. */
614 struct dwarf2_section_info
*die_section
;
616 /* die_section->buffer. */
619 /* The end of the buffer. */
620 const gdb_byte
*buffer_end
;
623 /* Type of function passed to init_cutu_and_read_dies, et.al. */
624 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
626 struct die_info
*comp_unit_die
,
630 /* The line number information for a compilation unit (found in the
631 .debug_line section) begins with a "statement program header",
632 which contains the following information. */
635 unsigned int total_length
;
636 unsigned short version
;
637 unsigned int header_length
;
638 unsigned char minimum_instruction_length
;
639 unsigned char maximum_ops_per_instruction
;
640 unsigned char default_is_stmt
;
642 unsigned char line_range
;
643 unsigned char opcode_base
;
645 /* standard_opcode_lengths[i] is the number of operands for the
646 standard opcode whose value is i. This means that
647 standard_opcode_lengths[0] is unused, and the last meaningful
648 element is standard_opcode_lengths[opcode_base - 1]. */
649 unsigned char *standard_opcode_lengths
;
651 /* The include_directories table. NOTE! These strings are not
652 allocated with xmalloc; instead, they are pointers into
653 debug_line_buffer. If you try to free them, `free' will get
655 unsigned int num_include_dirs
, include_dirs_size
;
658 /* The file_names table. NOTE! These strings are not allocated
659 with xmalloc; instead, they are pointers into debug_line_buffer.
660 Don't try to free them directly. */
661 unsigned int num_file_names
, file_names_size
;
665 unsigned int dir_index
;
666 unsigned int mod_time
;
668 int included_p
; /* Non-zero if referenced by the Line Number Program. */
669 struct symtab
*symtab
; /* The associated symbol table, if any. */
672 /* The start and end of the statement program following this
673 header. These point into dwarf2_per_objfile->line_buffer. */
674 gdb_byte
*statement_program_start
, *statement_program_end
;
677 /* When we construct a partial symbol table entry we only
678 need this much information. */
679 struct partial_die_info
681 /* Offset of this DIE. */
684 /* DWARF-2 tag for this DIE. */
685 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
687 /* Assorted flags describing the data found in this DIE. */
688 unsigned int has_children
: 1;
689 unsigned int is_external
: 1;
690 unsigned int is_declaration
: 1;
691 unsigned int has_type
: 1;
692 unsigned int has_specification
: 1;
693 unsigned int has_pc_info
: 1;
694 unsigned int may_be_inlined
: 1;
696 /* Flag set if the SCOPE field of this structure has been
698 unsigned int scope_set
: 1;
700 /* Flag set if the DIE has a byte_size attribute. */
701 unsigned int has_byte_size
: 1;
703 /* Flag set if any of the DIE's children are template arguments. */
704 unsigned int has_template_arguments
: 1;
706 /* Flag set if fixup_partial_die has been called on this die. */
707 unsigned int fixup_called
: 1;
709 /* The name of this DIE. Normally the value of DW_AT_name, but
710 sometimes a default name for unnamed DIEs. */
713 /* The linkage name, if present. */
714 const char *linkage_name
;
716 /* The scope to prepend to our children. This is generally
717 allocated on the comp_unit_obstack, so will disappear
718 when this compilation unit leaves the cache. */
721 /* Some data associated with the partial DIE. The tag determines
722 which field is live. */
725 /* The location description associated with this DIE, if any. */
726 struct dwarf_block
*locdesc
;
727 /* The offset of an import, for DW_TAG_imported_unit. */
731 /* If HAS_PC_INFO, the PC range associated with this DIE. */
735 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
736 DW_AT_sibling, if any. */
737 /* NOTE: This member isn't strictly necessary, read_partial_die could
738 return DW_AT_sibling values to its caller load_partial_dies. */
741 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
742 DW_AT_specification (or DW_AT_abstract_origin or
744 sect_offset spec_offset
;
746 /* Pointers to this DIE's parent, first child, and next sibling,
748 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
751 /* This data structure holds the information of an abbrev. */
754 unsigned int number
; /* number identifying abbrev */
755 enum dwarf_tag tag
; /* dwarf tag */
756 unsigned short has_children
; /* boolean */
757 unsigned short num_attrs
; /* number of attributes */
758 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
759 struct abbrev_info
*next
; /* next in chain */
764 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
765 ENUM_BITFIELD(dwarf_form
) form
: 16;
768 /* Attributes have a name and a value. */
771 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
772 ENUM_BITFIELD(dwarf_form
) form
: 15;
774 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
775 field should be in u.str (existing only for DW_STRING) but it is kept
776 here for better struct attribute alignment. */
777 unsigned int string_is_canonical
: 1;
782 struct dwarf_block
*blk
;
786 struct signatured_type
*signatured_type
;
791 /* This data structure holds a complete die structure. */
794 /* DWARF-2 tag for this DIE. */
795 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
797 /* Number of attributes */
798 unsigned char num_attrs
;
800 /* True if we're presently building the full type name for the
801 type derived from this DIE. */
802 unsigned char building_fullname
: 1;
807 /* Offset in .debug_info or .debug_types section. */
810 /* The dies in a compilation unit form an n-ary tree. PARENT
811 points to this die's parent; CHILD points to the first child of
812 this node; and all the children of a given node are chained
813 together via their SIBLING fields. */
814 struct die_info
*child
; /* Its first child, if any. */
815 struct die_info
*sibling
; /* Its next sibling, if any. */
816 struct die_info
*parent
; /* Its parent, if any. */
818 /* An array of attributes, with NUM_ATTRS elements. There may be
819 zero, but it's not common and zero-sized arrays are not
820 sufficiently portable C. */
821 struct attribute attrs
[1];
824 /* Get at parts of an attribute structure. */
826 #define DW_STRING(attr) ((attr)->u.str)
827 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
828 #define DW_UNSND(attr) ((attr)->u.unsnd)
829 #define DW_BLOCK(attr) ((attr)->u.blk)
830 #define DW_SND(attr) ((attr)->u.snd)
831 #define DW_ADDR(attr) ((attr)->u.addr)
832 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
834 /* Blocks are a bunch of untyped bytes. */
839 /* Valid only if SIZE is not zero. */
843 #ifndef ATTR_ALLOC_CHUNK
844 #define ATTR_ALLOC_CHUNK 4
847 /* Allocate fields for structs, unions and enums in this size. */
848 #ifndef DW_FIELD_ALLOC_CHUNK
849 #define DW_FIELD_ALLOC_CHUNK 4
852 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
853 but this would require a corresponding change in unpack_field_as_long
855 static int bits_per_byte
= 8;
857 /* The routines that read and process dies for a C struct or C++ class
858 pass lists of data member fields and lists of member function fields
859 in an instance of a field_info structure, as defined below. */
862 /* List of data member and baseclasses fields. */
865 struct nextfield
*next
;
870 *fields
, *baseclasses
;
872 /* Number of fields (including baseclasses). */
875 /* Number of baseclasses. */
878 /* Set if the accesibility of one of the fields is not public. */
879 int non_public_fields
;
881 /* Member function fields array, entries are allocated in the order they
882 are encountered in the object file. */
885 struct nextfnfield
*next
;
886 struct fn_field fnfield
;
890 /* Member function fieldlist array, contains name of possibly overloaded
891 member function, number of overloaded member functions and a pointer
892 to the head of the member function field chain. */
897 struct nextfnfield
*head
;
901 /* Number of entries in the fnfieldlists array. */
904 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
905 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
906 struct typedef_field_list
908 struct typedef_field field
;
909 struct typedef_field_list
*next
;
912 unsigned typedef_field_list_count
;
915 /* One item on the queue of compilation units to read in full symbols
917 struct dwarf2_queue_item
919 struct dwarf2_per_cu_data
*per_cu
;
920 enum language pretend_language
;
921 struct dwarf2_queue_item
*next
;
924 /* The current queue. */
925 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
927 /* Loaded secondary compilation units are kept in memory until they
928 have not been referenced for the processing of this many
929 compilation units. Set this to zero to disable caching. Cache
930 sizes of up to at least twenty will improve startup time for
931 typical inter-CU-reference binaries, at an obvious memory cost. */
932 static int dwarf2_max_cache_age
= 5;
934 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
935 struct cmd_list_element
*c
, const char *value
)
937 fprintf_filtered (file
, _("The upper bound on the age of cached "
938 "dwarf2 compilation units is %s.\n"),
943 /* Various complaints about symbol reading that don't abort the process. */
946 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
948 complaint (&symfile_complaints
,
949 _("statement list doesn't fit in .debug_line section"));
953 dwarf2_debug_line_missing_file_complaint (void)
955 complaint (&symfile_complaints
,
956 _(".debug_line section has line data without a file"));
960 dwarf2_debug_line_missing_end_sequence_complaint (void)
962 complaint (&symfile_complaints
,
963 _(".debug_line section has line "
964 "program sequence without an end"));
968 dwarf2_complex_location_expr_complaint (void)
970 complaint (&symfile_complaints
, _("location expression too complex"));
974 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
977 complaint (&symfile_complaints
,
978 _("const value length mismatch for '%s', got %d, expected %d"),
983 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
985 complaint (&symfile_complaints
,
986 _("debug info runs off end of %s section"
988 section
->asection
->name
,
989 bfd_get_filename (section
->asection
->owner
));
993 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
995 complaint (&symfile_complaints
,
996 _("macro debug info contains a "
997 "malformed macro definition:\n`%s'"),
1002 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1004 complaint (&symfile_complaints
,
1005 _("invalid attribute class or form for '%s' in '%s'"),
1009 /* local function prototypes */
1011 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
1013 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
1016 static void dwarf2_find_base_address (struct die_info
*die
,
1017 struct dwarf2_cu
*cu
);
1019 static void dwarf2_build_psymtabs_hard (struct objfile
*);
1021 static void scan_partial_symbols (struct partial_die_info
*,
1022 CORE_ADDR
*, CORE_ADDR
*,
1023 int, struct dwarf2_cu
*);
1025 static void add_partial_symbol (struct partial_die_info
*,
1026 struct dwarf2_cu
*);
1028 static void add_partial_namespace (struct partial_die_info
*pdi
,
1029 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1030 int need_pc
, struct dwarf2_cu
*cu
);
1032 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1033 CORE_ADDR
*highpc
, int need_pc
,
1034 struct dwarf2_cu
*cu
);
1036 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1037 struct dwarf2_cu
*cu
);
1039 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1040 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1041 int need_pc
, struct dwarf2_cu
*cu
);
1043 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
1045 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1047 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1048 struct dwarf2_section_info
*);
1050 static void dwarf2_free_abbrev_table (void *);
1052 static unsigned int peek_abbrev_code (bfd
*, gdb_byte
*);
1054 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
1055 struct dwarf2_cu
*);
1057 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
1058 struct dwarf2_cu
*);
1060 static struct partial_die_info
*load_partial_dies
1061 (const struct die_reader_specs
*, gdb_byte
*, int);
1063 static gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1064 struct partial_die_info
*,
1065 struct abbrev_info
*,
1069 static struct partial_die_info
*find_partial_die (sect_offset
,
1070 struct dwarf2_cu
*);
1072 static void fixup_partial_die (struct partial_die_info
*,
1073 struct dwarf2_cu
*);
1075 static gdb_byte
*read_attribute (const struct die_reader_specs
*,
1076 struct attribute
*, struct attr_abbrev
*,
1079 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
1081 static int read_1_signed_byte (bfd
*, gdb_byte
*);
1083 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
1085 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
1087 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
1089 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
1092 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
1094 static LONGEST read_checked_initial_length_and_offset
1095 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
1096 unsigned int *, unsigned int *);
1098 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
1101 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
1103 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
1105 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
1107 static char *read_indirect_string (bfd
*, gdb_byte
*,
1108 const struct comp_unit_head
*,
1111 static ULONGEST
read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
1113 static LONGEST
read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
1115 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*, gdb_byte
*,
1118 static char *read_str_index (const struct die_reader_specs
*reader
,
1119 struct dwarf2_cu
*cu
, ULONGEST str_index
);
1121 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1123 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1124 struct dwarf2_cu
*);
1126 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1128 struct dwarf2_cu
*);
1130 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1131 struct dwarf2_cu
*cu
);
1133 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1135 static struct die_info
*die_specification (struct die_info
*die
,
1136 struct dwarf2_cu
**);
1138 static void free_line_header (struct line_header
*lh
);
1140 static void add_file_name (struct line_header
*, char *, unsigned int,
1141 unsigned int, unsigned int);
1143 static struct line_header
*dwarf_decode_line_header (unsigned int offset
,
1144 struct dwarf2_cu
*cu
);
1146 static void dwarf_decode_lines (struct line_header
*, const char *,
1147 struct dwarf2_cu
*, struct partial_symtab
*,
1150 static void dwarf2_start_subfile (char *, const char *, const char *);
1152 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1153 struct dwarf2_cu
*);
1155 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1156 struct dwarf2_cu
*, struct symbol
*);
1158 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1159 struct dwarf2_cu
*);
1161 static void dwarf2_const_value_attr (struct attribute
*attr
,
1164 struct obstack
*obstack
,
1165 struct dwarf2_cu
*cu
, LONGEST
*value
,
1167 struct dwarf2_locexpr_baton
**baton
);
1169 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1171 static int need_gnat_info (struct dwarf2_cu
*);
1173 static struct type
*die_descriptive_type (struct die_info
*,
1174 struct dwarf2_cu
*);
1176 static void set_descriptive_type (struct type
*, struct die_info
*,
1177 struct dwarf2_cu
*);
1179 static struct type
*die_containing_type (struct die_info
*,
1180 struct dwarf2_cu
*);
1182 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1183 struct dwarf2_cu
*);
1185 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1187 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1189 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1191 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1192 const char *suffix
, int physname
,
1193 struct dwarf2_cu
*cu
);
1195 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1197 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1199 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1201 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1203 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1205 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1206 struct dwarf2_cu
*, struct partial_symtab
*);
1208 static int dwarf2_get_pc_bounds (struct die_info
*,
1209 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1210 struct partial_symtab
*);
1212 static void get_scope_pc_bounds (struct die_info
*,
1213 CORE_ADDR
*, CORE_ADDR
*,
1214 struct dwarf2_cu
*);
1216 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1217 CORE_ADDR
, struct dwarf2_cu
*);
1219 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1220 struct dwarf2_cu
*);
1222 static void dwarf2_attach_fields_to_type (struct field_info
*,
1223 struct type
*, struct dwarf2_cu
*);
1225 static void dwarf2_add_member_fn (struct field_info
*,
1226 struct die_info
*, struct type
*,
1227 struct dwarf2_cu
*);
1229 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1231 struct dwarf2_cu
*);
1233 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1235 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1237 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1239 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1241 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1243 static struct type
*read_module_type (struct die_info
*die
,
1244 struct dwarf2_cu
*cu
);
1246 static const char *namespace_name (struct die_info
*die
,
1247 int *is_anonymous
, struct dwarf2_cu
*);
1249 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1251 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1253 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1254 struct dwarf2_cu
*);
1256 static struct die_info
*read_die_and_children (const struct die_reader_specs
*,
1258 gdb_byte
**new_info_ptr
,
1259 struct die_info
*parent
);
1261 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1263 gdb_byte
**new_info_ptr
,
1264 struct die_info
*parent
);
1266 static gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1267 struct die_info
**, gdb_byte
*, int *, int);
1269 static gdb_byte
*read_full_die (const struct die_reader_specs
*,
1270 struct die_info
**, gdb_byte
*, int *);
1272 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1274 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1277 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1279 static const char *dwarf2_full_name (char *name
,
1280 struct die_info
*die
,
1281 struct dwarf2_cu
*cu
);
1283 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1284 struct dwarf2_cu
**);
1286 static const char *dwarf_tag_name (unsigned int);
1288 static const char *dwarf_attr_name (unsigned int);
1290 static const char *dwarf_form_name (unsigned int);
1292 static char *dwarf_bool_name (unsigned int);
1294 static const char *dwarf_type_encoding_name (unsigned int);
1296 static struct die_info
*sibling_die (struct die_info
*);
1298 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1300 static void dump_die_for_error (struct die_info
*);
1302 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1305 /*static*/ void dump_die (struct die_info
*, int max_level
);
1307 static void store_in_ref_table (struct die_info
*,
1308 struct dwarf2_cu
*);
1310 static int is_ref_attr (struct attribute
*);
1312 static sect_offset
dwarf2_get_ref_die_offset (struct attribute
*);
1314 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1316 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1318 struct dwarf2_cu
**);
1320 static struct die_info
*follow_die_ref (struct die_info
*,
1322 struct dwarf2_cu
**);
1324 static struct die_info
*follow_die_sig (struct die_info
*,
1326 struct dwarf2_cu
**);
1328 static struct signatured_type
*lookup_signatured_type_at_offset
1329 (struct objfile
*objfile
,
1330 struct dwarf2_section_info
*section
, sect_offset offset
);
1332 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1334 static void read_signatured_type (struct signatured_type
*);
1336 /* memory allocation interface */
1338 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1340 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1342 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1344 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1345 char *, bfd
*, struct dwarf2_cu
*,
1346 struct dwarf2_section_info
*,
1349 static int attr_form_is_block (struct attribute
*);
1351 static int attr_form_is_section_offset (struct attribute
*);
1353 static int attr_form_is_constant (struct attribute
*);
1355 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1356 struct dwarf2_loclist_baton
*baton
,
1357 struct attribute
*attr
);
1359 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1361 struct dwarf2_cu
*cu
);
1363 static gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1365 struct abbrev_info
*abbrev
);
1367 static void free_stack_comp_unit (void *);
1369 static hashval_t
partial_die_hash (const void *item
);
1371 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1373 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1374 (sect_offset offset
, struct objfile
*objfile
);
1376 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1377 struct dwarf2_per_cu_data
*per_cu
);
1379 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1380 struct die_info
*comp_unit_die
,
1381 enum language pretend_language
);
1383 static void free_heap_comp_unit (void *);
1385 static void free_cached_comp_units (void *);
1387 static void age_cached_comp_units (void);
1389 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1391 static struct type
*set_die_type (struct die_info
*, struct type
*,
1392 struct dwarf2_cu
*);
1394 static void create_all_comp_units (struct objfile
*);
1396 static int create_all_type_units (struct objfile
*);
1398 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1401 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1404 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1405 struct dwarf2_per_cu_data
*);
1407 static void dwarf2_mark (struct dwarf2_cu
*);
1409 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1411 static struct type
*get_die_type_at_offset (sect_offset
,
1412 struct dwarf2_per_cu_data
*per_cu
);
1414 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1416 static void dwarf2_release_queue (void *dummy
);
1418 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1419 enum language pretend_language
);
1421 static int maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
1422 struct dwarf2_per_cu_data
*per_cu
,
1423 enum language pretend_language
);
1425 static void process_queue (void);
1427 static void find_file_and_directory (struct die_info
*die
,
1428 struct dwarf2_cu
*cu
,
1429 char **name
, char **comp_dir
);
1431 static char *file_full_name (int file
, struct line_header
*lh
,
1432 const char *comp_dir
);
1434 static gdb_byte
*read_and_check_comp_unit_head
1435 (struct comp_unit_head
*header
,
1436 struct dwarf2_section_info
*section
, gdb_byte
*info_ptr
,
1437 int is_debug_types_section
);
1439 static void init_cutu_and_read_dies
1440 (struct dwarf2_per_cu_data
*this_cu
, int use_existing_cu
, int keep
,
1441 die_reader_func_ftype
*die_reader_func
, void *data
);
1443 static void init_cutu_and_read_dies_simple
1444 (struct dwarf2_per_cu_data
*this_cu
,
1445 die_reader_func_ftype
*die_reader_func
, void *data
);
1447 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1449 static void process_psymtab_comp_unit (struct dwarf2_per_cu_data
*, int);
1451 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1453 static struct dwo_unit
*lookup_dwo_comp_unit
1454 (struct dwarf2_per_cu_data
*, char *, const char *, ULONGEST
);
1456 static struct dwo_unit
*lookup_dwo_type_unit
1457 (struct signatured_type
*, char *, const char *);
1459 static void free_dwo_file_cleanup (void *);
1461 static void munmap_section_buffer (struct dwarf2_section_info
*);
1463 static void process_cu_includes (void);
1467 /* Convert VALUE between big- and little-endian. */
1469 byte_swap (offset_type value
)
1473 result
= (value
& 0xff) << 24;
1474 result
|= (value
& 0xff00) << 8;
1475 result
|= (value
& 0xff0000) >> 8;
1476 result
|= (value
& 0xff000000) >> 24;
1480 #define MAYBE_SWAP(V) byte_swap (V)
1483 #define MAYBE_SWAP(V) (V)
1484 #endif /* WORDS_BIGENDIAN */
1486 /* The suffix for an index file. */
1487 #define INDEX_SUFFIX ".gdb-index"
1489 static const char *dwarf2_physname (char *name
, struct die_info
*die
,
1490 struct dwarf2_cu
*cu
);
1492 /* Try to locate the sections we need for DWARF 2 debugging
1493 information and return true if we have enough to do something.
1494 NAMES points to the dwarf2 section names, or is NULL if the standard
1495 ELF names are used. */
1498 dwarf2_has_info (struct objfile
*objfile
,
1499 const struct dwarf2_debug_sections
*names
)
1501 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1502 if (!dwarf2_per_objfile
)
1504 /* Initialize per-objfile state. */
1505 struct dwarf2_per_objfile
*data
1506 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1508 memset (data
, 0, sizeof (*data
));
1509 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1510 dwarf2_per_objfile
= data
;
1512 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
1514 dwarf2_per_objfile
->objfile
= objfile
;
1516 return (dwarf2_per_objfile
->info
.asection
!= NULL
1517 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1520 /* When loading sections, we look either for uncompressed section or for
1521 compressed section names. */
1524 section_is_p (const char *section_name
,
1525 const struct dwarf2_section_names
*names
)
1527 if (names
->normal
!= NULL
1528 && strcmp (section_name
, names
->normal
) == 0)
1530 if (names
->compressed
!= NULL
1531 && strcmp (section_name
, names
->compressed
) == 0)
1536 /* This function is mapped across the sections and remembers the
1537 offset and size of each of the debugging sections we are interested
1541 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
1543 const struct dwarf2_debug_sections
*names
;
1546 names
= &dwarf2_elf_names
;
1548 names
= (const struct dwarf2_debug_sections
*) vnames
;
1550 if (section_is_p (sectp
->name
, &names
->info
))
1552 dwarf2_per_objfile
->info
.asection
= sectp
;
1553 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1555 else if (section_is_p (sectp
->name
, &names
->abbrev
))
1557 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1558 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1560 else if (section_is_p (sectp
->name
, &names
->line
))
1562 dwarf2_per_objfile
->line
.asection
= sectp
;
1563 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1565 else if (section_is_p (sectp
->name
, &names
->loc
))
1567 dwarf2_per_objfile
->loc
.asection
= sectp
;
1568 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1570 else if (section_is_p (sectp
->name
, &names
->macinfo
))
1572 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1573 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1575 else if (section_is_p (sectp
->name
, &names
->macro
))
1577 dwarf2_per_objfile
->macro
.asection
= sectp
;
1578 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
1580 else if (section_is_p (sectp
->name
, &names
->str
))
1582 dwarf2_per_objfile
->str
.asection
= sectp
;
1583 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1585 else if (section_is_p (sectp
->name
, &names
->addr
))
1587 dwarf2_per_objfile
->addr
.asection
= sectp
;
1588 dwarf2_per_objfile
->addr
.size
= bfd_get_section_size (sectp
);
1590 else if (section_is_p (sectp
->name
, &names
->frame
))
1592 dwarf2_per_objfile
->frame
.asection
= sectp
;
1593 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1595 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
1597 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
1599 if (aflag
& SEC_HAS_CONTENTS
)
1601 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1602 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1605 else if (section_is_p (sectp
->name
, &names
->ranges
))
1607 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1608 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1610 else if (section_is_p (sectp
->name
, &names
->types
))
1612 struct dwarf2_section_info type_section
;
1614 memset (&type_section
, 0, sizeof (type_section
));
1615 type_section
.asection
= sectp
;
1616 type_section
.size
= bfd_get_section_size (sectp
);
1618 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
1621 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
1623 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1624 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1627 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1628 && bfd_section_vma (abfd
, sectp
) == 0)
1629 dwarf2_per_objfile
->has_section_at_zero
= 1;
1632 /* Decompress a section that was compressed using zlib. Store the
1633 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1636 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1637 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1639 bfd
*abfd
= sectp
->owner
;
1641 error (_("Support for zlib-compressed DWARF data (from '%s') "
1642 "is disabled in this copy of GDB"),
1643 bfd_get_filename (abfd
));
1645 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1646 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1647 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1648 bfd_size_type uncompressed_size
;
1649 gdb_byte
*uncompressed_buffer
;
1652 int header_size
= 12;
1654 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1655 || bfd_bread (compressed_buffer
,
1656 compressed_size
, abfd
) != compressed_size
)
1657 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1658 bfd_get_filename (abfd
));
1660 /* Read the zlib header. In this case, it should be "ZLIB" followed
1661 by the uncompressed section size, 8 bytes in big-endian order. */
1662 if (compressed_size
< header_size
1663 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1664 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1665 bfd_get_filename (abfd
));
1666 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1667 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1668 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1669 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1670 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1671 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1672 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1673 uncompressed_size
+= compressed_buffer
[11];
1675 /* It is possible the section consists of several compressed
1676 buffers concatenated together, so we uncompress in a loop. */
1680 strm
.avail_in
= compressed_size
- header_size
;
1681 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1682 strm
.avail_out
= uncompressed_size
;
1683 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1685 rc
= inflateInit (&strm
);
1686 while (strm
.avail_in
> 0)
1689 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1690 bfd_get_filename (abfd
), rc
);
1691 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1692 + (uncompressed_size
- strm
.avail_out
));
1693 rc
= inflate (&strm
, Z_FINISH
);
1694 if (rc
!= Z_STREAM_END
)
1695 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1696 bfd_get_filename (abfd
), rc
);
1697 rc
= inflateReset (&strm
);
1699 rc
= inflateEnd (&strm
);
1701 || strm
.avail_out
!= 0)
1702 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1703 bfd_get_filename (abfd
), rc
);
1705 do_cleanups (cleanup
);
1706 *outbuf
= uncompressed_buffer
;
1707 *outsize
= uncompressed_size
;
1711 /* A helper function that decides whether a section is empty,
1715 dwarf2_section_empty_p (struct dwarf2_section_info
*info
)
1717 return info
->asection
== NULL
|| info
->size
== 0;
1720 /* Read the contents of the section INFO.
1721 OBJFILE is the main object file, but not necessarily the file where
1722 the section comes from. E.g., for DWO files INFO->asection->owner
1723 is the bfd of the DWO file.
1724 If the section is compressed, uncompress it before returning. */
1727 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1729 asection
*sectp
= info
->asection
;
1731 gdb_byte
*buf
, *retbuf
;
1732 unsigned char header
[4];
1736 info
->buffer
= NULL
;
1737 info
->map_addr
= NULL
;
1740 if (dwarf2_section_empty_p (info
))
1743 /* Note that ABFD may not be from OBJFILE, e.g. a DWO section. */
1744 abfd
= sectp
->owner
;
1746 /* Check if the file has a 4-byte header indicating compression. */
1747 if (info
->size
> sizeof (header
)
1748 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1749 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1751 /* Upon decompression, update the buffer and its size. */
1752 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1754 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1762 pagesize
= getpagesize ();
1764 /* Only try to mmap sections which are large enough: we don't want to
1765 waste space due to fragmentation. Also, only try mmap for sections
1766 without relocations. */
1768 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1770 info
->buffer
= bfd_mmap (abfd
, 0, info
->size
, PROT_READ
,
1771 MAP_PRIVATE
, sectp
->filepos
,
1772 &info
->map_addr
, &info
->map_len
);
1774 if ((caddr_t
)info
->buffer
!= MAP_FAILED
)
1776 #if HAVE_POSIX_MADVISE
1777 posix_madvise (info
->map_addr
, info
->map_len
, POSIX_MADV_WILLNEED
);
1784 /* If we get here, we are a normal, not-compressed section. */
1786 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1788 /* When debugging .o files, we may need to apply relocations; see
1789 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1790 We never compress sections in .o files, so we only need to
1791 try this when the section is not compressed. */
1792 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1795 info
->buffer
= retbuf
;
1799 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1800 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1801 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1802 bfd_get_filename (abfd
));
1805 /* A helper function that returns the size of a section in a safe way.
1806 If you are positive that the section has been read before using the
1807 size, then it is safe to refer to the dwarf2_section_info object's
1808 "size" field directly. In other cases, you must call this
1809 function, because for compressed sections the size field is not set
1810 correctly until the section has been read. */
1812 static bfd_size_type
1813 dwarf2_section_size (struct objfile
*objfile
,
1814 struct dwarf2_section_info
*info
)
1817 dwarf2_read_section (objfile
, info
);
1821 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1825 dwarf2_get_section_info (struct objfile
*objfile
,
1826 enum dwarf2_section_enum sect
,
1827 asection
**sectp
, gdb_byte
**bufp
,
1828 bfd_size_type
*sizep
)
1830 struct dwarf2_per_objfile
*data
1831 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1832 struct dwarf2_section_info
*info
;
1834 /* We may see an objfile without any DWARF, in which case we just
1845 case DWARF2_DEBUG_FRAME
:
1846 info
= &data
->frame
;
1848 case DWARF2_EH_FRAME
:
1849 info
= &data
->eh_frame
;
1852 gdb_assert_not_reached ("unexpected section");
1855 dwarf2_read_section (objfile
, info
);
1857 *sectp
= info
->asection
;
1858 *bufp
= info
->buffer
;
1859 *sizep
= info
->size
;
1863 /* DWARF quick_symbols_functions support. */
1865 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1866 unique line tables, so we maintain a separate table of all .debug_line
1867 derived entries to support the sharing.
1868 All the quick functions need is the list of file names. We discard the
1869 line_header when we're done and don't need to record it here. */
1870 struct quick_file_names
1872 /* The offset in .debug_line of the line table. We hash on this. */
1873 unsigned int offset
;
1875 /* The number of entries in file_names, real_names. */
1876 unsigned int num_file_names
;
1878 /* The file names from the line table, after being run through
1880 const char **file_names
;
1882 /* The file names from the line table after being run through
1883 gdb_realpath. These are computed lazily. */
1884 const char **real_names
;
1887 /* When using the index (and thus not using psymtabs), each CU has an
1888 object of this type. This is used to hold information needed by
1889 the various "quick" methods. */
1890 struct dwarf2_per_cu_quick_data
1892 /* The file table. This can be NULL if there was no file table
1893 or it's currently not read in.
1894 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1895 struct quick_file_names
*file_names
;
1897 /* The corresponding symbol table. This is NULL if symbols for this
1898 CU have not yet been read. */
1899 struct symtab
*symtab
;
1901 /* A temporary mark bit used when iterating over all CUs in
1902 expand_symtabs_matching. */
1903 unsigned int mark
: 1;
1905 /* True if we've tried to read the file table and found there isn't one.
1906 There will be no point in trying to read it again next time. */
1907 unsigned int no_file_data
: 1;
1910 /* Hash function for a quick_file_names. */
1913 hash_file_name_entry (const void *e
)
1915 const struct quick_file_names
*file_data
= e
;
1917 return file_data
->offset
;
1920 /* Equality function for a quick_file_names. */
1923 eq_file_name_entry (const void *a
, const void *b
)
1925 const struct quick_file_names
*ea
= a
;
1926 const struct quick_file_names
*eb
= b
;
1928 return ea
->offset
== eb
->offset
;
1931 /* Delete function for a quick_file_names. */
1934 delete_file_name_entry (void *e
)
1936 struct quick_file_names
*file_data
= e
;
1939 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
1941 xfree ((void*) file_data
->file_names
[i
]);
1942 if (file_data
->real_names
)
1943 xfree ((void*) file_data
->real_names
[i
]);
1946 /* The space for the struct itself lives on objfile_obstack,
1947 so we don't free it here. */
1950 /* Create a quick_file_names hash table. */
1953 create_quick_file_names_table (unsigned int nr_initial_entries
)
1955 return htab_create_alloc (nr_initial_entries
,
1956 hash_file_name_entry
, eq_file_name_entry
,
1957 delete_file_name_entry
, xcalloc
, xfree
);
1960 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
1961 have to be created afterwards. You should call age_cached_comp_units after
1962 processing PER_CU->CU. dw2_setup must have been already called. */
1965 load_cu (struct dwarf2_per_cu_data
*per_cu
)
1967 if (per_cu
->is_debug_types
)
1968 load_full_type_unit (per_cu
);
1970 load_full_comp_unit (per_cu
, language_minimal
);
1972 gdb_assert (per_cu
->cu
!= NULL
);
1974 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
1977 /* Read in the symbols for PER_CU. */
1980 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
1982 struct cleanup
*back_to
;
1984 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
1986 if (dwarf2_per_objfile
->using_index
1987 ? per_cu
->v
.quick
->symtab
== NULL
1988 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
1990 queue_comp_unit (per_cu
, language_minimal
);
1996 /* Age the cache, releasing compilation units that have not
1997 been used recently. */
1998 age_cached_comp_units ();
2000 do_cleanups (back_to
);
2003 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2004 the objfile from which this CU came. Returns the resulting symbol
2007 static struct symtab
*
2008 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2010 gdb_assert (dwarf2_per_objfile
->using_index
);
2011 if (!per_cu
->v
.quick
->symtab
)
2013 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2014 increment_reading_symtab ();
2015 dw2_do_instantiate_symtab (per_cu
);
2016 process_cu_includes ();
2017 do_cleanups (back_to
);
2019 return per_cu
->v
.quick
->symtab
;
2022 /* Return the CU given its index. */
2024 static struct dwarf2_per_cu_data
*
2025 dw2_get_cu (int index
)
2027 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2029 index
-= dwarf2_per_objfile
->n_comp_units
;
2030 return dwarf2_per_objfile
->all_type_units
[index
];
2032 return dwarf2_per_objfile
->all_comp_units
[index
];
2035 /* A helper function that knows how to read a 64-bit value in a way
2036 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
2040 extract_cu_value (const char *bytes
, ULONGEST
*result
)
2042 if (sizeof (ULONGEST
) < 8)
2046 /* Ignore the upper 4 bytes if they are all zero. */
2047 for (i
= 0; i
< 4; ++i
)
2048 if (bytes
[i
+ 4] != 0)
2051 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
2054 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2058 /* Read the CU list from the mapped index, and use it to create all
2059 the CU objects for this objfile. Return 0 if something went wrong,
2060 1 if everything went ok. */
2063 create_cus_from_index (struct objfile
*objfile
, const gdb_byte
*cu_list
,
2064 offset_type cu_list_elements
)
2068 dwarf2_per_objfile
->n_comp_units
= cu_list_elements
/ 2;
2069 dwarf2_per_objfile
->all_comp_units
2070 = obstack_alloc (&objfile
->objfile_obstack
,
2071 dwarf2_per_objfile
->n_comp_units
2072 * sizeof (struct dwarf2_per_cu_data
*));
2074 for (i
= 0; i
< cu_list_elements
; i
+= 2)
2076 struct dwarf2_per_cu_data
*the_cu
;
2077 ULONGEST offset
, length
;
2079 if (!extract_cu_value (cu_list
, &offset
)
2080 || !extract_cu_value (cu_list
+ 8, &length
))
2084 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2085 struct dwarf2_per_cu_data
);
2086 the_cu
->offset
.sect_off
= offset
;
2087 the_cu
->length
= length
;
2088 the_cu
->objfile
= objfile
;
2089 the_cu
->info_or_types_section
= &dwarf2_per_objfile
->info
;
2090 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2091 struct dwarf2_per_cu_quick_data
);
2092 dwarf2_per_objfile
->all_comp_units
[i
/ 2] = the_cu
;
2098 /* Create the signatured type hash table from the index. */
2101 create_signatured_type_table_from_index (struct objfile
*objfile
,
2102 struct dwarf2_section_info
*section
,
2103 const gdb_byte
*bytes
,
2104 offset_type elements
)
2107 htab_t sig_types_hash
;
2109 dwarf2_per_objfile
->n_type_units
= elements
/ 3;
2110 dwarf2_per_objfile
->all_type_units
2111 = obstack_alloc (&objfile
->objfile_obstack
,
2112 dwarf2_per_objfile
->n_type_units
2113 * sizeof (struct dwarf2_per_cu_data
*));
2115 sig_types_hash
= allocate_signatured_type_table (objfile
);
2117 for (i
= 0; i
< elements
; i
+= 3)
2119 struct signatured_type
*sig_type
;
2120 ULONGEST offset
, type_offset_in_tu
, signature
;
2123 if (!extract_cu_value (bytes
, &offset
)
2124 || !extract_cu_value (bytes
+ 8, &type_offset_in_tu
))
2126 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2129 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2130 struct signatured_type
);
2131 sig_type
->signature
= signature
;
2132 sig_type
->type_offset_in_tu
.cu_off
= type_offset_in_tu
;
2133 sig_type
->per_cu
.is_debug_types
= 1;
2134 sig_type
->per_cu
.info_or_types_section
= section
;
2135 sig_type
->per_cu
.offset
.sect_off
= offset
;
2136 sig_type
->per_cu
.objfile
= objfile
;
2137 sig_type
->per_cu
.v
.quick
2138 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2139 struct dwarf2_per_cu_quick_data
);
2141 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
2144 dwarf2_per_objfile
->all_type_units
[i
/ 3] = &sig_type
->per_cu
;
2147 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2152 /* Read the address map data from the mapped index, and use it to
2153 populate the objfile's psymtabs_addrmap. */
2156 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2158 const gdb_byte
*iter
, *end
;
2159 struct obstack temp_obstack
;
2160 struct addrmap
*mutable_map
;
2161 struct cleanup
*cleanup
;
2164 obstack_init (&temp_obstack
);
2165 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2166 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2168 iter
= index
->address_table
;
2169 end
= iter
+ index
->address_table_size
;
2171 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2175 ULONGEST hi
, lo
, cu_index
;
2176 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2178 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2180 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2183 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
2184 dw2_get_cu (cu_index
));
2187 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2188 &objfile
->objfile_obstack
);
2189 do_cleanups (cleanup
);
2192 /* The hash function for strings in the mapped index. This is the same as
2193 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2194 implementation. This is necessary because the hash function is tied to the
2195 format of the mapped index file. The hash values do not have to match with
2198 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2201 mapped_index_string_hash (int index_version
, const void *p
)
2203 const unsigned char *str
= (const unsigned char *) p
;
2207 while ((c
= *str
++) != 0)
2209 if (index_version
>= 5)
2211 r
= r
* 67 + c
- 113;
2217 /* Find a slot in the mapped index INDEX for the object named NAME.
2218 If NAME is found, set *VEC_OUT to point to the CU vector in the
2219 constant pool and return 1. If NAME cannot be found, return 0. */
2222 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2223 offset_type
**vec_out
)
2225 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2227 offset_type slot
, step
;
2228 int (*cmp
) (const char *, const char *);
2230 if (current_language
->la_language
== language_cplus
2231 || current_language
->la_language
== language_java
2232 || current_language
->la_language
== language_fortran
)
2234 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2236 const char *paren
= strchr (name
, '(');
2242 dup
= xmalloc (paren
- name
+ 1);
2243 memcpy (dup
, name
, paren
- name
);
2244 dup
[paren
- name
] = 0;
2246 make_cleanup (xfree
, dup
);
2251 /* Index version 4 did not support case insensitive searches. But the
2252 indices for case insensitive languages are built in lowercase, therefore
2253 simulate our NAME being searched is also lowercased. */
2254 hash
= mapped_index_string_hash ((index
->version
== 4
2255 && case_sensitivity
== case_sensitive_off
2256 ? 5 : index
->version
),
2259 slot
= hash
& (index
->symbol_table_slots
- 1);
2260 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2261 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2265 /* Convert a slot number to an offset into the table. */
2266 offset_type i
= 2 * slot
;
2268 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2270 do_cleanups (back_to
);
2274 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2275 if (!cmp (name
, str
))
2277 *vec_out
= (offset_type
*) (index
->constant_pool
2278 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2279 do_cleanups (back_to
);
2283 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2287 /* Read the index file. If everything went ok, initialize the "quick"
2288 elements of all the CUs and return 1. Otherwise, return 0. */
2291 dwarf2_read_index (struct objfile
*objfile
)
2294 struct mapped_index
*map
;
2295 offset_type
*metadata
;
2296 const gdb_byte
*cu_list
;
2297 const gdb_byte
*types_list
= NULL
;
2298 offset_type version
, cu_list_elements
;
2299 offset_type types_list_elements
= 0;
2302 if (dwarf2_section_empty_p (&dwarf2_per_objfile
->gdb_index
))
2305 /* Older elfutils strip versions could keep the section in the main
2306 executable while splitting it for the separate debug info file. */
2307 if ((bfd_get_file_flags (dwarf2_per_objfile
->gdb_index
.asection
)
2308 & SEC_HAS_CONTENTS
) == 0)
2311 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->gdb_index
);
2313 addr
= dwarf2_per_objfile
->gdb_index
.buffer
;
2314 /* Version check. */
2315 version
= MAYBE_SWAP (*(offset_type
*) addr
);
2316 /* Versions earlier than 3 emitted every copy of a psymbol. This
2317 causes the index to behave very poorly for certain requests. Version 3
2318 contained incomplete addrmap. So, it seems better to just ignore such
2322 static int warning_printed
= 0;
2323 if (!warning_printed
)
2325 warning (_("Skipping obsolete .gdb_index section in %s."),
2327 warning_printed
= 1;
2331 /* Index version 4 uses a different hash function than index version
2334 Versions earlier than 6 did not emit psymbols for inlined
2335 functions. Using these files will cause GDB not to be able to
2336 set breakpoints on inlined functions by name, so we ignore these
2337 indices unless the --use-deprecated-index-sections command line
2338 option was supplied. */
2339 if (version
< 6 && !use_deprecated_index_sections
)
2341 static int warning_printed
= 0;
2342 if (!warning_printed
)
2344 warning (_("Skipping deprecated .gdb_index section in %s, pass "
2345 "--use-deprecated-index-sections to use them anyway"),
2347 warning_printed
= 1;
2351 /* Indexes with higher version than the one supported by GDB may be no
2352 longer backward compatible. */
2356 map
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct mapped_index
);
2357 map
->version
= version
;
2358 map
->total_size
= dwarf2_per_objfile
->gdb_index
.size
;
2360 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2363 cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2364 cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2368 types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2369 types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2370 - MAYBE_SWAP (metadata
[i
]))
2374 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2375 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
2376 - MAYBE_SWAP (metadata
[i
]));
2379 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
2380 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
2381 - MAYBE_SWAP (metadata
[i
]))
2382 / (2 * sizeof (offset_type
)));
2385 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
2387 /* Don't use the index if it's empty. */
2388 if (map
->symbol_table_slots
== 0)
2391 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
))
2394 if (types_list_elements
)
2396 struct dwarf2_section_info
*section
;
2398 /* We can only handle a single .debug_types when we have an
2400 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
2403 section
= VEC_index (dwarf2_section_info_def
,
2404 dwarf2_per_objfile
->types
, 0);
2406 if (!create_signatured_type_table_from_index (objfile
, section
,
2408 types_list_elements
))
2412 create_addrmap_from_index (objfile
, map
);
2414 dwarf2_per_objfile
->index_table
= map
;
2415 dwarf2_per_objfile
->using_index
= 1;
2416 dwarf2_per_objfile
->quick_file_names_table
=
2417 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2422 /* A helper for the "quick" functions which sets the global
2423 dwarf2_per_objfile according to OBJFILE. */
2426 dw2_setup (struct objfile
*objfile
)
2428 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2429 gdb_assert (dwarf2_per_objfile
);
2432 /* die_reader_func for dw2_get_file_names. */
2435 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
2437 struct die_info
*comp_unit_die
,
2441 struct dwarf2_cu
*cu
= reader
->cu
;
2442 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
2443 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2444 struct line_header
*lh
;
2445 struct attribute
*attr
;
2447 char *name
, *comp_dir
;
2449 struct quick_file_names
*qfn
;
2450 unsigned int line_offset
;
2456 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
2459 struct quick_file_names find_entry
;
2461 line_offset
= DW_UNSND (attr
);
2463 /* We may have already read in this line header (TU line header sharing).
2464 If we have we're done. */
2465 find_entry
.offset
= line_offset
;
2466 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
2467 &find_entry
, INSERT
);
2470 this_cu
->v
.quick
->file_names
= *slot
;
2474 lh
= dwarf_decode_line_header (line_offset
, cu
);
2478 this_cu
->v
.quick
->no_file_data
= 1;
2482 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
2483 qfn
->offset
= line_offset
;
2484 gdb_assert (slot
!= NULL
);
2487 find_file_and_directory (comp_unit_die
, cu
, &name
, &comp_dir
);
2489 qfn
->num_file_names
= lh
->num_file_names
;
2490 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
2491 lh
->num_file_names
* sizeof (char *));
2492 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2493 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2494 qfn
->real_names
= NULL
;
2496 free_line_header (lh
);
2498 this_cu
->v
.quick
->file_names
= qfn
;
2501 /* A helper for the "quick" functions which attempts to read the line
2502 table for THIS_CU. */
2504 static struct quick_file_names
*
2505 dw2_get_file_names (struct objfile
*objfile
,
2506 struct dwarf2_per_cu_data
*this_cu
)
2508 if (this_cu
->v
.quick
->file_names
!= NULL
)
2509 return this_cu
->v
.quick
->file_names
;
2510 /* If we know there is no line data, no point in looking again. */
2511 if (this_cu
->v
.quick
->no_file_data
)
2514 /* If DWO files are in use, we can still find the DW_AT_stmt_list attribute
2515 in the stub for CUs, there's is no need to lookup the DWO file.
2516 However, that's not the case for TUs where DW_AT_stmt_list lives in the
2518 if (this_cu
->is_debug_types
)
2519 init_cutu_and_read_dies (this_cu
, 0, 0, dw2_get_file_names_reader
, NULL
);
2521 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
2523 if (this_cu
->v
.quick
->no_file_data
)
2525 return this_cu
->v
.quick
->file_names
;
2528 /* A helper for the "quick" functions which computes and caches the
2529 real path for a given file name from the line table. */
2532 dw2_get_real_path (struct objfile
*objfile
,
2533 struct quick_file_names
*qfn
, int index
)
2535 if (qfn
->real_names
== NULL
)
2536 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2537 qfn
->num_file_names
, sizeof (char *));
2539 if (qfn
->real_names
[index
] == NULL
)
2540 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
2542 return qfn
->real_names
[index
];
2545 static struct symtab
*
2546 dw2_find_last_source_symtab (struct objfile
*objfile
)
2550 dw2_setup (objfile
);
2551 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2552 return dw2_instantiate_symtab (dw2_get_cu (index
));
2555 /* Traversal function for dw2_forget_cached_source_info. */
2558 dw2_free_cached_file_names (void **slot
, void *info
)
2560 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
2562 if (file_data
->real_names
)
2566 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2568 xfree ((void*) file_data
->real_names
[i
]);
2569 file_data
->real_names
[i
] = NULL
;
2577 dw2_forget_cached_source_info (struct objfile
*objfile
)
2579 dw2_setup (objfile
);
2581 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
2582 dw2_free_cached_file_names
, NULL
);
2585 /* Helper function for dw2_map_symtabs_matching_filename that expands
2586 the symtabs and calls the iterator. */
2589 dw2_map_expand_apply (struct objfile
*objfile
,
2590 struct dwarf2_per_cu_data
*per_cu
,
2592 const char *full_path
, const char *real_path
,
2593 int (*callback
) (struct symtab
*, void *),
2596 struct symtab
*last_made
= objfile
->symtabs
;
2598 /* Don't visit already-expanded CUs. */
2599 if (per_cu
->v
.quick
->symtab
)
2602 /* This may expand more than one symtab, and we want to iterate over
2604 dw2_instantiate_symtab (per_cu
);
2606 return iterate_over_some_symtabs (name
, full_path
, real_path
, callback
, data
,
2607 objfile
->symtabs
, last_made
);
2610 /* Implementation of the map_symtabs_matching_filename method. */
2613 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
2614 const char *full_path
, const char *real_path
,
2615 int (*callback
) (struct symtab
*, void *),
2619 const char *name_basename
= lbasename (name
);
2620 int name_len
= strlen (name
);
2621 int is_abs
= IS_ABSOLUTE_PATH (name
);
2623 dw2_setup (objfile
);
2625 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2626 + dwarf2_per_objfile
->n_type_units
); ++i
)
2629 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2630 struct quick_file_names
*file_data
;
2632 /* We only need to look at symtabs not already expanded. */
2633 if (per_cu
->v
.quick
->symtab
)
2636 file_data
= dw2_get_file_names (objfile
, per_cu
);
2637 if (file_data
== NULL
)
2640 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2642 const char *this_name
= file_data
->file_names
[j
];
2644 if (FILENAME_CMP (name
, this_name
) == 0
2645 || (!is_abs
&& compare_filenames_for_search (this_name
,
2648 if (dw2_map_expand_apply (objfile
, per_cu
,
2649 name
, full_path
, real_path
,
2654 /* Before we invoke realpath, which can get expensive when many
2655 files are involved, do a quick comparison of the basenames. */
2656 if (! basenames_may_differ
2657 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
2660 if (full_path
!= NULL
)
2662 const char *this_real_name
= dw2_get_real_path (objfile
,
2665 if (this_real_name
!= NULL
2666 && (FILENAME_CMP (full_path
, this_real_name
) == 0
2668 && compare_filenames_for_search (this_real_name
,
2671 if (dw2_map_expand_apply (objfile
, per_cu
,
2672 name
, full_path
, real_path
,
2678 if (real_path
!= NULL
)
2680 const char *this_real_name
= dw2_get_real_path (objfile
,
2683 if (this_real_name
!= NULL
2684 && (FILENAME_CMP (real_path
, this_real_name
) == 0
2686 && compare_filenames_for_search (this_real_name
,
2689 if (dw2_map_expand_apply (objfile
, per_cu
,
2690 name
, full_path
, real_path
,
2701 static struct symtab
*
2702 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
2703 const char *name
, domain_enum domain
)
2705 /* We do all the work in the pre_expand_symtabs_matching hook
2710 /* A helper function that expands all symtabs that hold an object
2714 dw2_do_expand_symtabs_matching (struct objfile
*objfile
, const char *name
)
2716 dw2_setup (objfile
);
2718 /* index_table is NULL if OBJF_READNOW. */
2719 if (dwarf2_per_objfile
->index_table
)
2723 if (find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2726 offset_type i
, len
= MAYBE_SWAP (*vec
);
2727 for (i
= 0; i
< len
; ++i
)
2729 offset_type cu_index
= MAYBE_SWAP (vec
[i
+ 1]);
2730 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (cu_index
);
2732 dw2_instantiate_symtab (per_cu
);
2739 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
2740 enum block_enum block_kind
, const char *name
,
2743 dw2_do_expand_symtabs_matching (objfile
, name
);
2747 dw2_print_stats (struct objfile
*objfile
)
2751 dw2_setup (objfile
);
2753 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2754 + dwarf2_per_objfile
->n_type_units
); ++i
)
2756 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2758 if (!per_cu
->v
.quick
->symtab
)
2761 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
2765 dw2_dump (struct objfile
*objfile
)
2767 /* Nothing worth printing. */
2771 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
2772 struct section_offsets
*delta
)
2774 /* There's nothing to relocate here. */
2778 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
2779 const char *func_name
)
2781 dw2_do_expand_symtabs_matching (objfile
, func_name
);
2785 dw2_expand_all_symtabs (struct objfile
*objfile
)
2789 dw2_setup (objfile
);
2791 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2792 + dwarf2_per_objfile
->n_type_units
); ++i
)
2794 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2796 dw2_instantiate_symtab (per_cu
);
2801 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
2802 const char *filename
)
2806 dw2_setup (objfile
);
2808 /* We don't need to consider type units here.
2809 This is only called for examining code, e.g. expand_line_sal.
2810 There can be an order of magnitude (or more) more type units
2811 than comp units, and we avoid them if we can. */
2813 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
2816 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2817 struct quick_file_names
*file_data
;
2819 /* We only need to look at symtabs not already expanded. */
2820 if (per_cu
->v
.quick
->symtab
)
2823 file_data
= dw2_get_file_names (objfile
, per_cu
);
2824 if (file_data
== NULL
)
2827 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2829 const char *this_name
= file_data
->file_names
[j
];
2830 if (FILENAME_CMP (this_name
, filename
) == 0)
2832 dw2_instantiate_symtab (per_cu
);
2840 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
2842 struct dwarf2_per_cu_data
*per_cu
;
2844 struct quick_file_names
*file_data
;
2846 dw2_setup (objfile
);
2848 /* index_table is NULL if OBJF_READNOW. */
2849 if (!dwarf2_per_objfile
->index_table
)
2853 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, s
)
2855 struct blockvector
*bv
= BLOCKVECTOR (s
);
2856 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2857 struct symbol
*sym
= lookup_block_symbol (block
, name
, VAR_DOMAIN
);
2860 return sym
->symtab
->filename
;
2865 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2869 /* Note that this just looks at the very first one named NAME -- but
2870 actually we are looking for a function. find_main_filename
2871 should be rewritten so that it doesn't require a custom hook. It
2872 could just use the ordinary symbol tables. */
2873 /* vec[0] is the length, which must always be >0. */
2874 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[1]));
2876 file_data
= dw2_get_file_names (objfile
, per_cu
);
2877 if (file_data
== NULL
2878 || file_data
->num_file_names
== 0)
2881 return file_data
->file_names
[file_data
->num_file_names
- 1];
2885 dw2_map_matching_symbols (const char * name
, domain_enum
namespace,
2886 struct objfile
*objfile
, int global
,
2887 int (*callback
) (struct block
*,
2888 struct symbol
*, void *),
2889 void *data
, symbol_compare_ftype
*match
,
2890 symbol_compare_ftype
*ordered_compare
)
2892 /* Currently unimplemented; used for Ada. The function can be called if the
2893 current language is Ada for a non-Ada objfile using GNU index. As Ada
2894 does not look for non-Ada symbols this function should just return. */
2898 dw2_expand_symtabs_matching
2899 (struct objfile
*objfile
,
2900 int (*file_matcher
) (const char *, void *),
2901 int (*name_matcher
) (const char *, void *),
2902 enum search_domain kind
,
2907 struct mapped_index
*index
;
2909 dw2_setup (objfile
);
2911 /* index_table is NULL if OBJF_READNOW. */
2912 if (!dwarf2_per_objfile
->index_table
)
2914 index
= dwarf2_per_objfile
->index_table
;
2916 if (file_matcher
!= NULL
)
2918 struct cleanup
*cleanup
;
2919 htab_t visited_found
, visited_not_found
;
2921 visited_found
= htab_create_alloc (10,
2922 htab_hash_pointer
, htab_eq_pointer
,
2923 NULL
, xcalloc
, xfree
);
2924 cleanup
= make_cleanup_htab_delete (visited_found
);
2925 visited_not_found
= htab_create_alloc (10,
2926 htab_hash_pointer
, htab_eq_pointer
,
2927 NULL
, xcalloc
, xfree
);
2928 make_cleanup_htab_delete (visited_not_found
);
2930 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2931 + dwarf2_per_objfile
->n_type_units
); ++i
)
2934 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2935 struct quick_file_names
*file_data
;
2938 per_cu
->v
.quick
->mark
= 0;
2940 /* We only need to look at symtabs not already expanded. */
2941 if (per_cu
->v
.quick
->symtab
)
2944 file_data
= dw2_get_file_names (objfile
, per_cu
);
2945 if (file_data
== NULL
)
2948 if (htab_find (visited_not_found
, file_data
) != NULL
)
2950 else if (htab_find (visited_found
, file_data
) != NULL
)
2952 per_cu
->v
.quick
->mark
= 1;
2956 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2958 if (file_matcher (file_data
->file_names
[j
], data
))
2960 per_cu
->v
.quick
->mark
= 1;
2965 slot
= htab_find_slot (per_cu
->v
.quick
->mark
2967 : visited_not_found
,
2972 do_cleanups (cleanup
);
2975 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
2977 offset_type idx
= 2 * iter
;
2979 offset_type
*vec
, vec_len
, vec_idx
;
2981 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
2984 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
2986 if (! (*name_matcher
) (name
, data
))
2989 /* The name was matched, now expand corresponding CUs that were
2991 vec
= (offset_type
*) (index
->constant_pool
2992 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
2993 vec_len
= MAYBE_SWAP (vec
[0]);
2994 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
2996 struct dwarf2_per_cu_data
*per_cu
;
2998 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[vec_idx
+ 1]));
2999 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
3000 dw2_instantiate_symtab (per_cu
);
3005 /* A helper for dw2_find_pc_sect_symtab which finds the most specific
3008 static struct symtab
*
3009 recursively_find_pc_sect_symtab (struct symtab
*symtab
, CORE_ADDR pc
)
3013 if (BLOCKVECTOR (symtab
) != NULL
3014 && blockvector_contains_pc (BLOCKVECTOR (symtab
), pc
))
3017 if (symtab
->includes
== NULL
)
3020 for (i
= 0; symtab
->includes
[i
]; ++i
)
3022 struct symtab
*s
= symtab
->includes
[i
];
3024 s
= recursively_find_pc_sect_symtab (s
, pc
);
3032 static struct symtab
*
3033 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
3034 struct minimal_symbol
*msymbol
,
3036 struct obj_section
*section
,
3039 struct dwarf2_per_cu_data
*data
;
3040 struct symtab
*result
;
3042 dw2_setup (objfile
);
3044 if (!objfile
->psymtabs_addrmap
)
3047 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
3051 if (warn_if_readin
&& data
->v
.quick
->symtab
)
3052 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
3053 paddress (get_objfile_arch (objfile
), pc
));
3055 result
= recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data
), pc
);
3056 gdb_assert (result
!= NULL
);
3061 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
3062 void *data
, int need_fullname
)
3065 struct cleanup
*cleanup
;
3066 htab_t visited
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
3067 NULL
, xcalloc
, xfree
);
3069 cleanup
= make_cleanup_htab_delete (visited
);
3070 dw2_setup (objfile
);
3072 /* We can ignore file names coming from already-expanded CUs. */
3073 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3074 + dwarf2_per_objfile
->n_type_units
); ++i
)
3076 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3078 if (per_cu
->v
.quick
->symtab
)
3080 void **slot
= htab_find_slot (visited
, per_cu
->v
.quick
->file_names
,
3083 *slot
= per_cu
->v
.quick
->file_names
;
3087 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3088 + dwarf2_per_objfile
->n_type_units
); ++i
)
3091 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3092 struct quick_file_names
*file_data
;
3095 /* We only need to look at symtabs not already expanded. */
3096 if (per_cu
->v
.quick
->symtab
)
3099 file_data
= dw2_get_file_names (objfile
, per_cu
);
3100 if (file_data
== NULL
)
3103 slot
= htab_find_slot (visited
, file_data
, INSERT
);
3106 /* Already visited. */
3111 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3113 const char *this_real_name
;
3116 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3118 this_real_name
= NULL
;
3119 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
3123 do_cleanups (cleanup
);
3127 dw2_has_symbols (struct objfile
*objfile
)
3132 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
3135 dw2_find_last_source_symtab
,
3136 dw2_forget_cached_source_info
,
3137 dw2_map_symtabs_matching_filename
,
3139 dw2_pre_expand_symtabs_matching
,
3143 dw2_expand_symtabs_for_function
,
3144 dw2_expand_all_symtabs
,
3145 dw2_expand_symtabs_with_filename
,
3146 dw2_find_symbol_file
,
3147 dw2_map_matching_symbols
,
3148 dw2_expand_symtabs_matching
,
3149 dw2_find_pc_sect_symtab
,
3150 dw2_map_symbol_filenames
3153 /* Initialize for reading DWARF for this objfile. Return 0 if this
3154 file will use psymtabs, or 1 if using the GNU index. */
3157 dwarf2_initialize_objfile (struct objfile
*objfile
)
3159 /* If we're about to read full symbols, don't bother with the
3160 indices. In this case we also don't care if some other debug
3161 format is making psymtabs, because they are all about to be
3163 if ((objfile
->flags
& OBJF_READNOW
))
3167 dwarf2_per_objfile
->using_index
= 1;
3168 create_all_comp_units (objfile
);
3169 create_all_type_units (objfile
);
3170 dwarf2_per_objfile
->quick_file_names_table
=
3171 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3173 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3174 + dwarf2_per_objfile
->n_type_units
); ++i
)
3176 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3178 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3179 struct dwarf2_per_cu_quick_data
);
3182 /* Return 1 so that gdb sees the "quick" functions. However,
3183 these functions will be no-ops because we will have expanded
3188 if (dwarf2_read_index (objfile
))
3196 /* Build a partial symbol table. */
3199 dwarf2_build_psymtabs (struct objfile
*objfile
)
3201 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
3203 init_psymbol_list (objfile
, 1024);
3206 dwarf2_build_psymtabs_hard (objfile
);
3209 /* Return TRUE if OFFSET is within CU_HEADER. */
3212 offset_in_cu_p (const struct comp_unit_head
*cu_header
, sect_offset offset
)
3214 sect_offset bottom
= { cu_header
->offset
.sect_off
};
3215 sect_offset top
= { (cu_header
->offset
.sect_off
+ cu_header
->length
3216 + cu_header
->initial_length_size
) };
3218 return (offset
.sect_off
>= bottom
.sect_off
&& offset
.sect_off
< top
.sect_off
);
3221 /* Read in the comp unit header information from the debug_info at info_ptr.
3222 NOTE: This leaves members offset, first_die_offset to be filled in
3226 read_comp_unit_head (struct comp_unit_head
*cu_header
,
3227 gdb_byte
*info_ptr
, bfd
*abfd
)
3230 unsigned int bytes_read
;
3232 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
3233 cu_header
->initial_length_size
= bytes_read
;
3234 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
3235 info_ptr
+= bytes_read
;
3236 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
3238 cu_header
->abbrev_offset
.sect_off
= read_offset (abfd
, info_ptr
, cu_header
,
3240 info_ptr
+= bytes_read
;
3241 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
3243 signed_addr
= bfd_get_sign_extend_vma (abfd
);
3244 if (signed_addr
< 0)
3245 internal_error (__FILE__
, __LINE__
,
3246 _("read_comp_unit_head: dwarf from non elf file"));
3247 cu_header
->signed_addr_p
= signed_addr
;
3252 /* Subroutine of read_and_check_comp_unit_head and
3253 read_and_check_type_unit_head to simplify them.
3254 Perform various error checking on the header. */
3257 error_check_comp_unit_head (struct comp_unit_head
*header
,
3258 struct dwarf2_section_info
*section
)
3260 bfd
*abfd
= section
->asection
->owner
;
3261 const char *filename
= bfd_get_filename (abfd
);
3263 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
3264 error (_("Dwarf Error: wrong version in compilation unit header "
3265 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
3268 if (header
->abbrev_offset
.sect_off
3269 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
,
3270 &dwarf2_per_objfile
->abbrev
))
3271 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
3272 "(offset 0x%lx + 6) [in module %s]"),
3273 (long) header
->abbrev_offset
.sect_off
, (long) header
->offset
.sect_off
,
3276 /* Cast to unsigned long to use 64-bit arithmetic when possible to
3277 avoid potential 32-bit overflow. */
3278 if (((unsigned long) header
->offset
.sect_off
3279 + header
->length
+ header
->initial_length_size
)
3281 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
3282 "(offset 0x%lx + 0) [in module %s]"),
3283 (long) header
->length
, (long) header
->offset
.sect_off
,
3287 /* Read in a CU/TU header and perform some basic error checking.
3288 The contents of the header are stored in HEADER.
3289 The result is a pointer to the start of the first DIE. */
3292 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
3293 struct dwarf2_section_info
*section
,
3295 int is_debug_types_section
)
3297 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3298 bfd
*abfd
= section
->asection
->owner
;
3300 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
3302 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
3304 /* If we're reading a type unit, skip over the signature and
3305 type_offset fields. */
3306 if (is_debug_types_section
)
3307 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
3309 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
3311 error_check_comp_unit_head (header
, section
);
3316 /* Read in the types comp unit header information from .debug_types entry at
3317 types_ptr. The result is a pointer to one past the end of the header. */
3320 read_and_check_type_unit_head (struct comp_unit_head
*header
,
3321 struct dwarf2_section_info
*section
,
3323 ULONGEST
*signature
,
3324 cu_offset
*type_offset_in_tu
)
3326 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3327 bfd
*abfd
= section
->asection
->owner
;
3329 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
3331 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
3333 /* If we're reading a type unit, skip over the signature and
3334 type_offset fields. */
3335 if (signature
!= NULL
)
3336 *signature
= read_8_bytes (abfd
, info_ptr
);
3338 if (type_offset_in_tu
!= NULL
)
3339 type_offset_in_tu
->cu_off
= read_offset_1 (abfd
, info_ptr
,
3340 header
->offset_size
);
3341 info_ptr
+= header
->offset_size
;
3343 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
3345 error_check_comp_unit_head (header
, section
);
3350 /* Allocate a new partial symtab for file named NAME and mark this new
3351 partial symtab as being an include of PST. */
3354 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
3355 struct objfile
*objfile
)
3357 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
3359 subpst
->section_offsets
= pst
->section_offsets
;
3360 subpst
->textlow
= 0;
3361 subpst
->texthigh
= 0;
3363 subpst
->dependencies
= (struct partial_symtab
**)
3364 obstack_alloc (&objfile
->objfile_obstack
,
3365 sizeof (struct partial_symtab
*));
3366 subpst
->dependencies
[0] = pst
;
3367 subpst
->number_of_dependencies
= 1;
3369 subpst
->globals_offset
= 0;
3370 subpst
->n_global_syms
= 0;
3371 subpst
->statics_offset
= 0;
3372 subpst
->n_static_syms
= 0;
3373 subpst
->symtab
= NULL
;
3374 subpst
->read_symtab
= pst
->read_symtab
;
3377 /* No private part is necessary for include psymtabs. This property
3378 can be used to differentiate between such include psymtabs and
3379 the regular ones. */
3380 subpst
->read_symtab_private
= NULL
;
3383 /* Read the Line Number Program data and extract the list of files
3384 included by the source file represented by PST. Build an include
3385 partial symtab for each of these included files. */
3388 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
3389 struct die_info
*die
,
3390 struct partial_symtab
*pst
)
3392 struct line_header
*lh
= NULL
;
3393 struct attribute
*attr
;
3395 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3397 lh
= dwarf_decode_line_header (DW_UNSND (attr
), cu
);
3399 return; /* No linetable, so no includes. */
3401 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3402 dwarf_decode_lines (lh
, pst
->dirname
, cu
, pst
, 1);
3404 free_line_header (lh
);
3408 hash_signatured_type (const void *item
)
3410 const struct signatured_type
*sig_type
= item
;
3412 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3413 return sig_type
->signature
;
3417 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
3419 const struct signatured_type
*lhs
= item_lhs
;
3420 const struct signatured_type
*rhs
= item_rhs
;
3422 return lhs
->signature
== rhs
->signature
;
3425 /* Allocate a hash table for signatured types. */
3428 allocate_signatured_type_table (struct objfile
*objfile
)
3430 return htab_create_alloc_ex (41,
3431 hash_signatured_type
,
3434 &objfile
->objfile_obstack
,
3435 hashtab_obstack_allocate
,
3436 dummy_obstack_deallocate
);
3439 /* A helper function to add a signatured type CU to a table. */
3442 add_signatured_type_cu_to_table (void **slot
, void *datum
)
3444 struct signatured_type
*sigt
= *slot
;
3445 struct dwarf2_per_cu_data
***datap
= datum
;
3447 **datap
= &sigt
->per_cu
;
3453 /* Create the hash table of all entries in the .debug_types section.
3454 DWO_FILE is a pointer to the DWO file for .debug_types.dwo, NULL otherwise.
3455 The result is a pointer to the hash table or NULL if there are
3459 create_debug_types_hash_table (struct dwo_file
*dwo_file
,
3460 VEC (dwarf2_section_info_def
) *types
)
3462 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3463 htab_t types_htab
= NULL
;
3465 struct dwarf2_section_info
*section
;
3467 if (VEC_empty (dwarf2_section_info_def
, types
))
3471 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
3475 gdb_byte
*info_ptr
, *end_ptr
;
3477 dwarf2_read_section (objfile
, section
);
3478 info_ptr
= section
->buffer
;
3480 if (info_ptr
== NULL
)
3483 /* We can't set abfd until now because the section may be empty or
3484 not present, in which case section->asection will be NULL. */
3485 abfd
= section
->asection
->owner
;
3487 if (types_htab
== NULL
)
3490 types_htab
= allocate_dwo_unit_table (objfile
);
3492 types_htab
= allocate_signatured_type_table (objfile
);
3495 if (dwarf2_die_debug
)
3496 fprintf_unfiltered (gdb_stdlog
, "Reading signatured types for %s:\n",
3497 bfd_get_filename (abfd
));
3499 /* We don't use init_cutu_and_read_dies_simple, or some such, here
3500 because we don't need to read any dies: the signature is in the
3503 end_ptr
= info_ptr
+ section
->size
;
3504 while (info_ptr
< end_ptr
)
3507 cu_offset type_offset_in_tu
;
3509 struct signatured_type
*sig_type
;
3510 struct dwo_unit
*dwo_tu
;
3512 gdb_byte
*ptr
= info_ptr
;
3513 struct comp_unit_head header
;
3514 unsigned int length
;
3516 offset
.sect_off
= ptr
- section
->buffer
;
3518 /* We need to read the type's signature in order to build the hash
3519 table, but we don't need anything else just yet. */
3521 ptr
= read_and_check_type_unit_head (&header
, section
, ptr
,
3522 &signature
, &type_offset_in_tu
);
3524 length
= header
.initial_length_size
+ header
.length
;
3526 /* Skip dummy type units. */
3527 if (ptr
>= info_ptr
+ length
3528 || peek_abbrev_code (abfd
, ptr
) == 0)
3530 info_ptr
+= header
.initial_length_size
+ header
.length
;
3537 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3539 dwo_tu
->dwo_file
= dwo_file
;
3540 dwo_tu
->signature
= signature
;
3541 dwo_tu
->type_offset_in_tu
= type_offset_in_tu
;
3542 dwo_tu
->info_or_types_section
= section
;
3543 dwo_tu
->offset
= offset
;
3544 dwo_tu
->length
= length
;
3548 /* N.B.: type_offset is not usable if this type uses a DWO file.
3549 The real type_offset is in the DWO file. */
3551 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3552 struct signatured_type
);
3553 sig_type
->signature
= signature
;
3554 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
3555 sig_type
->per_cu
.objfile
= objfile
;
3556 sig_type
->per_cu
.is_debug_types
= 1;
3557 sig_type
->per_cu
.info_or_types_section
= section
;
3558 sig_type
->per_cu
.offset
= offset
;
3559 sig_type
->per_cu
.length
= length
;
3562 slot
= htab_find_slot (types_htab
,
3563 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
3565 gdb_assert (slot
!= NULL
);
3568 sect_offset dup_offset
;
3572 const struct dwo_unit
*dup_tu
= *slot
;
3574 dup_offset
= dup_tu
->offset
;
3578 const struct signatured_type
*dup_tu
= *slot
;
3580 dup_offset
= dup_tu
->per_cu
.offset
;
3583 complaint (&symfile_complaints
,
3584 _("debug type entry at offset 0x%x is duplicate to the "
3585 "entry at offset 0x%x, signature 0x%s"),
3586 offset
.sect_off
, dup_offset
.sect_off
,
3587 phex (signature
, sizeof (signature
)));
3589 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
3591 if (dwarf2_die_debug
)
3592 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
3594 phex (signature
, sizeof (signature
)));
3603 /* Create the hash table of all entries in the .debug_types section,
3604 and initialize all_type_units.
3605 The result is zero if there is an error (e.g. missing .debug_types section),
3606 otherwise non-zero. */
3609 create_all_type_units (struct objfile
*objfile
)
3612 struct dwarf2_per_cu_data
**iter
;
3614 types_htab
= create_debug_types_hash_table (NULL
, dwarf2_per_objfile
->types
);
3615 if (types_htab
== NULL
)
3617 dwarf2_per_objfile
->signatured_types
= NULL
;
3621 dwarf2_per_objfile
->signatured_types
= types_htab
;
3623 dwarf2_per_objfile
->n_type_units
= htab_elements (types_htab
);
3624 dwarf2_per_objfile
->all_type_units
3625 = obstack_alloc (&objfile
->objfile_obstack
,
3626 dwarf2_per_objfile
->n_type_units
3627 * sizeof (struct dwarf2_per_cu_data
*));
3628 iter
= &dwarf2_per_objfile
->all_type_units
[0];
3629 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
3630 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
3631 == dwarf2_per_objfile
->n_type_units
);
3636 /* Lookup a signature based type for DW_FORM_ref_sig8.
3637 Returns NULL if signature SIG is not present in the table. */
3639 static struct signatured_type
*
3640 lookup_signatured_type (ULONGEST sig
)
3642 struct signatured_type find_entry
, *entry
;
3644 if (dwarf2_per_objfile
->signatured_types
== NULL
)
3646 complaint (&symfile_complaints
,
3647 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3651 find_entry
.signature
= sig
;
3652 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
3656 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3659 init_cu_die_reader (struct die_reader_specs
*reader
,
3660 struct dwarf2_cu
*cu
,
3661 struct dwarf2_section_info
*section
,
3662 struct dwo_file
*dwo_file
)
3664 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
3665 reader
->abfd
= section
->asection
->owner
;
3667 reader
->dwo_file
= dwo_file
;
3668 reader
->die_section
= section
;
3669 reader
->buffer
= section
->buffer
;
3670 reader
->buffer_end
= section
->buffer
+ section
->size
;
3673 /* Find the base address of the compilation unit for range lists and
3674 location lists. It will normally be specified by DW_AT_low_pc.
3675 In DWARF-3 draft 4, the base address could be overridden by
3676 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3677 compilation units with discontinuous ranges. */
3680 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
3682 struct attribute
*attr
;
3685 cu
->base_address
= 0;
3687 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
3690 cu
->base_address
= DW_ADDR (attr
);
3695 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3698 cu
->base_address
= DW_ADDR (attr
);
3704 /* Initialize a CU (or TU) and read its DIEs.
3705 If the CU defers to a DWO file, read the DWO file as well.
3707 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
3708 Otherwise, a new CU is allocated with xmalloc.
3710 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
3711 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
3713 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
3714 linker) then DIE_READER_FUNC will not get called. */
3717 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
3718 int use_existing_cu
, int keep
,
3719 die_reader_func_ftype
*die_reader_func
,
3722 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3723 struct dwarf2_section_info
*section
= this_cu
->info_or_types_section
;
3724 bfd
*abfd
= section
->asection
->owner
;
3725 struct dwarf2_cu
*cu
;
3726 gdb_byte
*begin_info_ptr
, *info_ptr
;
3727 struct die_reader_specs reader
;
3728 struct die_info
*comp_unit_die
;
3730 struct attribute
*attr
;
3731 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
3732 struct signatured_type
*sig_type
= NULL
;
3734 if (use_existing_cu
)
3737 cleanups
= make_cleanup (null_cleanup
, NULL
);
3739 /* This is cheap if the section is already read in. */
3740 dwarf2_read_section (objfile
, section
);
3742 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
3744 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
3747 info_ptr
+= cu
->header
.first_die_offset
.cu_off
;
3751 /* If !use_existing_cu, this_cu->cu must be NULL. */
3752 gdb_assert (this_cu
->cu
== NULL
);
3754 cu
= xmalloc (sizeof (*cu
));
3755 init_one_comp_unit (cu
, this_cu
);
3757 /* If an error occurs while loading, release our storage. */
3758 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
3760 if (this_cu
->is_debug_types
)
3764 info_ptr
= read_and_check_type_unit_head (&cu
->header
,
3768 /* There's no way to get from PER_CU to its containing
3769 struct signatured_type.
3770 But we have the signature so we can use that. */
3771 sig_type
= lookup_signatured_type (signature
);
3772 /* We've already scanned all the signatured types,
3773 this must succeed. */
3774 gdb_assert (sig_type
!= NULL
);
3775 gdb_assert (&sig_type
->per_cu
== this_cu
);
3776 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
3778 /* LENGTH has not been set yet for type units. */
3779 this_cu
->length
= cu
->header
.length
+ cu
->header
.initial_length_size
;
3781 /* Establish the type offset that can be used to lookup the type. */
3782 sig_type
->type_offset_in_section
.sect_off
=
3783 this_cu
->offset
.sect_off
+ sig_type
->type_offset_in_tu
.cu_off
;
3787 info_ptr
= read_and_check_comp_unit_head (&cu
->header
,
3788 section
, info_ptr
, 0);
3790 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
3791 gdb_assert (this_cu
->length
3792 == cu
->header
.length
+ cu
->header
.initial_length_size
);
3796 /* Skip dummy compilation units. */
3797 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
3798 || peek_abbrev_code (abfd
, info_ptr
) == 0)
3800 do_cleanups (cleanups
);
3804 /* Read the abbrevs for this compilation unit into a table. */
3805 if (cu
->dwarf2_abbrevs
== NULL
)
3807 dwarf2_read_abbrevs (cu
, &dwarf2_per_objfile
->abbrev
);
3808 make_cleanup (dwarf2_free_abbrev_table
, cu
);
3811 /* Read the top level CU/TU die. */
3812 init_cu_die_reader (&reader
, cu
, section
, NULL
);
3813 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
3815 /* If we have a DWO stub, process it and then read in the DWO file.
3816 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains
3817 a DWO CU, that this test will fail. */
3818 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
3821 char *dwo_name
= DW_STRING (attr
);
3822 const char *comp_dir
;
3823 struct dwo_unit
*dwo_unit
;
3824 ULONGEST signature
; /* Or dwo_id. */
3825 struct attribute
*stmt_list
, *low_pc
, *high_pc
, *ranges
;
3826 int i
,num_extra_attrs
;
3829 error (_("Dwarf Error: compilation unit with DW_AT_GNU_dwo_name"
3830 " has children (offset 0x%x) [in module %s]"),
3831 this_cu
->offset
.sect_off
, bfd_get_filename (abfd
));
3833 /* These attributes aren't processed until later:
3834 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
3835 However, the attribute is found in the stub which we won't have later.
3836 In order to not impose this complication on the rest of the code,
3837 we read them here and copy them to the DWO CU/TU die. */
3838 stmt_list
= low_pc
= high_pc
= ranges
= NULL
;
3840 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
3842 if (! this_cu
->is_debug_types
)
3843 stmt_list
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3844 low_pc
= dwarf2_attr (comp_unit_die
, DW_AT_low_pc
, cu
);
3845 high_pc
= dwarf2_attr (comp_unit_die
, DW_AT_high_pc
, cu
);
3846 ranges
= dwarf2_attr (comp_unit_die
, DW_AT_ranges
, cu
);
3848 /* There should be a DW_AT_addr_base attribute here (if needed).
3849 We need the value before we can process DW_FORM_GNU_addr_index. */
3851 cu
->have_addr_base
= 0;
3852 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
3855 cu
->addr_base
= DW_UNSND (attr
);
3856 cu
->have_addr_base
= 1;
3859 if (this_cu
->is_debug_types
)
3861 gdb_assert (sig_type
!= NULL
);
3862 signature
= sig_type
->signature
;
3866 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
3868 error (_("Dwarf Error: missing dwo_id [in module %s]"),
3870 signature
= DW_UNSND (attr
);
3873 /* We may need the comp_dir in order to find the DWO file. */
3875 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
3877 comp_dir
= DW_STRING (attr
);
3879 if (this_cu
->is_debug_types
)
3880 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
3882 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
3885 if (dwo_unit
== NULL
)
3887 error (_("Dwarf Error: CU at offset 0x%x references unknown DWO"
3888 " with ID %s [in module %s]"),
3889 this_cu
->offset
.sect_off
,
3890 phex (signature
, sizeof (signature
)),
3894 /* Set up for reading the DWO CU/TU. */
3895 cu
->dwo_unit
= dwo_unit
;
3896 section
= dwo_unit
->info_or_types_section
;
3897 begin_info_ptr
= info_ptr
= section
->buffer
+ dwo_unit
->offset
.sect_off
;
3898 init_cu_die_reader (&reader
, cu
, section
, dwo_unit
->dwo_file
);
3900 if (this_cu
->is_debug_types
)
3904 info_ptr
= read_and_check_type_unit_head (&cu
->header
,
3907 gdb_assert (sig_type
->signature
== signature
);
3908 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
3909 gdb_assert (dwo_unit
->length
3910 == cu
->header
.length
+ cu
->header
.initial_length_size
);
3912 /* Establish the type offset that can be used to lookup the type.
3913 For DWO files, we don't know it until now. */
3914 sig_type
->type_offset_in_section
.sect_off
=
3915 dwo_unit
->offset
.sect_off
+ dwo_unit
->type_offset_in_tu
.cu_off
;
3919 info_ptr
= read_and_check_comp_unit_head (&cu
->header
,
3920 section
, info_ptr
, 0);
3921 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
3922 gdb_assert (dwo_unit
->length
3923 == cu
->header
.length
+ cu
->header
.initial_length_size
);
3926 /* Discard the original CU's abbrev table, and read the DWO's. */
3927 dwarf2_free_abbrev_table (cu
);
3928 dwarf2_read_abbrevs (cu
, &dwo_unit
->dwo_file
->sections
.abbrev
);
3930 /* Read in the die, but leave space to copy over the attributes
3931 from the stub. This has the benefit of simplifying the rest of
3932 the code - all the real work is done here. */
3933 num_extra_attrs
= ((stmt_list
!= NULL
)
3936 + (ranges
!= NULL
));
3937 info_ptr
= read_full_die_1 (&reader
, &comp_unit_die
, info_ptr
,
3938 &has_children
, num_extra_attrs
);
3940 /* Copy over the attributes from the stub to the DWO die. */
3941 i
= comp_unit_die
->num_attrs
;
3942 if (stmt_list
!= NULL
)
3943 comp_unit_die
->attrs
[i
++] = *stmt_list
;
3945 comp_unit_die
->attrs
[i
++] = *low_pc
;
3946 if (high_pc
!= NULL
)
3947 comp_unit_die
->attrs
[i
++] = *high_pc
;
3949 comp_unit_die
->attrs
[i
++] = *ranges
;
3950 comp_unit_die
->num_attrs
+= num_extra_attrs
;
3952 /* Skip dummy compilation units. */
3953 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
3954 || peek_abbrev_code (abfd
, info_ptr
) == 0)
3956 do_cleanups (cleanups
);
3961 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
3963 if (free_cu_cleanup
!= NULL
)
3967 /* We've successfully allocated this compilation unit. Let our
3968 caller clean it up when finished with it. */
3969 discard_cleanups (free_cu_cleanup
);
3971 /* We can only discard free_cu_cleanup and all subsequent cleanups.
3972 So we have to manually free the abbrev table. */
3973 dwarf2_free_abbrev_table (cu
);
3975 /* Link this CU into read_in_chain. */
3976 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3977 dwarf2_per_objfile
->read_in_chain
= this_cu
;
3980 do_cleanups (free_cu_cleanup
);
3983 do_cleanups (cleanups
);
3986 /* Read CU/TU THIS_CU in section SECTION,
3987 but do not follow DW_AT_GNU_dwo_name if present.
3988 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed to
3989 have already done the lookup to find the DWO file).
3991 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
3992 THIS_CU->is_debug_types, but nothing else.
3994 We fill in THIS_CU->length.
3996 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
3997 linker) then DIE_READER_FUNC will not get called.
3999 THIS_CU->cu is always freed when done.
4000 This is done in order to not leave THIS_CU->cu in a state where we have
4001 to care whether it refers to the "main" CU or the DWO CU. */
4004 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
4005 struct dwarf2_section_info
*abbrev_section
,
4006 struct dwo_file
*dwo_file
,
4007 die_reader_func_ftype
*die_reader_func
,
4010 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4011 struct dwarf2_section_info
*section
= this_cu
->info_or_types_section
;
4012 bfd
*abfd
= section
->asection
->owner
;
4013 struct dwarf2_cu cu
;
4014 gdb_byte
*begin_info_ptr
, *info_ptr
;
4015 struct die_reader_specs reader
;
4016 struct cleanup
*cleanups
;
4017 struct die_info
*comp_unit_die
;
4020 gdb_assert (this_cu
->cu
== NULL
);
4022 /* This is cheap if the section is already read in. */
4023 dwarf2_read_section (objfile
, section
);
4025 init_one_comp_unit (&cu
, this_cu
);
4027 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
4029 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
4030 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
, info_ptr
,
4031 this_cu
->is_debug_types
);
4033 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
4035 /* Skip dummy compilation units. */
4036 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
4037 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4039 do_cleanups (cleanups
);
4043 dwarf2_read_abbrevs (&cu
, abbrev_section
);
4044 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
4046 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
4047 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
4049 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
4051 do_cleanups (cleanups
);
4054 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
4055 does not lookup the specified DWO file.
4056 This cannot be used to read DWO files.
4058 THIS_CU->cu is always freed when done.
4059 This is done in order to not leave THIS_CU->cu in a state where we have
4060 to care whether it refers to the "main" CU or the DWO CU.
4061 We can revisit this if the data shows there's a performance issue. */
4064 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
4065 die_reader_func_ftype
*die_reader_func
,
4068 init_cutu_and_read_dies_no_follow (this_cu
,
4069 &dwarf2_per_objfile
->abbrev
,
4071 die_reader_func
, data
);
4074 /* die_reader_func for process_psymtab_comp_unit. */
4077 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
4079 struct die_info
*comp_unit_die
,
4083 struct dwarf2_cu
*cu
= reader
->cu
;
4084 struct objfile
*objfile
= cu
->objfile
;
4085 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
4086 struct attribute
*attr
;
4088 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
4089 struct partial_symtab
*pst
;
4091 const char *filename
;
4092 int *want_partial_unit_ptr
= data
;
4094 if (comp_unit_die
->tag
== DW_TAG_partial_unit
4095 && (want_partial_unit_ptr
== NULL
4096 || !*want_partial_unit_ptr
))
4099 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
4101 cu
->list_in_scope
= &file_symbols
;
4103 /* Allocate a new partial symbol table structure. */
4104 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, cu
);
4105 if (attr
== NULL
|| !DW_STRING (attr
))
4108 filename
= DW_STRING (attr
);
4109 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
4111 /* TEXTLOW and TEXTHIGH are set below. */
4113 objfile
->global_psymbols
.next
,
4114 objfile
->static_psymbols
.next
);
4115 pst
->psymtabs_addrmap_supported
= 1;
4117 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
4119 pst
->dirname
= DW_STRING (attr
);
4121 pst
->read_symtab_private
= per_cu
;
4123 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4125 /* Store the function that reads in the rest of the symbol table. */
4126 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
4128 per_cu
->v
.psymtab
= pst
;
4130 dwarf2_find_base_address (comp_unit_die
, cu
);
4132 /* Possibly set the default values of LOWPC and HIGHPC from
4134 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
4135 &best_highpc
, cu
, pst
);
4136 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
4137 /* Store the contiguous range if it is not empty; it can be empty for
4138 CUs with no code. */
4139 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4140 best_lowpc
+ baseaddr
,
4141 best_highpc
+ baseaddr
- 1, pst
);
4143 /* Check if comp unit has_children.
4144 If so, read the rest of the partial symbols from this comp unit.
4145 If not, there's no more debug_info for this comp unit. */
4148 struct partial_die_info
*first_die
;
4149 CORE_ADDR lowpc
, highpc
;
4151 lowpc
= ((CORE_ADDR
) -1);
4152 highpc
= ((CORE_ADDR
) 0);
4154 first_die
= load_partial_dies (reader
, info_ptr
, 1);
4156 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
4159 /* If we didn't find a lowpc, set it to highpc to avoid
4160 complaints from `maint check'. */
4161 if (lowpc
== ((CORE_ADDR
) -1))
4164 /* If the compilation unit didn't have an explicit address range,
4165 then use the information extracted from its child dies. */
4169 best_highpc
= highpc
;
4172 pst
->textlow
= best_lowpc
+ baseaddr
;
4173 pst
->texthigh
= best_highpc
+ baseaddr
;
4175 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
4176 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
4177 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
4178 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
4179 sort_pst_symbols (pst
);
4181 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
4184 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
4185 struct dwarf2_per_cu_data
*iter
;
4187 /* Fill in 'dependencies' here; we fill in 'users' in a
4189 pst
->number_of_dependencies
= len
;
4190 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
4191 len
* sizeof (struct symtab
*));
4193 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
4196 pst
->dependencies
[i
] = iter
->v
.psymtab
;
4198 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
4201 if (per_cu
->is_debug_types
)
4203 /* It's not clear we want to do anything with stmt lists here.
4204 Waiting to see what gcc ultimately does. */
4208 /* Get the list of files included in the current compilation unit,
4209 and build a psymtab for each of them. */
4210 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
4214 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
4215 Process compilation unit THIS_CU for a psymtab. */
4218 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
4219 int want_partial_unit
)
4221 /* If this compilation unit was already read in, free the
4222 cached copy in order to read it in again. This is
4223 necessary because we skipped some symbols when we first
4224 read in the compilation unit (see load_partial_dies).
4225 This problem could be avoided, but the benefit is unclear. */
4226 if (this_cu
->cu
!= NULL
)
4227 free_one_cached_comp_unit (this_cu
);
4229 gdb_assert (! this_cu
->is_debug_types
);
4230 init_cutu_and_read_dies (this_cu
, 0, 0, process_psymtab_comp_unit_reader
,
4231 &want_partial_unit
);
4233 /* Age out any secondary CUs. */
4234 age_cached_comp_units ();
4237 /* Traversal function for htab_traverse_noresize.
4238 Process one .debug_types comp-unit. */
4241 process_psymtab_type_unit (void **slot
, void *info
)
4243 struct signatured_type
*sig_type
= (struct signatured_type
*) *slot
;
4244 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
4246 gdb_assert (per_cu
->is_debug_types
);
4247 gdb_assert (info
== NULL
);
4249 /* If this compilation unit was already read in, free the
4250 cached copy in order to read it in again. This is
4251 necessary because we skipped some symbols when we first
4252 read in the compilation unit (see load_partial_dies).
4253 This problem could be avoided, but the benefit is unclear. */
4254 if (per_cu
->cu
!= NULL
)
4255 free_one_cached_comp_unit (per_cu
);
4257 init_cutu_and_read_dies (per_cu
, 0, 0, process_psymtab_comp_unit_reader
,
4260 /* Age out any secondary CUs. */
4261 age_cached_comp_units ();
4266 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
4267 Build partial symbol tables for the .debug_types comp-units. */
4270 build_type_psymtabs (struct objfile
*objfile
)
4272 if (! create_all_type_units (objfile
))
4275 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
4276 process_psymtab_type_unit
, NULL
);
4279 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
4282 psymtabs_addrmap_cleanup (void *o
)
4284 struct objfile
*objfile
= o
;
4286 objfile
->psymtabs_addrmap
= NULL
;
4289 /* Compute the 'user' field for each psymtab in OBJFILE. */
4292 set_partial_user (struct objfile
*objfile
)
4296 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4298 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
4299 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
4302 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
4304 /* Set the 'user' field only if it is not already set. */
4305 if (pst
->dependencies
[j
]->user
== NULL
)
4306 pst
->dependencies
[j
]->user
= pst
;
4311 /* Build the partial symbol table by doing a quick pass through the
4312 .debug_info and .debug_abbrev sections. */
4315 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
4317 struct cleanup
*back_to
, *addrmap_cleanup
;
4318 struct obstack temp_obstack
;
4321 dwarf2_per_objfile
->reading_partial_symbols
= 1;
4323 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4325 /* Any cached compilation units will be linked by the per-objfile
4326 read_in_chain. Make sure to free them when we're done. */
4327 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
4329 build_type_psymtabs (objfile
);
4331 create_all_comp_units (objfile
);
4333 /* Create a temporary address map on a temporary obstack. We later
4334 copy this to the final obstack. */
4335 obstack_init (&temp_obstack
);
4336 make_cleanup_obstack_free (&temp_obstack
);
4337 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
4338 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
4340 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4342 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
4344 process_psymtab_comp_unit (per_cu
, 0);
4347 set_partial_user (objfile
);
4349 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
4350 &objfile
->objfile_obstack
);
4351 discard_cleanups (addrmap_cleanup
);
4353 do_cleanups (back_to
);
4356 /* die_reader_func for load_partial_comp_unit. */
4359 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
4361 struct die_info
*comp_unit_die
,
4365 struct dwarf2_cu
*cu
= reader
->cu
;
4367 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
4369 /* Check if comp unit has_children.
4370 If so, read the rest of the partial symbols from this comp unit.
4371 If not, there's no more debug_info for this comp unit. */
4373 load_partial_dies (reader
, info_ptr
, 0);
4376 /* Load the partial DIEs for a secondary CU into memory.
4377 This is also used when rereading a primary CU with load_all_dies. */
4380 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
4382 init_cutu_and_read_dies (this_cu
, 1, 1, load_partial_comp_unit_reader
, NULL
);
4385 /* Create a list of all compilation units in OBJFILE.
4386 This is only done for -readnow and building partial symtabs. */
4389 create_all_comp_units (struct objfile
*objfile
)
4393 struct dwarf2_per_cu_data
**all_comp_units
;
4396 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4397 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
4401 all_comp_units
= xmalloc (n_allocated
4402 * sizeof (struct dwarf2_per_cu_data
*));
4404 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
4405 + dwarf2_per_objfile
->info
.size
)
4407 unsigned int length
, initial_length_size
;
4408 struct dwarf2_per_cu_data
*this_cu
;
4411 offset
.sect_off
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
4413 /* Read just enough information to find out where the next
4414 compilation unit is. */
4415 length
= read_initial_length (objfile
->obfd
, info_ptr
,
4416 &initial_length_size
);
4418 /* Save the compilation unit for later lookup. */
4419 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
4420 sizeof (struct dwarf2_per_cu_data
));
4421 memset (this_cu
, 0, sizeof (*this_cu
));
4422 this_cu
->offset
= offset
;
4423 this_cu
->length
= length
+ initial_length_size
;
4424 this_cu
->objfile
= objfile
;
4425 this_cu
->info_or_types_section
= &dwarf2_per_objfile
->info
;
4427 if (n_comp_units
== n_allocated
)
4430 all_comp_units
= xrealloc (all_comp_units
,
4432 * sizeof (struct dwarf2_per_cu_data
*));
4434 all_comp_units
[n_comp_units
++] = this_cu
;
4436 info_ptr
= info_ptr
+ this_cu
->length
;
4439 dwarf2_per_objfile
->all_comp_units
4440 = obstack_alloc (&objfile
->objfile_obstack
,
4441 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
4442 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
4443 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
4444 xfree (all_comp_units
);
4445 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
4448 /* Process all loaded DIEs for compilation unit CU, starting at
4449 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
4450 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
4451 DW_AT_ranges). If NEED_PC is set, then this function will set
4452 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
4453 and record the covered ranges in the addrmap. */
4456 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
4457 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
4459 struct partial_die_info
*pdi
;
4461 /* Now, march along the PDI's, descending into ones which have
4462 interesting children but skipping the children of the other ones,
4463 until we reach the end of the compilation unit. */
4469 fixup_partial_die (pdi
, cu
);
4471 /* Anonymous namespaces or modules have no name but have interesting
4472 children, so we need to look at them. Ditto for anonymous
4475 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
4476 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
4477 || pdi
->tag
== DW_TAG_imported_unit
)
4481 case DW_TAG_subprogram
:
4482 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
4484 case DW_TAG_constant
:
4485 case DW_TAG_variable
:
4486 case DW_TAG_typedef
:
4487 case DW_TAG_union_type
:
4488 if (!pdi
->is_declaration
)
4490 add_partial_symbol (pdi
, cu
);
4493 case DW_TAG_class_type
:
4494 case DW_TAG_interface_type
:
4495 case DW_TAG_structure_type
:
4496 if (!pdi
->is_declaration
)
4498 add_partial_symbol (pdi
, cu
);
4501 case DW_TAG_enumeration_type
:
4502 if (!pdi
->is_declaration
)
4503 add_partial_enumeration (pdi
, cu
);
4505 case DW_TAG_base_type
:
4506 case DW_TAG_subrange_type
:
4507 /* File scope base type definitions are added to the partial
4509 add_partial_symbol (pdi
, cu
);
4511 case DW_TAG_namespace
:
4512 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
4515 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
4517 case DW_TAG_imported_unit
:
4519 struct dwarf2_per_cu_data
*per_cu
;
4521 per_cu
= dwarf2_find_containing_comp_unit (pdi
->d
.offset
,
4524 /* Go read the partial unit, if needed. */
4525 if (per_cu
->v
.psymtab
== NULL
)
4526 process_psymtab_comp_unit (per_cu
, 1);
4528 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
4537 /* If the die has a sibling, skip to the sibling. */
4539 pdi
= pdi
->die_sibling
;
4543 /* Functions used to compute the fully scoped name of a partial DIE.
4545 Normally, this is simple. For C++, the parent DIE's fully scoped
4546 name is concatenated with "::" and the partial DIE's name. For
4547 Java, the same thing occurs except that "." is used instead of "::".
4548 Enumerators are an exception; they use the scope of their parent
4549 enumeration type, i.e. the name of the enumeration type is not
4550 prepended to the enumerator.
4552 There are two complexities. One is DW_AT_specification; in this
4553 case "parent" means the parent of the target of the specification,
4554 instead of the direct parent of the DIE. The other is compilers
4555 which do not emit DW_TAG_namespace; in this case we try to guess
4556 the fully qualified name of structure types from their members'
4557 linkage names. This must be done using the DIE's children rather
4558 than the children of any DW_AT_specification target. We only need
4559 to do this for structures at the top level, i.e. if the target of
4560 any DW_AT_specification (if any; otherwise the DIE itself) does not
4563 /* Compute the scope prefix associated with PDI's parent, in
4564 compilation unit CU. The result will be allocated on CU's
4565 comp_unit_obstack, or a copy of the already allocated PDI->NAME
4566 field. NULL is returned if no prefix is necessary. */
4568 partial_die_parent_scope (struct partial_die_info
*pdi
,
4569 struct dwarf2_cu
*cu
)
4571 char *grandparent_scope
;
4572 struct partial_die_info
*parent
, *real_pdi
;
4574 /* We need to look at our parent DIE; if we have a DW_AT_specification,
4575 then this means the parent of the specification DIE. */
4578 while (real_pdi
->has_specification
)
4579 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
4581 parent
= real_pdi
->die_parent
;
4585 if (parent
->scope_set
)
4586 return parent
->scope
;
4588 fixup_partial_die (parent
, cu
);
4590 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
4592 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
4593 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
4594 Work around this problem here. */
4595 if (cu
->language
== language_cplus
4596 && parent
->tag
== DW_TAG_namespace
4597 && strcmp (parent
->name
, "::") == 0
4598 && grandparent_scope
== NULL
)
4600 parent
->scope
= NULL
;
4601 parent
->scope_set
= 1;
4605 if (pdi
->tag
== DW_TAG_enumerator
)
4606 /* Enumerators should not get the name of the enumeration as a prefix. */
4607 parent
->scope
= grandparent_scope
;
4608 else if (parent
->tag
== DW_TAG_namespace
4609 || parent
->tag
== DW_TAG_module
4610 || parent
->tag
== DW_TAG_structure_type
4611 || parent
->tag
== DW_TAG_class_type
4612 || parent
->tag
== DW_TAG_interface_type
4613 || parent
->tag
== DW_TAG_union_type
4614 || parent
->tag
== DW_TAG_enumeration_type
)
4616 if (grandparent_scope
== NULL
)
4617 parent
->scope
= parent
->name
;
4619 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
4621 parent
->name
, 0, cu
);
4625 /* FIXME drow/2004-04-01: What should we be doing with
4626 function-local names? For partial symbols, we should probably be
4628 complaint (&symfile_complaints
,
4629 _("unhandled containing DIE tag %d for DIE at %d"),
4630 parent
->tag
, pdi
->offset
.sect_off
);
4631 parent
->scope
= grandparent_scope
;
4634 parent
->scope_set
= 1;
4635 return parent
->scope
;
4638 /* Return the fully scoped name associated with PDI, from compilation unit
4639 CU. The result will be allocated with malloc. */
4642 partial_die_full_name (struct partial_die_info
*pdi
,
4643 struct dwarf2_cu
*cu
)
4647 /* If this is a template instantiation, we can not work out the
4648 template arguments from partial DIEs. So, unfortunately, we have
4649 to go through the full DIEs. At least any work we do building
4650 types here will be reused if full symbols are loaded later. */
4651 if (pdi
->has_template_arguments
)
4653 fixup_partial_die (pdi
, cu
);
4655 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
4657 struct die_info
*die
;
4658 struct attribute attr
;
4659 struct dwarf2_cu
*ref_cu
= cu
;
4661 /* DW_FORM_ref_addr is using section offset. */
4663 attr
.form
= DW_FORM_ref_addr
;
4664 attr
.u
.unsnd
= pdi
->offset
.sect_off
;
4665 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
4667 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
4671 parent_scope
= partial_die_parent_scope (pdi
, cu
);
4672 if (parent_scope
== NULL
)
4675 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
4679 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
4681 struct objfile
*objfile
= cu
->objfile
;
4683 char *actual_name
= NULL
;
4685 int built_actual_name
= 0;
4687 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4689 actual_name
= partial_die_full_name (pdi
, cu
);
4691 built_actual_name
= 1;
4693 if (actual_name
== NULL
)
4694 actual_name
= pdi
->name
;
4698 case DW_TAG_subprogram
:
4699 if (pdi
->is_external
|| cu
->language
== language_ada
)
4701 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
4702 of the global scope. But in Ada, we want to be able to access
4703 nested procedures globally. So all Ada subprograms are stored
4704 in the global scope. */
4705 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4706 mst_text, objfile); */
4707 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4709 VAR_DOMAIN
, LOC_BLOCK
,
4710 &objfile
->global_psymbols
,
4711 0, pdi
->lowpc
+ baseaddr
,
4712 cu
->language
, objfile
);
4716 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4717 mst_file_text, objfile); */
4718 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4720 VAR_DOMAIN
, LOC_BLOCK
,
4721 &objfile
->static_psymbols
,
4722 0, pdi
->lowpc
+ baseaddr
,
4723 cu
->language
, objfile
);
4726 case DW_TAG_constant
:
4728 struct psymbol_allocation_list
*list
;
4730 if (pdi
->is_external
)
4731 list
= &objfile
->global_psymbols
;
4733 list
= &objfile
->static_psymbols
;
4734 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4735 built_actual_name
, VAR_DOMAIN
, LOC_STATIC
,
4736 list
, 0, 0, cu
->language
, objfile
);
4739 case DW_TAG_variable
:
4741 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
4745 && !dwarf2_per_objfile
->has_section_at_zero
)
4747 /* A global or static variable may also have been stripped
4748 out by the linker if unused, in which case its address
4749 will be nullified; do not add such variables into partial
4750 symbol table then. */
4752 else if (pdi
->is_external
)
4755 Don't enter into the minimal symbol tables as there is
4756 a minimal symbol table entry from the ELF symbols already.
4757 Enter into partial symbol table if it has a location
4758 descriptor or a type.
4759 If the location descriptor is missing, new_symbol will create
4760 a LOC_UNRESOLVED symbol, the address of the variable will then
4761 be determined from the minimal symbol table whenever the variable
4763 The address for the partial symbol table entry is not
4764 used by GDB, but it comes in handy for debugging partial symbol
4767 if (pdi
->d
.locdesc
|| pdi
->has_type
)
4768 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4770 VAR_DOMAIN
, LOC_STATIC
,
4771 &objfile
->global_psymbols
,
4773 cu
->language
, objfile
);
4777 /* Static Variable. Skip symbols without location descriptors. */
4778 if (pdi
->d
.locdesc
== NULL
)
4780 if (built_actual_name
)
4781 xfree (actual_name
);
4784 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
4785 mst_file_data, objfile); */
4786 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4788 VAR_DOMAIN
, LOC_STATIC
,
4789 &objfile
->static_psymbols
,
4791 cu
->language
, objfile
);
4794 case DW_TAG_typedef
:
4795 case DW_TAG_base_type
:
4796 case DW_TAG_subrange_type
:
4797 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4799 VAR_DOMAIN
, LOC_TYPEDEF
,
4800 &objfile
->static_psymbols
,
4801 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4803 case DW_TAG_namespace
:
4804 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4806 VAR_DOMAIN
, LOC_TYPEDEF
,
4807 &objfile
->global_psymbols
,
4808 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4810 case DW_TAG_class_type
:
4811 case DW_TAG_interface_type
:
4812 case DW_TAG_structure_type
:
4813 case DW_TAG_union_type
:
4814 case DW_TAG_enumeration_type
:
4815 /* Skip external references. The DWARF standard says in the section
4816 about "Structure, Union, and Class Type Entries": "An incomplete
4817 structure, union or class type is represented by a structure,
4818 union or class entry that does not have a byte size attribute
4819 and that has a DW_AT_declaration attribute." */
4820 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
4822 if (built_actual_name
)
4823 xfree (actual_name
);
4827 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
4828 static vs. global. */
4829 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4831 STRUCT_DOMAIN
, LOC_TYPEDEF
,
4832 (cu
->language
== language_cplus
4833 || cu
->language
== language_java
)
4834 ? &objfile
->global_psymbols
4835 : &objfile
->static_psymbols
,
4836 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4839 case DW_TAG_enumerator
:
4840 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4842 VAR_DOMAIN
, LOC_CONST
,
4843 (cu
->language
== language_cplus
4844 || cu
->language
== language_java
)
4845 ? &objfile
->global_psymbols
4846 : &objfile
->static_psymbols
,
4847 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4853 if (built_actual_name
)
4854 xfree (actual_name
);
4857 /* Read a partial die corresponding to a namespace; also, add a symbol
4858 corresponding to that namespace to the symbol table. NAMESPACE is
4859 the name of the enclosing namespace. */
4862 add_partial_namespace (struct partial_die_info
*pdi
,
4863 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4864 int need_pc
, struct dwarf2_cu
*cu
)
4866 /* Add a symbol for the namespace. */
4868 add_partial_symbol (pdi
, cu
);
4870 /* Now scan partial symbols in that namespace. */
4872 if (pdi
->has_children
)
4873 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4876 /* Read a partial die corresponding to a Fortran module. */
4879 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
4880 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
4882 /* Now scan partial symbols in that module. */
4884 if (pdi
->has_children
)
4885 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4888 /* Read a partial die corresponding to a subprogram and create a partial
4889 symbol for that subprogram. When the CU language allows it, this
4890 routine also defines a partial symbol for each nested subprogram
4891 that this subprogram contains.
4893 DIE my also be a lexical block, in which case we simply search
4894 recursively for suprograms defined inside that lexical block.
4895 Again, this is only performed when the CU language allows this
4896 type of definitions. */
4899 add_partial_subprogram (struct partial_die_info
*pdi
,
4900 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4901 int need_pc
, struct dwarf2_cu
*cu
)
4903 if (pdi
->tag
== DW_TAG_subprogram
)
4905 if (pdi
->has_pc_info
)
4907 if (pdi
->lowpc
< *lowpc
)
4908 *lowpc
= pdi
->lowpc
;
4909 if (pdi
->highpc
> *highpc
)
4910 *highpc
= pdi
->highpc
;
4914 struct objfile
*objfile
= cu
->objfile
;
4916 baseaddr
= ANOFFSET (objfile
->section_offsets
,
4917 SECT_OFF_TEXT (objfile
));
4918 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4919 pdi
->lowpc
+ baseaddr
,
4920 pdi
->highpc
- 1 + baseaddr
,
4921 cu
->per_cu
->v
.psymtab
);
4925 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
4927 if (!pdi
->is_declaration
)
4928 /* Ignore subprogram DIEs that do not have a name, they are
4929 illegal. Do not emit a complaint at this point, we will
4930 do so when we convert this psymtab into a symtab. */
4932 add_partial_symbol (pdi
, cu
);
4936 if (! pdi
->has_children
)
4939 if (cu
->language
== language_ada
)
4941 pdi
= pdi
->die_child
;
4944 fixup_partial_die (pdi
, cu
);
4945 if (pdi
->tag
== DW_TAG_subprogram
4946 || pdi
->tag
== DW_TAG_lexical_block
)
4947 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
4948 pdi
= pdi
->die_sibling
;
4953 /* Read a partial die corresponding to an enumeration type. */
4956 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
4957 struct dwarf2_cu
*cu
)
4959 struct partial_die_info
*pdi
;
4961 if (enum_pdi
->name
!= NULL
)
4962 add_partial_symbol (enum_pdi
, cu
);
4964 pdi
= enum_pdi
->die_child
;
4967 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
4968 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
4970 add_partial_symbol (pdi
, cu
);
4971 pdi
= pdi
->die_sibling
;
4975 /* Return the initial uleb128 in the die at INFO_PTR. */
4978 peek_abbrev_code (bfd
*abfd
, gdb_byte
*info_ptr
)
4980 unsigned int bytes_read
;
4982 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4985 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
4986 Return the corresponding abbrev, or NULL if the number is zero (indicating
4987 an empty DIE). In either case *BYTES_READ will be set to the length of
4988 the initial number. */
4990 static struct abbrev_info
*
4991 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
4992 struct dwarf2_cu
*cu
)
4994 bfd
*abfd
= cu
->objfile
->obfd
;
4995 unsigned int abbrev_number
;
4996 struct abbrev_info
*abbrev
;
4998 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
5000 if (abbrev_number
== 0)
5003 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5006 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
5007 abbrev_number
, bfd_get_filename (abfd
));
5013 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
5014 Returns a pointer to the end of a series of DIEs, terminated by an empty
5015 DIE. Any children of the skipped DIEs will also be skipped. */
5018 skip_children (const struct die_reader_specs
*reader
, gdb_byte
*info_ptr
)
5020 struct dwarf2_cu
*cu
= reader
->cu
;
5021 struct abbrev_info
*abbrev
;
5022 unsigned int bytes_read
;
5026 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5028 return info_ptr
+ bytes_read
;
5030 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
5034 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
5035 INFO_PTR should point just after the initial uleb128 of a DIE, and the
5036 abbrev corresponding to that skipped uleb128 should be passed in
5037 ABBREV. Returns a pointer to this DIE's sibling, skipping any
5041 skip_one_die (const struct die_reader_specs
*reader
, gdb_byte
*info_ptr
,
5042 struct abbrev_info
*abbrev
)
5044 unsigned int bytes_read
;
5045 struct attribute attr
;
5046 bfd
*abfd
= reader
->abfd
;
5047 struct dwarf2_cu
*cu
= reader
->cu
;
5048 gdb_byte
*buffer
= reader
->buffer
;
5049 const gdb_byte
*buffer_end
= reader
->buffer_end
;
5050 gdb_byte
*start_info_ptr
= info_ptr
;
5051 unsigned int form
, i
;
5053 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
5055 /* The only abbrev we care about is DW_AT_sibling. */
5056 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
5058 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
5059 if (attr
.form
== DW_FORM_ref_addr
)
5060 complaint (&symfile_complaints
,
5061 _("ignoring absolute DW_AT_sibling"));
5063 return buffer
+ dwarf2_get_ref_die_offset (&attr
).sect_off
;
5066 /* If it isn't DW_AT_sibling, skip this attribute. */
5067 form
= abbrev
->attrs
[i
].form
;
5071 case DW_FORM_ref_addr
:
5072 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
5073 and later it is offset sized. */
5074 if (cu
->header
.version
== 2)
5075 info_ptr
+= cu
->header
.addr_size
;
5077 info_ptr
+= cu
->header
.offset_size
;
5080 info_ptr
+= cu
->header
.addr_size
;
5087 case DW_FORM_flag_present
:
5099 case DW_FORM_ref_sig8
:
5102 case DW_FORM_string
:
5103 read_direct_string (abfd
, info_ptr
, &bytes_read
);
5104 info_ptr
+= bytes_read
;
5106 case DW_FORM_sec_offset
:
5108 info_ptr
+= cu
->header
.offset_size
;
5110 case DW_FORM_exprloc
:
5112 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5113 info_ptr
+= bytes_read
;
5115 case DW_FORM_block1
:
5116 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
5118 case DW_FORM_block2
:
5119 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
5121 case DW_FORM_block4
:
5122 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
5126 case DW_FORM_ref_udata
:
5127 case DW_FORM_GNU_addr_index
:
5128 case DW_FORM_GNU_str_index
:
5129 info_ptr
= (gdb_byte
*) safe_skip_leb128 (info_ptr
, buffer_end
);
5131 case DW_FORM_indirect
:
5132 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5133 info_ptr
+= bytes_read
;
5134 /* We need to continue parsing from here, so just go back to
5136 goto skip_attribute
;
5139 error (_("Dwarf Error: Cannot handle %s "
5140 "in DWARF reader [in module %s]"),
5141 dwarf_form_name (form
),
5142 bfd_get_filename (abfd
));
5146 if (abbrev
->has_children
)
5147 return skip_children (reader
, info_ptr
);
5152 /* Locate ORIG_PDI's sibling.
5153 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
5156 locate_pdi_sibling (const struct die_reader_specs
*reader
,
5157 struct partial_die_info
*orig_pdi
,
5160 /* Do we know the sibling already? */
5162 if (orig_pdi
->sibling
)
5163 return orig_pdi
->sibling
;
5165 /* Are there any children to deal with? */
5167 if (!orig_pdi
->has_children
)
5170 /* Skip the children the long way. */
5172 return skip_children (reader
, info_ptr
);
5175 /* Expand this partial symbol table into a full symbol table. */
5178 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
5184 warning (_("bug: psymtab for %s is already read in."),
5191 printf_filtered (_("Reading in symbols for %s..."),
5193 gdb_flush (gdb_stdout
);
5196 /* Restore our global data. */
5197 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
5198 dwarf2_objfile_data_key
);
5200 /* If this psymtab is constructed from a debug-only objfile, the
5201 has_section_at_zero flag will not necessarily be correct. We
5202 can get the correct value for this flag by looking at the data
5203 associated with the (presumably stripped) associated objfile. */
5204 if (pst
->objfile
->separate_debug_objfile_backlink
)
5206 struct dwarf2_per_objfile
*dpo_backlink
5207 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
5208 dwarf2_objfile_data_key
);
5210 dwarf2_per_objfile
->has_section_at_zero
5211 = dpo_backlink
->has_section_at_zero
;
5214 dwarf2_per_objfile
->reading_partial_symbols
= 0;
5216 psymtab_to_symtab_1 (pst
);
5218 /* Finish up the debug error message. */
5220 printf_filtered (_("done.\n"));
5224 process_cu_includes ();
5227 /* Reading in full CUs. */
5229 /* Add PER_CU to the queue. */
5232 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
5233 enum language pretend_language
)
5235 struct dwarf2_queue_item
*item
;
5238 item
= xmalloc (sizeof (*item
));
5239 item
->per_cu
= per_cu
;
5240 item
->pretend_language
= pretend_language
;
5243 if (dwarf2_queue
== NULL
)
5244 dwarf2_queue
= item
;
5246 dwarf2_queue_tail
->next
= item
;
5248 dwarf2_queue_tail
= item
;
5251 /* Process the queue. */
5254 process_queue (void)
5256 struct dwarf2_queue_item
*item
, *next_item
;
5258 /* The queue starts out with one item, but following a DIE reference
5259 may load a new CU, adding it to the end of the queue. */
5260 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
5262 if (dwarf2_per_objfile
->using_index
5263 ? !item
->per_cu
->v
.quick
->symtab
5264 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
5265 process_full_comp_unit (item
->per_cu
, item
->pretend_language
);
5267 item
->per_cu
->queued
= 0;
5268 next_item
= item
->next
;
5272 dwarf2_queue_tail
= NULL
;
5275 /* Free all allocated queue entries. This function only releases anything if
5276 an error was thrown; if the queue was processed then it would have been
5277 freed as we went along. */
5280 dwarf2_release_queue (void *dummy
)
5282 struct dwarf2_queue_item
*item
, *last
;
5284 item
= dwarf2_queue
;
5287 /* Anything still marked queued is likely to be in an
5288 inconsistent state, so discard it. */
5289 if (item
->per_cu
->queued
)
5291 if (item
->per_cu
->cu
!= NULL
)
5292 free_one_cached_comp_unit (item
->per_cu
);
5293 item
->per_cu
->queued
= 0;
5301 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
5304 /* Read in full symbols for PST, and anything it depends on. */
5307 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
5309 struct dwarf2_per_cu_data
*per_cu
;
5315 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
5316 if (!pst
->dependencies
[i
]->readin
5317 && pst
->dependencies
[i
]->user
== NULL
)
5319 /* Inform about additional files that need to be read in. */
5322 /* FIXME: i18n: Need to make this a single string. */
5323 fputs_filtered (" ", gdb_stdout
);
5325 fputs_filtered ("and ", gdb_stdout
);
5327 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
5328 wrap_here (""); /* Flush output. */
5329 gdb_flush (gdb_stdout
);
5331 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
5334 per_cu
= pst
->read_symtab_private
;
5338 /* It's an include file, no symbols to read for it.
5339 Everything is in the parent symtab. */
5344 dw2_do_instantiate_symtab (per_cu
);
5347 /* Trivial hash function for die_info: the hash value of a DIE
5348 is its offset in .debug_info for this objfile. */
5351 die_hash (const void *item
)
5353 const struct die_info
*die
= item
;
5355 return die
->offset
.sect_off
;
5358 /* Trivial comparison function for die_info structures: two DIEs
5359 are equal if they have the same offset. */
5362 die_eq (const void *item_lhs
, const void *item_rhs
)
5364 const struct die_info
*die_lhs
= item_lhs
;
5365 const struct die_info
*die_rhs
= item_rhs
;
5367 return die_lhs
->offset
.sect_off
== die_rhs
->offset
.sect_off
;
5370 /* die_reader_func for load_full_comp_unit.
5371 This is identical to read_signatured_type_reader,
5372 but is kept separate for now. */
5375 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
5377 struct die_info
*comp_unit_die
,
5381 struct dwarf2_cu
*cu
= reader
->cu
;
5382 enum language
*language_ptr
= data
;
5384 gdb_assert (cu
->die_hash
== NULL
);
5386 htab_create_alloc_ex (cu
->header
.length
/ 12,
5390 &cu
->comp_unit_obstack
,
5391 hashtab_obstack_allocate
,
5392 dummy_obstack_deallocate
);
5395 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
5396 &info_ptr
, comp_unit_die
);
5397 cu
->dies
= comp_unit_die
;
5398 /* comp_unit_die is not stored in die_hash, no need. */
5400 /* We try not to read any attributes in this function, because not
5401 all CUs needed for references have been loaded yet, and symbol
5402 table processing isn't initialized. But we have to set the CU language,
5403 or we won't be able to build types correctly.
5404 Similarly, if we do not read the producer, we can not apply
5405 producer-specific interpretation. */
5406 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
5409 /* Load the DIEs associated with PER_CU into memory. */
5412 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
5413 enum language pretend_language
)
5415 gdb_assert (! this_cu
->is_debug_types
);
5417 init_cutu_and_read_dies (this_cu
, 1, 1, load_full_comp_unit_reader
,
5421 /* Add a DIE to the delayed physname list. */
5424 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
5425 const char *name
, struct die_info
*die
,
5426 struct dwarf2_cu
*cu
)
5428 struct delayed_method_info mi
;
5430 mi
.fnfield_index
= fnfield_index
;
5434 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
5437 /* A cleanup for freeing the delayed method list. */
5440 free_delayed_list (void *ptr
)
5442 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
5443 if (cu
->method_list
!= NULL
)
5445 VEC_free (delayed_method_info
, cu
->method_list
);
5446 cu
->method_list
= NULL
;
5450 /* Compute the physnames of any methods on the CU's method list.
5452 The computation of method physnames is delayed in order to avoid the
5453 (bad) condition that one of the method's formal parameters is of an as yet
5457 compute_delayed_physnames (struct dwarf2_cu
*cu
)
5460 struct delayed_method_info
*mi
;
5461 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
5463 const char *physname
;
5464 struct fn_fieldlist
*fn_flp
5465 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
5466 physname
= dwarf2_physname ((char *) mi
->name
, mi
->die
, cu
);
5467 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
5471 /* Go objects should be embedded in a DW_TAG_module DIE,
5472 and it's not clear if/how imported objects will appear.
5473 To keep Go support simple until that's worked out,
5474 go back through what we've read and create something usable.
5475 We could do this while processing each DIE, and feels kinda cleaner,
5476 but that way is more invasive.
5477 This is to, for example, allow the user to type "p var" or "b main"
5478 without having to specify the package name, and allow lookups
5479 of module.object to work in contexts that use the expression
5483 fixup_go_packaging (struct dwarf2_cu
*cu
)
5485 char *package_name
= NULL
;
5486 struct pending
*list
;
5489 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
5491 for (i
= 0; i
< list
->nsyms
; ++i
)
5493 struct symbol
*sym
= list
->symbol
[i
];
5495 if (SYMBOL_LANGUAGE (sym
) == language_go
5496 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
5498 char *this_package_name
= go_symbol_package_name (sym
);
5500 if (this_package_name
== NULL
)
5502 if (package_name
== NULL
)
5503 package_name
= this_package_name
;
5506 if (strcmp (package_name
, this_package_name
) != 0)
5507 complaint (&symfile_complaints
,
5508 _("Symtab %s has objects from two different Go packages: %s and %s"),
5509 (sym
->symtab
&& sym
->symtab
->filename
5510 ? sym
->symtab
->filename
5511 : cu
->objfile
->name
),
5512 this_package_name
, package_name
);
5513 xfree (this_package_name
);
5519 if (package_name
!= NULL
)
5521 struct objfile
*objfile
= cu
->objfile
;
5522 struct type
*type
= init_type (TYPE_CODE_MODULE
, 0, 0,
5523 package_name
, objfile
);
5526 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
5528 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
5529 SYMBOL_SET_LANGUAGE (sym
, language_go
);
5530 SYMBOL_SET_NAMES (sym
, package_name
, strlen (package_name
), 1, objfile
);
5531 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
5532 e.g., "main" finds the "main" module and not C's main(). */
5533 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
5534 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5535 SYMBOL_TYPE (sym
) = type
;
5537 add_symbol_to_list (sym
, &global_symbols
);
5539 xfree (package_name
);
5543 static void compute_symtab_includes (struct dwarf2_per_cu_data
*per_cu
);
5545 /* Return the symtab for PER_CU. This works properly regardless of
5546 whether we're using the index or psymtabs. */
5548 static struct symtab
*
5549 get_symtab (struct dwarf2_per_cu_data
*per_cu
)
5551 return (dwarf2_per_objfile
->using_index
5552 ? per_cu
->v
.quick
->symtab
5553 : per_cu
->v
.psymtab
->symtab
);
5556 /* A helper function for computing the list of all symbol tables
5557 included by PER_CU. */
5560 recursively_compute_inclusions (VEC (dwarf2_per_cu_ptr
) **result
,
5561 htab_t all_children
,
5562 struct dwarf2_per_cu_data
*per_cu
)
5566 struct dwarf2_per_cu_data
*iter
;
5568 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
5571 /* This inclusion and its children have been processed. */
5576 /* Only add a CU if it has a symbol table. */
5577 if (get_symtab (per_cu
) != NULL
)
5578 VEC_safe_push (dwarf2_per_cu_ptr
, *result
, per_cu
);
5581 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
5583 recursively_compute_inclusions (result
, all_children
, iter
);
5586 /* Compute the symtab 'includes' fields for the symtab related to
5590 compute_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
5592 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
5595 struct dwarf2_per_cu_data
*iter
;
5596 VEC (dwarf2_per_cu_ptr
) *result_children
= NULL
;
5597 htab_t all_children
;
5598 struct symtab
*symtab
= get_symtab (per_cu
);
5600 /* If we don't have a symtab, we can just skip this case. */
5604 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
5605 NULL
, xcalloc
, xfree
);
5608 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
5611 recursively_compute_inclusions (&result_children
, all_children
, iter
);
5613 /* Now we have a transitive closure of all the included CUs, so
5614 we can convert it to a list of symtabs. */
5615 len
= VEC_length (dwarf2_per_cu_ptr
, result_children
);
5617 = obstack_alloc (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
5618 (len
+ 1) * sizeof (struct symtab
*));
5620 VEC_iterate (dwarf2_per_cu_ptr
, result_children
, ix
, iter
);
5622 symtab
->includes
[ix
] = get_symtab (iter
);
5623 symtab
->includes
[len
] = NULL
;
5625 VEC_free (dwarf2_per_cu_ptr
, result_children
);
5626 htab_delete (all_children
);
5630 /* Compute the 'includes' field for the symtabs of all the CUs we just
5634 process_cu_includes (void)
5637 struct dwarf2_per_cu_data
*iter
;
5640 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
5643 compute_symtab_includes (iter
);
5645 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
5648 /* Generate full symbol information for PER_CU, whose DIEs have
5649 already been loaded into memory. */
5652 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
5653 enum language pretend_language
)
5655 struct dwarf2_cu
*cu
= per_cu
->cu
;
5656 struct objfile
*objfile
= per_cu
->objfile
;
5657 CORE_ADDR lowpc
, highpc
;
5658 struct symtab
*symtab
;
5659 struct cleanup
*back_to
, *delayed_list_cleanup
;
5662 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5665 back_to
= make_cleanup (really_free_pendings
, NULL
);
5666 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
5668 cu
->list_in_scope
= &file_symbols
;
5670 cu
->language
= pretend_language
;
5671 cu
->language_defn
= language_def (cu
->language
);
5673 /* Do line number decoding in read_file_scope () */
5674 process_die (cu
->dies
, cu
);
5676 /* For now fudge the Go package. */
5677 if (cu
->language
== language_go
)
5678 fixup_go_packaging (cu
);
5680 /* Now that we have processed all the DIEs in the CU, all the types
5681 should be complete, and it should now be safe to compute all of the
5683 compute_delayed_physnames (cu
);
5684 do_cleanups (delayed_list_cleanup
);
5686 /* Some compilers don't define a DW_AT_high_pc attribute for the
5687 compilation unit. If the DW_AT_high_pc is missing, synthesize
5688 it, by scanning the DIE's below the compilation unit. */
5689 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
5691 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
5695 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
5697 /* Set symtab language to language from DW_AT_language. If the
5698 compilation is from a C file generated by language preprocessors, do
5699 not set the language if it was already deduced by start_subfile. */
5700 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
5701 symtab
->language
= cu
->language
;
5703 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
5704 produce DW_AT_location with location lists but it can be possibly
5705 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
5706 there were bugs in prologue debug info, fixed later in GCC-4.5
5707 by "unwind info for epilogues" patch (which is not directly related).
5709 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
5710 needed, it would be wrong due to missing DW_AT_producer there.
5712 Still one can confuse GDB by using non-standard GCC compilation
5713 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
5715 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
5716 symtab
->locations_valid
= 1;
5718 if (gcc_4_minor
>= 5)
5719 symtab
->epilogue_unwind_valid
= 1;
5721 symtab
->call_site_htab
= cu
->call_site_htab
;
5724 if (dwarf2_per_objfile
->using_index
)
5725 per_cu
->v
.quick
->symtab
= symtab
;
5728 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
5729 pst
->symtab
= symtab
;
5733 /* Push it for inclusion processing later. */
5734 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
5736 do_cleanups (back_to
);
5739 /* Process an imported unit DIE. */
5742 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
5744 struct attribute
*attr
;
5746 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
5749 struct dwarf2_per_cu_data
*per_cu
;
5750 struct symtab
*imported_symtab
;
5753 offset
= dwarf2_get_ref_die_offset (attr
);
5754 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5756 /* Queue the unit, if needed. */
5757 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
5758 load_full_comp_unit (per_cu
, cu
->language
);
5760 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
5765 /* Process a die and its children. */
5768 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
5772 case DW_TAG_padding
:
5774 case DW_TAG_compile_unit
:
5775 case DW_TAG_partial_unit
:
5776 read_file_scope (die
, cu
);
5778 case DW_TAG_type_unit
:
5779 read_type_unit_scope (die
, cu
);
5781 case DW_TAG_subprogram
:
5782 case DW_TAG_inlined_subroutine
:
5783 read_func_scope (die
, cu
);
5785 case DW_TAG_lexical_block
:
5786 case DW_TAG_try_block
:
5787 case DW_TAG_catch_block
:
5788 read_lexical_block_scope (die
, cu
);
5790 case DW_TAG_GNU_call_site
:
5791 read_call_site_scope (die
, cu
);
5793 case DW_TAG_class_type
:
5794 case DW_TAG_interface_type
:
5795 case DW_TAG_structure_type
:
5796 case DW_TAG_union_type
:
5797 process_structure_scope (die
, cu
);
5799 case DW_TAG_enumeration_type
:
5800 process_enumeration_scope (die
, cu
);
5803 /* These dies have a type, but processing them does not create
5804 a symbol or recurse to process the children. Therefore we can
5805 read them on-demand through read_type_die. */
5806 case DW_TAG_subroutine_type
:
5807 case DW_TAG_set_type
:
5808 case DW_TAG_array_type
:
5809 case DW_TAG_pointer_type
:
5810 case DW_TAG_ptr_to_member_type
:
5811 case DW_TAG_reference_type
:
5812 case DW_TAG_string_type
:
5815 case DW_TAG_base_type
:
5816 case DW_TAG_subrange_type
:
5817 case DW_TAG_typedef
:
5818 /* Add a typedef symbol for the type definition, if it has a
5820 new_symbol (die
, read_type_die (die
, cu
), cu
);
5822 case DW_TAG_common_block
:
5823 read_common_block (die
, cu
);
5825 case DW_TAG_common_inclusion
:
5827 case DW_TAG_namespace
:
5828 processing_has_namespace_info
= 1;
5829 read_namespace (die
, cu
);
5832 processing_has_namespace_info
= 1;
5833 read_module (die
, cu
);
5835 case DW_TAG_imported_declaration
:
5836 case DW_TAG_imported_module
:
5837 processing_has_namespace_info
= 1;
5838 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
5839 || cu
->language
!= language_fortran
))
5840 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
5841 dwarf_tag_name (die
->tag
));
5842 read_import_statement (die
, cu
);
5845 case DW_TAG_imported_unit
:
5846 process_imported_unit_die (die
, cu
);
5850 new_symbol (die
, NULL
, cu
);
5855 /* A helper function for dwarf2_compute_name which determines whether DIE
5856 needs to have the name of the scope prepended to the name listed in the
5860 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
5862 struct attribute
*attr
;
5866 case DW_TAG_namespace
:
5867 case DW_TAG_typedef
:
5868 case DW_TAG_class_type
:
5869 case DW_TAG_interface_type
:
5870 case DW_TAG_structure_type
:
5871 case DW_TAG_union_type
:
5872 case DW_TAG_enumeration_type
:
5873 case DW_TAG_enumerator
:
5874 case DW_TAG_subprogram
:
5878 case DW_TAG_variable
:
5879 case DW_TAG_constant
:
5880 /* We only need to prefix "globally" visible variables. These include
5881 any variable marked with DW_AT_external or any variable that
5882 lives in a namespace. [Variables in anonymous namespaces
5883 require prefixing, but they are not DW_AT_external.] */
5885 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
5887 struct dwarf2_cu
*spec_cu
= cu
;
5889 return die_needs_namespace (die_specification (die
, &spec_cu
),
5893 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5894 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
5895 && die
->parent
->tag
!= DW_TAG_module
)
5897 /* A variable in a lexical block of some kind does not need a
5898 namespace, even though in C++ such variables may be external
5899 and have a mangled name. */
5900 if (die
->parent
->tag
== DW_TAG_lexical_block
5901 || die
->parent
->tag
== DW_TAG_try_block
5902 || die
->parent
->tag
== DW_TAG_catch_block
5903 || die
->parent
->tag
== DW_TAG_subprogram
)
5912 /* Retrieve the last character from a mem_file. */
5915 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
5917 char *last_char_p
= (char *) object
;
5920 *last_char_p
= buffer
[length
- 1];
5923 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
5924 compute the physname for the object, which include a method's:
5925 - formal parameters (C++/Java),
5926 - receiver type (Go),
5927 - return type (Java).
5929 The term "physname" is a bit confusing.
5930 For C++, for example, it is the demangled name.
5931 For Go, for example, it's the mangled name.
5933 For Ada, return the DIE's linkage name rather than the fully qualified
5934 name. PHYSNAME is ignored..
5936 The result is allocated on the objfile_obstack and canonicalized. */
5939 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
5942 struct objfile
*objfile
= cu
->objfile
;
5945 name
= dwarf2_name (die
, cu
);
5947 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
5948 compute it by typename_concat inside GDB. */
5949 if (cu
->language
== language_ada
5950 || (cu
->language
== language_fortran
&& physname
))
5952 /* For Ada unit, we prefer the linkage name over the name, as
5953 the former contains the exported name, which the user expects
5954 to be able to reference. Ideally, we want the user to be able
5955 to reference this entity using either natural or linkage name,
5956 but we haven't started looking at this enhancement yet. */
5957 struct attribute
*attr
;
5959 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5961 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5962 if (attr
&& DW_STRING (attr
))
5963 return DW_STRING (attr
);
5966 /* These are the only languages we know how to qualify names in. */
5968 && (cu
->language
== language_cplus
|| cu
->language
== language_java
5969 || cu
->language
== language_fortran
))
5971 if (die_needs_namespace (die
, cu
))
5975 struct ui_file
*buf
;
5977 prefix
= determine_prefix (die
, cu
);
5978 buf
= mem_fileopen ();
5979 if (*prefix
!= '\0')
5981 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
5984 fputs_unfiltered (prefixed_name
, buf
);
5985 xfree (prefixed_name
);
5988 fputs_unfiltered (name
, buf
);
5990 /* Template parameters may be specified in the DIE's DW_AT_name, or
5991 as children with DW_TAG_template_type_param or
5992 DW_TAG_value_type_param. If the latter, add them to the name
5993 here. If the name already has template parameters, then
5994 skip this step; some versions of GCC emit both, and
5995 it is more efficient to use the pre-computed name.
5997 Something to keep in mind about this process: it is very
5998 unlikely, or in some cases downright impossible, to produce
5999 something that will match the mangled name of a function.
6000 If the definition of the function has the same debug info,
6001 we should be able to match up with it anyway. But fallbacks
6002 using the minimal symbol, for instance to find a method
6003 implemented in a stripped copy of libstdc++, will not work.
6004 If we do not have debug info for the definition, we will have to
6005 match them up some other way.
6007 When we do name matching there is a related problem with function
6008 templates; two instantiated function templates are allowed to
6009 differ only by their return types, which we do not add here. */
6011 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
6013 struct attribute
*attr
;
6014 struct die_info
*child
;
6017 die
->building_fullname
= 1;
6019 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
6024 struct dwarf2_locexpr_baton
*baton
;
6027 if (child
->tag
!= DW_TAG_template_type_param
6028 && child
->tag
!= DW_TAG_template_value_param
)
6033 fputs_unfiltered ("<", buf
);
6037 fputs_unfiltered (", ", buf
);
6039 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
6042 complaint (&symfile_complaints
,
6043 _("template parameter missing DW_AT_type"));
6044 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
6047 type
= die_type (child
, cu
);
6049 if (child
->tag
== DW_TAG_template_type_param
)
6051 c_print_type (type
, "", buf
, -1, 0);
6055 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
6058 complaint (&symfile_complaints
,
6059 _("template parameter missing "
6060 "DW_AT_const_value"));
6061 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
6065 dwarf2_const_value_attr (attr
, type
, name
,
6066 &cu
->comp_unit_obstack
, cu
,
6067 &value
, &bytes
, &baton
);
6069 if (TYPE_NOSIGN (type
))
6070 /* GDB prints characters as NUMBER 'CHAR'. If that's
6071 changed, this can use value_print instead. */
6072 c_printchar (value
, type
, buf
);
6075 struct value_print_options opts
;
6078 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
6082 else if (bytes
!= NULL
)
6084 v
= allocate_value (type
);
6085 memcpy (value_contents_writeable (v
), bytes
,
6086 TYPE_LENGTH (type
));
6089 v
= value_from_longest (type
, value
);
6091 /* Specify decimal so that we do not depend on
6093 get_formatted_print_options (&opts
, 'd');
6095 value_print (v
, buf
, &opts
);
6101 die
->building_fullname
= 0;
6105 /* Close the argument list, with a space if necessary
6106 (nested templates). */
6107 char last_char
= '\0';
6108 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
6109 if (last_char
== '>')
6110 fputs_unfiltered (" >", buf
);
6112 fputs_unfiltered (">", buf
);
6116 /* For Java and C++ methods, append formal parameter type
6117 information, if PHYSNAME. */
6119 if (physname
&& die
->tag
== DW_TAG_subprogram
6120 && (cu
->language
== language_cplus
6121 || cu
->language
== language_java
))
6123 struct type
*type
= read_type_die (die
, cu
);
6125 c_type_print_args (type
, buf
, 1, cu
->language
);
6127 if (cu
->language
== language_java
)
6129 /* For java, we must append the return type to method
6131 if (die
->tag
== DW_TAG_subprogram
)
6132 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
6135 else if (cu
->language
== language_cplus
)
6137 /* Assume that an artificial first parameter is
6138 "this", but do not crash if it is not. RealView
6139 marks unnamed (and thus unused) parameters as
6140 artificial; there is no way to differentiate
6142 if (TYPE_NFIELDS (type
) > 0
6143 && TYPE_FIELD_ARTIFICIAL (type
, 0)
6144 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
6145 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
6147 fputs_unfiltered (" const", buf
);
6151 name
= ui_file_obsavestring (buf
, &objfile
->objfile_obstack
,
6153 ui_file_delete (buf
);
6155 if (cu
->language
== language_cplus
)
6158 = dwarf2_canonicalize_name (name
, cu
,
6159 &objfile
->objfile_obstack
);
6170 /* Return the fully qualified name of DIE, based on its DW_AT_name.
6171 If scope qualifiers are appropriate they will be added. The result
6172 will be allocated on the objfile_obstack, or NULL if the DIE does
6173 not have a name. NAME may either be from a previous call to
6174 dwarf2_name or NULL.
6176 The output string will be canonicalized (if C++/Java). */
6179 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
6181 return dwarf2_compute_name (name
, die
, cu
, 0);
6184 /* Construct a physname for the given DIE in CU. NAME may either be
6185 from a previous call to dwarf2_name or NULL. The result will be
6186 allocated on the objfile_objstack or NULL if the DIE does not have a
6189 The output string will be canonicalized (if C++/Java). */
6192 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
6194 struct objfile
*objfile
= cu
->objfile
;
6195 struct attribute
*attr
;
6196 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
6197 struct cleanup
*back_to
;
6200 /* In this case dwarf2_compute_name is just a shortcut not building anything
6202 if (!die_needs_namespace (die
, cu
))
6203 return dwarf2_compute_name (name
, die
, cu
, 1);
6205 back_to
= make_cleanup (null_cleanup
, NULL
);
6207 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
6209 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
6211 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
6213 if (attr
&& DW_STRING (attr
))
6217 mangled
= DW_STRING (attr
);
6219 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
6220 type. It is easier for GDB users to search for such functions as
6221 `name(params)' than `long name(params)'. In such case the minimal
6222 symbol names do not match the full symbol names but for template
6223 functions there is never a need to look up their definition from their
6224 declaration so the only disadvantage remains the minimal symbol
6225 variant `long name(params)' does not have the proper inferior type.
6228 if (cu
->language
== language_go
)
6230 /* This is a lie, but we already lie to the caller new_symbol_full.
6231 new_symbol_full assumes we return the mangled name.
6232 This just undoes that lie until things are cleaned up. */
6237 demangled
= cplus_demangle (mangled
,
6238 (DMGL_PARAMS
| DMGL_ANSI
6239 | (cu
->language
== language_java
6240 ? DMGL_JAVA
| DMGL_RET_POSTFIX
6245 make_cleanup (xfree
, demangled
);
6255 if (canon
== NULL
|| check_physname
)
6257 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
6259 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
6261 /* It may not mean a bug in GDB. The compiler could also
6262 compute DW_AT_linkage_name incorrectly. But in such case
6263 GDB would need to be bug-to-bug compatible. */
6265 complaint (&symfile_complaints
,
6266 _("Computed physname <%s> does not match demangled <%s> "
6267 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
6268 physname
, canon
, mangled
, die
->offset
.sect_off
, objfile
->name
);
6270 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
6271 is available here - over computed PHYSNAME. It is safer
6272 against both buggy GDB and buggy compilers. */
6286 retval
= obsavestring (retval
, strlen (retval
),
6287 &objfile
->objfile_obstack
);
6289 do_cleanups (back_to
);
6293 /* Read the import statement specified by the given die and record it. */
6296 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
6298 struct objfile
*objfile
= cu
->objfile
;
6299 struct attribute
*import_attr
;
6300 struct die_info
*imported_die
, *child_die
;
6301 struct dwarf2_cu
*imported_cu
;
6302 const char *imported_name
;
6303 const char *imported_name_prefix
;
6304 const char *canonical_name
;
6305 const char *import_alias
;
6306 const char *imported_declaration
= NULL
;
6307 const char *import_prefix
;
6308 VEC (const_char_ptr
) *excludes
= NULL
;
6309 struct cleanup
*cleanups
;
6313 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
6314 if (import_attr
== NULL
)
6316 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
6317 dwarf_tag_name (die
->tag
));
6322 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
6323 imported_name
= dwarf2_name (imported_die
, imported_cu
);
6324 if (imported_name
== NULL
)
6326 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
6328 The import in the following code:
6342 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
6343 <52> DW_AT_decl_file : 1
6344 <53> DW_AT_decl_line : 6
6345 <54> DW_AT_import : <0x75>
6346 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
6348 <5b> DW_AT_decl_file : 1
6349 <5c> DW_AT_decl_line : 2
6350 <5d> DW_AT_type : <0x6e>
6352 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
6353 <76> DW_AT_byte_size : 4
6354 <77> DW_AT_encoding : 5 (signed)
6356 imports the wrong die ( 0x75 instead of 0x58 ).
6357 This case will be ignored until the gcc bug is fixed. */
6361 /* Figure out the local name after import. */
6362 import_alias
= dwarf2_name (die
, cu
);
6364 /* Figure out where the statement is being imported to. */
6365 import_prefix
= determine_prefix (die
, cu
);
6367 /* Figure out what the scope of the imported die is and prepend it
6368 to the name of the imported die. */
6369 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
6371 if (imported_die
->tag
!= DW_TAG_namespace
6372 && imported_die
->tag
!= DW_TAG_module
)
6374 imported_declaration
= imported_name
;
6375 canonical_name
= imported_name_prefix
;
6377 else if (strlen (imported_name_prefix
) > 0)
6379 temp
= alloca (strlen (imported_name_prefix
)
6380 + 2 + strlen (imported_name
) + 1);
6381 strcpy (temp
, imported_name_prefix
);
6382 strcat (temp
, "::");
6383 strcat (temp
, imported_name
);
6384 canonical_name
= temp
;
6387 canonical_name
= imported_name
;
6389 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
6391 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
6392 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
6393 child_die
= sibling_die (child_die
))
6395 /* DWARF-4: A Fortran use statement with a “rename list” may be
6396 represented by an imported module entry with an import attribute
6397 referring to the module and owned entries corresponding to those
6398 entities that are renamed as part of being imported. */
6400 if (child_die
->tag
!= DW_TAG_imported_declaration
)
6402 complaint (&symfile_complaints
,
6403 _("child DW_TAG_imported_declaration expected "
6404 "- DIE at 0x%x [in module %s]"),
6405 child_die
->offset
.sect_off
, objfile
->name
);
6409 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
6410 if (import_attr
== NULL
)
6412 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
6413 dwarf_tag_name (child_die
->tag
));
6418 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
6420 imported_name
= dwarf2_name (imported_die
, imported_cu
);
6421 if (imported_name
== NULL
)
6423 complaint (&symfile_complaints
,
6424 _("child DW_TAG_imported_declaration has unknown "
6425 "imported name - DIE at 0x%x [in module %s]"),
6426 child_die
->offset
.sect_off
, objfile
->name
);
6430 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
6432 process_die (child_die
, cu
);
6435 cp_add_using_directive (import_prefix
,
6438 imported_declaration
,
6440 &objfile
->objfile_obstack
);
6442 do_cleanups (cleanups
);
6445 /* Cleanup function for read_file_scope. */
6448 free_cu_line_header (void *arg
)
6450 struct dwarf2_cu
*cu
= arg
;
6452 free_line_header (cu
->line_header
);
6453 cu
->line_header
= NULL
;
6457 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
6458 char **name
, char **comp_dir
)
6460 struct attribute
*attr
;
6465 /* Find the filename. Do not use dwarf2_name here, since the filename
6466 is not a source language identifier. */
6467 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
6470 *name
= DW_STRING (attr
);
6473 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
6475 *comp_dir
= DW_STRING (attr
);
6476 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
6478 *comp_dir
= ldirname (*name
);
6479 if (*comp_dir
!= NULL
)
6480 make_cleanup (xfree
, *comp_dir
);
6482 if (*comp_dir
!= NULL
)
6484 /* Irix 6.2 native cc prepends <machine>.: to the compilation
6485 directory, get rid of it. */
6486 char *cp
= strchr (*comp_dir
, ':');
6488 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
6493 *name
= "<unknown>";
6496 /* Handle DW_AT_stmt_list for a compilation unit or type unit.
6497 DIE is the DW_TAG_compile_unit or DW_TAG_type_unit die for CU.
6498 COMP_DIR is the compilation directory.
6499 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
6502 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
6503 const char *comp_dir
, int want_line_info
)
6505 struct attribute
*attr
;
6507 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6510 unsigned int line_offset
= DW_UNSND (attr
);
6511 struct line_header
*line_header
6512 = dwarf_decode_line_header (line_offset
, cu
);
6516 cu
->line_header
= line_header
;
6517 make_cleanup (free_cu_line_header
, cu
);
6518 dwarf_decode_lines (line_header
, comp_dir
, cu
, NULL
, want_line_info
);
6523 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
6526 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6528 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6529 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
6530 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
6531 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
6532 struct attribute
*attr
;
6534 char *comp_dir
= NULL
;
6535 struct die_info
*child_die
;
6536 bfd
*abfd
= objfile
->obfd
;
6539 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6541 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
6543 /* If we didn't find a lowpc, set it to highpc to avoid complaints
6544 from finish_block. */
6545 if (lowpc
== ((CORE_ADDR
) -1))
6550 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
6552 prepare_one_comp_unit (cu
, die
, cu
->language
);
6554 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
6555 standardised yet. As a workaround for the language detection we fall
6556 back to the DW_AT_producer string. */
6557 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
6558 cu
->language
= language_opencl
;
6560 /* Similar hack for Go. */
6561 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
6562 set_cu_language (DW_LANG_Go
, cu
);
6564 /* We assume that we're processing GCC output. */
6565 processing_gcc_compilation
= 2;
6567 processing_has_namespace_info
= 0;
6569 start_symtab (name
, comp_dir
, lowpc
);
6570 record_debugformat ("DWARF 2");
6571 record_producer (cu
->producer
);
6573 /* Decode line number information if present. We do this before
6574 processing child DIEs, so that the line header table is available
6575 for DW_AT_decl_file. */
6576 handle_DW_AT_stmt_list (die
, cu
, comp_dir
, 1);
6578 /* Process all dies in compilation unit. */
6579 if (die
->child
!= NULL
)
6581 child_die
= die
->child
;
6582 while (child_die
&& child_die
->tag
)
6584 process_die (child_die
, cu
);
6585 child_die
= sibling_die (child_die
);
6589 /* Decode macro information, if present. Dwarf 2 macro information
6590 refers to information in the line number info statement program
6591 header, so we can only read it if we've read the header
6593 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
6594 if (attr
&& cu
->line_header
)
6596 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
6597 complaint (&symfile_complaints
,
6598 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
6600 dwarf_decode_macros (cu
->line_header
, DW_UNSND (attr
),
6602 &dwarf2_per_objfile
->macro
, 1,
6607 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
6608 if (attr
&& cu
->line_header
)
6610 unsigned int macro_offset
= DW_UNSND (attr
);
6612 dwarf_decode_macros (cu
->line_header
, macro_offset
,
6614 &dwarf2_per_objfile
->macinfo
, 0,
6619 do_cleanups (back_to
);
6622 /* Process DW_TAG_type_unit.
6623 For TUs we want to skip the first top level sibling if it's not the
6624 actual type being defined by this TU. In this case the first top
6625 level sibling is there to provide context only. */
6628 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6630 struct objfile
*objfile
= cu
->objfile
;
6631 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
6633 struct attribute
*attr
;
6635 char *comp_dir
= NULL
;
6636 struct die_info
*child_die
;
6637 bfd
*abfd
= objfile
->obfd
;
6639 /* start_symtab needs a low pc, but we don't really have one.
6640 Do what read_file_scope would do in the absence of such info. */
6641 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6643 /* Find the filename. Do not use dwarf2_name here, since the filename
6644 is not a source language identifier. */
6645 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
6647 name
= DW_STRING (attr
);
6649 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
6651 comp_dir
= DW_STRING (attr
);
6652 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
6654 comp_dir
= ldirname (name
);
6655 if (comp_dir
!= NULL
)
6656 make_cleanup (xfree
, comp_dir
);
6662 prepare_one_comp_unit (cu
, die
, language_minimal
);
6664 /* We assume that we're processing GCC output. */
6665 processing_gcc_compilation
= 2;
6667 processing_has_namespace_info
= 0;
6669 start_symtab (name
, comp_dir
, lowpc
);
6670 record_debugformat ("DWARF 2");
6671 record_producer (cu
->producer
);
6673 /* Decode line number information if present. We do this before
6674 processing child DIEs, so that the line header table is available
6675 for DW_AT_decl_file.
6676 We don't need the pc/line-number mapping for type units. */
6677 handle_DW_AT_stmt_list (die
, cu
, comp_dir
, 0);
6679 /* Process the dies in the type unit. */
6680 if (die
->child
== NULL
)
6682 dump_die_for_error (die
);
6683 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
6684 bfd_get_filename (abfd
));
6687 child_die
= die
->child
;
6689 while (child_die
&& child_die
->tag
)
6691 process_die (child_die
, cu
);
6693 child_die
= sibling_die (child_die
);
6696 do_cleanups (back_to
);
6702 hash_dwo_file (const void *item
)
6704 const struct dwo_file
*dwo_file
= item
;
6706 return htab_hash_string (dwo_file
->dwo_name
);
6710 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
6712 const struct dwo_file
*lhs
= item_lhs
;
6713 const struct dwo_file
*rhs
= item_rhs
;
6715 return strcmp (lhs
->dwo_name
, rhs
->dwo_name
) == 0;
6718 /* Allocate a hash table for DWO files. */
6721 allocate_dwo_file_hash_table (void)
6723 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6725 return htab_create_alloc_ex (41,
6729 &objfile
->objfile_obstack
,
6730 hashtab_obstack_allocate
,
6731 dummy_obstack_deallocate
);
6735 hash_dwo_unit (const void *item
)
6737 const struct dwo_unit
*dwo_unit
= item
;
6739 /* This drops the top 32 bits of the id, but is ok for a hash. */
6740 return dwo_unit
->signature
;
6744 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
6746 const struct dwo_unit
*lhs
= item_lhs
;
6747 const struct dwo_unit
*rhs
= item_rhs
;
6749 /* The signature is assumed to be unique within the DWO file.
6750 So while object file CU dwo_id's always have the value zero,
6751 that's OK, assuming each object file DWO file has only one CU,
6752 and that's the rule for now. */
6753 return lhs
->signature
== rhs
->signature
;
6756 /* Allocate a hash table for DWO CUs,TUs.
6757 There is one of these tables for each of CUs,TUs for each DWO file. */
6760 allocate_dwo_unit_table (struct objfile
*objfile
)
6762 /* Start out with a pretty small number.
6763 Generally DWO files contain only one CU and maybe some TUs. */
6764 return htab_create_alloc_ex (3,
6768 &objfile
->objfile_obstack
,
6769 hashtab_obstack_allocate
,
6770 dummy_obstack_deallocate
);
6773 /* This function is mapped across the sections and remembers the offset and
6774 size of each of the DWO debugging sections we are interested in. */
6777 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_file_ptr
)
6779 struct dwo_file
*dwo_file
= dwo_file_ptr
;
6780 const struct dwo_section_names
*names
= &dwo_section_names
;
6782 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
6784 dwo_file
->sections
.abbrev
.asection
= sectp
;
6785 dwo_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
6787 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
6789 dwo_file
->sections
.info
.asection
= sectp
;
6790 dwo_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
6792 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
6794 dwo_file
->sections
.line
.asection
= sectp
;
6795 dwo_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
6797 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
6799 dwo_file
->sections
.loc
.asection
= sectp
;
6800 dwo_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
6802 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
6804 dwo_file
->sections
.str
.asection
= sectp
;
6805 dwo_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
6807 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
6809 dwo_file
->sections
.str_offsets
.asection
= sectp
;
6810 dwo_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
6812 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
6814 struct dwarf2_section_info type_section
;
6816 memset (&type_section
, 0, sizeof (type_section
));
6817 type_section
.asection
= sectp
;
6818 type_section
.size
= bfd_get_section_size (sectp
);
6819 VEC_safe_push (dwarf2_section_info_def
, dwo_file
->sections
.types
,
6824 /* Structure used to pass data to create_debug_info_hash_table_reader. */
6826 struct create_dwo_info_table_data
6828 struct dwo_file
*dwo_file
;
6832 /* die_reader_func for create_debug_info_hash_table. */
6835 create_debug_info_hash_table_reader (const struct die_reader_specs
*reader
,
6837 struct die_info
*comp_unit_die
,
6841 struct dwarf2_cu
*cu
= reader
->cu
;
6842 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6843 sect_offset offset
= cu
->per_cu
->offset
;
6844 struct dwarf2_section_info
*section
= cu
->per_cu
->info_or_types_section
;
6845 struct create_dwo_info_table_data
*data
= datap
;
6846 struct dwo_file
*dwo_file
= data
->dwo_file
;
6847 htab_t cu_htab
= data
->cu_htab
;
6849 struct attribute
*attr
;
6850 struct dwo_unit
*dwo_unit
;
6852 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
6855 error (_("Dwarf Error: debug entry at offset 0x%x is missing"
6856 " its dwo_id [in module %s]"),
6857 offset
.sect_off
, dwo_file
->dwo_name
);
6861 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
6862 dwo_unit
->dwo_file
= dwo_file
;
6863 dwo_unit
->signature
= DW_UNSND (attr
);
6864 dwo_unit
->info_or_types_section
= section
;
6865 dwo_unit
->offset
= offset
;
6866 dwo_unit
->length
= cu
->per_cu
->length
;
6868 slot
= htab_find_slot (cu_htab
, dwo_unit
, INSERT
);
6869 gdb_assert (slot
!= NULL
);
6872 const struct dwo_unit
*dup_dwo_unit
= *slot
;
6874 complaint (&symfile_complaints
,
6875 _("debug entry at offset 0x%x is duplicate to the entry at"
6876 " offset 0x%x, dwo_id 0x%s [in module %s]"),
6877 offset
.sect_off
, dup_dwo_unit
->offset
.sect_off
,
6878 phex (dwo_unit
->signature
, sizeof (dwo_unit
->signature
)),
6879 dwo_file
->dwo_name
);
6884 if (dwarf2_die_debug
)
6885 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id 0x%s\n",
6887 phex (dwo_unit
->signature
,
6888 sizeof (dwo_unit
->signature
)));
6891 /* Create a hash table to map DWO IDs to their CU entry in .debug_info.dwo. */
6894 create_debug_info_hash_table (struct dwo_file
*dwo_file
)
6896 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6897 struct dwarf2_section_info
*section
= &dwo_file
->sections
.info
;
6900 gdb_byte
*info_ptr
, *end_ptr
;
6901 struct create_dwo_info_table_data create_dwo_info_table_data
;
6903 dwarf2_read_section (objfile
, section
);
6904 info_ptr
= section
->buffer
;
6906 if (info_ptr
== NULL
)
6909 /* We can't set abfd until now because the section may be empty or
6910 not present, in which case section->asection will be NULL. */
6911 abfd
= section
->asection
->owner
;
6913 if (dwarf2_die_debug
)
6914 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_info.dwo for %s:\n",
6915 bfd_get_filename (abfd
));
6917 cu_htab
= allocate_dwo_unit_table (objfile
);
6919 create_dwo_info_table_data
.dwo_file
= dwo_file
;
6920 create_dwo_info_table_data
.cu_htab
= cu_htab
;
6922 end_ptr
= info_ptr
+ section
->size
;
6923 while (info_ptr
< end_ptr
)
6925 struct dwarf2_per_cu_data per_cu
;
6927 memset (&per_cu
, 0, sizeof (per_cu
));
6928 per_cu
.objfile
= objfile
;
6929 per_cu
.is_debug_types
= 0;
6930 per_cu
.offset
.sect_off
= info_ptr
- section
->buffer
;
6931 per_cu
.info_or_types_section
= section
;
6933 init_cutu_and_read_dies_no_follow (&per_cu
,
6934 &dwo_file
->sections
.abbrev
,
6936 create_debug_info_hash_table_reader
,
6937 &create_dwo_info_table_data
);
6939 info_ptr
+= per_cu
.length
;
6945 /* Subroutine of open_dwo_file to simplify it.
6946 Open the file specified by FILE_NAME and hand it off to BFD for
6947 preliminary analysis. Return a newly initialized bfd *, which
6948 includes a canonicalized copy of FILE_NAME.
6949 In case of trouble, return NULL.
6950 NOTE: This function is derived from symfile_bfd_open. */
6953 try_open_dwo_file (const char *file_name
)
6957 char *absolute_name
;
6959 desc
= openp (debug_file_directory
, OPF_TRY_CWD_FIRST
, file_name
,
6960 O_RDONLY
| O_BINARY
, &absolute_name
);
6964 sym_bfd
= bfd_fopen (absolute_name
, gnutarget
, FOPEN_RB
, desc
);
6967 xfree (absolute_name
);
6970 bfd_set_cacheable (sym_bfd
, 1);
6972 if (!bfd_check_format (sym_bfd
, bfd_object
))
6974 bfd_close (sym_bfd
); /* This also closes desc. */
6975 xfree (absolute_name
);
6979 /* bfd_usrdata exists for applications and libbfd must not touch it. */
6980 gdb_assert (bfd_usrdata (sym_bfd
) == NULL
);
6985 /* Try to open DWO file DWO_NAME.
6986 COMP_DIR is the DW_AT_comp_dir attribute.
6987 The result is the bfd handle of the file.
6988 If there is a problem finding or opening the file, return NULL.
6989 Upon success, the canonicalized path of the file is stored in the bfd,
6990 same as symfile_bfd_open. */
6993 open_dwo_file (const char *dwo_name
, const char *comp_dir
)
6997 if (IS_ABSOLUTE_PATH (dwo_name
))
6998 return try_open_dwo_file (dwo_name
);
7000 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
7002 if (comp_dir
!= NULL
)
7004 char *path_to_try
= concat (comp_dir
, SLASH_STRING
, dwo_name
, NULL
);
7006 /* NOTE: If comp_dir is a relative path, this will also try the
7007 search path, which seems useful. */
7008 abfd
= try_open_dwo_file (path_to_try
);
7009 xfree (path_to_try
);
7014 /* That didn't work, try debug-file-directory, which, despite its name,
7015 is a list of paths. */
7017 if (*debug_file_directory
== '\0')
7020 return try_open_dwo_file (dwo_name
);
7023 /* Initialize the use of the DWO file specified by DWO_NAME. */
7025 static struct dwo_file
*
7026 init_dwo_file (const char *dwo_name
, const char *comp_dir
)
7028 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7029 struct dwo_file
*dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7032 struct cleanup
*cleanups
;
7034 if (dwarf2_die_debug
)
7035 fprintf_unfiltered (gdb_stdlog
, "Reading DWO file %s:\n", dwo_name
);
7037 abfd
= open_dwo_file (dwo_name
, comp_dir
);
7040 dwo_file
->dwo_name
= dwo_name
;
7041 dwo_file
->dwo_bfd
= abfd
;
7043 cleanups
= make_cleanup (free_dwo_file_cleanup
, dwo_file
);
7045 bfd_map_over_sections (abfd
, dwarf2_locate_dwo_sections
, dwo_file
);
7047 dwo_file
->cus
= create_debug_info_hash_table (dwo_file
);
7049 dwo_file
->tus
= create_debug_types_hash_table (dwo_file
,
7050 dwo_file
->sections
.types
);
7052 discard_cleanups (cleanups
);
7057 /* Lookup DWO file DWO_NAME. */
7059 static struct dwo_file
*
7060 lookup_dwo_file (char *dwo_name
, const char *comp_dir
)
7062 struct dwo_file
*dwo_file
;
7063 struct dwo_file find_entry
;
7066 if (dwarf2_per_objfile
->dwo_files
== NULL
)
7067 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
7069 /* Have we already seen this DWO file? */
7070 find_entry
.dwo_name
= dwo_name
;
7071 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
7073 /* If not, read it in and build a table of the DWOs it contains. */
7075 *slot
= init_dwo_file (dwo_name
, comp_dir
);
7077 /* NOTE: This will be NULL if unable to open the file. */
7083 /* Lookup the DWO CU referenced from THIS_CU in DWO file DWO_NAME.
7084 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
7085 SIGNATURE is the "dwo_id" of the CU (for consistency we use the same
7086 nomenclature as TUs).
7087 The result is the DWO CU or NULL if we didn't find it
7088 (dwo_id mismatch or couldn't find the DWO file). */
7090 static struct dwo_unit
*
7091 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
7092 char *dwo_name
, const char *comp_dir
,
7095 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7096 struct dwo_file
*dwo_file
;
7098 dwo_file
= lookup_dwo_file (dwo_name
, comp_dir
);
7099 if (dwo_file
== NULL
)
7102 /* Look up the DWO using its signature(dwo_id). */
7104 if (dwo_file
->cus
!= NULL
)
7106 struct dwo_unit find_dwo_cu
, *dwo_cu
;
7108 find_dwo_cu
.signature
= signature
;
7109 dwo_cu
= htab_find (dwo_file
->cus
, &find_dwo_cu
);
7115 /* We didn't find it. This must mean a dwo_id mismatch. */
7117 complaint (&symfile_complaints
,
7118 _("Could not find DWO CU referenced by CU at offset 0x%x"
7120 this_cu
->offset
.sect_off
, objfile
->name
);
7124 /* Lookup the DWO TU referenced from THIS_TU in DWO file DWO_NAME.
7125 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
7126 The result is the DWO CU or NULL if we didn't find it
7127 (dwo_id mismatch or couldn't find the DWO file). */
7129 static struct dwo_unit
*
7130 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
7131 char *dwo_name
, const char *comp_dir
)
7133 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7134 struct dwo_file
*dwo_file
;
7136 dwo_file
= lookup_dwo_file (dwo_name
, comp_dir
);
7137 if (dwo_file
== NULL
)
7140 /* Look up the DWO using its signature(dwo_id). */
7142 if (dwo_file
->tus
!= NULL
)
7144 struct dwo_unit find_dwo_tu
, *dwo_tu
;
7146 find_dwo_tu
.signature
= this_tu
->signature
;
7147 dwo_tu
= htab_find (dwo_file
->tus
, &find_dwo_tu
);
7153 /* We didn't find it. This must mean a dwo_id mismatch. */
7155 complaint (&symfile_complaints
,
7156 _("Could not find DWO TU referenced by TU at offset 0x%x"
7158 this_tu
->per_cu
.offset
.sect_off
, objfile
->name
);
7162 /* Free all resources associated with DWO_FILE.
7163 Close the DWO file and munmap the sections.
7164 All memory should be on the objfile obstack. */
7167 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
7170 struct dwarf2_section_info
*section
;
7172 gdb_assert (dwo_file
->dwo_bfd
!= objfile
->obfd
);
7173 bfd_close (dwo_file
->dwo_bfd
);
7175 munmap_section_buffer (&dwo_file
->sections
.abbrev
);
7176 munmap_section_buffer (&dwo_file
->sections
.info
);
7177 munmap_section_buffer (&dwo_file
->sections
.line
);
7178 munmap_section_buffer (&dwo_file
->sections
.loc
);
7179 munmap_section_buffer (&dwo_file
->sections
.str
);
7180 munmap_section_buffer (&dwo_file
->sections
.str_offsets
);
7183 VEC_iterate (dwarf2_section_info_def
, dwo_file
->sections
.types
,
7186 munmap_section_buffer (section
);
7188 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
7191 /* Wrapper for free_dwo_file for use in cleanups. */
7194 free_dwo_file_cleanup (void *arg
)
7196 struct dwo_file
*dwo_file
= (struct dwo_file
*) arg
;
7197 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7199 free_dwo_file (dwo_file
, objfile
);
7202 /* Traversal function for free_dwo_files. */
7205 free_dwo_file_from_slot (void **slot
, void *info
)
7207 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
7208 struct objfile
*objfile
= (struct objfile
*) info
;
7210 free_dwo_file (dwo_file
, objfile
);
7215 /* Free all resources associated with DWO_FILES. */
7218 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
7220 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
7223 /* Read in various DIEs. */
7225 /* qsort helper for inherit_abstract_dies. */
7228 unsigned_int_compar (const void *ap
, const void *bp
)
7230 unsigned int a
= *(unsigned int *) ap
;
7231 unsigned int b
= *(unsigned int *) bp
;
7233 return (a
> b
) - (b
> a
);
7236 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
7237 Inherit only the children of the DW_AT_abstract_origin DIE not being
7238 already referenced by DW_AT_abstract_origin from the children of the
7242 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
7244 struct die_info
*child_die
;
7245 unsigned die_children_count
;
7246 /* CU offsets which were referenced by children of the current DIE. */
7247 sect_offset
*offsets
;
7248 sect_offset
*offsets_end
, *offsetp
;
7249 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
7250 struct die_info
*origin_die
;
7251 /* Iterator of the ORIGIN_DIE children. */
7252 struct die_info
*origin_child_die
;
7253 struct cleanup
*cleanups
;
7254 struct attribute
*attr
;
7255 struct dwarf2_cu
*origin_cu
;
7256 struct pending
**origin_previous_list_in_scope
;
7258 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
7262 /* Note that following die references may follow to a die in a
7266 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
7268 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
7270 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
7271 origin_cu
->list_in_scope
= cu
->list_in_scope
;
7273 if (die
->tag
!= origin_die
->tag
7274 && !(die
->tag
== DW_TAG_inlined_subroutine
7275 && origin_die
->tag
== DW_TAG_subprogram
))
7276 complaint (&symfile_complaints
,
7277 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
7278 die
->offset
.sect_off
, origin_die
->offset
.sect_off
);
7280 child_die
= die
->child
;
7281 die_children_count
= 0;
7282 while (child_die
&& child_die
->tag
)
7284 child_die
= sibling_die (child_die
);
7285 die_children_count
++;
7287 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
7288 cleanups
= make_cleanup (xfree
, offsets
);
7290 offsets_end
= offsets
;
7291 child_die
= die
->child
;
7292 while (child_die
&& child_die
->tag
)
7294 /* For each CHILD_DIE, find the corresponding child of
7295 ORIGIN_DIE. If there is more than one layer of
7296 DW_AT_abstract_origin, follow them all; there shouldn't be,
7297 but GCC versions at least through 4.4 generate this (GCC PR
7299 struct die_info
*child_origin_die
= child_die
;
7300 struct dwarf2_cu
*child_origin_cu
= cu
;
7304 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
7308 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
7312 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
7313 counterpart may exist. */
7314 if (child_origin_die
!= child_die
)
7316 if (child_die
->tag
!= child_origin_die
->tag
7317 && !(child_die
->tag
== DW_TAG_inlined_subroutine
7318 && child_origin_die
->tag
== DW_TAG_subprogram
))
7319 complaint (&symfile_complaints
,
7320 _("Child DIE 0x%x and its abstract origin 0x%x have "
7321 "different tags"), child_die
->offset
.sect_off
,
7322 child_origin_die
->offset
.sect_off
);
7323 if (child_origin_die
->parent
!= origin_die
)
7324 complaint (&symfile_complaints
,
7325 _("Child DIE 0x%x and its abstract origin 0x%x have "
7326 "different parents"), child_die
->offset
.sect_off
,
7327 child_origin_die
->offset
.sect_off
);
7329 *offsets_end
++ = child_origin_die
->offset
;
7331 child_die
= sibling_die (child_die
);
7333 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
7334 unsigned_int_compar
);
7335 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
7336 if (offsetp
[-1].sect_off
== offsetp
->sect_off
)
7337 complaint (&symfile_complaints
,
7338 _("Multiple children of DIE 0x%x refer "
7339 "to DIE 0x%x as their abstract origin"),
7340 die
->offset
.sect_off
, offsetp
->sect_off
);
7343 origin_child_die
= origin_die
->child
;
7344 while (origin_child_die
&& origin_child_die
->tag
)
7346 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
7347 while (offsetp
< offsets_end
7348 && offsetp
->sect_off
< origin_child_die
->offset
.sect_off
)
7350 if (offsetp
>= offsets_end
7351 || offsetp
->sect_off
> origin_child_die
->offset
.sect_off
)
7353 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
7354 process_die (origin_child_die
, origin_cu
);
7356 origin_child_die
= sibling_die (origin_child_die
);
7358 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
7360 do_cleanups (cleanups
);
7364 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7366 struct objfile
*objfile
= cu
->objfile
;
7367 struct context_stack
*new;
7370 struct die_info
*child_die
;
7371 struct attribute
*attr
, *call_line
, *call_file
;
7374 struct block
*block
;
7375 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
7376 VEC (symbolp
) *template_args
= NULL
;
7377 struct template_symbol
*templ_func
= NULL
;
7381 /* If we do not have call site information, we can't show the
7382 caller of this inlined function. That's too confusing, so
7383 only use the scope for local variables. */
7384 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
7385 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
7386 if (call_line
== NULL
|| call_file
== NULL
)
7388 read_lexical_block_scope (die
, cu
);
7393 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7395 name
= dwarf2_name (die
, cu
);
7397 /* Ignore functions with missing or empty names. These are actually
7398 illegal according to the DWARF standard. */
7401 complaint (&symfile_complaints
,
7402 _("missing name for subprogram DIE at %d"),
7403 die
->offset
.sect_off
);
7407 /* Ignore functions with missing or invalid low and high pc attributes. */
7408 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
7410 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
7411 if (!attr
|| !DW_UNSND (attr
))
7412 complaint (&symfile_complaints
,
7413 _("cannot get low and high bounds "
7414 "for subprogram DIE at %d"),
7415 die
->offset
.sect_off
);
7422 /* If we have any template arguments, then we must allocate a
7423 different sort of symbol. */
7424 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
7426 if (child_die
->tag
== DW_TAG_template_type_param
7427 || child_die
->tag
== DW_TAG_template_value_param
)
7429 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7430 struct template_symbol
);
7431 templ_func
->base
.is_cplus_template_function
= 1;
7436 new = push_context (0, lowpc
);
7437 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
7438 (struct symbol
*) templ_func
);
7440 /* If there is a location expression for DW_AT_frame_base, record
7442 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
7444 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
7445 expression is being recorded directly in the function's symbol
7446 and not in a separate frame-base object. I guess this hack is
7447 to avoid adding some sort of frame-base adjunct/annex to the
7448 function's symbol :-(. The problem with doing this is that it
7449 results in a function symbol with a location expression that
7450 has nothing to do with the location of the function, ouch! The
7451 relationship should be: a function's symbol has-a frame base; a
7452 frame-base has-a location expression. */
7453 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
7455 cu
->list_in_scope
= &local_symbols
;
7457 if (die
->child
!= NULL
)
7459 child_die
= die
->child
;
7460 while (child_die
&& child_die
->tag
)
7462 if (child_die
->tag
== DW_TAG_template_type_param
7463 || child_die
->tag
== DW_TAG_template_value_param
)
7465 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
7468 VEC_safe_push (symbolp
, template_args
, arg
);
7471 process_die (child_die
, cu
);
7472 child_die
= sibling_die (child_die
);
7476 inherit_abstract_dies (die
, cu
);
7478 /* If we have a DW_AT_specification, we might need to import using
7479 directives from the context of the specification DIE. See the
7480 comment in determine_prefix. */
7481 if (cu
->language
== language_cplus
7482 && dwarf2_attr (die
, DW_AT_specification
, cu
))
7484 struct dwarf2_cu
*spec_cu
= cu
;
7485 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
7489 child_die
= spec_die
->child
;
7490 while (child_die
&& child_die
->tag
)
7492 if (child_die
->tag
== DW_TAG_imported_module
)
7493 process_die (child_die
, spec_cu
);
7494 child_die
= sibling_die (child_die
);
7497 /* In some cases, GCC generates specification DIEs that
7498 themselves contain DW_AT_specification attributes. */
7499 spec_die
= die_specification (spec_die
, &spec_cu
);
7503 new = pop_context ();
7504 /* Make a block for the local symbols within. */
7505 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
7506 lowpc
, highpc
, objfile
);
7508 /* For C++, set the block's scope. */
7509 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
7510 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
7511 determine_prefix (die
, cu
),
7512 processing_has_namespace_info
);
7514 /* If we have address ranges, record them. */
7515 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
7517 /* Attach template arguments to function. */
7518 if (! VEC_empty (symbolp
, template_args
))
7520 gdb_assert (templ_func
!= NULL
);
7522 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
7523 templ_func
->template_arguments
7524 = obstack_alloc (&objfile
->objfile_obstack
,
7525 (templ_func
->n_template_arguments
7526 * sizeof (struct symbol
*)));
7527 memcpy (templ_func
->template_arguments
,
7528 VEC_address (symbolp
, template_args
),
7529 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
7530 VEC_free (symbolp
, template_args
);
7533 /* In C++, we can have functions nested inside functions (e.g., when
7534 a function declares a class that has methods). This means that
7535 when we finish processing a function scope, we may need to go
7536 back to building a containing block's symbol lists. */
7537 local_symbols
= new->locals
;
7538 param_symbols
= new->params
;
7539 using_directives
= new->using_directives
;
7541 /* If we've finished processing a top-level function, subsequent
7542 symbols go in the file symbol list. */
7543 if (outermost_context_p ())
7544 cu
->list_in_scope
= &file_symbols
;
7547 /* Process all the DIES contained within a lexical block scope. Start
7548 a new scope, process the dies, and then close the scope. */
7551 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7553 struct objfile
*objfile
= cu
->objfile
;
7554 struct context_stack
*new;
7555 CORE_ADDR lowpc
, highpc
;
7556 struct die_info
*child_die
;
7559 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7561 /* Ignore blocks with missing or invalid low and high pc attributes. */
7562 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
7563 as multiple lexical blocks? Handling children in a sane way would
7564 be nasty. Might be easier to properly extend generic blocks to
7566 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
7571 push_context (0, lowpc
);
7572 if (die
->child
!= NULL
)
7574 child_die
= die
->child
;
7575 while (child_die
&& child_die
->tag
)
7577 process_die (child_die
, cu
);
7578 child_die
= sibling_die (child_die
);
7581 new = pop_context ();
7583 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
7586 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
7589 /* Note that recording ranges after traversing children, as we
7590 do here, means that recording a parent's ranges entails
7591 walking across all its children's ranges as they appear in
7592 the address map, which is quadratic behavior.
7594 It would be nicer to record the parent's ranges before
7595 traversing its children, simply overriding whatever you find
7596 there. But since we don't even decide whether to create a
7597 block until after we've traversed its children, that's hard
7599 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
7601 local_symbols
= new->locals
;
7602 using_directives
= new->using_directives
;
7605 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
7608 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7610 struct objfile
*objfile
= cu
->objfile
;
7611 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7612 CORE_ADDR pc
, baseaddr
;
7613 struct attribute
*attr
;
7614 struct call_site
*call_site
, call_site_local
;
7617 struct die_info
*child_die
;
7619 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7621 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7624 complaint (&symfile_complaints
,
7625 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
7626 "DIE 0x%x [in module %s]"),
7627 die
->offset
.sect_off
, objfile
->name
);
7630 pc
= DW_ADDR (attr
) + baseaddr
;
7632 if (cu
->call_site_htab
== NULL
)
7633 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
7634 NULL
, &objfile
->objfile_obstack
,
7635 hashtab_obstack_allocate
, NULL
);
7636 call_site_local
.pc
= pc
;
7637 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
7640 complaint (&symfile_complaints
,
7641 _("Duplicate PC %s for DW_TAG_GNU_call_site "
7642 "DIE 0x%x [in module %s]"),
7643 paddress (gdbarch
, pc
), die
->offset
.sect_off
, objfile
->name
);
7647 /* Count parameters at the caller. */
7650 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
7651 child_die
= sibling_die (child_die
))
7653 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
7655 complaint (&symfile_complaints
,
7656 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
7657 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
7658 child_die
->tag
, child_die
->offset
.sect_off
, objfile
->name
);
7665 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
7666 (sizeof (*call_site
)
7667 + (sizeof (*call_site
->parameter
)
7670 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
7673 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
7675 struct die_info
*func_die
;
7677 /* Skip also over DW_TAG_inlined_subroutine. */
7678 for (func_die
= die
->parent
;
7679 func_die
&& func_die
->tag
!= DW_TAG_subprogram
7680 && func_die
->tag
!= DW_TAG_subroutine_type
;
7681 func_die
= func_die
->parent
);
7683 /* DW_AT_GNU_all_call_sites is a superset
7684 of DW_AT_GNU_all_tail_call_sites. */
7686 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
7687 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
7689 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
7690 not complete. But keep CALL_SITE for look ups via call_site_htab,
7691 both the initial caller containing the real return address PC and
7692 the final callee containing the current PC of a chain of tail
7693 calls do not need to have the tail call list complete. But any
7694 function candidate for a virtual tail call frame searched via
7695 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
7696 determined unambiguously. */
7700 struct type
*func_type
= NULL
;
7703 func_type
= get_die_type (func_die
, cu
);
7704 if (func_type
!= NULL
)
7706 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
7708 /* Enlist this call site to the function. */
7709 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
7710 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
7713 complaint (&symfile_complaints
,
7714 _("Cannot find function owning DW_TAG_GNU_call_site "
7715 "DIE 0x%x [in module %s]"),
7716 die
->offset
.sect_off
, objfile
->name
);
7720 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
7722 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
7723 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
7724 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
7725 /* Keep NULL DWARF_BLOCK. */;
7726 else if (attr_form_is_block (attr
))
7728 struct dwarf2_locexpr_baton
*dlbaton
;
7730 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
7731 dlbaton
->data
= DW_BLOCK (attr
)->data
;
7732 dlbaton
->size
= DW_BLOCK (attr
)->size
;
7733 dlbaton
->per_cu
= cu
->per_cu
;
7735 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
7737 else if (is_ref_attr (attr
))
7739 struct dwarf2_cu
*target_cu
= cu
;
7740 struct die_info
*target_die
;
7742 target_die
= follow_die_ref_or_sig (die
, attr
, &target_cu
);
7743 gdb_assert (target_cu
->objfile
== objfile
);
7744 if (die_is_declaration (target_die
, target_cu
))
7746 const char *target_physname
;
7748 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
7749 if (target_physname
== NULL
)
7750 complaint (&symfile_complaints
,
7751 _("DW_AT_GNU_call_site_target target DIE has invalid "
7752 "physname, for referencing DIE 0x%x [in module %s]"),
7753 die
->offset
.sect_off
, objfile
->name
);
7755 SET_FIELD_PHYSNAME (call_site
->target
, (char *) target_physname
);
7761 /* DW_AT_entry_pc should be preferred. */
7762 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
7763 complaint (&symfile_complaints
,
7764 _("DW_AT_GNU_call_site_target target DIE has invalid "
7765 "low pc, for referencing DIE 0x%x [in module %s]"),
7766 die
->offset
.sect_off
, objfile
->name
);
7768 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
+ baseaddr
);
7772 complaint (&symfile_complaints
,
7773 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
7774 "block nor reference, for DIE 0x%x [in module %s]"),
7775 die
->offset
.sect_off
, objfile
->name
);
7777 call_site
->per_cu
= cu
->per_cu
;
7779 for (child_die
= die
->child
;
7780 child_die
&& child_die
->tag
;
7781 child_die
= sibling_die (child_die
))
7783 struct call_site_parameter
*parameter
;
7785 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
7787 /* Already printed the complaint above. */
7791 gdb_assert (call_site
->parameter_count
< nparams
);
7792 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
7794 /* DW_AT_location specifies the register number. Value of the data
7795 assumed for the register is contained in DW_AT_GNU_call_site_value. */
7797 attr
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
7798 if (!attr
|| !attr_form_is_block (attr
))
7800 complaint (&symfile_complaints
,
7801 _("No DW_FORM_block* DW_AT_location for "
7802 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
7803 child_die
->offset
.sect_off
, objfile
->name
);
7806 parameter
->dwarf_reg
= dwarf_block_to_dwarf_reg (DW_BLOCK (attr
)->data
,
7807 &DW_BLOCK (attr
)->data
[DW_BLOCK (attr
)->size
]);
7808 if (parameter
->dwarf_reg
== -1
7809 && !dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (attr
)->data
,
7810 &DW_BLOCK (attr
)->data
[DW_BLOCK (attr
)->size
],
7811 ¶meter
->fb_offset
))
7813 complaint (&symfile_complaints
,
7814 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
7815 "for DW_FORM_block* DW_AT_location for "
7816 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
7817 child_die
->offset
.sect_off
, objfile
->name
);
7821 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
7822 if (!attr_form_is_block (attr
))
7824 complaint (&symfile_complaints
,
7825 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
7826 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
7827 child_die
->offset
.sect_off
, objfile
->name
);
7830 parameter
->value
= DW_BLOCK (attr
)->data
;
7831 parameter
->value_size
= DW_BLOCK (attr
)->size
;
7833 /* Parameters are not pre-cleared by memset above. */
7834 parameter
->data_value
= NULL
;
7835 parameter
->data_value_size
= 0;
7836 call_site
->parameter_count
++;
7838 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
7841 if (!attr_form_is_block (attr
))
7842 complaint (&symfile_complaints
,
7843 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
7844 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
7845 child_die
->offset
.sect_off
, objfile
->name
);
7848 parameter
->data_value
= DW_BLOCK (attr
)->data
;
7849 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
7855 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
7856 Return 1 if the attributes are present and valid, otherwise, return 0.
7857 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
7860 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
7861 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
7862 struct partial_symtab
*ranges_pst
)
7864 struct objfile
*objfile
= cu
->objfile
;
7865 struct comp_unit_head
*cu_header
= &cu
->header
;
7866 bfd
*obfd
= objfile
->obfd
;
7867 unsigned int addr_size
= cu_header
->addr_size
;
7868 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
7869 /* Base address selection entry. */
7880 found_base
= cu
->base_known
;
7881 base
= cu
->base_address
;
7883 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
7884 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
7886 complaint (&symfile_complaints
,
7887 _("Offset %d out of bounds for DW_AT_ranges attribute"),
7891 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
7893 /* Read in the largest possible address. */
7894 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
7895 if ((marker
& mask
) == mask
)
7897 /* If we found the largest possible address, then
7898 read the base address. */
7899 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
7900 buffer
+= 2 * addr_size
;
7901 offset
+= 2 * addr_size
;
7907 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7911 CORE_ADDR range_beginning
, range_end
;
7913 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
7914 buffer
+= addr_size
;
7915 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
7916 buffer
+= addr_size
;
7917 offset
+= 2 * addr_size
;
7919 /* An end of list marker is a pair of zero addresses. */
7920 if (range_beginning
== 0 && range_end
== 0)
7921 /* Found the end of list entry. */
7924 /* Each base address selection entry is a pair of 2 values.
7925 The first is the largest possible address, the second is
7926 the base address. Check for a base address here. */
7927 if ((range_beginning
& mask
) == mask
)
7929 /* If we found the largest possible address, then
7930 read the base address. */
7931 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
7938 /* We have no valid base address for the ranges
7940 complaint (&symfile_complaints
,
7941 _("Invalid .debug_ranges data (no base address)"));
7945 if (range_beginning
> range_end
)
7947 /* Inverted range entries are invalid. */
7948 complaint (&symfile_complaints
,
7949 _("Invalid .debug_ranges data (inverted range)"));
7953 /* Empty range entries have no effect. */
7954 if (range_beginning
== range_end
)
7957 range_beginning
+= base
;
7960 if (ranges_pst
!= NULL
)
7961 addrmap_set_empty (objfile
->psymtabs_addrmap
,
7962 range_beginning
+ baseaddr
,
7963 range_end
- 1 + baseaddr
,
7966 /* FIXME: This is recording everything as a low-high
7967 segment of consecutive addresses. We should have a
7968 data structure for discontiguous block ranges
7972 low
= range_beginning
;
7978 if (range_beginning
< low
)
7979 low
= range_beginning
;
7980 if (range_end
> high
)
7986 /* If the first entry is an end-of-list marker, the range
7987 describes an empty scope, i.e. no instructions. */
7993 *high_return
= high
;
7997 /* Get low and high pc attributes from a die. Return 1 if the attributes
7998 are present and valid, otherwise, return 0. Return -1 if the range is
7999 discontinuous, i.e. derived from DW_AT_ranges information. */
8002 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
8003 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
8004 struct partial_symtab
*pst
)
8006 struct attribute
*attr
;
8007 struct attribute
*attr_high
;
8012 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
8015 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
8018 low
= DW_ADDR (attr
);
8019 if (attr_high
->form
== DW_FORM_addr
8020 || attr_high
->form
== DW_FORM_GNU_addr_index
)
8021 high
= DW_ADDR (attr_high
);
8023 high
= low
+ DW_UNSND (attr_high
);
8026 /* Found high w/o low attribute. */
8029 /* Found consecutive range of addresses. */
8034 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
8037 /* Value of the DW_AT_ranges attribute is the offset in the
8038 .debug_ranges section. */
8039 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
8041 /* Found discontinuous range of addresses. */
8046 /* read_partial_die has also the strict LOW < HIGH requirement. */
8050 /* When using the GNU linker, .gnu.linkonce. sections are used to
8051 eliminate duplicate copies of functions and vtables and such.
8052 The linker will arbitrarily choose one and discard the others.
8053 The AT_*_pc values for such functions refer to local labels in
8054 these sections. If the section from that file was discarded, the
8055 labels are not in the output, so the relocs get a value of 0.
8056 If this is a discarded function, mark the pc bounds as invalid,
8057 so that GDB will ignore it. */
8058 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
8067 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
8068 its low and high PC addresses. Do nothing if these addresses could not
8069 be determined. Otherwise, set LOWPC to the low address if it is smaller,
8070 and HIGHPC to the high address if greater than HIGHPC. */
8073 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
8074 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8075 struct dwarf2_cu
*cu
)
8077 CORE_ADDR low
, high
;
8078 struct die_info
*child
= die
->child
;
8080 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
8082 *lowpc
= min (*lowpc
, low
);
8083 *highpc
= max (*highpc
, high
);
8086 /* If the language does not allow nested subprograms (either inside
8087 subprograms or lexical blocks), we're done. */
8088 if (cu
->language
!= language_ada
)
8091 /* Check all the children of the given DIE. If it contains nested
8092 subprograms, then check their pc bounds. Likewise, we need to
8093 check lexical blocks as well, as they may also contain subprogram
8095 while (child
&& child
->tag
)
8097 if (child
->tag
== DW_TAG_subprogram
8098 || child
->tag
== DW_TAG_lexical_block
)
8099 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
8100 child
= sibling_die (child
);
8104 /* Get the low and high pc's represented by the scope DIE, and store
8105 them in *LOWPC and *HIGHPC. If the correct values can't be
8106 determined, set *LOWPC to -1 and *HIGHPC to 0. */
8109 get_scope_pc_bounds (struct die_info
*die
,
8110 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8111 struct dwarf2_cu
*cu
)
8113 CORE_ADDR best_low
= (CORE_ADDR
) -1;
8114 CORE_ADDR best_high
= (CORE_ADDR
) 0;
8115 CORE_ADDR current_low
, current_high
;
8117 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
8119 best_low
= current_low
;
8120 best_high
= current_high
;
8124 struct die_info
*child
= die
->child
;
8126 while (child
&& child
->tag
)
8128 switch (child
->tag
) {
8129 case DW_TAG_subprogram
:
8130 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
8132 case DW_TAG_namespace
:
8134 /* FIXME: carlton/2004-01-16: Should we do this for
8135 DW_TAG_class_type/DW_TAG_structure_type, too? I think
8136 that current GCC's always emit the DIEs corresponding
8137 to definitions of methods of classes as children of a
8138 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
8139 the DIEs giving the declarations, which could be
8140 anywhere). But I don't see any reason why the
8141 standards says that they have to be there. */
8142 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
8144 if (current_low
!= ((CORE_ADDR
) -1))
8146 best_low
= min (best_low
, current_low
);
8147 best_high
= max (best_high
, current_high
);
8155 child
= sibling_die (child
);
8160 *highpc
= best_high
;
8163 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
8167 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
8168 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
8170 struct objfile
*objfile
= cu
->objfile
;
8171 struct attribute
*attr
;
8172 struct attribute
*attr_high
;
8174 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
8177 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
8180 CORE_ADDR low
= DW_ADDR (attr
);
8182 if (attr_high
->form
== DW_FORM_addr
8183 || attr_high
->form
== DW_FORM_GNU_addr_index
)
8184 high
= DW_ADDR (attr_high
);
8186 high
= low
+ DW_UNSND (attr_high
);
8188 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
8192 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
8195 bfd
*obfd
= objfile
->obfd
;
8197 /* The value of the DW_AT_ranges attribute is the offset of the
8198 address range list in the .debug_ranges section. */
8199 unsigned long offset
= DW_UNSND (attr
);
8200 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
8202 /* For some target architectures, but not others, the
8203 read_address function sign-extends the addresses it returns.
8204 To recognize base address selection entries, we need a
8206 unsigned int addr_size
= cu
->header
.addr_size
;
8207 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
8209 /* The base address, to which the next pair is relative. Note
8210 that this 'base' is a DWARF concept: most entries in a range
8211 list are relative, to reduce the number of relocs against the
8212 debugging information. This is separate from this function's
8213 'baseaddr' argument, which GDB uses to relocate debugging
8214 information from a shared library based on the address at
8215 which the library was loaded. */
8216 CORE_ADDR base
= cu
->base_address
;
8217 int base_known
= cu
->base_known
;
8219 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
8220 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
8222 complaint (&symfile_complaints
,
8223 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
8230 unsigned int bytes_read
;
8231 CORE_ADDR start
, end
;
8233 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
8234 buffer
+= bytes_read
;
8235 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
8236 buffer
+= bytes_read
;
8238 /* Did we find the end of the range list? */
8239 if (start
== 0 && end
== 0)
8242 /* Did we find a base address selection entry? */
8243 else if ((start
& base_select_mask
) == base_select_mask
)
8249 /* We found an ordinary address range. */
8254 complaint (&symfile_complaints
,
8255 _("Invalid .debug_ranges data "
8256 "(no base address)"));
8262 /* Inverted range entries are invalid. */
8263 complaint (&symfile_complaints
,
8264 _("Invalid .debug_ranges data "
8265 "(inverted range)"));
8269 /* Empty range entries have no effect. */
8273 record_block_range (block
,
8274 baseaddr
+ base
+ start
,
8275 baseaddr
+ base
+ end
- 1);
8281 /* Check whether the producer field indicates either of GCC < 4.6, or the
8282 Intel C/C++ compiler, and cache the result in CU. */
8285 check_producer (struct dwarf2_cu
*cu
)
8288 int major
, minor
, release
;
8290 if (cu
->producer
== NULL
)
8292 /* For unknown compilers expect their behavior is DWARF version
8295 GCC started to support .debug_types sections by -gdwarf-4 since
8296 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
8297 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
8298 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
8299 interpreted incorrectly by GDB now - GCC PR debug/48229. */
8301 else if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) == 0)
8303 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
8305 cs
= &cu
->producer
[strlen ("GNU ")];
8306 while (*cs
&& !isdigit (*cs
))
8308 if (sscanf (cs
, "%d.%d.%d", &major
, &minor
, &release
) != 3)
8310 /* Not recognized as GCC. */
8313 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
8315 else if (strncmp (cu
->producer
, "Intel(R) C", strlen ("Intel(R) C")) == 0)
8316 cu
->producer_is_icc
= 1;
8319 /* For other non-GCC compilers, expect their behavior is DWARF version
8323 cu
->checked_producer
= 1;
8326 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
8327 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
8328 during 4.6.0 experimental. */
8331 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
8333 if (!cu
->checked_producer
)
8334 check_producer (cu
);
8336 return cu
->producer_is_gxx_lt_4_6
;
8339 /* Return the default accessibility type if it is not overriden by
8340 DW_AT_accessibility. */
8342 static enum dwarf_access_attribute
8343 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
8345 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
8347 /* The default DWARF 2 accessibility for members is public, the default
8348 accessibility for inheritance is private. */
8350 if (die
->tag
!= DW_TAG_inheritance
)
8351 return DW_ACCESS_public
;
8353 return DW_ACCESS_private
;
8357 /* DWARF 3+ defines the default accessibility a different way. The same
8358 rules apply now for DW_TAG_inheritance as for the members and it only
8359 depends on the container kind. */
8361 if (die
->parent
->tag
== DW_TAG_class_type
)
8362 return DW_ACCESS_private
;
8364 return DW_ACCESS_public
;
8368 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
8369 offset. If the attribute was not found return 0, otherwise return
8370 1. If it was found but could not properly be handled, set *OFFSET
8374 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
8377 struct attribute
*attr
;
8379 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
8384 /* Note that we do not check for a section offset first here.
8385 This is because DW_AT_data_member_location is new in DWARF 4,
8386 so if we see it, we can assume that a constant form is really
8387 a constant and not a section offset. */
8388 if (attr_form_is_constant (attr
))
8389 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
8390 else if (attr_form_is_section_offset (attr
))
8391 dwarf2_complex_location_expr_complaint ();
8392 else if (attr_form_is_block (attr
))
8393 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
8395 dwarf2_complex_location_expr_complaint ();
8403 /* Add an aggregate field to the field list. */
8406 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
8407 struct dwarf2_cu
*cu
)
8409 struct objfile
*objfile
= cu
->objfile
;
8410 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8411 struct nextfield
*new_field
;
8412 struct attribute
*attr
;
8414 char *fieldname
= "";
8416 /* Allocate a new field list entry and link it in. */
8417 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
8418 make_cleanup (xfree
, new_field
);
8419 memset (new_field
, 0, sizeof (struct nextfield
));
8421 if (die
->tag
== DW_TAG_inheritance
)
8423 new_field
->next
= fip
->baseclasses
;
8424 fip
->baseclasses
= new_field
;
8428 new_field
->next
= fip
->fields
;
8429 fip
->fields
= new_field
;
8433 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
8435 new_field
->accessibility
= DW_UNSND (attr
);
8437 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
8438 if (new_field
->accessibility
!= DW_ACCESS_public
)
8439 fip
->non_public_fields
= 1;
8441 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
8443 new_field
->virtuality
= DW_UNSND (attr
);
8445 new_field
->virtuality
= DW_VIRTUALITY_none
;
8447 fp
= &new_field
->field
;
8449 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
8453 /* Data member other than a C++ static data member. */
8455 /* Get type of field. */
8456 fp
->type
= die_type (die
, cu
);
8458 SET_FIELD_BITPOS (*fp
, 0);
8460 /* Get bit size of field (zero if none). */
8461 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
8464 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
8468 FIELD_BITSIZE (*fp
) = 0;
8471 /* Get bit offset of field. */
8472 if (handle_data_member_location (die
, cu
, &offset
))
8473 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
8474 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
8477 if (gdbarch_bits_big_endian (gdbarch
))
8479 /* For big endian bits, the DW_AT_bit_offset gives the
8480 additional bit offset from the MSB of the containing
8481 anonymous object to the MSB of the field. We don't
8482 have to do anything special since we don't need to
8483 know the size of the anonymous object. */
8484 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
8488 /* For little endian bits, compute the bit offset to the
8489 MSB of the anonymous object, subtract off the number of
8490 bits from the MSB of the field to the MSB of the
8491 object, and then subtract off the number of bits of
8492 the field itself. The result is the bit offset of
8493 the LSB of the field. */
8495 int bit_offset
= DW_UNSND (attr
);
8497 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8500 /* The size of the anonymous object containing
8501 the bit field is explicit, so use the
8502 indicated size (in bytes). */
8503 anonymous_size
= DW_UNSND (attr
);
8507 /* The size of the anonymous object containing
8508 the bit field must be inferred from the type
8509 attribute of the data member containing the
8511 anonymous_size
= TYPE_LENGTH (fp
->type
);
8513 SET_FIELD_BITPOS (*fp
,
8515 + anonymous_size
* bits_per_byte
8516 - bit_offset
- FIELD_BITSIZE (*fp
)));
8520 /* Get name of field. */
8521 fieldname
= dwarf2_name (die
, cu
);
8522 if (fieldname
== NULL
)
8525 /* The name is already allocated along with this objfile, so we don't
8526 need to duplicate it for the type. */
8527 fp
->name
= fieldname
;
8529 /* Change accessibility for artificial fields (e.g. virtual table
8530 pointer or virtual base class pointer) to private. */
8531 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
8533 FIELD_ARTIFICIAL (*fp
) = 1;
8534 new_field
->accessibility
= DW_ACCESS_private
;
8535 fip
->non_public_fields
= 1;
8538 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
8540 /* C++ static member. */
8542 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
8543 is a declaration, but all versions of G++ as of this writing
8544 (so through at least 3.2.1) incorrectly generate
8545 DW_TAG_variable tags. */
8547 const char *physname
;
8549 /* Get name of field. */
8550 fieldname
= dwarf2_name (die
, cu
);
8551 if (fieldname
== NULL
)
8554 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8556 /* Only create a symbol if this is an external value.
8557 new_symbol checks this and puts the value in the global symbol
8558 table, which we want. If it is not external, new_symbol
8559 will try to put the value in cu->list_in_scope which is wrong. */
8560 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
8562 /* A static const member, not much different than an enum as far as
8563 we're concerned, except that we can support more types. */
8564 new_symbol (die
, NULL
, cu
);
8567 /* Get physical name. */
8568 physname
= dwarf2_physname (fieldname
, die
, cu
);
8570 /* The name is already allocated along with this objfile, so we don't
8571 need to duplicate it for the type. */
8572 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
8573 FIELD_TYPE (*fp
) = die_type (die
, cu
);
8574 FIELD_NAME (*fp
) = fieldname
;
8576 else if (die
->tag
== DW_TAG_inheritance
)
8580 /* C++ base class field. */
8581 if (handle_data_member_location (die
, cu
, &offset
))
8582 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
8583 FIELD_BITSIZE (*fp
) = 0;
8584 FIELD_TYPE (*fp
) = die_type (die
, cu
);
8585 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
8586 fip
->nbaseclasses
++;
8590 /* Add a typedef defined in the scope of the FIP's class. */
8593 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
8594 struct dwarf2_cu
*cu
)
8596 struct objfile
*objfile
= cu
->objfile
;
8597 struct typedef_field_list
*new_field
;
8598 struct attribute
*attr
;
8599 struct typedef_field
*fp
;
8600 char *fieldname
= "";
8602 /* Allocate a new field list entry and link it in. */
8603 new_field
= xzalloc (sizeof (*new_field
));
8604 make_cleanup (xfree
, new_field
);
8606 gdb_assert (die
->tag
== DW_TAG_typedef
);
8608 fp
= &new_field
->field
;
8610 /* Get name of field. */
8611 fp
->name
= dwarf2_name (die
, cu
);
8612 if (fp
->name
== NULL
)
8615 fp
->type
= read_type_die (die
, cu
);
8617 new_field
->next
= fip
->typedef_field_list
;
8618 fip
->typedef_field_list
= new_field
;
8619 fip
->typedef_field_list_count
++;
8622 /* Create the vector of fields, and attach it to the type. */
8625 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
8626 struct dwarf2_cu
*cu
)
8628 int nfields
= fip
->nfields
;
8630 /* Record the field count, allocate space for the array of fields,
8631 and create blank accessibility bitfields if necessary. */
8632 TYPE_NFIELDS (type
) = nfields
;
8633 TYPE_FIELDS (type
) = (struct field
*)
8634 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
8635 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
8637 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
8639 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
8641 TYPE_FIELD_PRIVATE_BITS (type
) =
8642 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
8643 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
8645 TYPE_FIELD_PROTECTED_BITS (type
) =
8646 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
8647 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
8649 TYPE_FIELD_IGNORE_BITS (type
) =
8650 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
8651 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
8654 /* If the type has baseclasses, allocate and clear a bit vector for
8655 TYPE_FIELD_VIRTUAL_BITS. */
8656 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
8658 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
8659 unsigned char *pointer
;
8661 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
8662 pointer
= TYPE_ALLOC (type
, num_bytes
);
8663 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
8664 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
8665 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
8668 /* Copy the saved-up fields into the field vector. Start from the head of
8669 the list, adding to the tail of the field array, so that they end up in
8670 the same order in the array in which they were added to the list. */
8671 while (nfields
-- > 0)
8673 struct nextfield
*fieldp
;
8677 fieldp
= fip
->fields
;
8678 fip
->fields
= fieldp
->next
;
8682 fieldp
= fip
->baseclasses
;
8683 fip
->baseclasses
= fieldp
->next
;
8686 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
8687 switch (fieldp
->accessibility
)
8689 case DW_ACCESS_private
:
8690 if (cu
->language
!= language_ada
)
8691 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
8694 case DW_ACCESS_protected
:
8695 if (cu
->language
!= language_ada
)
8696 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
8699 case DW_ACCESS_public
:
8703 /* Unknown accessibility. Complain and treat it as public. */
8705 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
8706 fieldp
->accessibility
);
8710 if (nfields
< fip
->nbaseclasses
)
8712 switch (fieldp
->virtuality
)
8714 case DW_VIRTUALITY_virtual
:
8715 case DW_VIRTUALITY_pure_virtual
:
8716 if (cu
->language
== language_ada
)
8717 error (_("unexpected virtuality in component of Ada type"));
8718 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
8725 /* Add a member function to the proper fieldlist. */
8728 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
8729 struct type
*type
, struct dwarf2_cu
*cu
)
8731 struct objfile
*objfile
= cu
->objfile
;
8732 struct attribute
*attr
;
8733 struct fnfieldlist
*flp
;
8735 struct fn_field
*fnp
;
8737 struct nextfnfield
*new_fnfield
;
8738 struct type
*this_type
;
8739 enum dwarf_access_attribute accessibility
;
8741 if (cu
->language
== language_ada
)
8742 error (_("unexpected member function in Ada type"));
8744 /* Get name of member function. */
8745 fieldname
= dwarf2_name (die
, cu
);
8746 if (fieldname
== NULL
)
8749 /* Look up member function name in fieldlist. */
8750 for (i
= 0; i
< fip
->nfnfields
; i
++)
8752 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
8756 /* Create new list element if necessary. */
8757 if (i
< fip
->nfnfields
)
8758 flp
= &fip
->fnfieldlists
[i
];
8761 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
8763 fip
->fnfieldlists
= (struct fnfieldlist
*)
8764 xrealloc (fip
->fnfieldlists
,
8765 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
8766 * sizeof (struct fnfieldlist
));
8767 if (fip
->nfnfields
== 0)
8768 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
8770 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
8771 flp
->name
= fieldname
;
8774 i
= fip
->nfnfields
++;
8777 /* Create a new member function field and chain it to the field list
8779 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
8780 make_cleanup (xfree
, new_fnfield
);
8781 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
8782 new_fnfield
->next
= flp
->head
;
8783 flp
->head
= new_fnfield
;
8786 /* Fill in the member function field info. */
8787 fnp
= &new_fnfield
->fnfield
;
8789 /* Delay processing of the physname until later. */
8790 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
8792 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
8797 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
8798 fnp
->physname
= physname
? physname
: "";
8801 fnp
->type
= alloc_type (objfile
);
8802 this_type
= read_type_die (die
, cu
);
8803 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
8805 int nparams
= TYPE_NFIELDS (this_type
);
8807 /* TYPE is the domain of this method, and THIS_TYPE is the type
8808 of the method itself (TYPE_CODE_METHOD). */
8809 smash_to_method_type (fnp
->type
, type
,
8810 TYPE_TARGET_TYPE (this_type
),
8811 TYPE_FIELDS (this_type
),
8812 TYPE_NFIELDS (this_type
),
8813 TYPE_VARARGS (this_type
));
8815 /* Handle static member functions.
8816 Dwarf2 has no clean way to discern C++ static and non-static
8817 member functions. G++ helps GDB by marking the first
8818 parameter for non-static member functions (which is the this
8819 pointer) as artificial. We obtain this information from
8820 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
8821 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
8822 fnp
->voffset
= VOFFSET_STATIC
;
8825 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
8826 dwarf2_full_name (fieldname
, die
, cu
));
8828 /* Get fcontext from DW_AT_containing_type if present. */
8829 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
8830 fnp
->fcontext
= die_containing_type (die
, cu
);
8832 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
8833 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
8835 /* Get accessibility. */
8836 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
8838 accessibility
= DW_UNSND (attr
);
8840 accessibility
= dwarf2_default_access_attribute (die
, cu
);
8841 switch (accessibility
)
8843 case DW_ACCESS_private
:
8844 fnp
->is_private
= 1;
8846 case DW_ACCESS_protected
:
8847 fnp
->is_protected
= 1;
8851 /* Check for artificial methods. */
8852 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
8853 if (attr
&& DW_UNSND (attr
) != 0)
8854 fnp
->is_artificial
= 1;
8856 /* Get index in virtual function table if it is a virtual member
8857 function. For older versions of GCC, this is an offset in the
8858 appropriate virtual table, as specified by DW_AT_containing_type.
8859 For everyone else, it is an expression to be evaluated relative
8860 to the object address. */
8862 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
8865 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
8867 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
8869 /* Old-style GCC. */
8870 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
8872 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
8873 || (DW_BLOCK (attr
)->size
> 1
8874 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
8875 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
8877 struct dwarf_block blk
;
8880 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
8882 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
8883 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
8884 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
8885 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
8886 dwarf2_complex_location_expr_complaint ();
8888 fnp
->voffset
/= cu
->header
.addr_size
;
8892 dwarf2_complex_location_expr_complaint ();
8895 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
8897 else if (attr_form_is_section_offset (attr
))
8899 dwarf2_complex_location_expr_complaint ();
8903 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
8909 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
8910 if (attr
&& DW_UNSND (attr
))
8912 /* GCC does this, as of 2008-08-25; PR debug/37237. */
8913 complaint (&symfile_complaints
,
8914 _("Member function \"%s\" (offset %d) is virtual "
8915 "but the vtable offset is not specified"),
8916 fieldname
, die
->offset
.sect_off
);
8917 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
8918 TYPE_CPLUS_DYNAMIC (type
) = 1;
8923 /* Create the vector of member function fields, and attach it to the type. */
8926 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
8927 struct dwarf2_cu
*cu
)
8929 struct fnfieldlist
*flp
;
8932 if (cu
->language
== language_ada
)
8933 error (_("unexpected member functions in Ada type"));
8935 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
8936 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
8937 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
8939 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
8941 struct nextfnfield
*nfp
= flp
->head
;
8942 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
8945 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
8946 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
8947 fn_flp
->fn_fields
= (struct fn_field
*)
8948 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
8949 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
8950 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
8953 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
8956 /* Returns non-zero if NAME is the name of a vtable member in CU's
8957 language, zero otherwise. */
8959 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
8961 static const char vptr
[] = "_vptr";
8962 static const char vtable
[] = "vtable";
8964 /* Look for the C++ and Java forms of the vtable. */
8965 if ((cu
->language
== language_java
8966 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
8967 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
8968 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
8974 /* GCC outputs unnamed structures that are really pointers to member
8975 functions, with the ABI-specified layout. If TYPE describes
8976 such a structure, smash it into a member function type.
8978 GCC shouldn't do this; it should just output pointer to member DIEs.
8979 This is GCC PR debug/28767. */
8982 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
8984 struct type
*pfn_type
, *domain_type
, *new_type
;
8986 /* Check for a structure with no name and two children. */
8987 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
8990 /* Check for __pfn and __delta members. */
8991 if (TYPE_FIELD_NAME (type
, 0) == NULL
8992 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
8993 || TYPE_FIELD_NAME (type
, 1) == NULL
8994 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
8997 /* Find the type of the method. */
8998 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
8999 if (pfn_type
== NULL
9000 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
9001 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
9004 /* Look for the "this" argument. */
9005 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
9006 if (TYPE_NFIELDS (pfn_type
) == 0
9007 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
9008 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
9011 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
9012 new_type
= alloc_type (objfile
);
9013 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
9014 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
9015 TYPE_VARARGS (pfn_type
));
9016 smash_to_methodptr_type (type
, new_type
);
9019 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
9023 producer_is_icc (struct dwarf2_cu
*cu
)
9025 if (!cu
->checked_producer
)
9026 check_producer (cu
);
9028 return cu
->producer_is_icc
;
9031 /* Called when we find the DIE that starts a structure or union scope
9032 (definition) to create a type for the structure or union. Fill in
9033 the type's name and general properties; the members will not be
9034 processed until process_structure_type.
9036 NOTE: we need to call these functions regardless of whether or not the
9037 DIE has a DW_AT_name attribute, since it might be an anonymous
9038 structure or union. This gets the type entered into our set of
9041 However, if the structure is incomplete (an opaque struct/union)
9042 then suppress creating a symbol table entry for it since gdb only
9043 wants to find the one with the complete definition. Note that if
9044 it is complete, we just call new_symbol, which does it's own
9045 checking about whether the struct/union is anonymous or not (and
9046 suppresses creating a symbol table entry itself). */
9048 static struct type
*
9049 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9051 struct objfile
*objfile
= cu
->objfile
;
9053 struct attribute
*attr
;
9056 /* If the definition of this type lives in .debug_types, read that type.
9057 Don't follow DW_AT_specification though, that will take us back up
9058 the chain and we want to go down. */
9059 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
9062 struct dwarf2_cu
*type_cu
= cu
;
9063 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
9065 /* We could just recurse on read_structure_type, but we need to call
9066 get_die_type to ensure only one type for this DIE is created.
9067 This is important, for example, because for c++ classes we need
9068 TYPE_NAME set which is only done by new_symbol. Blech. */
9069 type
= read_type_die (type_die
, type_cu
);
9071 /* TYPE_CU may not be the same as CU.
9072 Ensure TYPE is recorded in CU's type_hash table. */
9073 return set_die_type (die
, type
, cu
);
9076 type
= alloc_type (objfile
);
9077 INIT_CPLUS_SPECIFIC (type
);
9079 name
= dwarf2_name (die
, cu
);
9082 if (cu
->language
== language_cplus
9083 || cu
->language
== language_java
)
9085 char *full_name
= (char *) dwarf2_full_name (name
, die
, cu
);
9087 /* dwarf2_full_name might have already finished building the DIE's
9088 type. If so, there is no need to continue. */
9089 if (get_die_type (die
, cu
) != NULL
)
9090 return get_die_type (die
, cu
);
9092 TYPE_TAG_NAME (type
) = full_name
;
9093 if (die
->tag
== DW_TAG_structure_type
9094 || die
->tag
== DW_TAG_class_type
)
9095 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
9099 /* The name is already allocated along with this objfile, so
9100 we don't need to duplicate it for the type. */
9101 TYPE_TAG_NAME (type
) = (char *) name
;
9102 if (die
->tag
== DW_TAG_class_type
)
9103 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
9107 if (die
->tag
== DW_TAG_structure_type
)
9109 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
9111 else if (die
->tag
== DW_TAG_union_type
)
9113 TYPE_CODE (type
) = TYPE_CODE_UNION
;
9117 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
9120 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
9121 TYPE_DECLARED_CLASS (type
) = 1;
9123 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
9126 TYPE_LENGTH (type
) = DW_UNSND (attr
);
9130 TYPE_LENGTH (type
) = 0;
9133 if (producer_is_icc (cu
))
9135 /* ICC does not output the required DW_AT_declaration
9136 on incomplete types, but gives them a size of zero. */
9139 TYPE_STUB_SUPPORTED (type
) = 1;
9141 if (die_is_declaration (die
, cu
))
9142 TYPE_STUB (type
) = 1;
9143 else if (attr
== NULL
&& die
->child
== NULL
9144 && producer_is_realview (cu
->producer
))
9145 /* RealView does not output the required DW_AT_declaration
9146 on incomplete types. */
9147 TYPE_STUB (type
) = 1;
9149 /* We need to add the type field to the die immediately so we don't
9150 infinitely recurse when dealing with pointers to the structure
9151 type within the structure itself. */
9152 set_die_type (die
, type
, cu
);
9154 /* set_die_type should be already done. */
9155 set_descriptive_type (type
, die
, cu
);
9160 /* Finish creating a structure or union type, including filling in
9161 its members and creating a symbol for it. */
9164 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9166 struct objfile
*objfile
= cu
->objfile
;
9167 struct die_info
*child_die
= die
->child
;
9170 type
= get_die_type (die
, cu
);
9172 type
= read_structure_type (die
, cu
);
9174 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
9176 struct field_info fi
;
9177 struct die_info
*child_die
;
9178 VEC (symbolp
) *template_args
= NULL
;
9179 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
9181 memset (&fi
, 0, sizeof (struct field_info
));
9183 child_die
= die
->child
;
9185 while (child_die
&& child_die
->tag
)
9187 if (child_die
->tag
== DW_TAG_member
9188 || child_die
->tag
== DW_TAG_variable
)
9190 /* NOTE: carlton/2002-11-05: A C++ static data member
9191 should be a DW_TAG_member that is a declaration, but
9192 all versions of G++ as of this writing (so through at
9193 least 3.2.1) incorrectly generate DW_TAG_variable
9194 tags for them instead. */
9195 dwarf2_add_field (&fi
, child_die
, cu
);
9197 else if (child_die
->tag
== DW_TAG_subprogram
)
9199 /* C++ member function. */
9200 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
9202 else if (child_die
->tag
== DW_TAG_inheritance
)
9204 /* C++ base class field. */
9205 dwarf2_add_field (&fi
, child_die
, cu
);
9207 else if (child_die
->tag
== DW_TAG_typedef
)
9208 dwarf2_add_typedef (&fi
, child_die
, cu
);
9209 else if (child_die
->tag
== DW_TAG_template_type_param
9210 || child_die
->tag
== DW_TAG_template_value_param
)
9212 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
9215 VEC_safe_push (symbolp
, template_args
, arg
);
9218 child_die
= sibling_die (child_die
);
9221 /* Attach template arguments to type. */
9222 if (! VEC_empty (symbolp
, template_args
))
9224 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
9225 TYPE_N_TEMPLATE_ARGUMENTS (type
)
9226 = VEC_length (symbolp
, template_args
);
9227 TYPE_TEMPLATE_ARGUMENTS (type
)
9228 = obstack_alloc (&objfile
->objfile_obstack
,
9229 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
9230 * sizeof (struct symbol
*)));
9231 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
9232 VEC_address (symbolp
, template_args
),
9233 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
9234 * sizeof (struct symbol
*)));
9235 VEC_free (symbolp
, template_args
);
9238 /* Attach fields and member functions to the type. */
9240 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
9243 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
9245 /* Get the type which refers to the base class (possibly this
9246 class itself) which contains the vtable pointer for the current
9247 class from the DW_AT_containing_type attribute. This use of
9248 DW_AT_containing_type is a GNU extension. */
9250 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
9252 struct type
*t
= die_containing_type (die
, cu
);
9254 TYPE_VPTR_BASETYPE (type
) = t
;
9259 /* Our own class provides vtbl ptr. */
9260 for (i
= TYPE_NFIELDS (t
) - 1;
9261 i
>= TYPE_N_BASECLASSES (t
);
9264 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
9266 if (is_vtable_name (fieldname
, cu
))
9268 TYPE_VPTR_FIELDNO (type
) = i
;
9273 /* Complain if virtual function table field not found. */
9274 if (i
< TYPE_N_BASECLASSES (t
))
9275 complaint (&symfile_complaints
,
9276 _("virtual function table pointer "
9277 "not found when defining class '%s'"),
9278 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
9283 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
9286 else if (cu
->producer
9287 && strncmp (cu
->producer
,
9288 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
9290 /* The IBM XLC compiler does not provide direct indication
9291 of the containing type, but the vtable pointer is
9292 always named __vfp. */
9296 for (i
= TYPE_NFIELDS (type
) - 1;
9297 i
>= TYPE_N_BASECLASSES (type
);
9300 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
9302 TYPE_VPTR_FIELDNO (type
) = i
;
9303 TYPE_VPTR_BASETYPE (type
) = type
;
9310 /* Copy fi.typedef_field_list linked list elements content into the
9311 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
9312 if (fi
.typedef_field_list
)
9314 int i
= fi
.typedef_field_list_count
;
9316 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
9317 TYPE_TYPEDEF_FIELD_ARRAY (type
)
9318 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
9319 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
9321 /* Reverse the list order to keep the debug info elements order. */
9324 struct typedef_field
*dest
, *src
;
9326 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
9327 src
= &fi
.typedef_field_list
->field
;
9328 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
9333 do_cleanups (back_to
);
9335 if (HAVE_CPLUS_STRUCT (type
))
9336 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
9339 quirk_gcc_member_function_pointer (type
, objfile
);
9341 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
9342 snapshots) has been known to create a die giving a declaration
9343 for a class that has, as a child, a die giving a definition for a
9344 nested class. So we have to process our children even if the
9345 current die is a declaration. Normally, of course, a declaration
9346 won't have any children at all. */
9348 while (child_die
!= NULL
&& child_die
->tag
)
9350 if (child_die
->tag
== DW_TAG_member
9351 || child_die
->tag
== DW_TAG_variable
9352 || child_die
->tag
== DW_TAG_inheritance
9353 || child_die
->tag
== DW_TAG_template_value_param
9354 || child_die
->tag
== DW_TAG_template_type_param
)
9359 process_die (child_die
, cu
);
9361 child_die
= sibling_die (child_die
);
9364 /* Do not consider external references. According to the DWARF standard,
9365 these DIEs are identified by the fact that they have no byte_size
9366 attribute, and a declaration attribute. */
9367 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
9368 || !die_is_declaration (die
, cu
))
9369 new_symbol (die
, type
, cu
);
9372 /* Given a DW_AT_enumeration_type die, set its type. We do not
9373 complete the type's fields yet, or create any symbols. */
9375 static struct type
*
9376 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9378 struct objfile
*objfile
= cu
->objfile
;
9380 struct attribute
*attr
;
9383 /* If the definition of this type lives in .debug_types, read that type.
9384 Don't follow DW_AT_specification though, that will take us back up
9385 the chain and we want to go down. */
9386 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
9389 struct dwarf2_cu
*type_cu
= cu
;
9390 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
9392 type
= read_type_die (type_die
, type_cu
);
9394 /* TYPE_CU may not be the same as CU.
9395 Ensure TYPE is recorded in CU's type_hash table. */
9396 return set_die_type (die
, type
, cu
);
9399 type
= alloc_type (objfile
);
9401 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
9402 name
= dwarf2_full_name (NULL
, die
, cu
);
9404 TYPE_TAG_NAME (type
) = (char *) name
;
9406 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
9409 TYPE_LENGTH (type
) = DW_UNSND (attr
);
9413 TYPE_LENGTH (type
) = 0;
9416 /* The enumeration DIE can be incomplete. In Ada, any type can be
9417 declared as private in the package spec, and then defined only
9418 inside the package body. Such types are known as Taft Amendment
9419 Types. When another package uses such a type, an incomplete DIE
9420 may be generated by the compiler. */
9421 if (die_is_declaration (die
, cu
))
9422 TYPE_STUB (type
) = 1;
9424 return set_die_type (die
, type
, cu
);
9427 /* Given a pointer to a die which begins an enumeration, process all
9428 the dies that define the members of the enumeration, and create the
9429 symbol for the enumeration type.
9431 NOTE: We reverse the order of the element list. */
9434 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9436 struct type
*this_type
;
9438 this_type
= get_die_type (die
, cu
);
9439 if (this_type
== NULL
)
9440 this_type
= read_enumeration_type (die
, cu
);
9442 if (die
->child
!= NULL
)
9444 struct die_info
*child_die
;
9446 struct field
*fields
= NULL
;
9448 int unsigned_enum
= 1;
9453 child_die
= die
->child
;
9454 while (child_die
&& child_die
->tag
)
9456 if (child_die
->tag
!= DW_TAG_enumerator
)
9458 process_die (child_die
, cu
);
9462 name
= dwarf2_name (child_die
, cu
);
9465 sym
= new_symbol (child_die
, this_type
, cu
);
9466 if (SYMBOL_VALUE (sym
) < 0)
9471 else if ((mask
& SYMBOL_VALUE (sym
)) != 0)
9474 mask
|= SYMBOL_VALUE (sym
);
9476 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
9478 fields
= (struct field
*)
9480 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
9481 * sizeof (struct field
));
9484 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
9485 FIELD_TYPE (fields
[num_fields
]) = NULL
;
9486 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
9487 FIELD_BITSIZE (fields
[num_fields
]) = 0;
9493 child_die
= sibling_die (child_die
);
9498 TYPE_NFIELDS (this_type
) = num_fields
;
9499 TYPE_FIELDS (this_type
) = (struct field
*)
9500 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
9501 memcpy (TYPE_FIELDS (this_type
), fields
,
9502 sizeof (struct field
) * num_fields
);
9506 TYPE_UNSIGNED (this_type
) = 1;
9508 TYPE_FLAG_ENUM (this_type
) = 1;
9511 /* If we are reading an enum from a .debug_types unit, and the enum
9512 is a declaration, and the enum is not the signatured type in the
9513 unit, then we do not want to add a symbol for it. Adding a
9514 symbol would in some cases obscure the true definition of the
9515 enum, giving users an incomplete type when the definition is
9516 actually available. Note that we do not want to do this for all
9517 enums which are just declarations, because C++0x allows forward
9518 enum declarations. */
9519 if (cu
->per_cu
->is_debug_types
9520 && die_is_declaration (die
, cu
))
9522 struct signatured_type
*sig_type
;
9525 = lookup_signatured_type_at_offset (dwarf2_per_objfile
->objfile
,
9526 cu
->per_cu
->info_or_types_section
,
9527 cu
->per_cu
->offset
);
9528 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
9529 if (sig_type
->type_offset_in_section
.sect_off
!= die
->offset
.sect_off
)
9533 new_symbol (die
, this_type
, cu
);
9536 /* Extract all information from a DW_TAG_array_type DIE and put it in
9537 the DIE's type field. For now, this only handles one dimensional
9540 static struct type
*
9541 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9543 struct objfile
*objfile
= cu
->objfile
;
9544 struct die_info
*child_die
;
9546 struct type
*element_type
, *range_type
, *index_type
;
9547 struct type
**range_types
= NULL
;
9548 struct attribute
*attr
;
9550 struct cleanup
*back_to
;
9553 element_type
= die_type (die
, cu
);
9555 /* The die_type call above may have already set the type for this DIE. */
9556 type
= get_die_type (die
, cu
);
9560 /* Irix 6.2 native cc creates array types without children for
9561 arrays with unspecified length. */
9562 if (die
->child
== NULL
)
9564 index_type
= objfile_type (objfile
)->builtin_int
;
9565 range_type
= create_range_type (NULL
, index_type
, 0, -1);
9566 type
= create_array_type (NULL
, element_type
, range_type
);
9567 return set_die_type (die
, type
, cu
);
9570 back_to
= make_cleanup (null_cleanup
, NULL
);
9571 child_die
= die
->child
;
9572 while (child_die
&& child_die
->tag
)
9574 if (child_die
->tag
== DW_TAG_subrange_type
)
9576 struct type
*child_type
= read_type_die (child_die
, cu
);
9578 if (child_type
!= NULL
)
9580 /* The range type was succesfully read. Save it for the
9581 array type creation. */
9582 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
9584 range_types
= (struct type
**)
9585 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
9586 * sizeof (struct type
*));
9588 make_cleanup (free_current_contents
, &range_types
);
9590 range_types
[ndim
++] = child_type
;
9593 child_die
= sibling_die (child_die
);
9596 /* Dwarf2 dimensions are output from left to right, create the
9597 necessary array types in backwards order. */
9599 type
= element_type
;
9601 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
9606 type
= create_array_type (NULL
, type
, range_types
[i
++]);
9611 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
9614 /* Understand Dwarf2 support for vector types (like they occur on
9615 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
9616 array type. This is not part of the Dwarf2/3 standard yet, but a
9617 custom vendor extension. The main difference between a regular
9618 array and the vector variant is that vectors are passed by value
9620 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
9622 make_vector_type (type
);
9624 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
9625 implementation may choose to implement triple vectors using this
9627 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
9630 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
9631 TYPE_LENGTH (type
) = DW_UNSND (attr
);
9633 complaint (&symfile_complaints
,
9634 _("DW_AT_byte_size for array type smaller "
9635 "than the total size of elements"));
9638 name
= dwarf2_name (die
, cu
);
9640 TYPE_NAME (type
) = name
;
9642 /* Install the type in the die. */
9643 set_die_type (die
, type
, cu
);
9645 /* set_die_type should be already done. */
9646 set_descriptive_type (type
, die
, cu
);
9648 do_cleanups (back_to
);
9653 static enum dwarf_array_dim_ordering
9654 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
9656 struct attribute
*attr
;
9658 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
9660 if (attr
) return DW_SND (attr
);
9662 /* GNU F77 is a special case, as at 08/2004 array type info is the
9663 opposite order to the dwarf2 specification, but data is still
9664 laid out as per normal fortran.
9666 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
9667 version checking. */
9669 if (cu
->language
== language_fortran
9670 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
9672 return DW_ORD_row_major
;
9675 switch (cu
->language_defn
->la_array_ordering
)
9677 case array_column_major
:
9678 return DW_ORD_col_major
;
9679 case array_row_major
:
9681 return DW_ORD_row_major
;
9685 /* Extract all information from a DW_TAG_set_type DIE and put it in
9686 the DIE's type field. */
9688 static struct type
*
9689 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9691 struct type
*domain_type
, *set_type
;
9692 struct attribute
*attr
;
9694 domain_type
= die_type (die
, cu
);
9696 /* The die_type call above may have already set the type for this DIE. */
9697 set_type
= get_die_type (die
, cu
);
9701 set_type
= create_set_type (NULL
, domain_type
);
9703 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
9705 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
9707 return set_die_type (die
, set_type
, cu
);
9710 /* First cut: install each common block member as a global variable. */
9713 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
9715 struct die_info
*child_die
;
9716 struct attribute
*attr
;
9718 CORE_ADDR base
= (CORE_ADDR
) 0;
9720 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
9723 /* Support the .debug_loc offsets. */
9724 if (attr_form_is_block (attr
))
9726 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
9728 else if (attr_form_is_section_offset (attr
))
9730 dwarf2_complex_location_expr_complaint ();
9734 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
9735 "common block member");
9738 if (die
->child
!= NULL
)
9740 child_die
= die
->child
;
9741 while (child_die
&& child_die
->tag
)
9745 sym
= new_symbol (child_die
, NULL
, cu
);
9747 && handle_data_member_location (child_die
, cu
, &offset
))
9749 SYMBOL_VALUE_ADDRESS (sym
) = base
+ offset
;
9750 add_symbol_to_list (sym
, &global_symbols
);
9752 child_die
= sibling_die (child_die
);
9757 /* Create a type for a C++ namespace. */
9759 static struct type
*
9760 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9762 struct objfile
*objfile
= cu
->objfile
;
9763 const char *previous_prefix
, *name
;
9767 /* For extensions, reuse the type of the original namespace. */
9768 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
9770 struct die_info
*ext_die
;
9771 struct dwarf2_cu
*ext_cu
= cu
;
9773 ext_die
= dwarf2_extension (die
, &ext_cu
);
9774 type
= read_type_die (ext_die
, ext_cu
);
9776 /* EXT_CU may not be the same as CU.
9777 Ensure TYPE is recorded in CU's type_hash table. */
9778 return set_die_type (die
, type
, cu
);
9781 name
= namespace_name (die
, &is_anonymous
, cu
);
9783 /* Now build the name of the current namespace. */
9785 previous_prefix
= determine_prefix (die
, cu
);
9786 if (previous_prefix
[0] != '\0')
9787 name
= typename_concat (&objfile
->objfile_obstack
,
9788 previous_prefix
, name
, 0, cu
);
9790 /* Create the type. */
9791 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
9793 TYPE_NAME (type
) = (char *) name
;
9794 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
9796 return set_die_type (die
, type
, cu
);
9799 /* Read a C++ namespace. */
9802 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
9804 struct objfile
*objfile
= cu
->objfile
;
9807 /* Add a symbol associated to this if we haven't seen the namespace
9808 before. Also, add a using directive if it's an anonymous
9811 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
9815 type
= read_type_die (die
, cu
);
9816 new_symbol (die
, type
, cu
);
9818 namespace_name (die
, &is_anonymous
, cu
);
9821 const char *previous_prefix
= determine_prefix (die
, cu
);
9823 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
9824 NULL
, NULL
, &objfile
->objfile_obstack
);
9828 if (die
->child
!= NULL
)
9830 struct die_info
*child_die
= die
->child
;
9832 while (child_die
&& child_die
->tag
)
9834 process_die (child_die
, cu
);
9835 child_die
= sibling_die (child_die
);
9840 /* Read a Fortran module as type. This DIE can be only a declaration used for
9841 imported module. Still we need that type as local Fortran "use ... only"
9842 declaration imports depend on the created type in determine_prefix. */
9844 static struct type
*
9845 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9847 struct objfile
*objfile
= cu
->objfile
;
9851 module_name
= dwarf2_name (die
, cu
);
9853 complaint (&symfile_complaints
,
9854 _("DW_TAG_module has no name, offset 0x%x"),
9855 die
->offset
.sect_off
);
9856 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
9858 /* determine_prefix uses TYPE_TAG_NAME. */
9859 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
9861 return set_die_type (die
, type
, cu
);
9864 /* Read a Fortran module. */
9867 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
9869 struct die_info
*child_die
= die
->child
;
9871 while (child_die
&& child_die
->tag
)
9873 process_die (child_die
, cu
);
9874 child_die
= sibling_die (child_die
);
9878 /* Return the name of the namespace represented by DIE. Set
9879 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
9883 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
9885 struct die_info
*current_die
;
9886 const char *name
= NULL
;
9888 /* Loop through the extensions until we find a name. */
9890 for (current_die
= die
;
9891 current_die
!= NULL
;
9892 current_die
= dwarf2_extension (die
, &cu
))
9894 name
= dwarf2_name (current_die
, cu
);
9899 /* Is it an anonymous namespace? */
9901 *is_anonymous
= (name
== NULL
);
9903 name
= CP_ANONYMOUS_NAMESPACE_STR
;
9908 /* Extract all information from a DW_TAG_pointer_type DIE and add to
9909 the user defined type vector. */
9911 static struct type
*
9912 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9914 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
9915 struct comp_unit_head
*cu_header
= &cu
->header
;
9917 struct attribute
*attr_byte_size
;
9918 struct attribute
*attr_address_class
;
9919 int byte_size
, addr_class
;
9920 struct type
*target_type
;
9922 target_type
= die_type (die
, cu
);
9924 /* The die_type call above may have already set the type for this DIE. */
9925 type
= get_die_type (die
, cu
);
9929 type
= lookup_pointer_type (target_type
);
9931 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
9933 byte_size
= DW_UNSND (attr_byte_size
);
9935 byte_size
= cu_header
->addr_size
;
9937 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
9938 if (attr_address_class
)
9939 addr_class
= DW_UNSND (attr_address_class
);
9941 addr_class
= DW_ADDR_none
;
9943 /* If the pointer size or address class is different than the
9944 default, create a type variant marked as such and set the
9945 length accordingly. */
9946 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
9948 if (gdbarch_address_class_type_flags_p (gdbarch
))
9952 type_flags
= gdbarch_address_class_type_flags
9953 (gdbarch
, byte_size
, addr_class
);
9954 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
9956 type
= make_type_with_address_space (type
, type_flags
);
9958 else if (TYPE_LENGTH (type
) != byte_size
)
9960 complaint (&symfile_complaints
,
9961 _("invalid pointer size %d"), byte_size
);
9965 /* Should we also complain about unhandled address classes? */
9969 TYPE_LENGTH (type
) = byte_size
;
9970 return set_die_type (die
, type
, cu
);
9973 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
9974 the user defined type vector. */
9976 static struct type
*
9977 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9980 struct type
*to_type
;
9981 struct type
*domain
;
9983 to_type
= die_type (die
, cu
);
9984 domain
= die_containing_type (die
, cu
);
9986 /* The calls above may have already set the type for this DIE. */
9987 type
= get_die_type (die
, cu
);
9991 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
9992 type
= lookup_methodptr_type (to_type
);
9994 type
= lookup_memberptr_type (to_type
, domain
);
9996 return set_die_type (die
, type
, cu
);
9999 /* Extract all information from a DW_TAG_reference_type DIE and add to
10000 the user defined type vector. */
10002 static struct type
*
10003 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10005 struct comp_unit_head
*cu_header
= &cu
->header
;
10006 struct type
*type
, *target_type
;
10007 struct attribute
*attr
;
10009 target_type
= die_type (die
, cu
);
10011 /* The die_type call above may have already set the type for this DIE. */
10012 type
= get_die_type (die
, cu
);
10016 type
= lookup_reference_type (target_type
);
10017 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
10020 TYPE_LENGTH (type
) = DW_UNSND (attr
);
10024 TYPE_LENGTH (type
) = cu_header
->addr_size
;
10026 return set_die_type (die
, type
, cu
);
10029 static struct type
*
10030 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10032 struct type
*base_type
, *cv_type
;
10034 base_type
= die_type (die
, cu
);
10036 /* The die_type call above may have already set the type for this DIE. */
10037 cv_type
= get_die_type (die
, cu
);
10041 /* In case the const qualifier is applied to an array type, the element type
10042 is so qualified, not the array type (section 6.7.3 of C99). */
10043 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
10045 struct type
*el_type
, *inner_array
;
10047 base_type
= copy_type (base_type
);
10048 inner_array
= base_type
;
10050 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
10052 TYPE_TARGET_TYPE (inner_array
) =
10053 copy_type (TYPE_TARGET_TYPE (inner_array
));
10054 inner_array
= TYPE_TARGET_TYPE (inner_array
);
10057 el_type
= TYPE_TARGET_TYPE (inner_array
);
10058 TYPE_TARGET_TYPE (inner_array
) =
10059 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
10061 return set_die_type (die
, base_type
, cu
);
10064 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
10065 return set_die_type (die
, cv_type
, cu
);
10068 static struct type
*
10069 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10071 struct type
*base_type
, *cv_type
;
10073 base_type
= die_type (die
, cu
);
10075 /* The die_type call above may have already set the type for this DIE. */
10076 cv_type
= get_die_type (die
, cu
);
10080 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
10081 return set_die_type (die
, cv_type
, cu
);
10084 /* Extract all information from a DW_TAG_string_type DIE and add to
10085 the user defined type vector. It isn't really a user defined type,
10086 but it behaves like one, with other DIE's using an AT_user_def_type
10087 attribute to reference it. */
10089 static struct type
*
10090 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10092 struct objfile
*objfile
= cu
->objfile
;
10093 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10094 struct type
*type
, *range_type
, *index_type
, *char_type
;
10095 struct attribute
*attr
;
10096 unsigned int length
;
10098 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
10101 length
= DW_UNSND (attr
);
10105 /* Check for the DW_AT_byte_size attribute. */
10106 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
10109 length
= DW_UNSND (attr
);
10117 index_type
= objfile_type (objfile
)->builtin_int
;
10118 range_type
= create_range_type (NULL
, index_type
, 1, length
);
10119 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
10120 type
= create_string_type (NULL
, char_type
, range_type
);
10122 return set_die_type (die
, type
, cu
);
10125 /* Handle DIES due to C code like:
10129 int (*funcp)(int a, long l);
10133 ('funcp' generates a DW_TAG_subroutine_type DIE). */
10135 static struct type
*
10136 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10138 struct objfile
*objfile
= cu
->objfile
;
10139 struct type
*type
; /* Type that this function returns. */
10140 struct type
*ftype
; /* Function that returns above type. */
10141 struct attribute
*attr
;
10143 type
= die_type (die
, cu
);
10145 /* The die_type call above may have already set the type for this DIE. */
10146 ftype
= get_die_type (die
, cu
);
10150 ftype
= lookup_function_type (type
);
10152 /* All functions in C++, Pascal and Java have prototypes. */
10153 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
10154 if ((attr
&& (DW_UNSND (attr
) != 0))
10155 || cu
->language
== language_cplus
10156 || cu
->language
== language_java
10157 || cu
->language
== language_pascal
)
10158 TYPE_PROTOTYPED (ftype
) = 1;
10159 else if (producer_is_realview (cu
->producer
))
10160 /* RealView does not emit DW_AT_prototyped. We can not
10161 distinguish prototyped and unprototyped functions; default to
10162 prototyped, since that is more common in modern code (and
10163 RealView warns about unprototyped functions). */
10164 TYPE_PROTOTYPED (ftype
) = 1;
10166 /* Store the calling convention in the type if it's available in
10167 the subroutine die. Otherwise set the calling convention to
10168 the default value DW_CC_normal. */
10169 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
10171 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
10172 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
10173 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
10175 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
10177 /* We need to add the subroutine type to the die immediately so
10178 we don't infinitely recurse when dealing with parameters
10179 declared as the same subroutine type. */
10180 set_die_type (die
, ftype
, cu
);
10182 if (die
->child
!= NULL
)
10184 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
10185 struct die_info
*child_die
;
10186 int nparams
, iparams
;
10188 /* Count the number of parameters.
10189 FIXME: GDB currently ignores vararg functions, but knows about
10190 vararg member functions. */
10192 child_die
= die
->child
;
10193 while (child_die
&& child_die
->tag
)
10195 if (child_die
->tag
== DW_TAG_formal_parameter
)
10197 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
10198 TYPE_VARARGS (ftype
) = 1;
10199 child_die
= sibling_die (child_die
);
10202 /* Allocate storage for parameters and fill them in. */
10203 TYPE_NFIELDS (ftype
) = nparams
;
10204 TYPE_FIELDS (ftype
) = (struct field
*)
10205 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
10207 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
10208 even if we error out during the parameters reading below. */
10209 for (iparams
= 0; iparams
< nparams
; iparams
++)
10210 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
10213 child_die
= die
->child
;
10214 while (child_die
&& child_die
->tag
)
10216 if (child_die
->tag
== DW_TAG_formal_parameter
)
10218 struct type
*arg_type
;
10220 /* DWARF version 2 has no clean way to discern C++
10221 static and non-static member functions. G++ helps
10222 GDB by marking the first parameter for non-static
10223 member functions (which is the this pointer) as
10224 artificial. We pass this information to
10225 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
10227 DWARF version 3 added DW_AT_object_pointer, which GCC
10228 4.5 does not yet generate. */
10229 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
10231 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
10234 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
10236 /* GCC/43521: In java, the formal parameter
10237 "this" is sometimes not marked with DW_AT_artificial. */
10238 if (cu
->language
== language_java
)
10240 const char *name
= dwarf2_name (child_die
, cu
);
10242 if (name
&& !strcmp (name
, "this"))
10243 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
10246 arg_type
= die_type (child_die
, cu
);
10248 /* RealView does not mark THIS as const, which the testsuite
10249 expects. GCC marks THIS as const in method definitions,
10250 but not in the class specifications (GCC PR 43053). */
10251 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
10252 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
10255 struct dwarf2_cu
*arg_cu
= cu
;
10256 const char *name
= dwarf2_name (child_die
, cu
);
10258 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
10261 /* If the compiler emits this, use it. */
10262 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
10265 else if (name
&& strcmp (name
, "this") == 0)
10266 /* Function definitions will have the argument names. */
10268 else if (name
== NULL
&& iparams
== 0)
10269 /* Declarations may not have the names, so like
10270 elsewhere in GDB, assume an artificial first
10271 argument is "this". */
10275 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
10279 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
10282 child_die
= sibling_die (child_die
);
10289 static struct type
*
10290 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
10292 struct objfile
*objfile
= cu
->objfile
;
10293 const char *name
= NULL
;
10294 struct type
*this_type
, *target_type
;
10296 name
= dwarf2_full_name (NULL
, die
, cu
);
10297 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
10298 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
10299 TYPE_NAME (this_type
) = (char *) name
;
10300 set_die_type (die
, this_type
, cu
);
10301 target_type
= die_type (die
, cu
);
10302 if (target_type
!= this_type
)
10303 TYPE_TARGET_TYPE (this_type
) = target_type
;
10306 /* Self-referential typedefs are, it seems, not allowed by the DWARF
10307 spec and cause infinite loops in GDB. */
10308 complaint (&symfile_complaints
,
10309 _("Self-referential DW_TAG_typedef "
10310 "- DIE at 0x%x [in module %s]"),
10311 die
->offset
.sect_off
, objfile
->name
);
10312 TYPE_TARGET_TYPE (this_type
) = NULL
;
10317 /* Find a representation of a given base type and install
10318 it in the TYPE field of the die. */
10320 static struct type
*
10321 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10323 struct objfile
*objfile
= cu
->objfile
;
10325 struct attribute
*attr
;
10326 int encoding
= 0, size
= 0;
10328 enum type_code code
= TYPE_CODE_INT
;
10329 int type_flags
= 0;
10330 struct type
*target_type
= NULL
;
10332 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
10335 encoding
= DW_UNSND (attr
);
10337 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
10340 size
= DW_UNSND (attr
);
10342 name
= dwarf2_name (die
, cu
);
10345 complaint (&symfile_complaints
,
10346 _("DW_AT_name missing from DW_TAG_base_type"));
10351 case DW_ATE_address
:
10352 /* Turn DW_ATE_address into a void * pointer. */
10353 code
= TYPE_CODE_PTR
;
10354 type_flags
|= TYPE_FLAG_UNSIGNED
;
10355 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
10357 case DW_ATE_boolean
:
10358 code
= TYPE_CODE_BOOL
;
10359 type_flags
|= TYPE_FLAG_UNSIGNED
;
10361 case DW_ATE_complex_float
:
10362 code
= TYPE_CODE_COMPLEX
;
10363 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
10365 case DW_ATE_decimal_float
:
10366 code
= TYPE_CODE_DECFLOAT
;
10369 code
= TYPE_CODE_FLT
;
10371 case DW_ATE_signed
:
10373 case DW_ATE_unsigned
:
10374 type_flags
|= TYPE_FLAG_UNSIGNED
;
10375 if (cu
->language
== language_fortran
10377 && strncmp (name
, "character(", sizeof ("character(") - 1) == 0)
10378 code
= TYPE_CODE_CHAR
;
10380 case DW_ATE_signed_char
:
10381 if (cu
->language
== language_ada
|| cu
->language
== language_m2
10382 || cu
->language
== language_pascal
10383 || cu
->language
== language_fortran
)
10384 code
= TYPE_CODE_CHAR
;
10386 case DW_ATE_unsigned_char
:
10387 if (cu
->language
== language_ada
|| cu
->language
== language_m2
10388 || cu
->language
== language_pascal
10389 || cu
->language
== language_fortran
)
10390 code
= TYPE_CODE_CHAR
;
10391 type_flags
|= TYPE_FLAG_UNSIGNED
;
10394 /* We just treat this as an integer and then recognize the
10395 type by name elsewhere. */
10399 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
10400 dwarf_type_encoding_name (encoding
));
10404 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
10405 TYPE_NAME (type
) = name
;
10406 TYPE_TARGET_TYPE (type
) = target_type
;
10408 if (name
&& strcmp (name
, "char") == 0)
10409 TYPE_NOSIGN (type
) = 1;
10411 return set_die_type (die
, type
, cu
);
10414 /* Read the given DW_AT_subrange DIE. */
10416 static struct type
*
10417 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10419 struct type
*base_type
;
10420 struct type
*range_type
;
10421 struct attribute
*attr
;
10423 int low_default_is_valid
;
10425 LONGEST negative_mask
;
10427 base_type
= die_type (die
, cu
);
10428 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
10429 check_typedef (base_type
);
10431 /* The die_type call above may have already set the type for this DIE. */
10432 range_type
= get_die_type (die
, cu
);
10436 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
10437 omitting DW_AT_lower_bound. */
10438 switch (cu
->language
)
10441 case language_cplus
:
10443 low_default_is_valid
= 1;
10445 case language_fortran
:
10447 low_default_is_valid
= 1;
10450 case language_java
:
10451 case language_objc
:
10453 low_default_is_valid
= (cu
->header
.version
>= 4);
10457 case language_pascal
:
10459 low_default_is_valid
= (cu
->header
.version
>= 4);
10463 low_default_is_valid
= 0;
10467 /* FIXME: For variable sized arrays either of these could be
10468 a variable rather than a constant value. We'll allow it,
10469 but we don't know how to handle it. */
10470 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
10472 low
= dwarf2_get_attr_constant_value (attr
, low
);
10473 else if (!low_default_is_valid
)
10474 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
10475 "- DIE at 0x%x [in module %s]"),
10476 die
->offset
.sect_off
, cu
->objfile
->name
);
10478 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
10481 if (attr_form_is_block (attr
) || is_ref_attr (attr
))
10483 /* GCC encodes arrays with unspecified or dynamic length
10484 with a DW_FORM_block1 attribute or a reference attribute.
10485 FIXME: GDB does not yet know how to handle dynamic
10486 arrays properly, treat them as arrays with unspecified
10489 FIXME: jimb/2003-09-22: GDB does not really know
10490 how to handle arrays of unspecified length
10491 either; we just represent them as zero-length
10492 arrays. Choose an appropriate upper bound given
10493 the lower bound we've computed above. */
10497 high
= dwarf2_get_attr_constant_value (attr
, 1);
10501 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
10504 int count
= dwarf2_get_attr_constant_value (attr
, 1);
10505 high
= low
+ count
- 1;
10509 /* Unspecified array length. */
10514 /* Dwarf-2 specifications explicitly allows to create subrange types
10515 without specifying a base type.
10516 In that case, the base type must be set to the type of
10517 the lower bound, upper bound or count, in that order, if any of these
10518 three attributes references an object that has a type.
10519 If no base type is found, the Dwarf-2 specifications say that
10520 a signed integer type of size equal to the size of an address should
10522 For the following C code: `extern char gdb_int [];'
10523 GCC produces an empty range DIE.
10524 FIXME: muller/2010-05-28: Possible references to object for low bound,
10525 high bound or count are not yet handled by this code. */
10526 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
10528 struct objfile
*objfile
= cu
->objfile
;
10529 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10530 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
10531 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
10533 /* Test "int", "long int", and "long long int" objfile types,
10534 and select the first one having a size above or equal to the
10535 architecture address size. */
10536 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
10537 base_type
= int_type
;
10540 int_type
= objfile_type (objfile
)->builtin_long
;
10541 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
10542 base_type
= int_type
;
10545 int_type
= objfile_type (objfile
)->builtin_long_long
;
10546 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
10547 base_type
= int_type
;
10553 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
10554 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
10555 low
|= negative_mask
;
10556 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
10557 high
|= negative_mask
;
10559 range_type
= create_range_type (NULL
, base_type
, low
, high
);
10561 /* Mark arrays with dynamic length at least as an array of unspecified
10562 length. GDB could check the boundary but before it gets implemented at
10563 least allow accessing the array elements. */
10564 if (attr
&& attr_form_is_block (attr
))
10565 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
10567 /* Ada expects an empty array on no boundary attributes. */
10568 if (attr
== NULL
&& cu
->language
!= language_ada
)
10569 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
10571 name
= dwarf2_name (die
, cu
);
10573 TYPE_NAME (range_type
) = name
;
10575 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
10577 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
10579 set_die_type (die
, range_type
, cu
);
10581 /* set_die_type should be already done. */
10582 set_descriptive_type (range_type
, die
, cu
);
10587 static struct type
*
10588 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10592 /* For now, we only support the C meaning of an unspecified type: void. */
10594 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
10595 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
10597 return set_die_type (die
, type
, cu
);
10600 /* Read a single die and all its descendents. Set the die's sibling
10601 field to NULL; set other fields in the die correctly, and set all
10602 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
10603 location of the info_ptr after reading all of those dies. PARENT
10604 is the parent of the die in question. */
10606 static struct die_info
*
10607 read_die_and_children (const struct die_reader_specs
*reader
,
10608 gdb_byte
*info_ptr
,
10609 gdb_byte
**new_info_ptr
,
10610 struct die_info
*parent
)
10612 struct die_info
*die
;
10616 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
10619 *new_info_ptr
= cur_ptr
;
10622 store_in_ref_table (die
, reader
->cu
);
10625 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
10629 *new_info_ptr
= cur_ptr
;
10632 die
->sibling
= NULL
;
10633 die
->parent
= parent
;
10637 /* Read a die, all of its descendents, and all of its siblings; set
10638 all of the fields of all of the dies correctly. Arguments are as
10639 in read_die_and_children. */
10641 static struct die_info
*
10642 read_die_and_siblings (const struct die_reader_specs
*reader
,
10643 gdb_byte
*info_ptr
,
10644 gdb_byte
**new_info_ptr
,
10645 struct die_info
*parent
)
10647 struct die_info
*first_die
, *last_sibling
;
10650 cur_ptr
= info_ptr
;
10651 first_die
= last_sibling
= NULL
;
10655 struct die_info
*die
10656 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
10660 *new_info_ptr
= cur_ptr
;
10667 last_sibling
->sibling
= die
;
10669 last_sibling
= die
;
10673 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
10675 The caller is responsible for filling in the extra attributes
10676 and updating (*DIEP)->num_attrs.
10677 Set DIEP to point to a newly allocated die with its information,
10678 except for its child, sibling, and parent fields.
10679 Set HAS_CHILDREN to tell whether the die has children or not. */
10682 read_full_die_1 (const struct die_reader_specs
*reader
,
10683 struct die_info
**diep
, gdb_byte
*info_ptr
,
10684 int *has_children
, int num_extra_attrs
)
10686 unsigned int abbrev_number
, bytes_read
, i
;
10687 sect_offset offset
;
10688 struct abbrev_info
*abbrev
;
10689 struct die_info
*die
;
10690 struct dwarf2_cu
*cu
= reader
->cu
;
10691 bfd
*abfd
= reader
->abfd
;
10693 offset
.sect_off
= info_ptr
- reader
->buffer
;
10694 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10695 info_ptr
+= bytes_read
;
10696 if (!abbrev_number
)
10703 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
10705 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
10707 bfd_get_filename (abfd
));
10709 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
10710 die
->offset
= offset
;
10711 die
->tag
= abbrev
->tag
;
10712 die
->abbrev
= abbrev_number
;
10714 /* Make the result usable.
10715 The caller needs to update num_attrs after adding the extra
10717 die
->num_attrs
= abbrev
->num_attrs
;
10719 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
10720 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
10724 *has_children
= abbrev
->has_children
;
10728 /* Read a die and all its attributes.
10729 Set DIEP to point to a newly allocated die with its information,
10730 except for its child, sibling, and parent fields.
10731 Set HAS_CHILDREN to tell whether the die has children or not. */
10734 read_full_die (const struct die_reader_specs
*reader
,
10735 struct die_info
**diep
, gdb_byte
*info_ptr
,
10738 return read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
10741 /* In DWARF version 2, the description of the debugging information is
10742 stored in a separate .debug_abbrev section. Before we read any
10743 dies from a section we read in all abbreviations and install them
10744 in a hash table. This function also sets flags in CU describing
10745 the data found in the abbrev table. */
10748 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
10749 struct dwarf2_section_info
*abbrev_section
)
10752 bfd
*abfd
= abbrev_section
->asection
->owner
;
10753 struct comp_unit_head
*cu_header
= &cu
->header
;
10754 gdb_byte
*abbrev_ptr
;
10755 struct abbrev_info
*cur_abbrev
;
10756 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
10757 unsigned int abbrev_form
, hash_number
;
10758 struct attr_abbrev
*cur_attrs
;
10759 unsigned int allocated_attrs
;
10761 /* Initialize dwarf2 abbrevs. */
10762 obstack_init (&cu
->abbrev_obstack
);
10763 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
10765 * sizeof (struct abbrev_info
*)));
10766 memset (cu
->dwarf2_abbrevs
, 0,
10767 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
10769 dwarf2_read_section (cu
->objfile
, abbrev_section
);
10770 abbrev_ptr
= abbrev_section
->buffer
+ cu_header
->abbrev_offset
.sect_off
;
10771 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
10772 abbrev_ptr
+= bytes_read
;
10774 allocated_attrs
= ATTR_ALLOC_CHUNK
;
10775 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
10777 /* Loop until we reach an abbrev number of 0. */
10778 while (abbrev_number
)
10780 cur_abbrev
= dwarf_alloc_abbrev (cu
);
10782 /* read in abbrev header */
10783 cur_abbrev
->number
= abbrev_number
;
10784 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
10785 abbrev_ptr
+= bytes_read
;
10786 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
10789 /* now read in declarations */
10790 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
10791 abbrev_ptr
+= bytes_read
;
10792 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
10793 abbrev_ptr
+= bytes_read
;
10794 while (abbrev_name
)
10796 if (cur_abbrev
->num_attrs
== allocated_attrs
)
10798 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
10800 = xrealloc (cur_attrs
, (allocated_attrs
10801 * sizeof (struct attr_abbrev
)));
10804 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
10805 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
10806 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
10807 abbrev_ptr
+= bytes_read
;
10808 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
10809 abbrev_ptr
+= bytes_read
;
10812 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
10813 (cur_abbrev
->num_attrs
10814 * sizeof (struct attr_abbrev
)));
10815 memcpy (cur_abbrev
->attrs
, cur_attrs
,
10816 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
10818 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
10819 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
10820 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
10822 /* Get next abbreviation.
10823 Under Irix6 the abbreviations for a compilation unit are not
10824 always properly terminated with an abbrev number of 0.
10825 Exit loop if we encounter an abbreviation which we have
10826 already read (which means we are about to read the abbreviations
10827 for the next compile unit) or if the end of the abbreviation
10828 table is reached. */
10829 if ((unsigned int) (abbrev_ptr
- abbrev_section
->buffer
)
10830 >= abbrev_section
->size
)
10832 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
10833 abbrev_ptr
+= bytes_read
;
10834 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
10841 /* Release the memory used by the abbrev table for a compilation unit. */
10844 dwarf2_free_abbrev_table (void *ptr_to_cu
)
10846 struct dwarf2_cu
*cu
= ptr_to_cu
;
10848 obstack_free (&cu
->abbrev_obstack
, NULL
);
10849 cu
->dwarf2_abbrevs
= NULL
;
10852 /* Lookup an abbrev_info structure in the abbrev hash table. */
10854 static struct abbrev_info
*
10855 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
10857 unsigned int hash_number
;
10858 struct abbrev_info
*abbrev
;
10860 hash_number
= number
% ABBREV_HASH_SIZE
;
10861 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
10865 if (abbrev
->number
== number
)
10868 abbrev
= abbrev
->next
;
10873 /* Returns nonzero if TAG represents a type that we might generate a partial
10877 is_type_tag_for_partial (int tag
)
10882 /* Some types that would be reasonable to generate partial symbols for,
10883 that we don't at present. */
10884 case DW_TAG_array_type
:
10885 case DW_TAG_file_type
:
10886 case DW_TAG_ptr_to_member_type
:
10887 case DW_TAG_set_type
:
10888 case DW_TAG_string_type
:
10889 case DW_TAG_subroutine_type
:
10891 case DW_TAG_base_type
:
10892 case DW_TAG_class_type
:
10893 case DW_TAG_interface_type
:
10894 case DW_TAG_enumeration_type
:
10895 case DW_TAG_structure_type
:
10896 case DW_TAG_subrange_type
:
10897 case DW_TAG_typedef
:
10898 case DW_TAG_union_type
:
10905 /* Load all DIEs that are interesting for partial symbols into memory. */
10907 static struct partial_die_info
*
10908 load_partial_dies (const struct die_reader_specs
*reader
,
10909 gdb_byte
*info_ptr
, int building_psymtab
)
10911 struct dwarf2_cu
*cu
= reader
->cu
;
10912 struct objfile
*objfile
= cu
->objfile
;
10913 struct partial_die_info
*part_die
;
10914 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
10915 struct abbrev_info
*abbrev
;
10916 unsigned int bytes_read
;
10917 unsigned int load_all
= 0;
10918 int nesting_level
= 1;
10923 gdb_assert (cu
->per_cu
!= NULL
);
10924 if (cu
->per_cu
->load_all_dies
)
10928 = htab_create_alloc_ex (cu
->header
.length
/ 12,
10932 &cu
->comp_unit_obstack
,
10933 hashtab_obstack_allocate
,
10934 dummy_obstack_deallocate
);
10936 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
10937 sizeof (struct partial_die_info
));
10941 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
10943 /* A NULL abbrev means the end of a series of children. */
10944 if (abbrev
== NULL
)
10946 if (--nesting_level
== 0)
10948 /* PART_DIE was probably the last thing allocated on the
10949 comp_unit_obstack, so we could call obstack_free
10950 here. We don't do that because the waste is small,
10951 and will be cleaned up when we're done with this
10952 compilation unit. This way, we're also more robust
10953 against other users of the comp_unit_obstack. */
10956 info_ptr
+= bytes_read
;
10957 last_die
= parent_die
;
10958 parent_die
= parent_die
->die_parent
;
10962 /* Check for template arguments. We never save these; if
10963 they're seen, we just mark the parent, and go on our way. */
10964 if (parent_die
!= NULL
10965 && cu
->language
== language_cplus
10966 && (abbrev
->tag
== DW_TAG_template_type_param
10967 || abbrev
->tag
== DW_TAG_template_value_param
))
10969 parent_die
->has_template_arguments
= 1;
10973 /* We don't need a partial DIE for the template argument. */
10974 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
10979 /* We only recurse into c++ subprograms looking for template arguments.
10980 Skip their other children. */
10982 && cu
->language
== language_cplus
10983 && parent_die
!= NULL
10984 && parent_die
->tag
== DW_TAG_subprogram
)
10986 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
10990 /* Check whether this DIE is interesting enough to save. Normally
10991 we would not be interested in members here, but there may be
10992 later variables referencing them via DW_AT_specification (for
10993 static members). */
10995 && !is_type_tag_for_partial (abbrev
->tag
)
10996 && abbrev
->tag
!= DW_TAG_constant
10997 && abbrev
->tag
!= DW_TAG_enumerator
10998 && abbrev
->tag
!= DW_TAG_subprogram
10999 && abbrev
->tag
!= DW_TAG_lexical_block
11000 && abbrev
->tag
!= DW_TAG_variable
11001 && abbrev
->tag
!= DW_TAG_namespace
11002 && abbrev
->tag
!= DW_TAG_module
11003 && abbrev
->tag
!= DW_TAG_member
11004 && abbrev
->tag
!= DW_TAG_imported_unit
)
11006 /* Otherwise we skip to the next sibling, if any. */
11007 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
11011 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
11014 /* This two-pass algorithm for processing partial symbols has a
11015 high cost in cache pressure. Thus, handle some simple cases
11016 here which cover the majority of C partial symbols. DIEs
11017 which neither have specification tags in them, nor could have
11018 specification tags elsewhere pointing at them, can simply be
11019 processed and discarded.
11021 This segment is also optional; scan_partial_symbols and
11022 add_partial_symbol will handle these DIEs if we chain
11023 them in normally. When compilers which do not emit large
11024 quantities of duplicate debug information are more common,
11025 this code can probably be removed. */
11027 /* Any complete simple types at the top level (pretty much all
11028 of them, for a language without namespaces), can be processed
11030 if (parent_die
== NULL
11031 && part_die
->has_specification
== 0
11032 && part_die
->is_declaration
== 0
11033 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
11034 || part_die
->tag
== DW_TAG_base_type
11035 || part_die
->tag
== DW_TAG_subrange_type
))
11037 if (building_psymtab
&& part_die
->name
!= NULL
)
11038 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
11039 VAR_DOMAIN
, LOC_TYPEDEF
,
11040 &objfile
->static_psymbols
,
11041 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
11042 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
11046 /* The exception for DW_TAG_typedef with has_children above is
11047 a workaround of GCC PR debug/47510. In the case of this complaint
11048 type_name_no_tag_or_error will error on such types later.
11050 GDB skipped children of DW_TAG_typedef by the shortcut above and then
11051 it could not find the child DIEs referenced later, this is checked
11052 above. In correct DWARF DW_TAG_typedef should have no children. */
11054 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
11055 complaint (&symfile_complaints
,
11056 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
11057 "- DIE at 0x%x [in module %s]"),
11058 part_die
->offset
.sect_off
, objfile
->name
);
11060 /* If we're at the second level, and we're an enumerator, and
11061 our parent has no specification (meaning possibly lives in a
11062 namespace elsewhere), then we can add the partial symbol now
11063 instead of queueing it. */
11064 if (part_die
->tag
== DW_TAG_enumerator
11065 && parent_die
!= NULL
11066 && parent_die
->die_parent
== NULL
11067 && parent_die
->tag
== DW_TAG_enumeration_type
11068 && parent_die
->has_specification
== 0)
11070 if (part_die
->name
== NULL
)
11071 complaint (&symfile_complaints
,
11072 _("malformed enumerator DIE ignored"));
11073 else if (building_psymtab
)
11074 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
11075 VAR_DOMAIN
, LOC_CONST
,
11076 (cu
->language
== language_cplus
11077 || cu
->language
== language_java
)
11078 ? &objfile
->global_psymbols
11079 : &objfile
->static_psymbols
,
11080 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
11082 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
11086 /* We'll save this DIE so link it in. */
11087 part_die
->die_parent
= parent_die
;
11088 part_die
->die_sibling
= NULL
;
11089 part_die
->die_child
= NULL
;
11091 if (last_die
&& last_die
== parent_die
)
11092 last_die
->die_child
= part_die
;
11094 last_die
->die_sibling
= part_die
;
11096 last_die
= part_die
;
11098 if (first_die
== NULL
)
11099 first_die
= part_die
;
11101 /* Maybe add the DIE to the hash table. Not all DIEs that we
11102 find interesting need to be in the hash table, because we
11103 also have the parent/sibling/child chains; only those that we
11104 might refer to by offset later during partial symbol reading.
11106 For now this means things that might have be the target of a
11107 DW_AT_specification, DW_AT_abstract_origin, or
11108 DW_AT_extension. DW_AT_extension will refer only to
11109 namespaces; DW_AT_abstract_origin refers to functions (and
11110 many things under the function DIE, but we do not recurse
11111 into function DIEs during partial symbol reading) and
11112 possibly variables as well; DW_AT_specification refers to
11113 declarations. Declarations ought to have the DW_AT_declaration
11114 flag. It happens that GCC forgets to put it in sometimes, but
11115 only for functions, not for types.
11117 Adding more things than necessary to the hash table is harmless
11118 except for the performance cost. Adding too few will result in
11119 wasted time in find_partial_die, when we reread the compilation
11120 unit with load_all_dies set. */
11123 || abbrev
->tag
== DW_TAG_constant
11124 || abbrev
->tag
== DW_TAG_subprogram
11125 || abbrev
->tag
== DW_TAG_variable
11126 || abbrev
->tag
== DW_TAG_namespace
11127 || part_die
->is_declaration
)
11131 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
11132 part_die
->offset
.sect_off
, INSERT
);
11136 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
11137 sizeof (struct partial_die_info
));
11139 /* For some DIEs we want to follow their children (if any). For C
11140 we have no reason to follow the children of structures; for other
11141 languages we have to, so that we can get at method physnames
11142 to infer fully qualified class names, for DW_AT_specification,
11143 and for C++ template arguments. For C++, we also look one level
11144 inside functions to find template arguments (if the name of the
11145 function does not already contain the template arguments).
11147 For Ada, we need to scan the children of subprograms and lexical
11148 blocks as well because Ada allows the definition of nested
11149 entities that could be interesting for the debugger, such as
11150 nested subprograms for instance. */
11151 if (last_die
->has_children
11153 || last_die
->tag
== DW_TAG_namespace
11154 || last_die
->tag
== DW_TAG_module
11155 || last_die
->tag
== DW_TAG_enumeration_type
11156 || (cu
->language
== language_cplus
11157 && last_die
->tag
== DW_TAG_subprogram
11158 && (last_die
->name
== NULL
11159 || strchr (last_die
->name
, '<') == NULL
))
11160 || (cu
->language
!= language_c
11161 && (last_die
->tag
== DW_TAG_class_type
11162 || last_die
->tag
== DW_TAG_interface_type
11163 || last_die
->tag
== DW_TAG_structure_type
11164 || last_die
->tag
== DW_TAG_union_type
))
11165 || (cu
->language
== language_ada
11166 && (last_die
->tag
== DW_TAG_subprogram
11167 || last_die
->tag
== DW_TAG_lexical_block
))))
11170 parent_die
= last_die
;
11174 /* Otherwise we skip to the next sibling, if any. */
11175 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
11177 /* Back to the top, do it again. */
11181 /* Read a minimal amount of information into the minimal die structure. */
11184 read_partial_die (const struct die_reader_specs
*reader
,
11185 struct partial_die_info
*part_die
,
11186 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
11187 gdb_byte
*info_ptr
)
11189 struct dwarf2_cu
*cu
= reader
->cu
;
11190 struct objfile
*objfile
= cu
->objfile
;
11191 gdb_byte
*buffer
= reader
->buffer
;
11193 struct attribute attr
;
11194 int has_low_pc_attr
= 0;
11195 int has_high_pc_attr
= 0;
11196 int high_pc_relative
= 0;
11198 memset (part_die
, 0, sizeof (struct partial_die_info
));
11200 part_die
->offset
.sect_off
= info_ptr
- buffer
;
11202 info_ptr
+= abbrev_len
;
11204 if (abbrev
== NULL
)
11207 part_die
->tag
= abbrev
->tag
;
11208 part_die
->has_children
= abbrev
->has_children
;
11210 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
11212 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
11214 /* Store the data if it is of an attribute we want to keep in a
11215 partial symbol table. */
11219 switch (part_die
->tag
)
11221 case DW_TAG_compile_unit
:
11222 case DW_TAG_partial_unit
:
11223 case DW_TAG_type_unit
:
11224 /* Compilation units have a DW_AT_name that is a filename, not
11225 a source language identifier. */
11226 case DW_TAG_enumeration_type
:
11227 case DW_TAG_enumerator
:
11228 /* These tags always have simple identifiers already; no need
11229 to canonicalize them. */
11230 part_die
->name
= DW_STRING (&attr
);
11234 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
11235 &objfile
->objfile_obstack
);
11239 case DW_AT_linkage_name
:
11240 case DW_AT_MIPS_linkage_name
:
11241 /* Note that both forms of linkage name might appear. We
11242 assume they will be the same, and we only store the last
11244 if (cu
->language
== language_ada
)
11245 part_die
->name
= DW_STRING (&attr
);
11246 part_die
->linkage_name
= DW_STRING (&attr
);
11249 has_low_pc_attr
= 1;
11250 part_die
->lowpc
= DW_ADDR (&attr
);
11252 case DW_AT_high_pc
:
11253 has_high_pc_attr
= 1;
11254 if (attr
.form
== DW_FORM_addr
11255 || attr
.form
== DW_FORM_GNU_addr_index
)
11256 part_die
->highpc
= DW_ADDR (&attr
);
11259 high_pc_relative
= 1;
11260 part_die
->highpc
= DW_UNSND (&attr
);
11263 case DW_AT_location
:
11264 /* Support the .debug_loc offsets. */
11265 if (attr_form_is_block (&attr
))
11267 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
11269 else if (attr_form_is_section_offset (&attr
))
11271 dwarf2_complex_location_expr_complaint ();
11275 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
11276 "partial symbol information");
11279 case DW_AT_external
:
11280 part_die
->is_external
= DW_UNSND (&attr
);
11282 case DW_AT_declaration
:
11283 part_die
->is_declaration
= DW_UNSND (&attr
);
11286 part_die
->has_type
= 1;
11288 case DW_AT_abstract_origin
:
11289 case DW_AT_specification
:
11290 case DW_AT_extension
:
11291 part_die
->has_specification
= 1;
11292 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
11294 case DW_AT_sibling
:
11295 /* Ignore absolute siblings, they might point outside of
11296 the current compile unit. */
11297 if (attr
.form
== DW_FORM_ref_addr
)
11298 complaint (&symfile_complaints
,
11299 _("ignoring absolute DW_AT_sibling"));
11301 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
).sect_off
;
11303 case DW_AT_byte_size
:
11304 part_die
->has_byte_size
= 1;
11306 case DW_AT_calling_convention
:
11307 /* DWARF doesn't provide a way to identify a program's source-level
11308 entry point. DW_AT_calling_convention attributes are only meant
11309 to describe functions' calling conventions.
11311 However, because it's a necessary piece of information in
11312 Fortran, and because DW_CC_program is the only piece of debugging
11313 information whose definition refers to a 'main program' at all,
11314 several compilers have begun marking Fortran main programs with
11315 DW_CC_program --- even when those functions use the standard
11316 calling conventions.
11318 So until DWARF specifies a way to provide this information and
11319 compilers pick up the new representation, we'll support this
11321 if (DW_UNSND (&attr
) == DW_CC_program
11322 && cu
->language
== language_fortran
)
11324 set_main_name (part_die
->name
);
11326 /* As this DIE has a static linkage the name would be difficult
11327 to look up later. */
11328 language_of_main
= language_fortran
;
11332 if (DW_UNSND (&attr
) == DW_INL_inlined
11333 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
11334 part_die
->may_be_inlined
= 1;
11338 if (part_die
->tag
== DW_TAG_imported_unit
)
11339 part_die
->d
.offset
= dwarf2_get_ref_die_offset (&attr
);
11347 if (high_pc_relative
)
11348 part_die
->highpc
+= part_die
->lowpc
;
11350 if (has_low_pc_attr
&& has_high_pc_attr
)
11352 /* When using the GNU linker, .gnu.linkonce. sections are used to
11353 eliminate duplicate copies of functions and vtables and such.
11354 The linker will arbitrarily choose one and discard the others.
11355 The AT_*_pc values for such functions refer to local labels in
11356 these sections. If the section from that file was discarded, the
11357 labels are not in the output, so the relocs get a value of 0.
11358 If this is a discarded function, mark the pc bounds as invalid,
11359 so that GDB will ignore it. */
11360 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
11362 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11364 complaint (&symfile_complaints
,
11365 _("DW_AT_low_pc %s is zero "
11366 "for DIE at 0x%x [in module %s]"),
11367 paddress (gdbarch
, part_die
->lowpc
),
11368 part_die
->offset
.sect_off
, objfile
->name
);
11370 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
11371 else if (part_die
->lowpc
>= part_die
->highpc
)
11373 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11375 complaint (&symfile_complaints
,
11376 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
11377 "for DIE at 0x%x [in module %s]"),
11378 paddress (gdbarch
, part_die
->lowpc
),
11379 paddress (gdbarch
, part_die
->highpc
),
11380 part_die
->offset
.sect_off
, objfile
->name
);
11383 part_die
->has_pc_info
= 1;
11389 /* Find a cached partial DIE at OFFSET in CU. */
11391 static struct partial_die_info
*
11392 find_partial_die_in_comp_unit (sect_offset offset
, struct dwarf2_cu
*cu
)
11394 struct partial_die_info
*lookup_die
= NULL
;
11395 struct partial_die_info part_die
;
11397 part_die
.offset
= offset
;
11398 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
,
11404 /* Find a partial DIE at OFFSET, which may or may not be in CU,
11405 except in the case of .debug_types DIEs which do not reference
11406 outside their CU (they do however referencing other types via
11407 DW_FORM_ref_sig8). */
11409 static struct partial_die_info
*
11410 find_partial_die (sect_offset offset
, struct dwarf2_cu
*cu
)
11412 struct objfile
*objfile
= cu
->objfile
;
11413 struct dwarf2_per_cu_data
*per_cu
= NULL
;
11414 struct partial_die_info
*pd
= NULL
;
11416 if (offset_in_cu_p (&cu
->header
, offset
))
11418 pd
= find_partial_die_in_comp_unit (offset
, cu
);
11421 /* We missed recording what we needed.
11422 Load all dies and try again. */
11423 per_cu
= cu
->per_cu
;
11427 /* TUs don't reference other CUs/TUs (except via type signatures). */
11428 if (cu
->per_cu
->is_debug_types
)
11430 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
11431 " external reference to offset 0x%lx [in module %s].\n"),
11432 (long) cu
->header
.offset
.sect_off
, (long) offset
.sect_off
,
11433 bfd_get_filename (objfile
->obfd
));
11435 per_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
11437 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
11438 load_partial_comp_unit (per_cu
);
11440 per_cu
->cu
->last_used
= 0;
11441 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
11444 /* If we didn't find it, and not all dies have been loaded,
11445 load them all and try again. */
11447 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
11449 per_cu
->load_all_dies
= 1;
11451 /* This is nasty. When we reread the DIEs, somewhere up the call chain
11452 THIS_CU->cu may already be in use. So we can't just free it and
11453 replace its DIEs with the ones we read in. Instead, we leave those
11454 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
11455 and clobber THIS_CU->cu->partial_dies with the hash table for the new
11457 load_partial_comp_unit (per_cu
);
11459 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
11463 internal_error (__FILE__
, __LINE__
,
11464 _("could not find partial DIE 0x%x "
11465 "in cache [from module %s]\n"),
11466 offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
11470 /* See if we can figure out if the class lives in a namespace. We do
11471 this by looking for a member function; its demangled name will
11472 contain namespace info, if there is any. */
11475 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
11476 struct dwarf2_cu
*cu
)
11478 /* NOTE: carlton/2003-10-07: Getting the info this way changes
11479 what template types look like, because the demangler
11480 frequently doesn't give the same name as the debug info. We
11481 could fix this by only using the demangled name to get the
11482 prefix (but see comment in read_structure_type). */
11484 struct partial_die_info
*real_pdi
;
11485 struct partial_die_info
*child_pdi
;
11487 /* If this DIE (this DIE's specification, if any) has a parent, then
11488 we should not do this. We'll prepend the parent's fully qualified
11489 name when we create the partial symbol. */
11491 real_pdi
= struct_pdi
;
11492 while (real_pdi
->has_specification
)
11493 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
11495 if (real_pdi
->die_parent
!= NULL
)
11498 for (child_pdi
= struct_pdi
->die_child
;
11500 child_pdi
= child_pdi
->die_sibling
)
11502 if (child_pdi
->tag
== DW_TAG_subprogram
11503 && child_pdi
->linkage_name
!= NULL
)
11505 char *actual_class_name
11506 = language_class_name_from_physname (cu
->language_defn
,
11507 child_pdi
->linkage_name
);
11508 if (actual_class_name
!= NULL
)
11511 = obsavestring (actual_class_name
,
11512 strlen (actual_class_name
),
11513 &cu
->objfile
->objfile_obstack
);
11514 xfree (actual_class_name
);
11521 /* Adjust PART_DIE before generating a symbol for it. This function
11522 may set the is_external flag or change the DIE's name. */
11525 fixup_partial_die (struct partial_die_info
*part_die
,
11526 struct dwarf2_cu
*cu
)
11528 /* Once we've fixed up a die, there's no point in doing so again.
11529 This also avoids a memory leak if we were to call
11530 guess_partial_die_structure_name multiple times. */
11531 if (part_die
->fixup_called
)
11534 /* If we found a reference attribute and the DIE has no name, try
11535 to find a name in the referred to DIE. */
11537 if (part_die
->name
== NULL
&& part_die
->has_specification
)
11539 struct partial_die_info
*spec_die
;
11541 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
11543 fixup_partial_die (spec_die
, cu
);
11545 if (spec_die
->name
)
11547 part_die
->name
= spec_die
->name
;
11549 /* Copy DW_AT_external attribute if it is set. */
11550 if (spec_die
->is_external
)
11551 part_die
->is_external
= spec_die
->is_external
;
11555 /* Set default names for some unnamed DIEs. */
11557 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
11558 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
11560 /* If there is no parent die to provide a namespace, and there are
11561 children, see if we can determine the namespace from their linkage
11563 if (cu
->language
== language_cplus
11564 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
11565 && part_die
->die_parent
== NULL
11566 && part_die
->has_children
11567 && (part_die
->tag
== DW_TAG_class_type
11568 || part_die
->tag
== DW_TAG_structure_type
11569 || part_die
->tag
== DW_TAG_union_type
))
11570 guess_partial_die_structure_name (part_die
, cu
);
11572 /* GCC might emit a nameless struct or union that has a linkage
11573 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
11574 if (part_die
->name
== NULL
11575 && (part_die
->tag
== DW_TAG_class_type
11576 || part_die
->tag
== DW_TAG_interface_type
11577 || part_die
->tag
== DW_TAG_structure_type
11578 || part_die
->tag
== DW_TAG_union_type
)
11579 && part_die
->linkage_name
!= NULL
)
11583 demangled
= cplus_demangle (part_die
->linkage_name
, DMGL_TYPES
);
11588 /* Strip any leading namespaces/classes, keep only the base name.
11589 DW_AT_name for named DIEs does not contain the prefixes. */
11590 base
= strrchr (demangled
, ':');
11591 if (base
&& base
> demangled
&& base
[-1] == ':')
11596 part_die
->name
= obsavestring (base
, strlen (base
),
11597 &cu
->objfile
->objfile_obstack
);
11602 part_die
->fixup_called
= 1;
11605 /* Read an attribute value described by an attribute form. */
11608 read_attribute_value (const struct die_reader_specs
*reader
,
11609 struct attribute
*attr
, unsigned form
,
11610 gdb_byte
*info_ptr
)
11612 struct dwarf2_cu
*cu
= reader
->cu
;
11613 bfd
*abfd
= reader
->abfd
;
11614 struct comp_unit_head
*cu_header
= &cu
->header
;
11615 unsigned int bytes_read
;
11616 struct dwarf_block
*blk
;
11621 case DW_FORM_ref_addr
:
11622 if (cu
->header
.version
== 2)
11623 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
11625 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
11626 &cu
->header
, &bytes_read
);
11627 info_ptr
+= bytes_read
;
11630 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
11631 info_ptr
+= bytes_read
;
11633 case DW_FORM_block2
:
11634 blk
= dwarf_alloc_block (cu
);
11635 blk
->size
= read_2_bytes (abfd
, info_ptr
);
11637 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
11638 info_ptr
+= blk
->size
;
11639 DW_BLOCK (attr
) = blk
;
11641 case DW_FORM_block4
:
11642 blk
= dwarf_alloc_block (cu
);
11643 blk
->size
= read_4_bytes (abfd
, info_ptr
);
11645 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
11646 info_ptr
+= blk
->size
;
11647 DW_BLOCK (attr
) = blk
;
11649 case DW_FORM_data2
:
11650 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
11653 case DW_FORM_data4
:
11654 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
11657 case DW_FORM_data8
:
11658 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
11661 case DW_FORM_sec_offset
:
11662 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
11663 info_ptr
+= bytes_read
;
11665 case DW_FORM_string
:
11666 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
11667 DW_STRING_IS_CANONICAL (attr
) = 0;
11668 info_ptr
+= bytes_read
;
11671 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
11673 DW_STRING_IS_CANONICAL (attr
) = 0;
11674 info_ptr
+= bytes_read
;
11676 case DW_FORM_exprloc
:
11677 case DW_FORM_block
:
11678 blk
= dwarf_alloc_block (cu
);
11679 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
11680 info_ptr
+= bytes_read
;
11681 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
11682 info_ptr
+= blk
->size
;
11683 DW_BLOCK (attr
) = blk
;
11685 case DW_FORM_block1
:
11686 blk
= dwarf_alloc_block (cu
);
11687 blk
->size
= read_1_byte (abfd
, info_ptr
);
11689 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
11690 info_ptr
+= blk
->size
;
11691 DW_BLOCK (attr
) = blk
;
11693 case DW_FORM_data1
:
11694 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
11698 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
11701 case DW_FORM_flag_present
:
11702 DW_UNSND (attr
) = 1;
11704 case DW_FORM_sdata
:
11705 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
11706 info_ptr
+= bytes_read
;
11708 case DW_FORM_udata
:
11709 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
11710 info_ptr
+= bytes_read
;
11713 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
11714 + read_1_byte (abfd
, info_ptr
));
11718 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
11719 + read_2_bytes (abfd
, info_ptr
));
11723 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
11724 + read_4_bytes (abfd
, info_ptr
));
11728 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
11729 + read_8_bytes (abfd
, info_ptr
));
11732 case DW_FORM_ref_sig8
:
11733 /* Convert the signature to something we can record in DW_UNSND
11735 NOTE: This is NULL if the type wasn't found. */
11736 DW_SIGNATURED_TYPE (attr
) =
11737 lookup_signatured_type (read_8_bytes (abfd
, info_ptr
));
11740 case DW_FORM_ref_udata
:
11741 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
11742 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
11743 info_ptr
+= bytes_read
;
11745 case DW_FORM_indirect
:
11746 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
11747 info_ptr
+= bytes_read
;
11748 info_ptr
= read_attribute_value (reader
, attr
, form
, info_ptr
);
11750 case DW_FORM_GNU_addr_index
:
11751 if (reader
->dwo_file
== NULL
)
11753 /* For now flag a hard error.
11754 Later we can turn this into a complaint. */
11755 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
11756 dwarf_form_name (form
),
11757 bfd_get_filename (abfd
));
11759 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
11760 info_ptr
+= bytes_read
;
11762 case DW_FORM_GNU_str_index
:
11763 if (reader
->dwo_file
== NULL
)
11765 /* For now flag a hard error.
11766 Later we can turn this into a complaint if warranted. */
11767 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
11768 dwarf_form_name (form
),
11769 bfd_get_filename (abfd
));
11772 ULONGEST str_index
=
11773 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
11775 DW_STRING (attr
) = read_str_index (reader
, cu
, str_index
);
11776 DW_STRING_IS_CANONICAL (attr
) = 0;
11777 info_ptr
+= bytes_read
;
11781 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
11782 dwarf_form_name (form
),
11783 bfd_get_filename (abfd
));
11786 /* We have seen instances where the compiler tried to emit a byte
11787 size attribute of -1 which ended up being encoded as an unsigned
11788 0xffffffff. Although 0xffffffff is technically a valid size value,
11789 an object of this size seems pretty unlikely so we can relatively
11790 safely treat these cases as if the size attribute was invalid and
11791 treat them as zero by default. */
11792 if (attr
->name
== DW_AT_byte_size
11793 && form
== DW_FORM_data4
11794 && DW_UNSND (attr
) >= 0xffffffff)
11797 (&symfile_complaints
,
11798 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
11799 hex_string (DW_UNSND (attr
)));
11800 DW_UNSND (attr
) = 0;
11806 /* Read an attribute described by an abbreviated attribute. */
11809 read_attribute (const struct die_reader_specs
*reader
,
11810 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
11811 gdb_byte
*info_ptr
)
11813 attr
->name
= abbrev
->name
;
11814 return read_attribute_value (reader
, attr
, abbrev
->form
, info_ptr
);
11817 /* Read dwarf information from a buffer. */
11819 static unsigned int
11820 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
11822 return bfd_get_8 (abfd
, buf
);
11826 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
11828 return bfd_get_signed_8 (abfd
, buf
);
11831 static unsigned int
11832 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
11834 return bfd_get_16 (abfd
, buf
);
11838 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
11840 return bfd_get_signed_16 (abfd
, buf
);
11843 static unsigned int
11844 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
11846 return bfd_get_32 (abfd
, buf
);
11850 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
11852 return bfd_get_signed_32 (abfd
, buf
);
11856 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
11858 return bfd_get_64 (abfd
, buf
);
11862 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
11863 unsigned int *bytes_read
)
11865 struct comp_unit_head
*cu_header
= &cu
->header
;
11866 CORE_ADDR retval
= 0;
11868 if (cu_header
->signed_addr_p
)
11870 switch (cu_header
->addr_size
)
11873 retval
= bfd_get_signed_16 (abfd
, buf
);
11876 retval
= bfd_get_signed_32 (abfd
, buf
);
11879 retval
= bfd_get_signed_64 (abfd
, buf
);
11882 internal_error (__FILE__
, __LINE__
,
11883 _("read_address: bad switch, signed [in module %s]"),
11884 bfd_get_filename (abfd
));
11889 switch (cu_header
->addr_size
)
11892 retval
= bfd_get_16 (abfd
, buf
);
11895 retval
= bfd_get_32 (abfd
, buf
);
11898 retval
= bfd_get_64 (abfd
, buf
);
11901 internal_error (__FILE__
, __LINE__
,
11902 _("read_address: bad switch, "
11903 "unsigned [in module %s]"),
11904 bfd_get_filename (abfd
));
11908 *bytes_read
= cu_header
->addr_size
;
11912 /* Read the initial length from a section. The (draft) DWARF 3
11913 specification allows the initial length to take up either 4 bytes
11914 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
11915 bytes describe the length and all offsets will be 8 bytes in length
11918 An older, non-standard 64-bit format is also handled by this
11919 function. The older format in question stores the initial length
11920 as an 8-byte quantity without an escape value. Lengths greater
11921 than 2^32 aren't very common which means that the initial 4 bytes
11922 is almost always zero. Since a length value of zero doesn't make
11923 sense for the 32-bit format, this initial zero can be considered to
11924 be an escape value which indicates the presence of the older 64-bit
11925 format. As written, the code can't detect (old format) lengths
11926 greater than 4GB. If it becomes necessary to handle lengths
11927 somewhat larger than 4GB, we could allow other small values (such
11928 as the non-sensical values of 1, 2, and 3) to also be used as
11929 escape values indicating the presence of the old format.
11931 The value returned via bytes_read should be used to increment the
11932 relevant pointer after calling read_initial_length().
11934 [ Note: read_initial_length() and read_offset() are based on the
11935 document entitled "DWARF Debugging Information Format", revision
11936 3, draft 8, dated November 19, 2001. This document was obtained
11939 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
11941 This document is only a draft and is subject to change. (So beware.)
11943 Details regarding the older, non-standard 64-bit format were
11944 determined empirically by examining 64-bit ELF files produced by
11945 the SGI toolchain on an IRIX 6.5 machine.
11947 - Kevin, July 16, 2002
11951 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
11953 LONGEST length
= bfd_get_32 (abfd
, buf
);
11955 if (length
== 0xffffffff)
11957 length
= bfd_get_64 (abfd
, buf
+ 4);
11960 else if (length
== 0)
11962 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
11963 length
= bfd_get_64 (abfd
, buf
);
11974 /* Cover function for read_initial_length.
11975 Returns the length of the object at BUF, and stores the size of the
11976 initial length in *BYTES_READ and stores the size that offsets will be in
11978 If the initial length size is not equivalent to that specified in
11979 CU_HEADER then issue a complaint.
11980 This is useful when reading non-comp-unit headers. */
11983 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
11984 const struct comp_unit_head
*cu_header
,
11985 unsigned int *bytes_read
,
11986 unsigned int *offset_size
)
11988 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
11990 gdb_assert (cu_header
->initial_length_size
== 4
11991 || cu_header
->initial_length_size
== 8
11992 || cu_header
->initial_length_size
== 12);
11994 if (cu_header
->initial_length_size
!= *bytes_read
)
11995 complaint (&symfile_complaints
,
11996 _("intermixed 32-bit and 64-bit DWARF sections"));
11998 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
12002 /* Read an offset from the data stream. The size of the offset is
12003 given by cu_header->offset_size. */
12006 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
12007 unsigned int *bytes_read
)
12009 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
12011 *bytes_read
= cu_header
->offset_size
;
12015 /* Read an offset from the data stream. */
12018 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
12020 LONGEST retval
= 0;
12022 switch (offset_size
)
12025 retval
= bfd_get_32 (abfd
, buf
);
12028 retval
= bfd_get_64 (abfd
, buf
);
12031 internal_error (__FILE__
, __LINE__
,
12032 _("read_offset_1: bad switch [in module %s]"),
12033 bfd_get_filename (abfd
));
12040 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
12042 /* If the size of a host char is 8 bits, we can return a pointer
12043 to the buffer, otherwise we have to copy the data to a buffer
12044 allocated on the temporary obstack. */
12045 gdb_assert (HOST_CHAR_BIT
== 8);
12050 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
12052 /* If the size of a host char is 8 bits, we can return a pointer
12053 to the string, otherwise we have to copy the string to a buffer
12054 allocated on the temporary obstack. */
12055 gdb_assert (HOST_CHAR_BIT
== 8);
12058 *bytes_read_ptr
= 1;
12061 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
12062 return (char *) buf
;
12066 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
12068 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
12069 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
12070 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
12071 bfd_get_filename (abfd
));
12072 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
12073 error (_("DW_FORM_strp pointing outside of "
12074 ".debug_str section [in module %s]"),
12075 bfd_get_filename (abfd
));
12076 gdb_assert (HOST_CHAR_BIT
== 8);
12077 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
12079 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
12083 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
12084 const struct comp_unit_head
*cu_header
,
12085 unsigned int *bytes_read_ptr
)
12087 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
12089 return read_indirect_string_at_offset (abfd
, str_offset
);
12093 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
12096 unsigned int num_read
;
12098 unsigned char byte
;
12106 byte
= bfd_get_8 (abfd
, buf
);
12109 result
|= ((ULONGEST
) (byte
& 127) << shift
);
12110 if ((byte
& 128) == 0)
12116 *bytes_read_ptr
= num_read
;
12121 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
12124 int i
, shift
, num_read
;
12125 unsigned char byte
;
12133 byte
= bfd_get_8 (abfd
, buf
);
12136 result
|= ((LONGEST
) (byte
& 127) << shift
);
12138 if ((byte
& 128) == 0)
12143 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
12144 result
|= -(((LONGEST
) 1) << shift
);
12145 *bytes_read_ptr
= num_read
;
12149 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
12150 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
12151 ADDR_SIZE is the size of addresses from the CU header. */
12154 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
12156 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12157 bfd
*abfd
= objfile
->obfd
;
12158 const gdb_byte
*info_ptr
;
12160 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
12161 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
12162 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
12164 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
12165 error (_("DW_FORM_addr_index pointing outside of "
12166 ".debug_addr section [in module %s]"),
12168 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
12169 + addr_base
+ addr_index
* addr_size
);
12170 if (addr_size
== 4)
12171 return bfd_get_32 (abfd
, info_ptr
);
12173 return bfd_get_64 (abfd
, info_ptr
);
12176 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
12179 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
12181 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
12184 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
12187 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, gdb_byte
*info_ptr
,
12188 unsigned int *bytes_read
)
12190 bfd
*abfd
= cu
->objfile
->obfd
;
12191 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
12193 return read_addr_index (cu
, addr_index
);
12196 /* Data structure to pass results from dwarf2_read_addr_index_reader
12197 back to dwarf2_read_addr_index. */
12199 struct dwarf2_read_addr_index_data
12201 ULONGEST addr_base
;
12205 /* die_reader_func for dwarf2_read_addr_index. */
12208 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
12209 gdb_byte
*info_ptr
,
12210 struct die_info
*comp_unit_die
,
12214 struct dwarf2_cu
*cu
= reader
->cu
;
12215 struct dwarf2_read_addr_index_data
*aidata
=
12216 (struct dwarf2_read_addr_index_data
*) data
;
12218 aidata
->addr_base
= cu
->addr_base
;
12219 aidata
->addr_size
= cu
->header
.addr_size
;
12222 /* Given an index in .debug_addr, fetch the value.
12223 NOTE: This can be called during dwarf expression evaluation,
12224 long after the debug information has been read, and thus per_cu->cu
12225 may no longer exist. */
12228 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
12229 unsigned int addr_index
)
12231 struct objfile
*objfile
= per_cu
->objfile
;
12232 struct dwarf2_cu
*cu
= per_cu
->cu
;
12233 ULONGEST addr_base
;
12236 /* This is intended to be called from outside this file. */
12237 dw2_setup (objfile
);
12239 /* We need addr_base and addr_size.
12240 If we don't have PER_CU->cu, we have to get it.
12241 Nasty, but the alternative is storing the needed info in PER_CU,
12242 which at this point doesn't seem justified: it's not clear how frequently
12243 it would get used and it would increase the size of every PER_CU.
12244 Entry points like dwarf2_per_cu_addr_size do a similar thing
12245 so we're not in uncharted territory here.
12246 Alas we need to be a bit more complicated as addr_base is contained
12249 We don't need to read the entire CU(/TU).
12250 We just need the header and top level die.
12251 IWBN to use the aging mechanism to let us lazily later discard the CU.
12252 See however init_cutu_and_read_dies_simple. */
12256 addr_base
= cu
->addr_base
;
12257 addr_size
= cu
->header
.addr_size
;
12261 struct dwarf2_read_addr_index_data aidata
;
12263 init_cutu_and_read_dies_simple (per_cu
, dwarf2_read_addr_index_reader
,
12265 addr_base
= aidata
.addr_base
;
12266 addr_size
= aidata
.addr_size
;
12269 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
12272 /* Given a DW_AT_str_index, fetch the string. */
12275 read_str_index (const struct die_reader_specs
*reader
,
12276 struct dwarf2_cu
*cu
, ULONGEST str_index
)
12278 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12279 const char *dwo_name
= objfile
->name
;
12280 bfd
*abfd
= objfile
->obfd
;
12281 struct dwo_sections
*sections
= &reader
->dwo_file
->sections
;
12282 gdb_byte
*info_ptr
;
12283 ULONGEST str_offset
;
12285 dwarf2_read_section (objfile
, §ions
->str
);
12286 dwarf2_read_section (objfile
, §ions
->str_offsets
);
12287 if (sections
->str
.buffer
== NULL
)
12288 error (_("DW_FORM_str_index used without .debug_str.dwo section"
12289 " in CU at offset 0x%lx [in module %s]"),
12290 (long) cu
->header
.offset
.sect_off
, dwo_name
);
12291 if (sections
->str_offsets
.buffer
== NULL
)
12292 error (_("DW_FORM_str_index used without .debug_str_offsets.dwo section"
12293 " in CU at offset 0x%lx [in module %s]"),
12294 (long) cu
->header
.offset
.sect_off
, dwo_name
);
12295 if (str_index
* cu
->header
.offset_size
>= sections
->str_offsets
.size
)
12296 error (_("DW_FORM_str_index pointing outside of .debug_str_offsets.dwo"
12297 " section in CU at offset 0x%lx [in module %s]"),
12298 (long) cu
->header
.offset
.sect_off
, dwo_name
);
12299 info_ptr
= (sections
->str_offsets
.buffer
12300 + str_index
* cu
->header
.offset_size
);
12301 if (cu
->header
.offset_size
== 4)
12302 str_offset
= bfd_get_32 (abfd
, info_ptr
);
12304 str_offset
= bfd_get_64 (abfd
, info_ptr
);
12305 if (str_offset
>= sections
->str
.size
)
12306 error (_("Offset from DW_FORM_str_index pointing outside of"
12307 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
12308 (long) cu
->header
.offset
.sect_off
, dwo_name
);
12309 return (char *) (sections
->str
.buffer
+ str_offset
);
12312 /* Return the length of an LEB128 number in BUF. */
12315 leb128_size (const gdb_byte
*buf
)
12317 const gdb_byte
*begin
= buf
;
12323 if ((byte
& 128) == 0)
12324 return buf
- begin
;
12329 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
12336 cu
->language
= language_c
;
12338 case DW_LANG_C_plus_plus
:
12339 cu
->language
= language_cplus
;
12342 cu
->language
= language_d
;
12344 case DW_LANG_Fortran77
:
12345 case DW_LANG_Fortran90
:
12346 case DW_LANG_Fortran95
:
12347 cu
->language
= language_fortran
;
12350 cu
->language
= language_go
;
12352 case DW_LANG_Mips_Assembler
:
12353 cu
->language
= language_asm
;
12356 cu
->language
= language_java
;
12358 case DW_LANG_Ada83
:
12359 case DW_LANG_Ada95
:
12360 cu
->language
= language_ada
;
12362 case DW_LANG_Modula2
:
12363 cu
->language
= language_m2
;
12365 case DW_LANG_Pascal83
:
12366 cu
->language
= language_pascal
;
12369 cu
->language
= language_objc
;
12371 case DW_LANG_Cobol74
:
12372 case DW_LANG_Cobol85
:
12374 cu
->language
= language_minimal
;
12377 cu
->language_defn
= language_def (cu
->language
);
12380 /* Return the named attribute or NULL if not there. */
12382 static struct attribute
*
12383 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
12388 struct attribute
*spec
= NULL
;
12390 for (i
= 0; i
< die
->num_attrs
; ++i
)
12392 if (die
->attrs
[i
].name
== name
)
12393 return &die
->attrs
[i
];
12394 if (die
->attrs
[i
].name
== DW_AT_specification
12395 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
12396 spec
= &die
->attrs
[i
];
12402 die
= follow_die_ref (die
, spec
, &cu
);
12408 /* Return the named attribute or NULL if not there,
12409 but do not follow DW_AT_specification, etc.
12410 This is for use in contexts where we're reading .debug_types dies.
12411 Following DW_AT_specification, DW_AT_abstract_origin will take us
12412 back up the chain, and we want to go down. */
12414 static struct attribute
*
12415 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
12416 struct dwarf2_cu
*cu
)
12420 for (i
= 0; i
< die
->num_attrs
; ++i
)
12421 if (die
->attrs
[i
].name
== name
)
12422 return &die
->attrs
[i
];
12427 /* Return non-zero iff the attribute NAME is defined for the given DIE,
12428 and holds a non-zero value. This function should only be used for
12429 DW_FORM_flag or DW_FORM_flag_present attributes. */
12432 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
12434 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
12436 return (attr
&& DW_UNSND (attr
));
12440 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
12442 /* A DIE is a declaration if it has a DW_AT_declaration attribute
12443 which value is non-zero. However, we have to be careful with
12444 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
12445 (via dwarf2_flag_true_p) follows this attribute. So we may
12446 end up accidently finding a declaration attribute that belongs
12447 to a different DIE referenced by the specification attribute,
12448 even though the given DIE does not have a declaration attribute. */
12449 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
12450 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
12453 /* Return the die giving the specification for DIE, if there is
12454 one. *SPEC_CU is the CU containing DIE on input, and the CU
12455 containing the return value on output. If there is no
12456 specification, but there is an abstract origin, that is
12459 static struct die_info
*
12460 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
12462 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
12465 if (spec_attr
== NULL
)
12466 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
12468 if (spec_attr
== NULL
)
12471 return follow_die_ref (die
, spec_attr
, spec_cu
);
12474 /* Free the line_header structure *LH, and any arrays and strings it
12476 NOTE: This is also used as a "cleanup" function. */
12479 free_line_header (struct line_header
*lh
)
12481 if (lh
->standard_opcode_lengths
)
12482 xfree (lh
->standard_opcode_lengths
);
12484 /* Remember that all the lh->file_names[i].name pointers are
12485 pointers into debug_line_buffer, and don't need to be freed. */
12486 if (lh
->file_names
)
12487 xfree (lh
->file_names
);
12489 /* Similarly for the include directory names. */
12490 if (lh
->include_dirs
)
12491 xfree (lh
->include_dirs
);
12496 /* Add an entry to LH's include directory table. */
12499 add_include_dir (struct line_header
*lh
, char *include_dir
)
12501 /* Grow the array if necessary. */
12502 if (lh
->include_dirs_size
== 0)
12504 lh
->include_dirs_size
= 1; /* for testing */
12505 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
12506 * sizeof (*lh
->include_dirs
));
12508 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
12510 lh
->include_dirs_size
*= 2;
12511 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
12512 (lh
->include_dirs_size
12513 * sizeof (*lh
->include_dirs
)));
12516 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
12519 /* Add an entry to LH's file name table. */
12522 add_file_name (struct line_header
*lh
,
12524 unsigned int dir_index
,
12525 unsigned int mod_time
,
12526 unsigned int length
)
12528 struct file_entry
*fe
;
12530 /* Grow the array if necessary. */
12531 if (lh
->file_names_size
== 0)
12533 lh
->file_names_size
= 1; /* for testing */
12534 lh
->file_names
= xmalloc (lh
->file_names_size
12535 * sizeof (*lh
->file_names
));
12537 else if (lh
->num_file_names
>= lh
->file_names_size
)
12539 lh
->file_names_size
*= 2;
12540 lh
->file_names
= xrealloc (lh
->file_names
,
12541 (lh
->file_names_size
12542 * sizeof (*lh
->file_names
)));
12545 fe
= &lh
->file_names
[lh
->num_file_names
++];
12547 fe
->dir_index
= dir_index
;
12548 fe
->mod_time
= mod_time
;
12549 fe
->length
= length
;
12550 fe
->included_p
= 0;
12554 /* Read the statement program header starting at OFFSET in
12555 .debug_line, or .debug_line.dwo. Return a pointer
12556 to a struct line_header, allocated using xmalloc.
12558 NOTE: the strings in the include directory and file name tables of
12559 the returned object point into the dwarf line section buffer,
12560 and must not be freed. */
12562 static struct line_header
*
12563 dwarf_decode_line_header (unsigned int offset
, struct dwarf2_cu
*cu
)
12565 struct cleanup
*back_to
;
12566 struct line_header
*lh
;
12567 gdb_byte
*line_ptr
;
12568 unsigned int bytes_read
, offset_size
;
12570 char *cur_dir
, *cur_file
;
12571 struct dwarf2_section_info
*section
;
12574 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
12576 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
12577 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
12579 section
= &dwarf2_per_objfile
->line
;
12581 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
12582 if (section
->buffer
== NULL
)
12584 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
12585 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
12587 complaint (&symfile_complaints
, _("missing .debug_line section"));
12591 /* We can't do this until we know the section is non-empty.
12592 Only then do we know we have such a section. */
12593 abfd
= section
->asection
->owner
;
12595 /* Make sure that at least there's room for the total_length field.
12596 That could be 12 bytes long, but we're just going to fudge that. */
12597 if (offset
+ 4 >= section
->size
)
12599 dwarf2_statement_list_fits_in_line_number_section_complaint ();
12603 lh
= xmalloc (sizeof (*lh
));
12604 memset (lh
, 0, sizeof (*lh
));
12605 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
12608 line_ptr
= section
->buffer
+ offset
;
12610 /* Read in the header. */
12612 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
12613 &bytes_read
, &offset_size
);
12614 line_ptr
+= bytes_read
;
12615 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
12617 dwarf2_statement_list_fits_in_line_number_section_complaint ();
12620 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
12621 lh
->version
= read_2_bytes (abfd
, line_ptr
);
12623 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
12624 line_ptr
+= offset_size
;
12625 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
12627 if (lh
->version
>= 4)
12629 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
12633 lh
->maximum_ops_per_instruction
= 1;
12635 if (lh
->maximum_ops_per_instruction
== 0)
12637 lh
->maximum_ops_per_instruction
= 1;
12638 complaint (&symfile_complaints
,
12639 _("invalid maximum_ops_per_instruction "
12640 "in `.debug_line' section"));
12643 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
12645 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
12647 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
12649 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
12651 lh
->standard_opcode_lengths
12652 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
12654 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
12655 for (i
= 1; i
< lh
->opcode_base
; ++i
)
12657 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
12661 /* Read directory table. */
12662 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
12664 line_ptr
+= bytes_read
;
12665 add_include_dir (lh
, cur_dir
);
12667 line_ptr
+= bytes_read
;
12669 /* Read file name table. */
12670 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
12672 unsigned int dir_index
, mod_time
, length
;
12674 line_ptr
+= bytes_read
;
12675 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
12676 line_ptr
+= bytes_read
;
12677 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
12678 line_ptr
+= bytes_read
;
12679 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
12680 line_ptr
+= bytes_read
;
12682 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
12684 line_ptr
+= bytes_read
;
12685 lh
->statement_program_start
= line_ptr
;
12687 if (line_ptr
> (section
->buffer
+ section
->size
))
12688 complaint (&symfile_complaints
,
12689 _("line number info header doesn't "
12690 "fit in `.debug_line' section"));
12692 discard_cleanups (back_to
);
12696 /* Subroutine of dwarf_decode_lines to simplify it.
12697 Return the file name of the psymtab for included file FILE_INDEX
12698 in line header LH of PST.
12699 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
12700 If space for the result is malloc'd, it will be freed by a cleanup.
12701 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
12704 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
12705 const struct partial_symtab
*pst
,
12706 const char *comp_dir
)
12708 const struct file_entry fe
= lh
->file_names
[file_index
];
12709 char *include_name
= fe
.name
;
12710 char *include_name_to_compare
= include_name
;
12711 char *dir_name
= NULL
;
12712 const char *pst_filename
;
12713 char *copied_name
= NULL
;
12717 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
12719 if (!IS_ABSOLUTE_PATH (include_name
)
12720 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
12722 /* Avoid creating a duplicate psymtab for PST.
12723 We do this by comparing INCLUDE_NAME and PST_FILENAME.
12724 Before we do the comparison, however, we need to account
12725 for DIR_NAME and COMP_DIR.
12726 First prepend dir_name (if non-NULL). If we still don't
12727 have an absolute path prepend comp_dir (if non-NULL).
12728 However, the directory we record in the include-file's
12729 psymtab does not contain COMP_DIR (to match the
12730 corresponding symtab(s)).
12735 bash$ gcc -g ./hello.c
12736 include_name = "hello.c"
12738 DW_AT_comp_dir = comp_dir = "/tmp"
12739 DW_AT_name = "./hello.c" */
12741 if (dir_name
!= NULL
)
12743 include_name
= concat (dir_name
, SLASH_STRING
,
12744 include_name
, (char *)NULL
);
12745 include_name_to_compare
= include_name
;
12746 make_cleanup (xfree
, include_name
);
12748 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
12750 include_name_to_compare
= concat (comp_dir
, SLASH_STRING
,
12751 include_name
, (char *)NULL
);
12755 pst_filename
= pst
->filename
;
12756 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
12758 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
12759 pst_filename
, (char *)NULL
);
12760 pst_filename
= copied_name
;
12763 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
12765 if (include_name_to_compare
!= include_name
)
12766 xfree (include_name_to_compare
);
12767 if (copied_name
!= NULL
)
12768 xfree (copied_name
);
12772 return include_name
;
12775 /* Ignore this record_line request. */
12778 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
12783 /* Subroutine of dwarf_decode_lines to simplify it.
12784 Process the line number information in LH. */
12787 dwarf_decode_lines_1 (struct line_header
*lh
, const char *comp_dir
,
12788 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
12790 gdb_byte
*line_ptr
, *extended_end
;
12791 gdb_byte
*line_end
;
12792 unsigned int bytes_read
, extended_len
;
12793 unsigned char op_code
, extended_op
, adj_opcode
;
12794 CORE_ADDR baseaddr
;
12795 struct objfile
*objfile
= cu
->objfile
;
12796 bfd
*abfd
= objfile
->obfd
;
12797 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12798 const int decode_for_pst_p
= (pst
!= NULL
);
12799 struct subfile
*last_subfile
= NULL
;
12800 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
12803 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
12805 line_ptr
= lh
->statement_program_start
;
12806 line_end
= lh
->statement_program_end
;
12808 /* Read the statement sequences until there's nothing left. */
12809 while (line_ptr
< line_end
)
12811 /* state machine registers */
12812 CORE_ADDR address
= 0;
12813 unsigned int file
= 1;
12814 unsigned int line
= 1;
12815 unsigned int column
= 0;
12816 int is_stmt
= lh
->default_is_stmt
;
12817 int basic_block
= 0;
12818 int end_sequence
= 0;
12820 unsigned char op_index
= 0;
12822 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
12824 /* Start a subfile for the current file of the state machine. */
12825 /* lh->include_dirs and lh->file_names are 0-based, but the
12826 directory and file name numbers in the statement program
12828 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
12832 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
12834 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
12837 /* Decode the table. */
12838 while (!end_sequence
)
12840 op_code
= read_1_byte (abfd
, line_ptr
);
12842 if (line_ptr
> line_end
)
12844 dwarf2_debug_line_missing_end_sequence_complaint ();
12848 if (op_code
>= lh
->opcode_base
)
12850 /* Special operand. */
12851 adj_opcode
= op_code
- lh
->opcode_base
;
12852 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
12853 / lh
->maximum_ops_per_instruction
)
12854 * lh
->minimum_instruction_length
);
12855 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
12856 % lh
->maximum_ops_per_instruction
);
12857 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
12858 if (lh
->num_file_names
< file
|| file
== 0)
12859 dwarf2_debug_line_missing_file_complaint ();
12860 /* For now we ignore lines not starting on an
12861 instruction boundary. */
12862 else if (op_index
== 0)
12864 lh
->file_names
[file
- 1].included_p
= 1;
12865 if (!decode_for_pst_p
&& is_stmt
)
12867 if (last_subfile
!= current_subfile
)
12869 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
12871 (*p_record_line
) (last_subfile
, 0, addr
);
12872 last_subfile
= current_subfile
;
12874 /* Append row to matrix using current values. */
12875 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
12876 (*p_record_line
) (current_subfile
, line
, addr
);
12881 else switch (op_code
)
12883 case DW_LNS_extended_op
:
12884 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
12886 line_ptr
+= bytes_read
;
12887 extended_end
= line_ptr
+ extended_len
;
12888 extended_op
= read_1_byte (abfd
, line_ptr
);
12890 switch (extended_op
)
12892 case DW_LNE_end_sequence
:
12893 p_record_line
= record_line
;
12896 case DW_LNE_set_address
:
12897 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
12899 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12901 /* This line table is for a function which has been
12902 GCd by the linker. Ignore it. PR gdb/12528 */
12905 = line_ptr
- dwarf2_per_objfile
->line
.buffer
;
12907 complaint (&symfile_complaints
,
12908 _(".debug_line address at offset 0x%lx is 0 "
12910 line_offset
, objfile
->name
);
12911 p_record_line
= noop_record_line
;
12915 line_ptr
+= bytes_read
;
12916 address
+= baseaddr
;
12918 case DW_LNE_define_file
:
12921 unsigned int dir_index
, mod_time
, length
;
12923 cur_file
= read_direct_string (abfd
, line_ptr
,
12925 line_ptr
+= bytes_read
;
12927 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
12928 line_ptr
+= bytes_read
;
12930 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
12931 line_ptr
+= bytes_read
;
12933 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
12934 line_ptr
+= bytes_read
;
12935 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
12938 case DW_LNE_set_discriminator
:
12939 /* The discriminator is not interesting to the debugger;
12941 line_ptr
= extended_end
;
12944 complaint (&symfile_complaints
,
12945 _("mangled .debug_line section"));
12948 /* Make sure that we parsed the extended op correctly. If e.g.
12949 we expected a different address size than the producer used,
12950 we may have read the wrong number of bytes. */
12951 if (line_ptr
!= extended_end
)
12953 complaint (&symfile_complaints
,
12954 _("mangled .debug_line section"));
12959 if (lh
->num_file_names
< file
|| file
== 0)
12960 dwarf2_debug_line_missing_file_complaint ();
12963 lh
->file_names
[file
- 1].included_p
= 1;
12964 if (!decode_for_pst_p
&& is_stmt
)
12966 if (last_subfile
!= current_subfile
)
12968 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
12970 (*p_record_line
) (last_subfile
, 0, addr
);
12971 last_subfile
= current_subfile
;
12973 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
12974 (*p_record_line
) (current_subfile
, line
, addr
);
12979 case DW_LNS_advance_pc
:
12982 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
12984 address
+= (((op_index
+ adjust
)
12985 / lh
->maximum_ops_per_instruction
)
12986 * lh
->minimum_instruction_length
);
12987 op_index
= ((op_index
+ adjust
)
12988 % lh
->maximum_ops_per_instruction
);
12989 line_ptr
+= bytes_read
;
12992 case DW_LNS_advance_line
:
12993 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
12994 line_ptr
+= bytes_read
;
12996 case DW_LNS_set_file
:
12998 /* The arrays lh->include_dirs and lh->file_names are
12999 0-based, but the directory and file name numbers in
13000 the statement program are 1-based. */
13001 struct file_entry
*fe
;
13004 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
13005 line_ptr
+= bytes_read
;
13006 if (lh
->num_file_names
< file
|| file
== 0)
13007 dwarf2_debug_line_missing_file_complaint ();
13010 fe
= &lh
->file_names
[file
- 1];
13012 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
13013 if (!decode_for_pst_p
)
13015 last_subfile
= current_subfile
;
13016 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
13021 case DW_LNS_set_column
:
13022 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
13023 line_ptr
+= bytes_read
;
13025 case DW_LNS_negate_stmt
:
13026 is_stmt
= (!is_stmt
);
13028 case DW_LNS_set_basic_block
:
13031 /* Add to the address register of the state machine the
13032 address increment value corresponding to special opcode
13033 255. I.e., this value is scaled by the minimum
13034 instruction length since special opcode 255 would have
13035 scaled the increment. */
13036 case DW_LNS_const_add_pc
:
13038 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
13040 address
+= (((op_index
+ adjust
)
13041 / lh
->maximum_ops_per_instruction
)
13042 * lh
->minimum_instruction_length
);
13043 op_index
= ((op_index
+ adjust
)
13044 % lh
->maximum_ops_per_instruction
);
13047 case DW_LNS_fixed_advance_pc
:
13048 address
+= read_2_bytes (abfd
, line_ptr
);
13054 /* Unknown standard opcode, ignore it. */
13057 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
13059 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
13060 line_ptr
+= bytes_read
;
13065 if (lh
->num_file_names
< file
|| file
== 0)
13066 dwarf2_debug_line_missing_file_complaint ();
13069 lh
->file_names
[file
- 1].included_p
= 1;
13070 if (!decode_for_pst_p
)
13072 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
13073 (*p_record_line
) (current_subfile
, 0, addr
);
13079 /* Decode the Line Number Program (LNP) for the given line_header
13080 structure and CU. The actual information extracted and the type
13081 of structures created from the LNP depends on the value of PST.
13083 1. If PST is NULL, then this procedure uses the data from the program
13084 to create all necessary symbol tables, and their linetables.
13086 2. If PST is not NULL, this procedure reads the program to determine
13087 the list of files included by the unit represented by PST, and
13088 builds all the associated partial symbol tables.
13090 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
13091 It is used for relative paths in the line table.
13092 NOTE: When processing partial symtabs (pst != NULL),
13093 comp_dir == pst->dirname.
13095 NOTE: It is important that psymtabs have the same file name (via strcmp)
13096 as the corresponding symtab. Since COMP_DIR is not used in the name of the
13097 symtab we don't use it in the name of the psymtabs we create.
13098 E.g. expand_line_sal requires this when finding psymtabs to expand.
13099 A good testcase for this is mb-inline.exp. */
13102 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
13103 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
13104 int want_line_info
)
13106 struct objfile
*objfile
= cu
->objfile
;
13107 const int decode_for_pst_p
= (pst
!= NULL
);
13108 struct subfile
*first_subfile
= current_subfile
;
13110 if (want_line_info
)
13111 dwarf_decode_lines_1 (lh
, comp_dir
, cu
, pst
);
13113 if (decode_for_pst_p
)
13117 /* Now that we're done scanning the Line Header Program, we can
13118 create the psymtab of each included file. */
13119 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
13120 if (lh
->file_names
[file_index
].included_p
== 1)
13122 char *include_name
=
13123 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
13124 if (include_name
!= NULL
)
13125 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
13130 /* Make sure a symtab is created for every file, even files
13131 which contain only variables (i.e. no code with associated
13135 for (i
= 0; i
< lh
->num_file_names
; i
++)
13138 struct file_entry
*fe
;
13140 fe
= &lh
->file_names
[i
];
13142 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
13143 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
13145 /* Skip the main file; we don't need it, and it must be
13146 allocated last, so that it will show up before the
13147 non-primary symtabs in the objfile's symtab list. */
13148 if (current_subfile
== first_subfile
)
13151 if (current_subfile
->symtab
== NULL
)
13152 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
13154 fe
->symtab
= current_subfile
->symtab
;
13159 /* Start a subfile for DWARF. FILENAME is the name of the file and
13160 DIRNAME the name of the source directory which contains FILENAME
13161 or NULL if not known. COMP_DIR is the compilation directory for the
13162 linetable's compilation unit or NULL if not known.
13163 This routine tries to keep line numbers from identical absolute and
13164 relative file names in a common subfile.
13166 Using the `list' example from the GDB testsuite, which resides in
13167 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
13168 of /srcdir/list0.c yields the following debugging information for list0.c:
13170 DW_AT_name: /srcdir/list0.c
13171 DW_AT_comp_dir: /compdir
13172 files.files[0].name: list0.h
13173 files.files[0].dir: /srcdir
13174 files.files[1].name: list0.c
13175 files.files[1].dir: /srcdir
13177 The line number information for list0.c has to end up in a single
13178 subfile, so that `break /srcdir/list0.c:1' works as expected.
13179 start_subfile will ensure that this happens provided that we pass the
13180 concatenation of files.files[1].dir and files.files[1].name as the
13184 dwarf2_start_subfile (char *filename
, const char *dirname
,
13185 const char *comp_dir
)
13189 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
13190 `start_symtab' will always pass the contents of DW_AT_comp_dir as
13191 second argument to start_subfile. To be consistent, we do the
13192 same here. In order not to lose the line information directory,
13193 we concatenate it to the filename when it makes sense.
13194 Note that the Dwarf3 standard says (speaking of filenames in line
13195 information): ``The directory index is ignored for file names
13196 that represent full path names''. Thus ignoring dirname in the
13197 `else' branch below isn't an issue. */
13199 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
13200 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
13202 fullname
= filename
;
13204 start_subfile (fullname
, comp_dir
);
13206 if (fullname
!= filename
)
13211 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
13212 struct dwarf2_cu
*cu
)
13214 struct objfile
*objfile
= cu
->objfile
;
13215 struct comp_unit_head
*cu_header
= &cu
->header
;
13217 /* NOTE drow/2003-01-30: There used to be a comment and some special
13218 code here to turn a symbol with DW_AT_external and a
13219 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
13220 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
13221 with some versions of binutils) where shared libraries could have
13222 relocations against symbols in their debug information - the
13223 minimal symbol would have the right address, but the debug info
13224 would not. It's no longer necessary, because we will explicitly
13225 apply relocations when we read in the debug information now. */
13227 /* A DW_AT_location attribute with no contents indicates that a
13228 variable has been optimized away. */
13229 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
13231 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
13235 /* Handle one degenerate form of location expression specially, to
13236 preserve GDB's previous behavior when section offsets are
13237 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
13238 then mark this symbol as LOC_STATIC. */
13240 if (attr_form_is_block (attr
)
13241 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
13242 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
13243 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
13244 && (DW_BLOCK (attr
)->size
13245 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
13247 unsigned int dummy
;
13249 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
13250 SYMBOL_VALUE_ADDRESS (sym
) =
13251 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
13253 SYMBOL_VALUE_ADDRESS (sym
) =
13254 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
13255 SYMBOL_CLASS (sym
) = LOC_STATIC
;
13256 fixup_symbol_section (sym
, objfile
);
13257 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
13258 SYMBOL_SECTION (sym
));
13262 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
13263 expression evaluator, and use LOC_COMPUTED only when necessary
13264 (i.e. when the value of a register or memory location is
13265 referenced, or a thread-local block, etc.). Then again, it might
13266 not be worthwhile. I'm assuming that it isn't unless performance
13267 or memory numbers show me otherwise. */
13269 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
13270 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
13272 if (SYMBOL_COMPUTED_OPS (sym
) == &dwarf2_loclist_funcs
)
13273 cu
->has_loclist
= 1;
13276 /* Given a pointer to a DWARF information entry, figure out if we need
13277 to make a symbol table entry for it, and if so, create a new entry
13278 and return a pointer to it.
13279 If TYPE is NULL, determine symbol type from the die, otherwise
13280 used the passed type.
13281 If SPACE is not NULL, use it to hold the new symbol. If it is
13282 NULL, allocate a new symbol on the objfile's obstack. */
13284 static struct symbol
*
13285 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
13286 struct symbol
*space
)
13288 struct objfile
*objfile
= cu
->objfile
;
13289 struct symbol
*sym
= NULL
;
13291 struct attribute
*attr
= NULL
;
13292 struct attribute
*attr2
= NULL
;
13293 CORE_ADDR baseaddr
;
13294 struct pending
**list_to_add
= NULL
;
13296 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13298 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13300 name
= dwarf2_name (die
, cu
);
13303 const char *linkagename
;
13304 int suppress_add
= 0;
13309 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
13310 OBJSTAT (objfile
, n_syms
++);
13312 /* Cache this symbol's name and the name's demangled form (if any). */
13313 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
13314 linkagename
= dwarf2_physname (name
, die
, cu
);
13315 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
13317 /* Fortran does not have mangling standard and the mangling does differ
13318 between gfortran, iFort etc. */
13319 if (cu
->language
== language_fortran
13320 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
13321 symbol_set_demangled_name (&(sym
->ginfo
),
13322 (char *) dwarf2_full_name (name
, die
, cu
),
13325 /* Default assumptions.
13326 Use the passed type or decode it from the die. */
13327 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
13328 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
13330 SYMBOL_TYPE (sym
) = type
;
13332 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
13333 attr
= dwarf2_attr (die
,
13334 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
13338 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
13341 attr
= dwarf2_attr (die
,
13342 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
13346 int file_index
= DW_UNSND (attr
);
13348 if (cu
->line_header
== NULL
13349 || file_index
> cu
->line_header
->num_file_names
)
13350 complaint (&symfile_complaints
,
13351 _("file index out of range"));
13352 else if (file_index
> 0)
13354 struct file_entry
*fe
;
13356 fe
= &cu
->line_header
->file_names
[file_index
- 1];
13357 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
13364 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13367 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
13369 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
13370 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
13371 SYMBOL_CLASS (sym
) = LOC_LABEL
;
13372 add_symbol_to_list (sym
, cu
->list_in_scope
);
13374 case DW_TAG_subprogram
:
13375 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
13377 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
13378 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
13379 if ((attr2
&& (DW_UNSND (attr2
) != 0))
13380 || cu
->language
== language_ada
)
13382 /* Subprograms marked external are stored as a global symbol.
13383 Ada subprograms, whether marked external or not, are always
13384 stored as a global symbol, because we want to be able to
13385 access them globally. For instance, we want to be able
13386 to break on a nested subprogram without having to
13387 specify the context. */
13388 list_to_add
= &global_symbols
;
13392 list_to_add
= cu
->list_in_scope
;
13395 case DW_TAG_inlined_subroutine
:
13396 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
13398 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
13399 SYMBOL_INLINED (sym
) = 1;
13400 list_to_add
= cu
->list_in_scope
;
13402 case DW_TAG_template_value_param
:
13404 /* Fall through. */
13405 case DW_TAG_constant
:
13406 case DW_TAG_variable
:
13407 case DW_TAG_member
:
13408 /* Compilation with minimal debug info may result in
13409 variables with missing type entries. Change the
13410 misleading `void' type to something sensible. */
13411 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
13413 = objfile_type (objfile
)->nodebug_data_symbol
;
13415 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
13416 /* In the case of DW_TAG_member, we should only be called for
13417 static const members. */
13418 if (die
->tag
== DW_TAG_member
)
13420 /* dwarf2_add_field uses die_is_declaration,
13421 so we do the same. */
13422 gdb_assert (die_is_declaration (die
, cu
));
13427 dwarf2_const_value (attr
, sym
, cu
);
13428 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
13431 if (attr2
&& (DW_UNSND (attr2
) != 0))
13432 list_to_add
= &global_symbols
;
13434 list_to_add
= cu
->list_in_scope
;
13438 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
13441 var_decode_location (attr
, sym
, cu
);
13442 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
13443 if (SYMBOL_CLASS (sym
) == LOC_STATIC
13444 && SYMBOL_VALUE_ADDRESS (sym
) == 0
13445 && !dwarf2_per_objfile
->has_section_at_zero
)
13447 /* When a static variable is eliminated by the linker,
13448 the corresponding debug information is not stripped
13449 out, but the variable address is set to null;
13450 do not add such variables into symbol table. */
13452 else if (attr2
&& (DW_UNSND (attr2
) != 0))
13454 /* Workaround gfortran PR debug/40040 - it uses
13455 DW_AT_location for variables in -fPIC libraries which may
13456 get overriden by other libraries/executable and get
13457 a different address. Resolve it by the minimal symbol
13458 which may come from inferior's executable using copy
13459 relocation. Make this workaround only for gfortran as for
13460 other compilers GDB cannot guess the minimal symbol
13461 Fortran mangling kind. */
13462 if (cu
->language
== language_fortran
&& die
->parent
13463 && die
->parent
->tag
== DW_TAG_module
13465 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
13466 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
13468 /* A variable with DW_AT_external is never static,
13469 but it may be block-scoped. */
13470 list_to_add
= (cu
->list_in_scope
== &file_symbols
13471 ? &global_symbols
: cu
->list_in_scope
);
13474 list_to_add
= cu
->list_in_scope
;
13478 /* We do not know the address of this symbol.
13479 If it is an external symbol and we have type information
13480 for it, enter the symbol as a LOC_UNRESOLVED symbol.
13481 The address of the variable will then be determined from
13482 the minimal symbol table whenever the variable is
13484 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
13485 if (attr2
&& (DW_UNSND (attr2
) != 0)
13486 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
13488 /* A variable with DW_AT_external is never static, but it
13489 may be block-scoped. */
13490 list_to_add
= (cu
->list_in_scope
== &file_symbols
13491 ? &global_symbols
: cu
->list_in_scope
);
13493 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
13495 else if (!die_is_declaration (die
, cu
))
13497 /* Use the default LOC_OPTIMIZED_OUT class. */
13498 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
13500 list_to_add
= cu
->list_in_scope
;
13504 case DW_TAG_formal_parameter
:
13505 /* If we are inside a function, mark this as an argument. If
13506 not, we might be looking at an argument to an inlined function
13507 when we do not have enough information to show inlined frames;
13508 pretend it's a local variable in that case so that the user can
13510 if (context_stack_depth
> 0
13511 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
13512 SYMBOL_IS_ARGUMENT (sym
) = 1;
13513 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
13516 var_decode_location (attr
, sym
, cu
);
13518 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
13521 dwarf2_const_value (attr
, sym
, cu
);
13524 list_to_add
= cu
->list_in_scope
;
13526 case DW_TAG_unspecified_parameters
:
13527 /* From varargs functions; gdb doesn't seem to have any
13528 interest in this information, so just ignore it for now.
13531 case DW_TAG_template_type_param
:
13533 /* Fall through. */
13534 case DW_TAG_class_type
:
13535 case DW_TAG_interface_type
:
13536 case DW_TAG_structure_type
:
13537 case DW_TAG_union_type
:
13538 case DW_TAG_set_type
:
13539 case DW_TAG_enumeration_type
:
13540 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
13541 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
13544 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
13545 really ever be static objects: otherwise, if you try
13546 to, say, break of a class's method and you're in a file
13547 which doesn't mention that class, it won't work unless
13548 the check for all static symbols in lookup_symbol_aux
13549 saves you. See the OtherFileClass tests in
13550 gdb.c++/namespace.exp. */
13554 list_to_add
= (cu
->list_in_scope
== &file_symbols
13555 && (cu
->language
== language_cplus
13556 || cu
->language
== language_java
)
13557 ? &global_symbols
: cu
->list_in_scope
);
13559 /* The semantics of C++ state that "struct foo {
13560 ... }" also defines a typedef for "foo". A Java
13561 class declaration also defines a typedef for the
13563 if (cu
->language
== language_cplus
13564 || cu
->language
== language_java
13565 || cu
->language
== language_ada
)
13567 /* The symbol's name is already allocated along
13568 with this objfile, so we don't need to
13569 duplicate it for the type. */
13570 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
13571 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
13576 case DW_TAG_typedef
:
13577 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
13578 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
13579 list_to_add
= cu
->list_in_scope
;
13581 case DW_TAG_base_type
:
13582 case DW_TAG_subrange_type
:
13583 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
13584 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
13585 list_to_add
= cu
->list_in_scope
;
13587 case DW_TAG_enumerator
:
13588 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
13591 dwarf2_const_value (attr
, sym
, cu
);
13594 /* NOTE: carlton/2003-11-10: See comment above in the
13595 DW_TAG_class_type, etc. block. */
13597 list_to_add
= (cu
->list_in_scope
== &file_symbols
13598 && (cu
->language
== language_cplus
13599 || cu
->language
== language_java
)
13600 ? &global_symbols
: cu
->list_in_scope
);
13603 case DW_TAG_namespace
:
13604 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
13605 list_to_add
= &global_symbols
;
13608 /* Not a tag we recognize. Hopefully we aren't processing
13609 trash data, but since we must specifically ignore things
13610 we don't recognize, there is nothing else we should do at
13612 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
13613 dwarf_tag_name (die
->tag
));
13619 sym
->hash_next
= objfile
->template_symbols
;
13620 objfile
->template_symbols
= sym
;
13621 list_to_add
= NULL
;
13624 if (list_to_add
!= NULL
)
13625 add_symbol_to_list (sym
, list_to_add
);
13627 /* For the benefit of old versions of GCC, check for anonymous
13628 namespaces based on the demangled name. */
13629 if (!processing_has_namespace_info
13630 && cu
->language
== language_cplus
)
13631 cp_scan_for_anonymous_namespaces (sym
, objfile
);
13636 /* A wrapper for new_symbol_full that always allocates a new symbol. */
13638 static struct symbol
*
13639 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
13641 return new_symbol_full (die
, type
, cu
, NULL
);
13644 /* Given an attr with a DW_FORM_dataN value in host byte order,
13645 zero-extend it as appropriate for the symbol's type. The DWARF
13646 standard (v4) is not entirely clear about the meaning of using
13647 DW_FORM_dataN for a constant with a signed type, where the type is
13648 wider than the data. The conclusion of a discussion on the DWARF
13649 list was that this is unspecified. We choose to always zero-extend
13650 because that is the interpretation long in use by GCC. */
13653 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
13654 const char *name
, struct obstack
*obstack
,
13655 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
13657 struct objfile
*objfile
= cu
->objfile
;
13658 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
13659 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
13660 LONGEST l
= DW_UNSND (attr
);
13662 if (bits
< sizeof (*value
) * 8)
13664 l
&= ((LONGEST
) 1 << bits
) - 1;
13667 else if (bits
== sizeof (*value
) * 8)
13671 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
13672 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
13679 /* Read a constant value from an attribute. Either set *VALUE, or if
13680 the value does not fit in *VALUE, set *BYTES - either already
13681 allocated on the objfile obstack, or newly allocated on OBSTACK,
13682 or, set *BATON, if we translated the constant to a location
13686 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
13687 const char *name
, struct obstack
*obstack
,
13688 struct dwarf2_cu
*cu
,
13689 LONGEST
*value
, gdb_byte
**bytes
,
13690 struct dwarf2_locexpr_baton
**baton
)
13692 struct objfile
*objfile
= cu
->objfile
;
13693 struct comp_unit_head
*cu_header
= &cu
->header
;
13694 struct dwarf_block
*blk
;
13695 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
13696 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
13702 switch (attr
->form
)
13705 case DW_FORM_GNU_addr_index
:
13709 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
13710 dwarf2_const_value_length_mismatch_complaint (name
,
13711 cu_header
->addr_size
,
13712 TYPE_LENGTH (type
));
13713 /* Symbols of this form are reasonably rare, so we just
13714 piggyback on the existing location code rather than writing
13715 a new implementation of symbol_computed_ops. */
13716 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
13717 sizeof (struct dwarf2_locexpr_baton
));
13718 (*baton
)->per_cu
= cu
->per_cu
;
13719 gdb_assert ((*baton
)->per_cu
);
13721 (*baton
)->size
= 2 + cu_header
->addr_size
;
13722 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
13723 (*baton
)->data
= data
;
13725 data
[0] = DW_OP_addr
;
13726 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
13727 byte_order
, DW_ADDR (attr
));
13728 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
13731 case DW_FORM_string
:
13733 case DW_FORM_GNU_str_index
:
13734 /* DW_STRING is already allocated on the objfile obstack, point
13736 *bytes
= (gdb_byte
*) DW_STRING (attr
);
13738 case DW_FORM_block1
:
13739 case DW_FORM_block2
:
13740 case DW_FORM_block4
:
13741 case DW_FORM_block
:
13742 case DW_FORM_exprloc
:
13743 blk
= DW_BLOCK (attr
);
13744 if (TYPE_LENGTH (type
) != blk
->size
)
13745 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
13746 TYPE_LENGTH (type
));
13747 *bytes
= blk
->data
;
13750 /* The DW_AT_const_value attributes are supposed to carry the
13751 symbol's value "represented as it would be on the target
13752 architecture." By the time we get here, it's already been
13753 converted to host endianness, so we just need to sign- or
13754 zero-extend it as appropriate. */
13755 case DW_FORM_data1
:
13756 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
13757 obstack
, cu
, value
, 8);
13759 case DW_FORM_data2
:
13760 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
13761 obstack
, cu
, value
, 16);
13763 case DW_FORM_data4
:
13764 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
13765 obstack
, cu
, value
, 32);
13767 case DW_FORM_data8
:
13768 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
13769 obstack
, cu
, value
, 64);
13772 case DW_FORM_sdata
:
13773 *value
= DW_SND (attr
);
13776 case DW_FORM_udata
:
13777 *value
= DW_UNSND (attr
);
13781 complaint (&symfile_complaints
,
13782 _("unsupported const value attribute form: '%s'"),
13783 dwarf_form_name (attr
->form
));
13790 /* Copy constant value from an attribute to a symbol. */
13793 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
13794 struct dwarf2_cu
*cu
)
13796 struct objfile
*objfile
= cu
->objfile
;
13797 struct comp_unit_head
*cu_header
= &cu
->header
;
13800 struct dwarf2_locexpr_baton
*baton
;
13802 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
13803 SYMBOL_PRINT_NAME (sym
),
13804 &objfile
->objfile_obstack
, cu
,
13805 &value
, &bytes
, &baton
);
13809 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
13810 SYMBOL_LOCATION_BATON (sym
) = baton
;
13811 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
13813 else if (bytes
!= NULL
)
13815 SYMBOL_VALUE_BYTES (sym
) = bytes
;
13816 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
13820 SYMBOL_VALUE (sym
) = value
;
13821 SYMBOL_CLASS (sym
) = LOC_CONST
;
13825 /* Return the type of the die in question using its DW_AT_type attribute. */
13827 static struct type
*
13828 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13830 struct attribute
*type_attr
;
13832 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13835 /* A missing DW_AT_type represents a void type. */
13836 return objfile_type (cu
->objfile
)->builtin_void
;
13839 return lookup_die_type (die
, type_attr
, cu
);
13842 /* True iff CU's producer generates GNAT Ada auxiliary information
13843 that allows to find parallel types through that information instead
13844 of having to do expensive parallel lookups by type name. */
13847 need_gnat_info (struct dwarf2_cu
*cu
)
13849 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
13850 of GNAT produces this auxiliary information, without any indication
13851 that it is produced. Part of enhancing the FSF version of GNAT
13852 to produce that information will be to put in place an indicator
13853 that we can use in order to determine whether the descriptive type
13854 info is available or not. One suggestion that has been made is
13855 to use a new attribute, attached to the CU die. For now, assume
13856 that the descriptive type info is not available. */
13860 /* Return the auxiliary type of the die in question using its
13861 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
13862 attribute is not present. */
13864 static struct type
*
13865 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13867 struct attribute
*type_attr
;
13869 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
13873 return lookup_die_type (die
, type_attr
, cu
);
13876 /* If DIE has a descriptive_type attribute, then set the TYPE's
13877 descriptive type accordingly. */
13880 set_descriptive_type (struct type
*type
, struct die_info
*die
,
13881 struct dwarf2_cu
*cu
)
13883 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
13885 if (descriptive_type
)
13887 ALLOCATE_GNAT_AUX_TYPE (type
);
13888 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
13892 /* Return the containing type of the die in question using its
13893 DW_AT_containing_type attribute. */
13895 static struct type
*
13896 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13898 struct attribute
*type_attr
;
13900 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
13902 error (_("Dwarf Error: Problem turning containing type into gdb type "
13903 "[in module %s]"), cu
->objfile
->name
);
13905 return lookup_die_type (die
, type_attr
, cu
);
13908 /* Look up the type of DIE in CU using its type attribute ATTR.
13909 If there is no type substitute an error marker. */
13911 static struct type
*
13912 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
13913 struct dwarf2_cu
*cu
)
13915 struct objfile
*objfile
= cu
->objfile
;
13916 struct type
*this_type
;
13918 /* First see if we have it cached. */
13920 if (is_ref_attr (attr
))
13922 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
13924 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
13926 else if (attr
->form
== DW_FORM_ref_sig8
)
13928 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
13930 /* sig_type will be NULL if the signatured type is missing from
13932 if (sig_type
== NULL
)
13933 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
13934 "at 0x%x [in module %s]"),
13935 die
->offset
.sect_off
, objfile
->name
);
13937 gdb_assert (sig_type
->per_cu
.is_debug_types
);
13938 /* If we haven't filled in type_offset_in_section yet, then we
13939 haven't read the type in yet. */
13941 if (sig_type
->type_offset_in_section
.sect_off
!= 0)
13944 get_die_type_at_offset (sig_type
->type_offset_in_section
,
13945 &sig_type
->per_cu
);
13950 dump_die_for_error (die
);
13951 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
13952 dwarf_attr_name (attr
->name
), objfile
->name
);
13955 /* If not cached we need to read it in. */
13957 if (this_type
== NULL
)
13959 struct die_info
*type_die
;
13960 struct dwarf2_cu
*type_cu
= cu
;
13962 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
13963 /* If we found the type now, it's probably because the type came
13964 from an inter-CU reference and the type's CU got expanded before
13966 this_type
= get_die_type (type_die
, type_cu
);
13967 if (this_type
== NULL
)
13968 this_type
= read_type_die_1 (type_die
, type_cu
);
13971 /* If we still don't have a type use an error marker. */
13973 if (this_type
== NULL
)
13975 char *message
, *saved
;
13977 /* read_type_die already issued a complaint. */
13978 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
13980 cu
->header
.offset
.sect_off
,
13981 die
->offset
.sect_off
);
13982 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
13983 message
, strlen (message
));
13986 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
13992 /* Return the type in DIE, CU.
13993 Returns NULL for invalid types.
13995 This first does a lookup in the appropriate type_hash table,
13996 and only reads the die in if necessary.
13998 NOTE: This can be called when reading in partial or full symbols. */
14000 static struct type
*
14001 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
14003 struct type
*this_type
;
14005 this_type
= get_die_type (die
, cu
);
14009 return read_type_die_1 (die
, cu
);
14012 /* Read the type in DIE, CU.
14013 Returns NULL for invalid types. */
14015 static struct type
*
14016 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
14018 struct type
*this_type
= NULL
;
14022 case DW_TAG_class_type
:
14023 case DW_TAG_interface_type
:
14024 case DW_TAG_structure_type
:
14025 case DW_TAG_union_type
:
14026 this_type
= read_structure_type (die
, cu
);
14028 case DW_TAG_enumeration_type
:
14029 this_type
= read_enumeration_type (die
, cu
);
14031 case DW_TAG_subprogram
:
14032 case DW_TAG_subroutine_type
:
14033 case DW_TAG_inlined_subroutine
:
14034 this_type
= read_subroutine_type (die
, cu
);
14036 case DW_TAG_array_type
:
14037 this_type
= read_array_type (die
, cu
);
14039 case DW_TAG_set_type
:
14040 this_type
= read_set_type (die
, cu
);
14042 case DW_TAG_pointer_type
:
14043 this_type
= read_tag_pointer_type (die
, cu
);
14045 case DW_TAG_ptr_to_member_type
:
14046 this_type
= read_tag_ptr_to_member_type (die
, cu
);
14048 case DW_TAG_reference_type
:
14049 this_type
= read_tag_reference_type (die
, cu
);
14051 case DW_TAG_const_type
:
14052 this_type
= read_tag_const_type (die
, cu
);
14054 case DW_TAG_volatile_type
:
14055 this_type
= read_tag_volatile_type (die
, cu
);
14057 case DW_TAG_string_type
:
14058 this_type
= read_tag_string_type (die
, cu
);
14060 case DW_TAG_typedef
:
14061 this_type
= read_typedef (die
, cu
);
14063 case DW_TAG_subrange_type
:
14064 this_type
= read_subrange_type (die
, cu
);
14066 case DW_TAG_base_type
:
14067 this_type
= read_base_type (die
, cu
);
14069 case DW_TAG_unspecified_type
:
14070 this_type
= read_unspecified_type (die
, cu
);
14072 case DW_TAG_namespace
:
14073 this_type
= read_namespace_type (die
, cu
);
14075 case DW_TAG_module
:
14076 this_type
= read_module_type (die
, cu
);
14079 complaint (&symfile_complaints
,
14080 _("unexpected tag in read_type_die: '%s'"),
14081 dwarf_tag_name (die
->tag
));
14088 /* See if we can figure out if the class lives in a namespace. We do
14089 this by looking for a member function; its demangled name will
14090 contain namespace info, if there is any.
14091 Return the computed name or NULL.
14092 Space for the result is allocated on the objfile's obstack.
14093 This is the full-die version of guess_partial_die_structure_name.
14094 In this case we know DIE has no useful parent. */
14097 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
14099 struct die_info
*spec_die
;
14100 struct dwarf2_cu
*spec_cu
;
14101 struct die_info
*child
;
14104 spec_die
= die_specification (die
, &spec_cu
);
14105 if (spec_die
!= NULL
)
14111 for (child
= die
->child
;
14113 child
= child
->sibling
)
14115 if (child
->tag
== DW_TAG_subprogram
)
14117 struct attribute
*attr
;
14119 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
14121 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
14125 = language_class_name_from_physname (cu
->language_defn
,
14129 if (actual_name
!= NULL
)
14131 char *die_name
= dwarf2_name (die
, cu
);
14133 if (die_name
!= NULL
14134 && strcmp (die_name
, actual_name
) != 0)
14136 /* Strip off the class name from the full name.
14137 We want the prefix. */
14138 int die_name_len
= strlen (die_name
);
14139 int actual_name_len
= strlen (actual_name
);
14141 /* Test for '::' as a sanity check. */
14142 if (actual_name_len
> die_name_len
+ 2
14143 && actual_name
[actual_name_len
14144 - die_name_len
- 1] == ':')
14146 obsavestring (actual_name
,
14147 actual_name_len
- die_name_len
- 2,
14148 &cu
->objfile
->objfile_obstack
);
14151 xfree (actual_name
);
14160 /* GCC might emit a nameless typedef that has a linkage name. Determine the
14161 prefix part in such case. See
14162 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
14165 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
14167 struct attribute
*attr
;
14170 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
14171 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
14174 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
14175 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
14178 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
14180 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
14181 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
14184 /* dwarf2_name had to be already called. */
14185 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
14187 /* Strip the base name, keep any leading namespaces/classes. */
14188 base
= strrchr (DW_STRING (attr
), ':');
14189 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
14192 return obsavestring (DW_STRING (attr
), &base
[-1] - DW_STRING (attr
),
14193 &cu
->objfile
->objfile_obstack
);
14196 /* Return the name of the namespace/class that DIE is defined within,
14197 or "" if we can't tell. The caller should not xfree the result.
14199 For example, if we're within the method foo() in the following
14209 then determine_prefix on foo's die will return "N::C". */
14211 static const char *
14212 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
14214 struct die_info
*parent
, *spec_die
;
14215 struct dwarf2_cu
*spec_cu
;
14216 struct type
*parent_type
;
14219 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
14220 && cu
->language
!= language_fortran
)
14223 retval
= anonymous_struct_prefix (die
, cu
);
14227 /* We have to be careful in the presence of DW_AT_specification.
14228 For example, with GCC 3.4, given the code
14232 // Definition of N::foo.
14236 then we'll have a tree of DIEs like this:
14238 1: DW_TAG_compile_unit
14239 2: DW_TAG_namespace // N
14240 3: DW_TAG_subprogram // declaration of N::foo
14241 4: DW_TAG_subprogram // definition of N::foo
14242 DW_AT_specification // refers to die #3
14244 Thus, when processing die #4, we have to pretend that we're in
14245 the context of its DW_AT_specification, namely the contex of die
14248 spec_die
= die_specification (die
, &spec_cu
);
14249 if (spec_die
== NULL
)
14250 parent
= die
->parent
;
14253 parent
= spec_die
->parent
;
14257 if (parent
== NULL
)
14259 else if (parent
->building_fullname
)
14262 const char *parent_name
;
14264 /* It has been seen on RealView 2.2 built binaries,
14265 DW_TAG_template_type_param types actually _defined_ as
14266 children of the parent class:
14269 template class <class Enum> Class{};
14270 Class<enum E> class_e;
14272 1: DW_TAG_class_type (Class)
14273 2: DW_TAG_enumeration_type (E)
14274 3: DW_TAG_enumerator (enum1:0)
14275 3: DW_TAG_enumerator (enum2:1)
14277 2: DW_TAG_template_type_param
14278 DW_AT_type DW_FORM_ref_udata (E)
14280 Besides being broken debug info, it can put GDB into an
14281 infinite loop. Consider:
14283 When we're building the full name for Class<E>, we'll start
14284 at Class, and go look over its template type parameters,
14285 finding E. We'll then try to build the full name of E, and
14286 reach here. We're now trying to build the full name of E,
14287 and look over the parent DIE for containing scope. In the
14288 broken case, if we followed the parent DIE of E, we'd again
14289 find Class, and once again go look at its template type
14290 arguments, etc., etc. Simply don't consider such parent die
14291 as source-level parent of this die (it can't be, the language
14292 doesn't allow it), and break the loop here. */
14293 name
= dwarf2_name (die
, cu
);
14294 parent_name
= dwarf2_name (parent
, cu
);
14295 complaint (&symfile_complaints
,
14296 _("template param type '%s' defined within parent '%s'"),
14297 name
? name
: "<unknown>",
14298 parent_name
? parent_name
: "<unknown>");
14302 switch (parent
->tag
)
14304 case DW_TAG_namespace
:
14305 parent_type
= read_type_die (parent
, cu
);
14306 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
14307 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
14308 Work around this problem here. */
14309 if (cu
->language
== language_cplus
14310 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
14312 /* We give a name to even anonymous namespaces. */
14313 return TYPE_TAG_NAME (parent_type
);
14314 case DW_TAG_class_type
:
14315 case DW_TAG_interface_type
:
14316 case DW_TAG_structure_type
:
14317 case DW_TAG_union_type
:
14318 case DW_TAG_module
:
14319 parent_type
= read_type_die (parent
, cu
);
14320 if (TYPE_TAG_NAME (parent_type
) != NULL
)
14321 return TYPE_TAG_NAME (parent_type
);
14323 /* An anonymous structure is only allowed non-static data
14324 members; no typedefs, no member functions, et cetera.
14325 So it does not need a prefix. */
14327 case DW_TAG_compile_unit
:
14328 case DW_TAG_partial_unit
:
14329 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
14330 if (cu
->language
== language_cplus
14331 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
14332 && die
->child
!= NULL
14333 && (die
->tag
== DW_TAG_class_type
14334 || die
->tag
== DW_TAG_structure_type
14335 || die
->tag
== DW_TAG_union_type
))
14337 char *name
= guess_full_die_structure_name (die
, cu
);
14343 return determine_prefix (parent
, cu
);
14347 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
14348 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
14349 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
14350 an obconcat, otherwise allocate storage for the result. The CU argument is
14351 used to determine the language and hence, the appropriate separator. */
14353 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
14356 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
14357 int physname
, struct dwarf2_cu
*cu
)
14359 const char *lead
= "";
14362 if (suffix
== NULL
|| suffix
[0] == '\0'
14363 || prefix
== NULL
|| prefix
[0] == '\0')
14365 else if (cu
->language
== language_java
)
14367 else if (cu
->language
== language_fortran
&& physname
)
14369 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
14370 DW_AT_MIPS_linkage_name is preferred and used instead. */
14378 if (prefix
== NULL
)
14380 if (suffix
== NULL
)
14386 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
14388 strcpy (retval
, lead
);
14389 strcat (retval
, prefix
);
14390 strcat (retval
, sep
);
14391 strcat (retval
, suffix
);
14396 /* We have an obstack. */
14397 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
14401 /* Return sibling of die, NULL if no sibling. */
14403 static struct die_info
*
14404 sibling_die (struct die_info
*die
)
14406 return die
->sibling
;
14409 /* Get name of a die, return NULL if not found. */
14412 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
14413 struct obstack
*obstack
)
14415 if (name
&& cu
->language
== language_cplus
)
14417 char *canon_name
= cp_canonicalize_string (name
);
14419 if (canon_name
!= NULL
)
14421 if (strcmp (canon_name
, name
) != 0)
14422 name
= obsavestring (canon_name
, strlen (canon_name
),
14424 xfree (canon_name
);
14431 /* Get name of a die, return NULL if not found. */
14434 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
14436 struct attribute
*attr
;
14438 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
14439 if ((!attr
|| !DW_STRING (attr
))
14440 && die
->tag
!= DW_TAG_class_type
14441 && die
->tag
!= DW_TAG_interface_type
14442 && die
->tag
!= DW_TAG_structure_type
14443 && die
->tag
!= DW_TAG_union_type
)
14448 case DW_TAG_compile_unit
:
14449 case DW_TAG_partial_unit
:
14450 /* Compilation units have a DW_AT_name that is a filename, not
14451 a source language identifier. */
14452 case DW_TAG_enumeration_type
:
14453 case DW_TAG_enumerator
:
14454 /* These tags always have simple identifiers already; no need
14455 to canonicalize them. */
14456 return DW_STRING (attr
);
14458 case DW_TAG_subprogram
:
14459 /* Java constructors will all be named "<init>", so return
14460 the class name when we see this special case. */
14461 if (cu
->language
== language_java
14462 && DW_STRING (attr
) != NULL
14463 && strcmp (DW_STRING (attr
), "<init>") == 0)
14465 struct dwarf2_cu
*spec_cu
= cu
;
14466 struct die_info
*spec_die
;
14468 /* GCJ will output '<init>' for Java constructor names.
14469 For this special case, return the name of the parent class. */
14471 /* GCJ may output suprogram DIEs with AT_specification set.
14472 If so, use the name of the specified DIE. */
14473 spec_die
= die_specification (die
, &spec_cu
);
14474 if (spec_die
!= NULL
)
14475 return dwarf2_name (spec_die
, spec_cu
);
14480 if (die
->tag
== DW_TAG_class_type
)
14481 return dwarf2_name (die
, cu
);
14483 while (die
->tag
!= DW_TAG_compile_unit
14484 && die
->tag
!= DW_TAG_partial_unit
);
14488 case DW_TAG_class_type
:
14489 case DW_TAG_interface_type
:
14490 case DW_TAG_structure_type
:
14491 case DW_TAG_union_type
:
14492 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
14493 structures or unions. These were of the form "._%d" in GCC 4.1,
14494 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
14495 and GCC 4.4. We work around this problem by ignoring these. */
14496 if (attr
&& DW_STRING (attr
)
14497 && (strncmp (DW_STRING (attr
), "._", 2) == 0
14498 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
14501 /* GCC might emit a nameless typedef that has a linkage name. See
14502 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
14503 if (!attr
|| DW_STRING (attr
) == NULL
)
14505 char *demangled
= NULL
;
14507 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
14509 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
14511 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
14514 /* Avoid demangling DW_STRING (attr) the second time on a second
14515 call for the same DIE. */
14516 if (!DW_STRING_IS_CANONICAL (attr
))
14517 demangled
= cplus_demangle (DW_STRING (attr
), DMGL_TYPES
);
14523 /* FIXME: we already did this for the partial symbol... */
14524 DW_STRING (attr
) = obsavestring (demangled
, strlen (demangled
),
14525 &cu
->objfile
->objfile_obstack
);
14526 DW_STRING_IS_CANONICAL (attr
) = 1;
14529 /* Strip any leading namespaces/classes, keep only the base name.
14530 DW_AT_name for named DIEs does not contain the prefixes. */
14531 base
= strrchr (DW_STRING (attr
), ':');
14532 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
14535 return DW_STRING (attr
);
14544 if (!DW_STRING_IS_CANONICAL (attr
))
14547 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
14548 &cu
->objfile
->objfile_obstack
);
14549 DW_STRING_IS_CANONICAL (attr
) = 1;
14551 return DW_STRING (attr
);
14554 /* Return the die that this die in an extension of, or NULL if there
14555 is none. *EXT_CU is the CU containing DIE on input, and the CU
14556 containing the return value on output. */
14558 static struct die_info
*
14559 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
14561 struct attribute
*attr
;
14563 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
14567 return follow_die_ref (die
, attr
, ext_cu
);
14570 /* Convert a DIE tag into its string name. */
14572 static const char *
14573 dwarf_tag_name (unsigned tag
)
14575 const char *name
= get_DW_TAG_name (tag
);
14578 return "DW_TAG_<unknown>";
14583 /* Convert a DWARF attribute code into its string name. */
14585 static const char *
14586 dwarf_attr_name (unsigned attr
)
14590 #ifdef MIPS /* collides with DW_AT_HP_block_index */
14591 if (attr
== DW_AT_MIPS_fde
)
14592 return "DW_AT_MIPS_fde";
14594 if (attr
== DW_AT_HP_block_index
)
14595 return "DW_AT_HP_block_index";
14598 name
= get_DW_AT_name (attr
);
14601 return "DW_AT_<unknown>";
14606 /* Convert a DWARF value form code into its string name. */
14608 static const char *
14609 dwarf_form_name (unsigned form
)
14611 const char *name
= get_DW_FORM_name (form
);
14614 return "DW_FORM_<unknown>";
14620 dwarf_bool_name (unsigned mybool
)
14628 /* Convert a DWARF type code into its string name. */
14630 static const char *
14631 dwarf_type_encoding_name (unsigned enc
)
14633 const char *name
= get_DW_ATE_name (enc
);
14636 return "DW_ATE_<unknown>";
14642 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
14646 print_spaces (indent
, f
);
14647 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
14648 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
.sect_off
);
14650 if (die
->parent
!= NULL
)
14652 print_spaces (indent
, f
);
14653 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
14654 die
->parent
->offset
.sect_off
);
14657 print_spaces (indent
, f
);
14658 fprintf_unfiltered (f
, " has children: %s\n",
14659 dwarf_bool_name (die
->child
!= NULL
));
14661 print_spaces (indent
, f
);
14662 fprintf_unfiltered (f
, " attributes:\n");
14664 for (i
= 0; i
< die
->num_attrs
; ++i
)
14666 print_spaces (indent
, f
);
14667 fprintf_unfiltered (f
, " %s (%s) ",
14668 dwarf_attr_name (die
->attrs
[i
].name
),
14669 dwarf_form_name (die
->attrs
[i
].form
));
14671 switch (die
->attrs
[i
].form
)
14674 case DW_FORM_GNU_addr_index
:
14675 fprintf_unfiltered (f
, "address: ");
14676 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
14678 case DW_FORM_block2
:
14679 case DW_FORM_block4
:
14680 case DW_FORM_block
:
14681 case DW_FORM_block1
:
14682 fprintf_unfiltered (f
, "block: size %d",
14683 DW_BLOCK (&die
->attrs
[i
])->size
);
14685 case DW_FORM_exprloc
:
14686 fprintf_unfiltered (f
, "expression: size %u",
14687 DW_BLOCK (&die
->attrs
[i
])->size
);
14689 case DW_FORM_ref_addr
:
14690 fprintf_unfiltered (f
, "ref address: ");
14691 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
14697 case DW_FORM_ref_udata
:
14698 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
14699 (long) (DW_UNSND (&die
->attrs
[i
])));
14701 case DW_FORM_data1
:
14702 case DW_FORM_data2
:
14703 case DW_FORM_data4
:
14704 case DW_FORM_data8
:
14705 case DW_FORM_udata
:
14706 case DW_FORM_sdata
:
14707 fprintf_unfiltered (f
, "constant: %s",
14708 pulongest (DW_UNSND (&die
->attrs
[i
])));
14710 case DW_FORM_sec_offset
:
14711 fprintf_unfiltered (f
, "section offset: %s",
14712 pulongest (DW_UNSND (&die
->attrs
[i
])));
14714 case DW_FORM_ref_sig8
:
14715 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
14716 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
14717 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->per_cu
.offset
.sect_off
);
14719 fprintf_unfiltered (f
, "signatured type, offset: unknown");
14721 case DW_FORM_string
:
14723 case DW_FORM_GNU_str_index
:
14724 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
14725 DW_STRING (&die
->attrs
[i
])
14726 ? DW_STRING (&die
->attrs
[i
]) : "",
14727 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
14730 if (DW_UNSND (&die
->attrs
[i
]))
14731 fprintf_unfiltered (f
, "flag: TRUE");
14733 fprintf_unfiltered (f
, "flag: FALSE");
14735 case DW_FORM_flag_present
:
14736 fprintf_unfiltered (f
, "flag: TRUE");
14738 case DW_FORM_indirect
:
14739 /* The reader will have reduced the indirect form to
14740 the "base form" so this form should not occur. */
14741 fprintf_unfiltered (f
,
14742 "unexpected attribute form: DW_FORM_indirect");
14745 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
14746 die
->attrs
[i
].form
);
14749 fprintf_unfiltered (f
, "\n");
14754 dump_die_for_error (struct die_info
*die
)
14756 dump_die_shallow (gdb_stderr
, 0, die
);
14760 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
14762 int indent
= level
* 4;
14764 gdb_assert (die
!= NULL
);
14766 if (level
>= max_level
)
14769 dump_die_shallow (f
, indent
, die
);
14771 if (die
->child
!= NULL
)
14773 print_spaces (indent
, f
);
14774 fprintf_unfiltered (f
, " Children:");
14775 if (level
+ 1 < max_level
)
14777 fprintf_unfiltered (f
, "\n");
14778 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
14782 fprintf_unfiltered (f
,
14783 " [not printed, max nesting level reached]\n");
14787 if (die
->sibling
!= NULL
&& level
> 0)
14789 dump_die_1 (f
, level
, max_level
, die
->sibling
);
14793 /* This is called from the pdie macro in gdbinit.in.
14794 It's not static so gcc will keep a copy callable from gdb. */
14797 dump_die (struct die_info
*die
, int max_level
)
14799 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
14803 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
14807 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
.sect_off
,
14813 /* DW_ADDR is always stored already as sect_offset; despite for the forms
14814 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
14817 is_ref_attr (struct attribute
*attr
)
14819 switch (attr
->form
)
14821 case DW_FORM_ref_addr
:
14826 case DW_FORM_ref_udata
:
14833 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
14837 dwarf2_get_ref_die_offset (struct attribute
*attr
)
14839 sect_offset retval
= { DW_UNSND (attr
) };
14841 if (is_ref_attr (attr
))
14844 retval
.sect_off
= 0;
14845 complaint (&symfile_complaints
,
14846 _("unsupported die ref attribute form: '%s'"),
14847 dwarf_form_name (attr
->form
));
14851 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
14852 * the value held by the attribute is not constant. */
14855 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
14857 if (attr
->form
== DW_FORM_sdata
)
14858 return DW_SND (attr
);
14859 else if (attr
->form
== DW_FORM_udata
14860 || attr
->form
== DW_FORM_data1
14861 || attr
->form
== DW_FORM_data2
14862 || attr
->form
== DW_FORM_data4
14863 || attr
->form
== DW_FORM_data8
)
14864 return DW_UNSND (attr
);
14867 complaint (&symfile_complaints
,
14868 _("Attribute value is not a constant (%s)"),
14869 dwarf_form_name (attr
->form
));
14870 return default_value
;
14874 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
14875 unit and add it to our queue.
14876 The result is non-zero if PER_CU was queued, otherwise the result is zero
14877 meaning either PER_CU is already queued or it is already loaded. */
14880 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
14881 struct dwarf2_per_cu_data
*per_cu
,
14882 enum language pretend_language
)
14884 /* We may arrive here during partial symbol reading, if we need full
14885 DIEs to process an unusual case (e.g. template arguments). Do
14886 not queue PER_CU, just tell our caller to load its DIEs. */
14887 if (dwarf2_per_objfile
->reading_partial_symbols
)
14889 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
14894 /* Mark the dependence relation so that we don't flush PER_CU
14896 dwarf2_add_dependence (this_cu
, per_cu
);
14898 /* If it's already on the queue, we have nothing to do. */
14899 if (per_cu
->queued
)
14902 /* If the compilation unit is already loaded, just mark it as
14904 if (per_cu
->cu
!= NULL
)
14906 per_cu
->cu
->last_used
= 0;
14910 /* Add it to the queue. */
14911 queue_comp_unit (per_cu
, pretend_language
);
14916 /* Follow reference or signature attribute ATTR of SRC_DIE.
14917 On entry *REF_CU is the CU of SRC_DIE.
14918 On exit *REF_CU is the CU of the result. */
14920 static struct die_info
*
14921 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
14922 struct dwarf2_cu
**ref_cu
)
14924 struct die_info
*die
;
14926 if (is_ref_attr (attr
))
14927 die
= follow_die_ref (src_die
, attr
, ref_cu
);
14928 else if (attr
->form
== DW_FORM_ref_sig8
)
14929 die
= follow_die_sig (src_die
, attr
, ref_cu
);
14932 dump_die_for_error (src_die
);
14933 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
14934 (*ref_cu
)->objfile
->name
);
14940 /* Follow reference OFFSET.
14941 On entry *REF_CU is the CU of the source die referencing OFFSET.
14942 On exit *REF_CU is the CU of the result.
14943 Returns NULL if OFFSET is invalid. */
14945 static struct die_info
*
14946 follow_die_offset (sect_offset offset
, struct dwarf2_cu
**ref_cu
)
14948 struct die_info temp_die
;
14949 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
14951 gdb_assert (cu
->per_cu
!= NULL
);
14955 if (cu
->per_cu
->is_debug_types
)
14957 /* .debug_types CUs cannot reference anything outside their CU.
14958 If they need to, they have to reference a signatured type via
14959 DW_FORM_ref_sig8. */
14960 if (! offset_in_cu_p (&cu
->header
, offset
))
14963 else if (! offset_in_cu_p (&cu
->header
, offset
))
14965 struct dwarf2_per_cu_data
*per_cu
;
14967 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
14969 /* If necessary, add it to the queue and load its DIEs. */
14970 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
14971 load_full_comp_unit (per_cu
, cu
->language
);
14973 target_cu
= per_cu
->cu
;
14975 else if (cu
->dies
== NULL
)
14977 /* We're loading full DIEs during partial symbol reading. */
14978 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
14979 load_full_comp_unit (cu
->per_cu
, language_minimal
);
14982 *ref_cu
= target_cu
;
14983 temp_die
.offset
= offset
;
14984 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
.sect_off
);
14987 /* Follow reference attribute ATTR of SRC_DIE.
14988 On entry *REF_CU is the CU of SRC_DIE.
14989 On exit *REF_CU is the CU of the result. */
14991 static struct die_info
*
14992 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
14993 struct dwarf2_cu
**ref_cu
)
14995 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
14996 struct dwarf2_cu
*cu
= *ref_cu
;
14997 struct die_info
*die
;
14999 die
= follow_die_offset (offset
, ref_cu
);
15001 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
15002 "at 0x%x [in module %s]"),
15003 offset
.sect_off
, src_die
->offset
.sect_off
, cu
->objfile
->name
);
15008 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
15009 Returned value is intended for DW_OP_call*. Returned
15010 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
15012 struct dwarf2_locexpr_baton
15013 dwarf2_fetch_die_location_block (cu_offset offset_in_cu
,
15014 struct dwarf2_per_cu_data
*per_cu
,
15015 CORE_ADDR (*get_frame_pc
) (void *baton
),
15018 sect_offset offset
= { per_cu
->offset
.sect_off
+ offset_in_cu
.cu_off
};
15019 struct dwarf2_cu
*cu
;
15020 struct die_info
*die
;
15021 struct attribute
*attr
;
15022 struct dwarf2_locexpr_baton retval
;
15024 dw2_setup (per_cu
->objfile
);
15026 if (per_cu
->cu
== NULL
)
15030 die
= follow_die_offset (offset
, &cu
);
15032 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
15033 offset
.sect_off
, per_cu
->objfile
->name
);
15035 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
15038 /* DWARF: "If there is no such attribute, then there is no effect.".
15039 DATA is ignored if SIZE is 0. */
15041 retval
.data
= NULL
;
15044 else if (attr_form_is_section_offset (attr
))
15046 struct dwarf2_loclist_baton loclist_baton
;
15047 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
15050 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
15052 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
15054 retval
.size
= size
;
15058 if (!attr_form_is_block (attr
))
15059 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
15060 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
15061 offset
.sect_off
, per_cu
->objfile
->name
);
15063 retval
.data
= DW_BLOCK (attr
)->data
;
15064 retval
.size
= DW_BLOCK (attr
)->size
;
15066 retval
.per_cu
= cu
->per_cu
;
15068 age_cached_comp_units ();
15073 /* Return the type of the DIE at DIE_OFFSET in the CU named by
15077 dwarf2_get_die_type (cu_offset die_offset
,
15078 struct dwarf2_per_cu_data
*per_cu
)
15080 sect_offset die_offset_sect
;
15082 dw2_setup (per_cu
->objfile
);
15084 die_offset_sect
.sect_off
= per_cu
->offset
.sect_off
+ die_offset
.cu_off
;
15085 return get_die_type_at_offset (die_offset_sect
, per_cu
);
15088 /* Follow the signature attribute ATTR in SRC_DIE.
15089 On entry *REF_CU is the CU of SRC_DIE.
15090 On exit *REF_CU is the CU of the result. */
15092 static struct die_info
*
15093 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
15094 struct dwarf2_cu
**ref_cu
)
15096 struct objfile
*objfile
= (*ref_cu
)->objfile
;
15097 struct die_info temp_die
;
15098 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
15099 struct dwarf2_cu
*sig_cu
;
15100 struct die_info
*die
;
15102 /* sig_type will be NULL if the signatured type is missing from
15104 if (sig_type
== NULL
)
15105 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
15106 "at 0x%x [in module %s]"),
15107 src_die
->offset
.sect_off
, objfile
->name
);
15109 /* If necessary, add it to the queue and load its DIEs. */
15111 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
15112 read_signatured_type (sig_type
);
15114 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
15116 sig_cu
= sig_type
->per_cu
.cu
;
15117 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
15118 temp_die
.offset
= sig_type
->type_offset_in_section
;
15119 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
15120 temp_die
.offset
.sect_off
);
15127 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
15128 "from DIE at 0x%x [in module %s]"),
15129 temp_die
.offset
.sect_off
, src_die
->offset
.sect_off
, objfile
->name
);
15132 /* Given an offset of a signatured type, return its signatured_type. */
15134 static struct signatured_type
*
15135 lookup_signatured_type_at_offset (struct objfile
*objfile
,
15136 struct dwarf2_section_info
*section
,
15137 sect_offset offset
)
15139 gdb_byte
*info_ptr
= section
->buffer
+ offset
.sect_off
;
15140 unsigned int length
, initial_length_size
;
15141 unsigned int sig_offset
;
15142 struct signatured_type find_entry
, *sig_type
;
15144 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
15145 sig_offset
= (initial_length_size
15147 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
15148 + 1 /*address_size*/);
15149 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
15150 sig_type
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
15152 /* This is only used to lookup previously recorded types.
15153 If we didn't find it, it's our bug. */
15154 gdb_assert (sig_type
!= NULL
);
15155 gdb_assert (offset
.sect_off
== sig_type
->per_cu
.offset
.sect_off
);
15160 /* Load the DIEs associated with type unit PER_CU into memory. */
15163 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
15165 struct objfile
*objfile
= per_cu
->objfile
;
15166 struct dwarf2_section_info
*sect
= per_cu
->info_or_types_section
;
15167 sect_offset offset
= per_cu
->offset
;
15168 struct signatured_type
*sig_type
;
15170 dwarf2_read_section (objfile
, sect
);
15172 /* We have the section offset, but we need the signature to do the
15173 hash table lookup. */
15174 /* FIXME: This is sorta unnecessary, read_signatured_type only uses
15175 the signature to assert we found the right one.
15176 Ok, but it's a lot of work. We should simplify things so any needed
15177 assert doesn't require all this clumsiness. */
15178 sig_type
= lookup_signatured_type_at_offset (objfile
, sect
, offset
);
15180 gdb_assert (&sig_type
->per_cu
== per_cu
);
15181 gdb_assert (sig_type
->per_cu
.cu
== NULL
);
15183 read_signatured_type (sig_type
);
15185 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
15188 /* die_reader_func for read_signatured_type.
15189 This is identical to load_full_comp_unit_reader,
15190 but is kept separate for now. */
15193 read_signatured_type_reader (const struct die_reader_specs
*reader
,
15194 gdb_byte
*info_ptr
,
15195 struct die_info
*comp_unit_die
,
15199 struct dwarf2_cu
*cu
= reader
->cu
;
15201 gdb_assert (cu
->die_hash
== NULL
);
15203 htab_create_alloc_ex (cu
->header
.length
/ 12,
15207 &cu
->comp_unit_obstack
,
15208 hashtab_obstack_allocate
,
15209 dummy_obstack_deallocate
);
15212 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
15213 &info_ptr
, comp_unit_die
);
15214 cu
->dies
= comp_unit_die
;
15215 /* comp_unit_die is not stored in die_hash, no need. */
15217 /* We try not to read any attributes in this function, because not
15218 all CUs needed for references have been loaded yet, and symbol
15219 table processing isn't initialized. But we have to set the CU language,
15220 or we won't be able to build types correctly.
15221 Similarly, if we do not read the producer, we can not apply
15222 producer-specific interpretation. */
15223 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
15226 /* Read in a signatured type and build its CU and DIEs.
15227 If the type is a stub for the real type in a DWO file,
15228 read in the real type from the DWO file as well. */
15231 read_signatured_type (struct signatured_type
*sig_type
)
15233 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
15235 gdb_assert (per_cu
->is_debug_types
);
15236 gdb_assert (per_cu
->cu
== NULL
);
15238 init_cutu_and_read_dies (per_cu
, 0, 1, read_signatured_type_reader
, NULL
);
15241 /* Decode simple location descriptions.
15242 Given a pointer to a dwarf block that defines a location, compute
15243 the location and return the value.
15245 NOTE drow/2003-11-18: This function is called in two situations
15246 now: for the address of static or global variables (partial symbols
15247 only) and for offsets into structures which are expected to be
15248 (more or less) constant. The partial symbol case should go away,
15249 and only the constant case should remain. That will let this
15250 function complain more accurately. A few special modes are allowed
15251 without complaint for global variables (for instance, global
15252 register values and thread-local values).
15254 A location description containing no operations indicates that the
15255 object is optimized out. The return value is 0 for that case.
15256 FIXME drow/2003-11-16: No callers check for this case any more; soon all
15257 callers will only want a very basic result and this can become a
15260 Note that stack[0] is unused except as a default error return. */
15263 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
15265 struct objfile
*objfile
= cu
->objfile
;
15267 int size
= blk
->size
;
15268 gdb_byte
*data
= blk
->data
;
15269 CORE_ADDR stack
[64];
15271 unsigned int bytes_read
, unsnd
;
15277 stack
[++stacki
] = 0;
15316 stack
[++stacki
] = op
- DW_OP_lit0
;
15351 stack
[++stacki
] = op
- DW_OP_reg0
;
15353 dwarf2_complex_location_expr_complaint ();
15357 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
15359 stack
[++stacki
] = unsnd
;
15361 dwarf2_complex_location_expr_complaint ();
15365 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
15370 case DW_OP_const1u
:
15371 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
15375 case DW_OP_const1s
:
15376 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
15380 case DW_OP_const2u
:
15381 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
15385 case DW_OP_const2s
:
15386 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
15390 case DW_OP_const4u
:
15391 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
15395 case DW_OP_const4s
:
15396 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
15400 case DW_OP_const8u
:
15401 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
15406 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
15412 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
15417 stack
[stacki
+ 1] = stack
[stacki
];
15422 stack
[stacki
- 1] += stack
[stacki
];
15426 case DW_OP_plus_uconst
:
15427 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
15433 stack
[stacki
- 1] -= stack
[stacki
];
15438 /* If we're not the last op, then we definitely can't encode
15439 this using GDB's address_class enum. This is valid for partial
15440 global symbols, although the variable's address will be bogus
15443 dwarf2_complex_location_expr_complaint ();
15446 case DW_OP_GNU_push_tls_address
:
15447 /* The top of the stack has the offset from the beginning
15448 of the thread control block at which the variable is located. */
15449 /* Nothing should follow this operator, so the top of stack would
15451 /* This is valid for partial global symbols, but the variable's
15452 address will be bogus in the psymtab. Make it always at least
15453 non-zero to not look as a variable garbage collected by linker
15454 which have DW_OP_addr 0. */
15456 dwarf2_complex_location_expr_complaint ();
15460 case DW_OP_GNU_uninit
:
15463 case DW_OP_GNU_addr_index
:
15464 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
15471 const char *name
= get_DW_OP_name (op
);
15474 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
15477 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
15481 return (stack
[stacki
]);
15484 /* Enforce maximum stack depth of SIZE-1 to avoid writing
15485 outside of the allocated space. Also enforce minimum>0. */
15486 if (stacki
>= ARRAY_SIZE (stack
) - 1)
15488 complaint (&symfile_complaints
,
15489 _("location description stack overflow"));
15495 complaint (&symfile_complaints
,
15496 _("location description stack underflow"));
15500 return (stack
[stacki
]);
15503 /* memory allocation interface */
15505 static struct dwarf_block
*
15506 dwarf_alloc_block (struct dwarf2_cu
*cu
)
15508 struct dwarf_block
*blk
;
15510 blk
= (struct dwarf_block
*)
15511 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
15515 static struct abbrev_info
*
15516 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
15518 struct abbrev_info
*abbrev
;
15520 abbrev
= (struct abbrev_info
*)
15521 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
15522 memset (abbrev
, 0, sizeof (struct abbrev_info
));
15526 static struct die_info
*
15527 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
15529 struct die_info
*die
;
15530 size_t size
= sizeof (struct die_info
);
15533 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
15535 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
15536 memset (die
, 0, sizeof (struct die_info
));
15541 /* Macro support. */
15543 /* Return the full name of file number I in *LH's file name table.
15544 Use COMP_DIR as the name of the current directory of the
15545 compilation. The result is allocated using xmalloc; the caller is
15546 responsible for freeing it. */
15548 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
15550 /* Is the file number a valid index into the line header's file name
15551 table? Remember that file numbers start with one, not zero. */
15552 if (1 <= file
&& file
<= lh
->num_file_names
)
15554 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
15556 if (IS_ABSOLUTE_PATH (fe
->name
))
15557 return xstrdup (fe
->name
);
15565 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
15571 dir_len
= strlen (dir
);
15572 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
15573 strcpy (full_name
, dir
);
15574 full_name
[dir_len
] = '/';
15575 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
15579 return xstrdup (fe
->name
);
15584 /* The compiler produced a bogus file number. We can at least
15585 record the macro definitions made in the file, even if we
15586 won't be able to find the file by name. */
15587 char fake_name
[80];
15589 sprintf (fake_name
, "<bad macro file number %d>", file
);
15591 complaint (&symfile_complaints
,
15592 _("bad file number in macro information (%d)"),
15595 return xstrdup (fake_name
);
15600 static struct macro_source_file
*
15601 macro_start_file (int file
, int line
,
15602 struct macro_source_file
*current_file
,
15603 const char *comp_dir
,
15604 struct line_header
*lh
, struct objfile
*objfile
)
15606 /* The full name of this source file. */
15607 char *full_name
= file_full_name (file
, lh
, comp_dir
);
15609 /* We don't create a macro table for this compilation unit
15610 at all until we actually get a filename. */
15611 if (! pending_macros
)
15612 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
15613 objfile
->macro_cache
);
15615 if (! current_file
)
15617 /* If we have no current file, then this must be the start_file
15618 directive for the compilation unit's main source file. */
15619 current_file
= macro_set_main (pending_macros
, full_name
);
15620 macro_define_special (pending_macros
);
15623 current_file
= macro_include (current_file
, line
, full_name
);
15627 return current_file
;
15631 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
15632 followed by a null byte. */
15634 copy_string (const char *buf
, int len
)
15636 char *s
= xmalloc (len
+ 1);
15638 memcpy (s
, buf
, len
);
15644 static const char *
15645 consume_improper_spaces (const char *p
, const char *body
)
15649 complaint (&symfile_complaints
,
15650 _("macro definition contains spaces "
15651 "in formal argument list:\n`%s'"),
15663 parse_macro_definition (struct macro_source_file
*file
, int line
,
15668 /* The body string takes one of two forms. For object-like macro
15669 definitions, it should be:
15671 <macro name> " " <definition>
15673 For function-like macro definitions, it should be:
15675 <macro name> "() " <definition>
15677 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
15679 Spaces may appear only where explicitly indicated, and in the
15682 The Dwarf 2 spec says that an object-like macro's name is always
15683 followed by a space, but versions of GCC around March 2002 omit
15684 the space when the macro's definition is the empty string.
15686 The Dwarf 2 spec says that there should be no spaces between the
15687 formal arguments in a function-like macro's formal argument list,
15688 but versions of GCC around March 2002 include spaces after the
15692 /* Find the extent of the macro name. The macro name is terminated
15693 by either a space or null character (for an object-like macro) or
15694 an opening paren (for a function-like macro). */
15695 for (p
= body
; *p
; p
++)
15696 if (*p
== ' ' || *p
== '(')
15699 if (*p
== ' ' || *p
== '\0')
15701 /* It's an object-like macro. */
15702 int name_len
= p
- body
;
15703 char *name
= copy_string (body
, name_len
);
15704 const char *replacement
;
15707 replacement
= body
+ name_len
+ 1;
15710 dwarf2_macro_malformed_definition_complaint (body
);
15711 replacement
= body
+ name_len
;
15714 macro_define_object (file
, line
, name
, replacement
);
15718 else if (*p
== '(')
15720 /* It's a function-like macro. */
15721 char *name
= copy_string (body
, p
- body
);
15724 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
15728 p
= consume_improper_spaces (p
, body
);
15730 /* Parse the formal argument list. */
15731 while (*p
&& *p
!= ')')
15733 /* Find the extent of the current argument name. */
15734 const char *arg_start
= p
;
15736 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
15739 if (! *p
|| p
== arg_start
)
15740 dwarf2_macro_malformed_definition_complaint (body
);
15743 /* Make sure argv has room for the new argument. */
15744 if (argc
>= argv_size
)
15747 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
15750 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
15753 p
= consume_improper_spaces (p
, body
);
15755 /* Consume the comma, if present. */
15760 p
= consume_improper_spaces (p
, body
);
15769 /* Perfectly formed definition, no complaints. */
15770 macro_define_function (file
, line
, name
,
15771 argc
, (const char **) argv
,
15773 else if (*p
== '\0')
15775 /* Complain, but do define it. */
15776 dwarf2_macro_malformed_definition_complaint (body
);
15777 macro_define_function (file
, line
, name
,
15778 argc
, (const char **) argv
,
15782 /* Just complain. */
15783 dwarf2_macro_malformed_definition_complaint (body
);
15786 /* Just complain. */
15787 dwarf2_macro_malformed_definition_complaint (body
);
15793 for (i
= 0; i
< argc
; i
++)
15799 dwarf2_macro_malformed_definition_complaint (body
);
15802 /* Skip some bytes from BYTES according to the form given in FORM.
15803 Returns the new pointer. */
15806 skip_form_bytes (bfd
*abfd
, gdb_byte
*bytes
, gdb_byte
*buffer_end
,
15807 enum dwarf_form form
,
15808 unsigned int offset_size
,
15809 struct dwarf2_section_info
*section
)
15811 unsigned int bytes_read
;
15815 case DW_FORM_data1
:
15820 case DW_FORM_data2
:
15824 case DW_FORM_data4
:
15828 case DW_FORM_data8
:
15832 case DW_FORM_string
:
15833 read_direct_string (abfd
, bytes
, &bytes_read
);
15834 bytes
+= bytes_read
;
15837 case DW_FORM_sec_offset
:
15839 bytes
+= offset_size
;
15842 case DW_FORM_block
:
15843 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
15844 bytes
+= bytes_read
;
15847 case DW_FORM_block1
:
15848 bytes
+= 1 + read_1_byte (abfd
, bytes
);
15850 case DW_FORM_block2
:
15851 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
15853 case DW_FORM_block4
:
15854 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
15857 case DW_FORM_sdata
:
15858 case DW_FORM_udata
:
15859 case DW_FORM_GNU_addr_index
:
15860 case DW_FORM_GNU_str_index
:
15861 bytes
= (gdb_byte
*) gdb_skip_leb128 (bytes
, buffer_end
);
15864 dwarf2_section_buffer_overflow_complaint (section
);
15872 complaint (&symfile_complaints
,
15873 _("invalid form 0x%x in `%s'"),
15875 section
->asection
->name
);
15883 /* A helper for dwarf_decode_macros that handles skipping an unknown
15884 opcode. Returns an updated pointer to the macro data buffer; or,
15885 on error, issues a complaint and returns NULL. */
15888 skip_unknown_opcode (unsigned int opcode
,
15889 gdb_byte
**opcode_definitions
,
15890 gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
15892 unsigned int offset_size
,
15893 struct dwarf2_section_info
*section
)
15895 unsigned int bytes_read
, i
;
15899 if (opcode_definitions
[opcode
] == NULL
)
15901 complaint (&symfile_complaints
,
15902 _("unrecognized DW_MACFINO opcode 0x%x"),
15907 defn
= opcode_definitions
[opcode
];
15908 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
15909 defn
+= bytes_read
;
15911 for (i
= 0; i
< arg
; ++i
)
15913 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
, defn
[i
], offset_size
,
15915 if (mac_ptr
== NULL
)
15917 /* skip_form_bytes already issued the complaint. */
15925 /* A helper function which parses the header of a macro section.
15926 If the macro section is the extended (for now called "GNU") type,
15927 then this updates *OFFSET_SIZE. Returns a pointer to just after
15928 the header, or issues a complaint and returns NULL on error. */
15931 dwarf_parse_macro_header (gdb_byte
**opcode_definitions
,
15934 unsigned int *offset_size
,
15935 int section_is_gnu
)
15937 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
15939 if (section_is_gnu
)
15941 unsigned int version
, flags
;
15943 version
= read_2_bytes (abfd
, mac_ptr
);
15946 complaint (&symfile_complaints
,
15947 _("unrecognized version `%d' in .debug_macro section"),
15953 flags
= read_1_byte (abfd
, mac_ptr
);
15955 *offset_size
= (flags
& 1) ? 8 : 4;
15957 if ((flags
& 2) != 0)
15958 /* We don't need the line table offset. */
15959 mac_ptr
+= *offset_size
;
15961 /* Vendor opcode descriptions. */
15962 if ((flags
& 4) != 0)
15964 unsigned int i
, count
;
15966 count
= read_1_byte (abfd
, mac_ptr
);
15968 for (i
= 0; i
< count
; ++i
)
15970 unsigned int opcode
, bytes_read
;
15973 opcode
= read_1_byte (abfd
, mac_ptr
);
15975 opcode_definitions
[opcode
] = mac_ptr
;
15976 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15977 mac_ptr
+= bytes_read
;
15986 /* A helper for dwarf_decode_macros that handles the GNU extensions,
15987 including DW_MACRO_GNU_transparent_include. */
15990 dwarf_decode_macro_bytes (bfd
*abfd
, gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
15991 struct macro_source_file
*current_file
,
15992 struct line_header
*lh
, char *comp_dir
,
15993 struct dwarf2_section_info
*section
,
15994 int section_is_gnu
,
15995 unsigned int offset_size
,
15996 struct objfile
*objfile
,
15997 htab_t include_hash
)
15999 enum dwarf_macro_record_type macinfo_type
;
16000 int at_commandline
;
16001 gdb_byte
*opcode_definitions
[256];
16003 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
16004 &offset_size
, section_is_gnu
);
16005 if (mac_ptr
== NULL
)
16007 /* We already issued a complaint. */
16011 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
16012 GDB is still reading the definitions from command line. First
16013 DW_MACINFO_start_file will need to be ignored as it was already executed
16014 to create CURRENT_FILE for the main source holding also the command line
16015 definitions. On first met DW_MACINFO_start_file this flag is reset to
16016 normally execute all the remaining DW_MACINFO_start_file macinfos. */
16018 at_commandline
= 1;
16022 /* Do we at least have room for a macinfo type byte? */
16023 if (mac_ptr
>= mac_end
)
16025 dwarf2_section_buffer_overflow_complaint (section
);
16029 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
16032 /* Note that we rely on the fact that the corresponding GNU and
16033 DWARF constants are the same. */
16034 switch (macinfo_type
)
16036 /* A zero macinfo type indicates the end of the macro
16041 case DW_MACRO_GNU_define
:
16042 case DW_MACRO_GNU_undef
:
16043 case DW_MACRO_GNU_define_indirect
:
16044 case DW_MACRO_GNU_undef_indirect
:
16046 unsigned int bytes_read
;
16051 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
16052 mac_ptr
+= bytes_read
;
16054 if (macinfo_type
== DW_MACRO_GNU_define
16055 || macinfo_type
== DW_MACRO_GNU_undef
)
16057 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
16058 mac_ptr
+= bytes_read
;
16062 LONGEST str_offset
;
16064 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
16065 mac_ptr
+= offset_size
;
16067 body
= read_indirect_string_at_offset (abfd
, str_offset
);
16070 is_define
= (macinfo_type
== DW_MACRO_GNU_define
16071 || macinfo_type
== DW_MACRO_GNU_define_indirect
);
16072 if (! current_file
)
16074 /* DWARF violation as no main source is present. */
16075 complaint (&symfile_complaints
,
16076 _("debug info with no main source gives macro %s "
16078 is_define
? _("definition") : _("undefinition"),
16082 if ((line
== 0 && !at_commandline
)
16083 || (line
!= 0 && at_commandline
))
16084 complaint (&symfile_complaints
,
16085 _("debug info gives %s macro %s with %s line %d: %s"),
16086 at_commandline
? _("command-line") : _("in-file"),
16087 is_define
? _("definition") : _("undefinition"),
16088 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
16091 parse_macro_definition (current_file
, line
, body
);
16094 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
16095 || macinfo_type
== DW_MACRO_GNU_undef_indirect
);
16096 macro_undef (current_file
, line
, body
);
16101 case DW_MACRO_GNU_start_file
:
16103 unsigned int bytes_read
;
16106 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
16107 mac_ptr
+= bytes_read
;
16108 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
16109 mac_ptr
+= bytes_read
;
16111 if ((line
== 0 && !at_commandline
)
16112 || (line
!= 0 && at_commandline
))
16113 complaint (&symfile_complaints
,
16114 _("debug info gives source %d included "
16115 "from %s at %s line %d"),
16116 file
, at_commandline
? _("command-line") : _("file"),
16117 line
== 0 ? _("zero") : _("non-zero"), line
);
16119 if (at_commandline
)
16121 /* This DW_MACRO_GNU_start_file was executed in the
16123 at_commandline
= 0;
16126 current_file
= macro_start_file (file
, line
,
16127 current_file
, comp_dir
,
16132 case DW_MACRO_GNU_end_file
:
16133 if (! current_file
)
16134 complaint (&symfile_complaints
,
16135 _("macro debug info has an unmatched "
16136 "`close_file' directive"));
16139 current_file
= current_file
->included_by
;
16140 if (! current_file
)
16142 enum dwarf_macro_record_type next_type
;
16144 /* GCC circa March 2002 doesn't produce the zero
16145 type byte marking the end of the compilation
16146 unit. Complain if it's not there, but exit no
16149 /* Do we at least have room for a macinfo type byte? */
16150 if (mac_ptr
>= mac_end
)
16152 dwarf2_section_buffer_overflow_complaint (section
);
16156 /* We don't increment mac_ptr here, so this is just
16158 next_type
= read_1_byte (abfd
, mac_ptr
);
16159 if (next_type
!= 0)
16160 complaint (&symfile_complaints
,
16161 _("no terminating 0-type entry for "
16162 "macros in `.debug_macinfo' section"));
16169 case DW_MACRO_GNU_transparent_include
:
16174 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
16175 mac_ptr
+= offset_size
;
16177 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
16180 /* This has actually happened; see
16181 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
16182 complaint (&symfile_complaints
,
16183 _("recursive DW_MACRO_GNU_transparent_include in "
16184 ".debug_macro section"));
16190 dwarf_decode_macro_bytes (abfd
,
16191 section
->buffer
+ offset
,
16192 mac_end
, current_file
,
16194 section
, section_is_gnu
,
16195 offset_size
, objfile
, include_hash
);
16197 htab_remove_elt (include_hash
, mac_ptr
);
16202 case DW_MACINFO_vendor_ext
:
16203 if (!section_is_gnu
)
16205 unsigned int bytes_read
;
16208 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
16209 mac_ptr
+= bytes_read
;
16210 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
16211 mac_ptr
+= bytes_read
;
16213 /* We don't recognize any vendor extensions. */
16219 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
16220 mac_ptr
, mac_end
, abfd
, offset_size
,
16222 if (mac_ptr
== NULL
)
16226 } while (macinfo_type
!= 0);
16230 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
16231 char *comp_dir
, bfd
*abfd
,
16232 struct dwarf2_cu
*cu
,
16233 struct dwarf2_section_info
*section
,
16234 int section_is_gnu
, const char *section_name
)
16236 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16237 gdb_byte
*mac_ptr
, *mac_end
;
16238 struct macro_source_file
*current_file
= 0;
16239 enum dwarf_macro_record_type macinfo_type
;
16240 unsigned int offset_size
= cu
->header
.offset_size
;
16241 gdb_byte
*opcode_definitions
[256];
16242 struct cleanup
*cleanup
;
16243 htab_t include_hash
;
16246 dwarf2_read_section (objfile
, section
);
16247 if (section
->buffer
== NULL
)
16249 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
16253 /* First pass: Find the name of the base filename.
16254 This filename is needed in order to process all macros whose definition
16255 (or undefinition) comes from the command line. These macros are defined
16256 before the first DW_MACINFO_start_file entry, and yet still need to be
16257 associated to the base file.
16259 To determine the base file name, we scan the macro definitions until we
16260 reach the first DW_MACINFO_start_file entry. We then initialize
16261 CURRENT_FILE accordingly so that any macro definition found before the
16262 first DW_MACINFO_start_file can still be associated to the base file. */
16264 mac_ptr
= section
->buffer
+ offset
;
16265 mac_end
= section
->buffer
+ section
->size
;
16267 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
16268 &offset_size
, section_is_gnu
);
16269 if (mac_ptr
== NULL
)
16271 /* We already issued a complaint. */
16277 /* Do we at least have room for a macinfo type byte? */
16278 if (mac_ptr
>= mac_end
)
16280 /* Complaint is printed during the second pass as GDB will probably
16281 stop the first pass earlier upon finding
16282 DW_MACINFO_start_file. */
16286 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
16289 /* Note that we rely on the fact that the corresponding GNU and
16290 DWARF constants are the same. */
16291 switch (macinfo_type
)
16293 /* A zero macinfo type indicates the end of the macro
16298 case DW_MACRO_GNU_define
:
16299 case DW_MACRO_GNU_undef
:
16300 /* Only skip the data by MAC_PTR. */
16302 unsigned int bytes_read
;
16304 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
16305 mac_ptr
+= bytes_read
;
16306 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
16307 mac_ptr
+= bytes_read
;
16311 case DW_MACRO_GNU_start_file
:
16313 unsigned int bytes_read
;
16316 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
16317 mac_ptr
+= bytes_read
;
16318 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
16319 mac_ptr
+= bytes_read
;
16321 current_file
= macro_start_file (file
, line
, current_file
,
16322 comp_dir
, lh
, objfile
);
16326 case DW_MACRO_GNU_end_file
:
16327 /* No data to skip by MAC_PTR. */
16330 case DW_MACRO_GNU_define_indirect
:
16331 case DW_MACRO_GNU_undef_indirect
:
16333 unsigned int bytes_read
;
16335 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
16336 mac_ptr
+= bytes_read
;
16337 mac_ptr
+= offset_size
;
16341 case DW_MACRO_GNU_transparent_include
:
16342 /* Note that, according to the spec, a transparent include
16343 chain cannot call DW_MACRO_GNU_start_file. So, we can just
16344 skip this opcode. */
16345 mac_ptr
+= offset_size
;
16348 case DW_MACINFO_vendor_ext
:
16349 /* Only skip the data by MAC_PTR. */
16350 if (!section_is_gnu
)
16352 unsigned int bytes_read
;
16354 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
16355 mac_ptr
+= bytes_read
;
16356 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
16357 mac_ptr
+= bytes_read
;
16362 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
16363 mac_ptr
, mac_end
, abfd
, offset_size
,
16365 if (mac_ptr
== NULL
)
16369 } while (macinfo_type
!= 0 && current_file
== NULL
);
16371 /* Second pass: Process all entries.
16373 Use the AT_COMMAND_LINE flag to determine whether we are still processing
16374 command-line macro definitions/undefinitions. This flag is unset when we
16375 reach the first DW_MACINFO_start_file entry. */
16377 include_hash
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
16378 NULL
, xcalloc
, xfree
);
16379 cleanup
= make_cleanup_htab_delete (include_hash
);
16380 mac_ptr
= section
->buffer
+ offset
;
16381 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
16383 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
16384 current_file
, lh
, comp_dir
, section
, section_is_gnu
,
16385 offset_size
, objfile
, include_hash
);
16386 do_cleanups (cleanup
);
16389 /* Check if the attribute's form is a DW_FORM_block*
16390 if so return true else false. */
16393 attr_form_is_block (struct attribute
*attr
)
16395 return (attr
== NULL
? 0 :
16396 attr
->form
== DW_FORM_block1
16397 || attr
->form
== DW_FORM_block2
16398 || attr
->form
== DW_FORM_block4
16399 || attr
->form
== DW_FORM_block
16400 || attr
->form
== DW_FORM_exprloc
);
16403 /* Return non-zero if ATTR's value is a section offset --- classes
16404 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
16405 You may use DW_UNSND (attr) to retrieve such offsets.
16407 Section 7.5.4, "Attribute Encodings", explains that no attribute
16408 may have a value that belongs to more than one of these classes; it
16409 would be ambiguous if we did, because we use the same forms for all
16413 attr_form_is_section_offset (struct attribute
*attr
)
16415 return (attr
->form
== DW_FORM_data4
16416 || attr
->form
== DW_FORM_data8
16417 || attr
->form
== DW_FORM_sec_offset
);
16420 /* Return non-zero if ATTR's value falls in the 'constant' class, or
16421 zero otherwise. When this function returns true, you can apply
16422 dwarf2_get_attr_constant_value to it.
16424 However, note that for some attributes you must check
16425 attr_form_is_section_offset before using this test. DW_FORM_data4
16426 and DW_FORM_data8 are members of both the constant class, and of
16427 the classes that contain offsets into other debug sections
16428 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
16429 that, if an attribute's can be either a constant or one of the
16430 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
16431 taken as section offsets, not constants. */
16434 attr_form_is_constant (struct attribute
*attr
)
16436 switch (attr
->form
)
16438 case DW_FORM_sdata
:
16439 case DW_FORM_udata
:
16440 case DW_FORM_data1
:
16441 case DW_FORM_data2
:
16442 case DW_FORM_data4
:
16443 case DW_FORM_data8
:
16450 /* Return the .debug_loc section to use for CU.
16451 For DWO files use .debug_loc.dwo. */
16453 static struct dwarf2_section_info
*
16454 cu_debug_loc_section (struct dwarf2_cu
*cu
)
16457 return &cu
->dwo_unit
->dwo_file
->sections
.loc
;
16458 return &dwarf2_per_objfile
->loc
;
16461 /* A helper function that fills in a dwarf2_loclist_baton. */
16464 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
16465 struct dwarf2_loclist_baton
*baton
,
16466 struct attribute
*attr
)
16468 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
16470 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
16472 baton
->per_cu
= cu
->per_cu
;
16473 gdb_assert (baton
->per_cu
);
16474 /* We don't know how long the location list is, but make sure we
16475 don't run off the edge of the section. */
16476 baton
->size
= section
->size
- DW_UNSND (attr
);
16477 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
16478 baton
->base_address
= cu
->base_address
;
16479 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
16483 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
16484 struct dwarf2_cu
*cu
)
16486 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16487 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
16489 if (attr_form_is_section_offset (attr
)
16490 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
16491 the section. If so, fall through to the complaint in the
16493 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
16495 struct dwarf2_loclist_baton
*baton
;
16497 baton
= obstack_alloc (&objfile
->objfile_obstack
,
16498 sizeof (struct dwarf2_loclist_baton
));
16500 fill_in_loclist_baton (cu
, baton
, attr
);
16502 if (cu
->base_known
== 0)
16503 complaint (&symfile_complaints
,
16504 _("Location list used without "
16505 "specifying the CU base address."));
16507 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
16508 SYMBOL_LOCATION_BATON (sym
) = baton
;
16512 struct dwarf2_locexpr_baton
*baton
;
16514 baton
= obstack_alloc (&objfile
->objfile_obstack
,
16515 sizeof (struct dwarf2_locexpr_baton
));
16516 baton
->per_cu
= cu
->per_cu
;
16517 gdb_assert (baton
->per_cu
);
16519 if (attr_form_is_block (attr
))
16521 /* Note that we're just copying the block's data pointer
16522 here, not the actual data. We're still pointing into the
16523 info_buffer for SYM's objfile; right now we never release
16524 that buffer, but when we do clean up properly this may
16526 baton
->size
= DW_BLOCK (attr
)->size
;
16527 baton
->data
= DW_BLOCK (attr
)->data
;
16531 dwarf2_invalid_attrib_class_complaint ("location description",
16532 SYMBOL_NATURAL_NAME (sym
));
16536 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
16537 SYMBOL_LOCATION_BATON (sym
) = baton
;
16541 /* Return the OBJFILE associated with the compilation unit CU. If CU
16542 came from a separate debuginfo file, then the master objfile is
16546 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
16548 struct objfile
*objfile
= per_cu
->objfile
;
16550 /* Return the master objfile, so that we can report and look up the
16551 correct file containing this variable. */
16552 if (objfile
->separate_debug_objfile_backlink
)
16553 objfile
= objfile
->separate_debug_objfile_backlink
;
16558 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
16559 (CU_HEADERP is unused in such case) or prepare a temporary copy at
16560 CU_HEADERP first. */
16562 static const struct comp_unit_head
*
16563 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
16564 struct dwarf2_per_cu_data
*per_cu
)
16566 struct objfile
*objfile
;
16567 struct dwarf2_per_objfile
*per_objfile
;
16568 gdb_byte
*info_ptr
;
16571 return &per_cu
->cu
->header
;
16573 objfile
= per_cu
->objfile
;
16574 per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
16575 info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
.sect_off
;
16577 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
16578 read_comp_unit_head (cu_headerp
, info_ptr
, objfile
->obfd
);
16583 /* Return the address size given in the compilation unit header for CU. */
16586 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
16588 struct comp_unit_head cu_header_local
;
16589 const struct comp_unit_head
*cu_headerp
;
16591 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
16593 return cu_headerp
->addr_size
;
16596 /* Return the offset size given in the compilation unit header for CU. */
16599 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
16601 struct comp_unit_head cu_header_local
;
16602 const struct comp_unit_head
*cu_headerp
;
16604 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
16606 return cu_headerp
->offset_size
;
16609 /* See its dwarf2loc.h declaration. */
16612 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
16614 struct comp_unit_head cu_header_local
;
16615 const struct comp_unit_head
*cu_headerp
;
16617 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
16619 if (cu_headerp
->version
== 2)
16620 return cu_headerp
->addr_size
;
16622 return cu_headerp
->offset_size
;
16625 /* Return the text offset of the CU. The returned offset comes from
16626 this CU's objfile. If this objfile came from a separate debuginfo
16627 file, then the offset may be different from the corresponding
16628 offset in the parent objfile. */
16631 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
16633 struct objfile
*objfile
= per_cu
->objfile
;
16635 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
16638 /* Locate the .debug_info compilation unit from CU's objfile which contains
16639 the DIE at OFFSET. Raises an error on failure. */
16641 static struct dwarf2_per_cu_data
*
16642 dwarf2_find_containing_comp_unit (sect_offset offset
,
16643 struct objfile
*objfile
)
16645 struct dwarf2_per_cu_data
*this_cu
;
16649 high
= dwarf2_per_objfile
->n_comp_units
- 1;
16652 int mid
= low
+ (high
- low
) / 2;
16654 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
.sect_off
16655 >= offset
.sect_off
)
16660 gdb_assert (low
== high
);
16661 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
.sect_off
16665 error (_("Dwarf Error: could not find partial DIE containing "
16666 "offset 0x%lx [in module %s]"),
16667 (long) offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
16669 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
.sect_off
16670 <= offset
.sect_off
);
16671 return dwarf2_per_objfile
->all_comp_units
[low
-1];
16675 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
16676 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
16677 && offset
.sect_off
>= this_cu
->offset
.sect_off
+ this_cu
->length
)
16678 error (_("invalid dwarf2 offset %u"), offset
.sect_off
);
16679 gdb_assert (offset
.sect_off
< this_cu
->offset
.sect_off
+ this_cu
->length
);
16684 /* Initialize dwarf2_cu CU, owned by PER_CU. */
16687 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
16689 memset (cu
, 0, sizeof (*cu
));
16691 cu
->per_cu
= per_cu
;
16692 cu
->objfile
= per_cu
->objfile
;
16693 obstack_init (&cu
->comp_unit_obstack
);
16696 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
16699 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
16700 enum language pretend_language
)
16702 struct attribute
*attr
;
16704 /* Set the language we're debugging. */
16705 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
16707 set_cu_language (DW_UNSND (attr
), cu
);
16710 cu
->language
= pretend_language
;
16711 cu
->language_defn
= language_def (cu
->language
);
16714 attr
= dwarf2_attr (comp_unit_die
, DW_AT_producer
, cu
);
16716 cu
->producer
= DW_STRING (attr
);
16719 /* Release one cached compilation unit, CU. We unlink it from the tree
16720 of compilation units, but we don't remove it from the read_in_chain;
16721 the caller is responsible for that.
16722 NOTE: DATA is a void * because this function is also used as a
16723 cleanup routine. */
16726 free_heap_comp_unit (void *data
)
16728 struct dwarf2_cu
*cu
= data
;
16730 gdb_assert (cu
->per_cu
!= NULL
);
16731 cu
->per_cu
->cu
= NULL
;
16734 obstack_free (&cu
->comp_unit_obstack
, NULL
);
16739 /* This cleanup function is passed the address of a dwarf2_cu on the stack
16740 when we're finished with it. We can't free the pointer itself, but be
16741 sure to unlink it from the cache. Also release any associated storage. */
16744 free_stack_comp_unit (void *data
)
16746 struct dwarf2_cu
*cu
= data
;
16748 gdb_assert (cu
->per_cu
!= NULL
);
16749 cu
->per_cu
->cu
= NULL
;
16752 obstack_free (&cu
->comp_unit_obstack
, NULL
);
16753 cu
->partial_dies
= NULL
;
16756 /* Free all cached compilation units. */
16759 free_cached_comp_units (void *data
)
16761 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
16763 per_cu
= dwarf2_per_objfile
->read_in_chain
;
16764 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
16765 while (per_cu
!= NULL
)
16767 struct dwarf2_per_cu_data
*next_cu
;
16769 next_cu
= per_cu
->cu
->read_in_chain
;
16771 free_heap_comp_unit (per_cu
->cu
);
16772 *last_chain
= next_cu
;
16778 /* Increase the age counter on each cached compilation unit, and free
16779 any that are too old. */
16782 age_cached_comp_units (void)
16784 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
16786 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
16787 per_cu
= dwarf2_per_objfile
->read_in_chain
;
16788 while (per_cu
!= NULL
)
16790 per_cu
->cu
->last_used
++;
16791 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
16792 dwarf2_mark (per_cu
->cu
);
16793 per_cu
= per_cu
->cu
->read_in_chain
;
16796 per_cu
= dwarf2_per_objfile
->read_in_chain
;
16797 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
16798 while (per_cu
!= NULL
)
16800 struct dwarf2_per_cu_data
*next_cu
;
16802 next_cu
= per_cu
->cu
->read_in_chain
;
16804 if (!per_cu
->cu
->mark
)
16806 free_heap_comp_unit (per_cu
->cu
);
16807 *last_chain
= next_cu
;
16810 last_chain
= &per_cu
->cu
->read_in_chain
;
16816 /* Remove a single compilation unit from the cache. */
16819 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
16821 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
16823 per_cu
= dwarf2_per_objfile
->read_in_chain
;
16824 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
16825 while (per_cu
!= NULL
)
16827 struct dwarf2_per_cu_data
*next_cu
;
16829 next_cu
= per_cu
->cu
->read_in_chain
;
16831 if (per_cu
== target_per_cu
)
16833 free_heap_comp_unit (per_cu
->cu
);
16835 *last_chain
= next_cu
;
16839 last_chain
= &per_cu
->cu
->read_in_chain
;
16845 /* Release all extra memory associated with OBJFILE. */
16848 dwarf2_free_objfile (struct objfile
*objfile
)
16850 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
16852 if (dwarf2_per_objfile
== NULL
)
16855 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
16856 free_cached_comp_units (NULL
);
16858 if (dwarf2_per_objfile
->quick_file_names_table
)
16859 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
16861 /* Everything else should be on the objfile obstack. */
16864 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
16865 We store these in a hash table separate from the DIEs, and preserve them
16866 when the DIEs are flushed out of cache.
16868 The CU "per_cu" pointer is needed because offset alone is not enough to
16869 uniquely identify the type. A file may have multiple .debug_types sections,
16870 or the type may come from a DWO file. We have to use something in
16871 dwarf2_per_cu_data (or the pointer to it) because we can enter the lookup
16872 routine, get_die_type_at_offset, from outside this file, and thus won't
16873 necessarily have PER_CU->cu. Fortunately, PER_CU is stable for the life
16876 struct dwarf2_per_cu_offset_and_type
16878 const struct dwarf2_per_cu_data
*per_cu
;
16879 sect_offset offset
;
16883 /* Hash function for a dwarf2_per_cu_offset_and_type. */
16886 per_cu_offset_and_type_hash (const void *item
)
16888 const struct dwarf2_per_cu_offset_and_type
*ofs
= item
;
16890 return (uintptr_t) ofs
->per_cu
+ ofs
->offset
.sect_off
;
16893 /* Equality function for a dwarf2_per_cu_offset_and_type. */
16896 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
16898 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
= item_lhs
;
16899 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
= item_rhs
;
16901 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
16902 && ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
);
16905 /* Set the type associated with DIE to TYPE. Save it in CU's hash
16906 table if necessary. For convenience, return TYPE.
16908 The DIEs reading must have careful ordering to:
16909 * Not cause infite loops trying to read in DIEs as a prerequisite for
16910 reading current DIE.
16911 * Not trying to dereference contents of still incompletely read in types
16912 while reading in other DIEs.
16913 * Enable referencing still incompletely read in types just by a pointer to
16914 the type without accessing its fields.
16916 Therefore caller should follow these rules:
16917 * Try to fetch any prerequisite types we may need to build this DIE type
16918 before building the type and calling set_die_type.
16919 * After building type call set_die_type for current DIE as soon as
16920 possible before fetching more types to complete the current type.
16921 * Make the type as complete as possible before fetching more types. */
16923 static struct type
*
16924 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
16926 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
16927 struct objfile
*objfile
= cu
->objfile
;
16929 /* For Ada types, make sure that the gnat-specific data is always
16930 initialized (if not already set). There are a few types where
16931 we should not be doing so, because the type-specific area is
16932 already used to hold some other piece of info (eg: TYPE_CODE_FLT
16933 where the type-specific area is used to store the floatformat).
16934 But this is not a problem, because the gnat-specific information
16935 is actually not needed for these types. */
16936 if (need_gnat_info (cu
)
16937 && TYPE_CODE (type
) != TYPE_CODE_FUNC
16938 && TYPE_CODE (type
) != TYPE_CODE_FLT
16939 && !HAVE_GNAT_AUX_INFO (type
))
16940 INIT_GNAT_SPECIFIC (type
);
16942 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
16944 dwarf2_per_objfile
->die_type_hash
=
16945 htab_create_alloc_ex (127,
16946 per_cu_offset_and_type_hash
,
16947 per_cu_offset_and_type_eq
,
16949 &objfile
->objfile_obstack
,
16950 hashtab_obstack_allocate
,
16951 dummy_obstack_deallocate
);
16954 ofs
.per_cu
= cu
->per_cu
;
16955 ofs
.offset
= die
->offset
;
16957 slot
= (struct dwarf2_per_cu_offset_and_type
**)
16958 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
16960 complaint (&symfile_complaints
,
16961 _("A problem internal to GDB: DIE 0x%x has type already set"),
16962 die
->offset
.sect_off
);
16963 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
16968 /* Look up the type for the die at OFFSET in the appropriate type_hash
16969 table, or return NULL if the die does not have a saved type. */
16971 static struct type
*
16972 get_die_type_at_offset (sect_offset offset
,
16973 struct dwarf2_per_cu_data
*per_cu
)
16975 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
16977 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
16980 ofs
.per_cu
= per_cu
;
16981 ofs
.offset
= offset
;
16982 slot
= htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
);
16989 /* Look up the type for DIE in the appropriate type_hash table,
16990 or return NULL if DIE does not have a saved type. */
16992 static struct type
*
16993 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16995 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
16998 /* Add a dependence relationship from CU to REF_PER_CU. */
17001 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
17002 struct dwarf2_per_cu_data
*ref_per_cu
)
17006 if (cu
->dependencies
== NULL
)
17008 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
17009 NULL
, &cu
->comp_unit_obstack
,
17010 hashtab_obstack_allocate
,
17011 dummy_obstack_deallocate
);
17013 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
17015 *slot
= ref_per_cu
;
17018 /* Subroutine of dwarf2_mark to pass to htab_traverse.
17019 Set the mark field in every compilation unit in the
17020 cache that we must keep because we are keeping CU. */
17023 dwarf2_mark_helper (void **slot
, void *data
)
17025 struct dwarf2_per_cu_data
*per_cu
;
17027 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
17029 /* cu->dependencies references may not yet have been ever read if QUIT aborts
17030 reading of the chain. As such dependencies remain valid it is not much
17031 useful to track and undo them during QUIT cleanups. */
17032 if (per_cu
->cu
== NULL
)
17035 if (per_cu
->cu
->mark
)
17037 per_cu
->cu
->mark
= 1;
17039 if (per_cu
->cu
->dependencies
!= NULL
)
17040 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
17045 /* Set the mark field in CU and in every other compilation unit in the
17046 cache that we must keep because we are keeping CU. */
17049 dwarf2_mark (struct dwarf2_cu
*cu
)
17054 if (cu
->dependencies
!= NULL
)
17055 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
17059 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
17063 per_cu
->cu
->mark
= 0;
17064 per_cu
= per_cu
->cu
->read_in_chain
;
17068 /* Trivial hash function for partial_die_info: the hash value of a DIE
17069 is its offset in .debug_info for this objfile. */
17072 partial_die_hash (const void *item
)
17074 const struct partial_die_info
*part_die
= item
;
17076 return part_die
->offset
.sect_off
;
17079 /* Trivial comparison function for partial_die_info structures: two DIEs
17080 are equal if they have the same offset. */
17083 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
17085 const struct partial_die_info
*part_die_lhs
= item_lhs
;
17086 const struct partial_die_info
*part_die_rhs
= item_rhs
;
17088 return part_die_lhs
->offset
.sect_off
== part_die_rhs
->offset
.sect_off
;
17091 static struct cmd_list_element
*set_dwarf2_cmdlist
;
17092 static struct cmd_list_element
*show_dwarf2_cmdlist
;
17095 set_dwarf2_cmd (char *args
, int from_tty
)
17097 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
17101 show_dwarf2_cmd (char *args
, int from_tty
)
17103 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
17106 /* If section described by INFO was mmapped, munmap it now. */
17109 munmap_section_buffer (struct dwarf2_section_info
*info
)
17111 if (info
->map_addr
!= NULL
)
17116 res
= munmap (info
->map_addr
, info
->map_len
);
17117 gdb_assert (res
== 0);
17119 /* Without HAVE_MMAP, we should never be here to begin with. */
17120 gdb_assert_not_reached ("no mmap support");
17125 /* munmap debug sections for OBJFILE, if necessary. */
17128 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
17130 struct dwarf2_per_objfile
*data
= d
;
17132 struct dwarf2_section_info
*section
;
17134 /* This is sorted according to the order they're defined in to make it easier
17135 to keep in sync. */
17136 munmap_section_buffer (&data
->info
);
17137 munmap_section_buffer (&data
->abbrev
);
17138 munmap_section_buffer (&data
->line
);
17139 munmap_section_buffer (&data
->loc
);
17140 munmap_section_buffer (&data
->macinfo
);
17141 munmap_section_buffer (&data
->macro
);
17142 munmap_section_buffer (&data
->str
);
17143 munmap_section_buffer (&data
->ranges
);
17144 munmap_section_buffer (&data
->addr
);
17145 munmap_section_buffer (&data
->frame
);
17146 munmap_section_buffer (&data
->eh_frame
);
17147 munmap_section_buffer (&data
->gdb_index
);
17150 VEC_iterate (dwarf2_section_info_def
, data
->types
, ix
, section
);
17152 munmap_section_buffer (section
);
17154 for (ix
= 0; ix
< dwarf2_per_objfile
->n_comp_units
; ++ix
)
17155 VEC_free (dwarf2_per_cu_ptr
,
17156 dwarf2_per_objfile
->all_comp_units
[ix
]->imported_symtabs
);
17158 VEC_free (dwarf2_section_info_def
, data
->types
);
17160 if (data
->dwo_files
)
17161 free_dwo_files (data
->dwo_files
, objfile
);
17165 /* The "save gdb-index" command. */
17167 /* The contents of the hash table we create when building the string
17169 struct strtab_entry
17171 offset_type offset
;
17175 /* Hash function for a strtab_entry.
17177 Function is used only during write_hash_table so no index format backward
17178 compatibility is needed. */
17181 hash_strtab_entry (const void *e
)
17183 const struct strtab_entry
*entry
= e
;
17184 return mapped_index_string_hash (INT_MAX
, entry
->str
);
17187 /* Equality function for a strtab_entry. */
17190 eq_strtab_entry (const void *a
, const void *b
)
17192 const struct strtab_entry
*ea
= a
;
17193 const struct strtab_entry
*eb
= b
;
17194 return !strcmp (ea
->str
, eb
->str
);
17197 /* Create a strtab_entry hash table. */
17200 create_strtab (void)
17202 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
17203 xfree
, xcalloc
, xfree
);
17206 /* Add a string to the constant pool. Return the string's offset in
17210 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
17213 struct strtab_entry entry
;
17214 struct strtab_entry
*result
;
17217 slot
= htab_find_slot (table
, &entry
, INSERT
);
17222 result
= XNEW (struct strtab_entry
);
17223 result
->offset
= obstack_object_size (cpool
);
17225 obstack_grow_str0 (cpool
, str
);
17228 return result
->offset
;
17231 /* An entry in the symbol table. */
17232 struct symtab_index_entry
17234 /* The name of the symbol. */
17236 /* The offset of the name in the constant pool. */
17237 offset_type index_offset
;
17238 /* A sorted vector of the indices of all the CUs that hold an object
17240 VEC (offset_type
) *cu_indices
;
17243 /* The symbol table. This is a power-of-2-sized hash table. */
17244 struct mapped_symtab
17246 offset_type n_elements
;
17248 struct symtab_index_entry
**data
;
17251 /* Hash function for a symtab_index_entry. */
17254 hash_symtab_entry (const void *e
)
17256 const struct symtab_index_entry
*entry
= e
;
17257 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
17258 sizeof (offset_type
) * VEC_length (offset_type
,
17259 entry
->cu_indices
),
17263 /* Equality function for a symtab_index_entry. */
17266 eq_symtab_entry (const void *a
, const void *b
)
17268 const struct symtab_index_entry
*ea
= a
;
17269 const struct symtab_index_entry
*eb
= b
;
17270 int len
= VEC_length (offset_type
, ea
->cu_indices
);
17271 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
17273 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
17274 VEC_address (offset_type
, eb
->cu_indices
),
17275 sizeof (offset_type
) * len
);
17278 /* Destroy a symtab_index_entry. */
17281 delete_symtab_entry (void *p
)
17283 struct symtab_index_entry
*entry
= p
;
17284 VEC_free (offset_type
, entry
->cu_indices
);
17288 /* Create a hash table holding symtab_index_entry objects. */
17291 create_symbol_hash_table (void)
17293 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
17294 delete_symtab_entry
, xcalloc
, xfree
);
17297 /* Create a new mapped symtab object. */
17299 static struct mapped_symtab
*
17300 create_mapped_symtab (void)
17302 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
17303 symtab
->n_elements
= 0;
17304 symtab
->size
= 1024;
17305 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
17309 /* Destroy a mapped_symtab. */
17312 cleanup_mapped_symtab (void *p
)
17314 struct mapped_symtab
*symtab
= p
;
17315 /* The contents of the array are freed when the other hash table is
17317 xfree (symtab
->data
);
17321 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
17324 Function is used only during write_hash_table so no index format backward
17325 compatibility is needed. */
17327 static struct symtab_index_entry
**
17328 find_slot (struct mapped_symtab
*symtab
, const char *name
)
17330 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
17332 index
= hash
& (symtab
->size
- 1);
17333 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
17337 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
17338 return &symtab
->data
[index
];
17339 index
= (index
+ step
) & (symtab
->size
- 1);
17343 /* Expand SYMTAB's hash table. */
17346 hash_expand (struct mapped_symtab
*symtab
)
17348 offset_type old_size
= symtab
->size
;
17350 struct symtab_index_entry
**old_entries
= symtab
->data
;
17353 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
17355 for (i
= 0; i
< old_size
; ++i
)
17357 if (old_entries
[i
])
17359 struct symtab_index_entry
**slot
= find_slot (symtab
,
17360 old_entries
[i
]->name
);
17361 *slot
= old_entries
[i
];
17365 xfree (old_entries
);
17368 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
17369 is the index of the CU in which the symbol appears. */
17372 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
17373 offset_type cu_index
)
17375 struct symtab_index_entry
**slot
;
17377 ++symtab
->n_elements
;
17378 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
17379 hash_expand (symtab
);
17381 slot
= find_slot (symtab
, name
);
17384 *slot
= XNEW (struct symtab_index_entry
);
17385 (*slot
)->name
= name
;
17386 (*slot
)->cu_indices
= NULL
;
17388 /* Don't push an index twice. Due to how we add entries we only
17389 have to check the last one. */
17390 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
17391 || VEC_last (offset_type
, (*slot
)->cu_indices
) != cu_index
)
17392 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
17395 /* Add a vector of indices to the constant pool. */
17398 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
17399 struct symtab_index_entry
*entry
)
17403 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
17406 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
17407 offset_type val
= MAYBE_SWAP (len
);
17412 entry
->index_offset
= obstack_object_size (cpool
);
17414 obstack_grow (cpool
, &val
, sizeof (val
));
17416 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
17419 val
= MAYBE_SWAP (iter
);
17420 obstack_grow (cpool
, &val
, sizeof (val
));
17425 struct symtab_index_entry
*old_entry
= *slot
;
17426 entry
->index_offset
= old_entry
->index_offset
;
17429 return entry
->index_offset
;
17432 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
17433 constant pool entries going into the obstack CPOOL. */
17436 write_hash_table (struct mapped_symtab
*symtab
,
17437 struct obstack
*output
, struct obstack
*cpool
)
17440 htab_t symbol_hash_table
;
17443 symbol_hash_table
= create_symbol_hash_table ();
17444 str_table
= create_strtab ();
17446 /* We add all the index vectors to the constant pool first, to
17447 ensure alignment is ok. */
17448 for (i
= 0; i
< symtab
->size
; ++i
)
17450 if (symtab
->data
[i
])
17451 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
17454 /* Now write out the hash table. */
17455 for (i
= 0; i
< symtab
->size
; ++i
)
17457 offset_type str_off
, vec_off
;
17459 if (symtab
->data
[i
])
17461 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
17462 vec_off
= symtab
->data
[i
]->index_offset
;
17466 /* While 0 is a valid constant pool index, it is not valid
17467 to have 0 for both offsets. */
17472 str_off
= MAYBE_SWAP (str_off
);
17473 vec_off
= MAYBE_SWAP (vec_off
);
17475 obstack_grow (output
, &str_off
, sizeof (str_off
));
17476 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
17479 htab_delete (str_table
);
17480 htab_delete (symbol_hash_table
);
17483 /* Struct to map psymtab to CU index in the index file. */
17484 struct psymtab_cu_index_map
17486 struct partial_symtab
*psymtab
;
17487 unsigned int cu_index
;
17491 hash_psymtab_cu_index (const void *item
)
17493 const struct psymtab_cu_index_map
*map
= item
;
17495 return htab_hash_pointer (map
->psymtab
);
17499 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
17501 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
17502 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
17504 return lhs
->psymtab
== rhs
->psymtab
;
17507 /* Helper struct for building the address table. */
17508 struct addrmap_index_data
17510 struct objfile
*objfile
;
17511 struct obstack
*addr_obstack
;
17512 htab_t cu_index_htab
;
17514 /* Non-zero if the previous_* fields are valid.
17515 We can't write an entry until we see the next entry (since it is only then
17516 that we know the end of the entry). */
17517 int previous_valid
;
17518 /* Index of the CU in the table of all CUs in the index file. */
17519 unsigned int previous_cu_index
;
17520 /* Start address of the CU. */
17521 CORE_ADDR previous_cu_start
;
17524 /* Write an address entry to OBSTACK. */
17527 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
17528 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
17530 offset_type cu_index_to_write
;
17532 CORE_ADDR baseaddr
;
17534 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
17536 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
17537 obstack_grow (obstack
, addr
, 8);
17538 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
17539 obstack_grow (obstack
, addr
, 8);
17540 cu_index_to_write
= MAYBE_SWAP (cu_index
);
17541 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
17544 /* Worker function for traversing an addrmap to build the address table. */
17547 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
17549 struct addrmap_index_data
*data
= datap
;
17550 struct partial_symtab
*pst
= obj
;
17552 if (data
->previous_valid
)
17553 add_address_entry (data
->objfile
, data
->addr_obstack
,
17554 data
->previous_cu_start
, start_addr
,
17555 data
->previous_cu_index
);
17557 data
->previous_cu_start
= start_addr
;
17560 struct psymtab_cu_index_map find_map
, *map
;
17561 find_map
.psymtab
= pst
;
17562 map
= htab_find (data
->cu_index_htab
, &find_map
);
17563 gdb_assert (map
!= NULL
);
17564 data
->previous_cu_index
= map
->cu_index
;
17565 data
->previous_valid
= 1;
17568 data
->previous_valid
= 0;
17573 /* Write OBJFILE's address map to OBSTACK.
17574 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
17575 in the index file. */
17578 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
17579 htab_t cu_index_htab
)
17581 struct addrmap_index_data addrmap_index_data
;
17583 /* When writing the address table, we have to cope with the fact that
17584 the addrmap iterator only provides the start of a region; we have to
17585 wait until the next invocation to get the start of the next region. */
17587 addrmap_index_data
.objfile
= objfile
;
17588 addrmap_index_data
.addr_obstack
= obstack
;
17589 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
17590 addrmap_index_data
.previous_valid
= 0;
17592 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
17593 &addrmap_index_data
);
17595 /* It's highly unlikely the last entry (end address = 0xff...ff)
17596 is valid, but we should still handle it.
17597 The end address is recorded as the start of the next region, but that
17598 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
17600 if (addrmap_index_data
.previous_valid
)
17601 add_address_entry (objfile
, obstack
,
17602 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
17603 addrmap_index_data
.previous_cu_index
);
17606 /* Add a list of partial symbols to SYMTAB. */
17609 write_psymbols (struct mapped_symtab
*symtab
,
17611 struct partial_symbol
**psymp
,
17613 offset_type cu_index
,
17616 for (; count
-- > 0; ++psymp
)
17618 void **slot
, *lookup
;
17620 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
17621 error (_("Ada is not currently supported by the index"));
17623 /* We only want to add a given psymbol once. However, we also
17624 want to account for whether it is global or static. So, we
17625 may add it twice, using slightly different values. */
17628 uintptr_t val
= 1 | (uintptr_t) *psymp
;
17630 lookup
= (void *) val
;
17635 /* Only add a given psymbol once. */
17636 slot
= htab_find_slot (psyms_seen
, lookup
, INSERT
);
17640 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (*psymp
), cu_index
);
17645 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
17646 exception if there is an error. */
17649 write_obstack (FILE *file
, struct obstack
*obstack
)
17651 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
17653 != obstack_object_size (obstack
))
17654 error (_("couldn't data write to file"));
17657 /* Unlink a file if the argument is not NULL. */
17660 unlink_if_set (void *p
)
17662 char **filename
= p
;
17664 unlink (*filename
);
17667 /* A helper struct used when iterating over debug_types. */
17668 struct signatured_type_index_data
17670 struct objfile
*objfile
;
17671 struct mapped_symtab
*symtab
;
17672 struct obstack
*types_list
;
17677 /* A helper function that writes a single signatured_type to an
17681 write_one_signatured_type (void **slot
, void *d
)
17683 struct signatured_type_index_data
*info
= d
;
17684 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
17685 struct dwarf2_per_cu_data
*per_cu
= &entry
->per_cu
;
17686 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
17689 write_psymbols (info
->symtab
,
17691 info
->objfile
->global_psymbols
.list
17692 + psymtab
->globals_offset
,
17693 psymtab
->n_global_syms
, info
->cu_index
,
17695 write_psymbols (info
->symtab
,
17697 info
->objfile
->static_psymbols
.list
17698 + psymtab
->statics_offset
,
17699 psymtab
->n_static_syms
, info
->cu_index
,
17702 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
17703 entry
->per_cu
.offset
.sect_off
);
17704 obstack_grow (info
->types_list
, val
, 8);
17705 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
17706 entry
->type_offset_in_tu
.cu_off
);
17707 obstack_grow (info
->types_list
, val
, 8);
17708 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
17709 obstack_grow (info
->types_list
, val
, 8);
17716 /* Recurse into all "included" dependencies and write their symbols as
17717 if they appeared in this psymtab. */
17720 recursively_write_psymbols (struct objfile
*objfile
,
17721 struct partial_symtab
*psymtab
,
17722 struct mapped_symtab
*symtab
,
17724 offset_type cu_index
)
17728 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
17729 if (psymtab
->dependencies
[i
]->user
!= NULL
)
17730 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
17731 symtab
, psyms_seen
, cu_index
);
17733 write_psymbols (symtab
,
17735 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
17736 psymtab
->n_global_syms
, cu_index
,
17738 write_psymbols (symtab
,
17740 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
17741 psymtab
->n_static_syms
, cu_index
,
17745 /* Create an index file for OBJFILE in the directory DIR. */
17748 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
17750 struct cleanup
*cleanup
;
17751 char *filename
, *cleanup_filename
;
17752 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
17753 struct obstack cu_list
, types_cu_list
;
17756 struct mapped_symtab
*symtab
;
17757 offset_type val
, size_of_contents
, total_len
;
17760 htab_t cu_index_htab
;
17761 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
17763 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
17766 if (dwarf2_per_objfile
->using_index
)
17767 error (_("Cannot use an index to create the index"));
17769 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
17770 error (_("Cannot make an index when the file has multiple .debug_types sections"));
17772 if (stat (objfile
->name
, &st
) < 0)
17773 perror_with_name (objfile
->name
);
17775 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
17776 INDEX_SUFFIX
, (char *) NULL
);
17777 cleanup
= make_cleanup (xfree
, filename
);
17779 out_file
= fopen (filename
, "wb");
17781 error (_("Can't open `%s' for writing"), filename
);
17783 cleanup_filename
= filename
;
17784 make_cleanup (unlink_if_set
, &cleanup_filename
);
17786 symtab
= create_mapped_symtab ();
17787 make_cleanup (cleanup_mapped_symtab
, symtab
);
17789 obstack_init (&addr_obstack
);
17790 make_cleanup_obstack_free (&addr_obstack
);
17792 obstack_init (&cu_list
);
17793 make_cleanup_obstack_free (&cu_list
);
17795 obstack_init (&types_cu_list
);
17796 make_cleanup_obstack_free (&types_cu_list
);
17798 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
17799 NULL
, xcalloc
, xfree
);
17800 make_cleanup_htab_delete (psyms_seen
);
17802 /* While we're scanning CU's create a table that maps a psymtab pointer
17803 (which is what addrmap records) to its index (which is what is recorded
17804 in the index file). This will later be needed to write the address
17806 cu_index_htab
= htab_create_alloc (100,
17807 hash_psymtab_cu_index
,
17808 eq_psymtab_cu_index
,
17809 NULL
, xcalloc
, xfree
);
17810 make_cleanup_htab_delete (cu_index_htab
);
17811 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
17812 xmalloc (sizeof (struct psymtab_cu_index_map
)
17813 * dwarf2_per_objfile
->n_comp_units
);
17814 make_cleanup (xfree
, psymtab_cu_index_map
);
17816 /* The CU list is already sorted, so we don't need to do additional
17817 work here. Also, the debug_types entries do not appear in
17818 all_comp_units, but only in their own hash table. */
17819 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
17821 struct dwarf2_per_cu_data
*per_cu
17822 = dwarf2_per_objfile
->all_comp_units
[i
];
17823 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
17825 struct psymtab_cu_index_map
*map
;
17828 if (psymtab
->user
== NULL
)
17829 recursively_write_psymbols (objfile
, psymtab
, symtab
, psyms_seen
, i
);
17831 map
= &psymtab_cu_index_map
[i
];
17832 map
->psymtab
= psymtab
;
17834 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
17835 gdb_assert (slot
!= NULL
);
17836 gdb_assert (*slot
== NULL
);
17839 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
17840 per_cu
->offset
.sect_off
);
17841 obstack_grow (&cu_list
, val
, 8);
17842 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
17843 obstack_grow (&cu_list
, val
, 8);
17846 /* Dump the address map. */
17847 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
17849 /* Write out the .debug_type entries, if any. */
17850 if (dwarf2_per_objfile
->signatured_types
)
17852 struct signatured_type_index_data sig_data
;
17854 sig_data
.objfile
= objfile
;
17855 sig_data
.symtab
= symtab
;
17856 sig_data
.types_list
= &types_cu_list
;
17857 sig_data
.psyms_seen
= psyms_seen
;
17858 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
17859 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
17860 write_one_signatured_type
, &sig_data
);
17863 obstack_init (&constant_pool
);
17864 make_cleanup_obstack_free (&constant_pool
);
17865 obstack_init (&symtab_obstack
);
17866 make_cleanup_obstack_free (&symtab_obstack
);
17867 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
17869 obstack_init (&contents
);
17870 make_cleanup_obstack_free (&contents
);
17871 size_of_contents
= 6 * sizeof (offset_type
);
17872 total_len
= size_of_contents
;
17874 /* The version number. */
17875 val
= MAYBE_SWAP (6);
17876 obstack_grow (&contents
, &val
, sizeof (val
));
17878 /* The offset of the CU list from the start of the file. */
17879 val
= MAYBE_SWAP (total_len
);
17880 obstack_grow (&contents
, &val
, sizeof (val
));
17881 total_len
+= obstack_object_size (&cu_list
);
17883 /* The offset of the types CU list from the start of the file. */
17884 val
= MAYBE_SWAP (total_len
);
17885 obstack_grow (&contents
, &val
, sizeof (val
));
17886 total_len
+= obstack_object_size (&types_cu_list
);
17888 /* The offset of the address table from the start of the file. */
17889 val
= MAYBE_SWAP (total_len
);
17890 obstack_grow (&contents
, &val
, sizeof (val
));
17891 total_len
+= obstack_object_size (&addr_obstack
);
17893 /* The offset of the symbol table from the start of the file. */
17894 val
= MAYBE_SWAP (total_len
);
17895 obstack_grow (&contents
, &val
, sizeof (val
));
17896 total_len
+= obstack_object_size (&symtab_obstack
);
17898 /* The offset of the constant pool from the start of the file. */
17899 val
= MAYBE_SWAP (total_len
);
17900 obstack_grow (&contents
, &val
, sizeof (val
));
17901 total_len
+= obstack_object_size (&constant_pool
);
17903 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
17905 write_obstack (out_file
, &contents
);
17906 write_obstack (out_file
, &cu_list
);
17907 write_obstack (out_file
, &types_cu_list
);
17908 write_obstack (out_file
, &addr_obstack
);
17909 write_obstack (out_file
, &symtab_obstack
);
17910 write_obstack (out_file
, &constant_pool
);
17914 /* We want to keep the file, so we set cleanup_filename to NULL
17915 here. See unlink_if_set. */
17916 cleanup_filename
= NULL
;
17918 do_cleanups (cleanup
);
17921 /* Implementation of the `save gdb-index' command.
17923 Note that the file format used by this command is documented in the
17924 GDB manual. Any changes here must be documented there. */
17927 save_gdb_index_command (char *arg
, int from_tty
)
17929 struct objfile
*objfile
;
17932 error (_("usage: save gdb-index DIRECTORY"));
17934 ALL_OBJFILES (objfile
)
17938 /* If the objfile does not correspond to an actual file, skip it. */
17939 if (stat (objfile
->name
, &st
) < 0)
17942 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
17943 if (dwarf2_per_objfile
)
17945 volatile struct gdb_exception except
;
17947 TRY_CATCH (except
, RETURN_MASK_ERROR
)
17949 write_psymtabs_to_index (objfile
, arg
);
17951 if (except
.reason
< 0)
17952 exception_fprintf (gdb_stderr
, except
,
17953 _("Error while writing index for `%s': "),
17961 int dwarf2_always_disassemble
;
17964 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
17965 struct cmd_list_element
*c
, const char *value
)
17967 fprintf_filtered (file
,
17968 _("Whether to always disassemble "
17969 "DWARF expressions is %s.\n"),
17974 show_check_physname (struct ui_file
*file
, int from_tty
,
17975 struct cmd_list_element
*c
, const char *value
)
17977 fprintf_filtered (file
,
17978 _("Whether to check \"physname\" is %s.\n"),
17982 void _initialize_dwarf2_read (void);
17985 _initialize_dwarf2_read (void)
17987 struct cmd_list_element
*c
;
17989 dwarf2_objfile_data_key
17990 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
17992 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
17993 Set DWARF 2 specific variables.\n\
17994 Configure DWARF 2 variables such as the cache size"),
17995 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
17996 0/*allow-unknown*/, &maintenance_set_cmdlist
);
17998 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
17999 Show DWARF 2 specific variables\n\
18000 Show DWARF 2 variables such as the cache size"),
18001 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
18002 0/*allow-unknown*/, &maintenance_show_cmdlist
);
18004 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
18005 &dwarf2_max_cache_age
, _("\
18006 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
18007 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
18008 A higher limit means that cached compilation units will be stored\n\
18009 in memory longer, and more total memory will be used. Zero disables\n\
18010 caching, which can slow down startup."),
18012 show_dwarf2_max_cache_age
,
18013 &set_dwarf2_cmdlist
,
18014 &show_dwarf2_cmdlist
);
18016 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
18017 &dwarf2_always_disassemble
, _("\
18018 Set whether `info address' always disassembles DWARF expressions."), _("\
18019 Show whether `info address' always disassembles DWARF expressions."), _("\
18020 When enabled, DWARF expressions are always printed in an assembly-like\n\
18021 syntax. When disabled, expressions will be printed in a more\n\
18022 conversational style, when possible."),
18024 show_dwarf2_always_disassemble
,
18025 &set_dwarf2_cmdlist
,
18026 &show_dwarf2_cmdlist
);
18028 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
18029 Set debugging of the dwarf2 DIE reader."), _("\
18030 Show debugging of the dwarf2 DIE reader."), _("\
18031 When enabled (non-zero), DIEs are dumped after they are read in.\n\
18032 The value is the maximum depth to print."),
18035 &setdebuglist
, &showdebuglist
);
18037 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
18038 Set cross-checking of \"physname\" code against demangler."), _("\
18039 Show cross-checking of \"physname\" code against demangler."), _("\
18040 When enabled, GDB's internal \"physname\" code is checked against\n\
18042 NULL
, show_check_physname
,
18043 &setdebuglist
, &showdebuglist
);
18045 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
18047 Save a gdb-index file.\n\
18048 Usage: save gdb-index DIRECTORY"),
18050 set_cmd_completer (c
, filename_completer
);