1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "expression.h"
38 #include "filenames.h" /* for DOSish file names */
41 #include "complaints.h"
43 #include "dwarf2expr.h"
44 #include "dwarf2loc.h"
45 #include "cp-support.h"
51 #include "typeprint.h"
54 #include "exceptions.h"
56 #include "completer.h"
62 #include "gdb_string.h"
63 #include "gdb_assert.h"
64 #include <sys/types.h>
71 #define MAP_FAILED ((void *) -1)
75 typedef struct symbol
*symbolp
;
79 /* .debug_info header for a compilation unit
80 Because of alignment constraints, this structure has padding and cannot
81 be mapped directly onto the beginning of the .debug_info section. */
82 typedef struct comp_unit_header
84 unsigned int length
; /* length of the .debug_info
86 unsigned short version
; /* version number -- 2 for DWARF
88 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
89 unsigned char addr_size
; /* byte size of an address -- 4 */
92 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
95 /* .debug_line statement program prologue
96 Because of alignment constraints, this structure has padding and cannot
97 be mapped directly onto the beginning of the .debug_info section. */
98 typedef struct statement_prologue
100 unsigned int total_length
; /* byte length of the statement
102 unsigned short version
; /* version number -- 2 for DWARF
104 unsigned int prologue_length
; /* # bytes between prologue &
106 unsigned char minimum_instruction_length
; /* byte size of
108 unsigned char default_is_stmt
; /* initial value of is_stmt
111 unsigned char line_range
;
112 unsigned char opcode_base
; /* number assigned to first special
114 unsigned char *standard_opcode_lengths
;
118 /* When non-zero, dump DIEs after they are read in. */
119 static int dwarf2_die_debug
= 0;
123 /* When set, the file that we're processing is known to have debugging
124 info for C++ namespaces. GCC 3.3.x did not produce this information,
125 but later versions do. */
127 static int processing_has_namespace_info
;
129 static const struct objfile_data
*dwarf2_objfile_data_key
;
131 struct dwarf2_section_info
137 /* True if we have tried to read this section. */
141 /* All offsets in the index are of this type. It must be
142 architecture-independent. */
143 typedef uint32_t offset_type
;
145 DEF_VEC_I (offset_type
);
147 /* A description of the mapped index. The file format is described in
148 a comment by the code that writes the index. */
151 /* The total length of the buffer. */
153 /* A pointer to the address table data. */
154 const gdb_byte
*address_table
;
155 /* Size of the address table data in bytes. */
156 offset_type address_table_size
;
157 /* The hash table. */
158 const offset_type
*index_table
;
159 /* Size in slots, each slot is 2 offset_types. */
160 offset_type index_table_slots
;
161 /* A pointer to the constant pool. */
162 const char *constant_pool
;
165 struct dwarf2_per_objfile
167 struct dwarf2_section_info info
;
168 struct dwarf2_section_info abbrev
;
169 struct dwarf2_section_info line
;
170 struct dwarf2_section_info loc
;
171 struct dwarf2_section_info macinfo
;
172 struct dwarf2_section_info str
;
173 struct dwarf2_section_info ranges
;
174 struct dwarf2_section_info types
;
175 struct dwarf2_section_info frame
;
176 struct dwarf2_section_info eh_frame
;
177 struct dwarf2_section_info gdb_index
;
180 struct objfile
*objfile
;
182 /* A list of all the compilation units. This is used to locate
183 the target compilation unit of a particular reference. */
184 struct dwarf2_per_cu_data
**all_comp_units
;
186 /* The number of compilation units in ALL_COMP_UNITS. */
189 /* The number of .debug_types-related CUs. */
190 int n_type_comp_units
;
192 /* The .debug_types-related CUs. */
193 struct dwarf2_per_cu_data
**type_comp_units
;
195 /* A chain of compilation units that are currently read in, so that
196 they can be freed later. */
197 struct dwarf2_per_cu_data
*read_in_chain
;
199 /* A table mapping .debug_types signatures to its signatured_type entry.
200 This is NULL if the .debug_types section hasn't been read in yet. */
201 htab_t signatured_types
;
203 /* A flag indicating wether this objfile has a section loaded at a
205 int has_section_at_zero
;
207 /* True if we are using the mapped index. */
208 unsigned char using_index
;
210 /* The mapped index. */
211 struct mapped_index
*index_table
;
213 /* Set during partial symbol reading, to prevent queueing of full
215 int reading_partial_symbols
;
217 /* Table mapping type .debug_info DIE offsets to types.
218 This is NULL if not allocated yet.
219 It (currently) makes sense to allocate debug_types_type_hash lazily.
220 To keep things simple we allocate both lazily. */
221 htab_t debug_info_type_hash
;
223 /* Table mapping type .debug_types DIE offsets to types.
224 This is NULL if not allocated yet. */
225 htab_t debug_types_type_hash
;
228 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
230 /* names of the debugging sections */
232 /* Note that if the debugging section has been compressed, it might
233 have a name like .zdebug_info. */
235 #define INFO_SECTION "debug_info"
236 #define ABBREV_SECTION "debug_abbrev"
237 #define LINE_SECTION "debug_line"
238 #define LOC_SECTION "debug_loc"
239 #define MACINFO_SECTION "debug_macinfo"
240 #define STR_SECTION "debug_str"
241 #define RANGES_SECTION "debug_ranges"
242 #define TYPES_SECTION "debug_types"
243 #define FRAME_SECTION "debug_frame"
244 #define EH_FRAME_SECTION "eh_frame"
245 #define GDB_INDEX_SECTION "gdb_index"
247 /* local data types */
249 /* We hold several abbreviation tables in memory at the same time. */
250 #ifndef ABBREV_HASH_SIZE
251 #define ABBREV_HASH_SIZE 121
254 /* The data in a compilation unit header, after target2host
255 translation, looks like this. */
256 struct comp_unit_head
260 unsigned char addr_size
;
261 unsigned char signed_addr_p
;
262 unsigned int abbrev_offset
;
264 /* Size of file offsets; either 4 or 8. */
265 unsigned int offset_size
;
267 /* Size of the length field; either 4 or 12. */
268 unsigned int initial_length_size
;
270 /* Offset to the first byte of this compilation unit header in the
271 .debug_info section, for resolving relative reference dies. */
274 /* Offset to first die in this cu from the start of the cu.
275 This will be the first byte following the compilation unit header. */
276 unsigned int first_die_offset
;
279 /* Type used for delaying computation of method physnames.
280 See comments for compute_delayed_physnames. */
281 struct delayed_method_info
283 /* The type to which the method is attached, i.e., its parent class. */
286 /* The index of the method in the type's function fieldlists. */
289 /* The index of the method in the fieldlist. */
292 /* The name of the DIE. */
295 /* The DIE associated with this method. */
296 struct die_info
*die
;
299 typedef struct delayed_method_info delayed_method_info
;
300 DEF_VEC_O (delayed_method_info
);
302 /* Internal state when decoding a particular compilation unit. */
305 /* The objfile containing this compilation unit. */
306 struct objfile
*objfile
;
308 /* The header of the compilation unit. */
309 struct comp_unit_head header
;
311 /* Base address of this compilation unit. */
312 CORE_ADDR base_address
;
314 /* Non-zero if base_address has been set. */
317 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
319 /* The language we are debugging. */
320 enum language language
;
321 const struct language_defn
*language_defn
;
323 const char *producer
;
325 /* The generic symbol table building routines have separate lists for
326 file scope symbols and all all other scopes (local scopes). So
327 we need to select the right one to pass to add_symbol_to_list().
328 We do it by keeping a pointer to the correct list in list_in_scope.
330 FIXME: The original dwarf code just treated the file scope as the
331 first local scope, and all other local scopes as nested local
332 scopes, and worked fine. Check to see if we really need to
333 distinguish these in buildsym.c. */
334 struct pending
**list_in_scope
;
336 /* DWARF abbreviation table associated with this compilation unit. */
337 struct abbrev_info
**dwarf2_abbrevs
;
339 /* Storage for the abbrev table. */
340 struct obstack abbrev_obstack
;
342 /* Hash table holding all the loaded partial DIEs. */
345 /* Storage for things with the same lifetime as this read-in compilation
346 unit, including partial DIEs. */
347 struct obstack comp_unit_obstack
;
349 /* When multiple dwarf2_cu structures are living in memory, this field
350 chains them all together, so that they can be released efficiently.
351 We will probably also want a generation counter so that most-recently-used
352 compilation units are cached... */
353 struct dwarf2_per_cu_data
*read_in_chain
;
355 /* Backchain to our per_cu entry if the tree has been built. */
356 struct dwarf2_per_cu_data
*per_cu
;
358 /* How many compilation units ago was this CU last referenced? */
361 /* A hash table of die offsets for following references. */
364 /* Full DIEs if read in. */
365 struct die_info
*dies
;
367 /* A set of pointers to dwarf2_per_cu_data objects for compilation
368 units referenced by this one. Only set during full symbol processing;
369 partial symbol tables do not have dependencies. */
372 /* Header data from the line table, during full symbol processing. */
373 struct line_header
*line_header
;
375 /* A list of methods which need to have physnames computed
376 after all type information has been read. */
377 VEC (delayed_method_info
) *method_list
;
379 /* Mark used when releasing cached dies. */
380 unsigned int mark
: 1;
382 /* This flag will be set if this compilation unit might include
383 inter-compilation-unit references. */
384 unsigned int has_form_ref_addr
: 1;
386 /* This flag will be set if this compilation unit includes any
387 DW_TAG_namespace DIEs. If we know that there are explicit
388 DIEs for namespaces, we don't need to try to infer them
389 from mangled names. */
390 unsigned int has_namespace_info
: 1;
393 /* When using the index (and thus not using psymtabs), each CU has an
394 object of this type. This is used to hold information needed by
395 the various "quick" methods. */
396 struct dwarf2_per_cu_quick_data
398 /* The line table. This can be NULL if there was no line table. */
399 struct line_header
*lines
;
401 /* The file names from the line table. */
402 const char **file_names
;
403 /* The file names from the line table after being run through
405 const char **full_names
;
407 /* The corresponding symbol table. This is NULL if symbols for this
408 CU have not yet been read. */
409 struct symtab
*symtab
;
411 /* A temporary mark bit used when iterating over all CUs in
412 expand_symtabs_matching. */
413 unsigned int mark
: 1;
415 /* True if we've tried to read the line table. */
416 unsigned int read_lines
: 1;
419 /* Persistent data held for a compilation unit, even when not
420 processing it. We put a pointer to this structure in the
421 read_symtab_private field of the psymtab. If we encounter
422 inter-compilation-unit references, we also maintain a sorted
423 list of all compilation units. */
425 struct dwarf2_per_cu_data
427 /* The start offset and length of this compilation unit. 2**29-1
428 bytes should suffice to store the length of any compilation unit
429 - if it doesn't, GDB will fall over anyway.
430 NOTE: Unlike comp_unit_head.length, this length includes
431 initial_length_size. */
433 unsigned int length
: 29;
435 /* Flag indicating this compilation unit will be read in before
436 any of the current compilation units are processed. */
437 unsigned int queued
: 1;
439 /* This flag will be set if we need to load absolutely all DIEs
440 for this compilation unit, instead of just the ones we think
441 are interesting. It gets set if we look for a DIE in the
442 hash table and don't find it. */
443 unsigned int load_all_dies
: 1;
445 /* Non-zero if this CU is from .debug_types.
446 Otherwise it's from .debug_info. */
447 unsigned int from_debug_types
: 1;
449 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
450 of the CU cache it gets reset to NULL again. */
451 struct dwarf2_cu
*cu
;
453 /* The corresponding objfile. */
454 struct objfile
*objfile
;
456 /* When using partial symbol tables, the 'psymtab' field is active.
457 Otherwise the 'quick' field is active. */
460 /* The partial symbol table associated with this compilation unit,
461 or NULL for partial units (which do not have an associated
463 struct partial_symtab
*psymtab
;
465 /* Data needed by the "quick" functions. */
466 struct dwarf2_per_cu_quick_data
*quick
;
470 /* Entry in the signatured_types hash table. */
472 struct signatured_type
476 /* Offset in .debug_types of the TU (type_unit) for this type. */
479 /* Offset in .debug_types of the type defined by this TU. */
480 unsigned int type_offset
;
482 /* The CU(/TU) of this type. */
483 struct dwarf2_per_cu_data per_cu
;
486 /* Struct used to pass misc. parameters to read_die_and_children, et. al.
487 which are used for both .debug_info and .debug_types dies.
488 All parameters here are unchanging for the life of the call.
489 This struct exists to abstract away the constant parameters of
492 struct die_reader_specs
494 /* The bfd of this objfile. */
497 /* The CU of the DIE we are parsing. */
498 struct dwarf2_cu
*cu
;
500 /* Pointer to start of section buffer.
501 This is either the start of .debug_info or .debug_types. */
502 const gdb_byte
*buffer
;
505 /* The line number information for a compilation unit (found in the
506 .debug_line section) begins with a "statement program header",
507 which contains the following information. */
510 unsigned int total_length
;
511 unsigned short version
;
512 unsigned int header_length
;
513 unsigned char minimum_instruction_length
;
514 unsigned char maximum_ops_per_instruction
;
515 unsigned char default_is_stmt
;
517 unsigned char line_range
;
518 unsigned char opcode_base
;
520 /* standard_opcode_lengths[i] is the number of operands for the
521 standard opcode whose value is i. This means that
522 standard_opcode_lengths[0] is unused, and the last meaningful
523 element is standard_opcode_lengths[opcode_base - 1]. */
524 unsigned char *standard_opcode_lengths
;
526 /* The include_directories table. NOTE! These strings are not
527 allocated with xmalloc; instead, they are pointers into
528 debug_line_buffer. If you try to free them, `free' will get
530 unsigned int num_include_dirs
, include_dirs_size
;
533 /* The file_names table. NOTE! These strings are not allocated
534 with xmalloc; instead, they are pointers into debug_line_buffer.
535 Don't try to free them directly. */
536 unsigned int num_file_names
, file_names_size
;
540 unsigned int dir_index
;
541 unsigned int mod_time
;
543 int included_p
; /* Non-zero if referenced by the Line Number Program. */
544 struct symtab
*symtab
; /* The associated symbol table, if any. */
547 /* The start and end of the statement program following this
548 header. These point into dwarf2_per_objfile->line_buffer. */
549 gdb_byte
*statement_program_start
, *statement_program_end
;
552 /* When we construct a partial symbol table entry we only
553 need this much information. */
554 struct partial_die_info
556 /* Offset of this DIE. */
559 /* DWARF-2 tag for this DIE. */
560 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
562 /* Assorted flags describing the data found in this DIE. */
563 unsigned int has_children
: 1;
564 unsigned int is_external
: 1;
565 unsigned int is_declaration
: 1;
566 unsigned int has_type
: 1;
567 unsigned int has_specification
: 1;
568 unsigned int has_pc_info
: 1;
570 /* Flag set if the SCOPE field of this structure has been
572 unsigned int scope_set
: 1;
574 /* Flag set if the DIE has a byte_size attribute. */
575 unsigned int has_byte_size
: 1;
577 /* Flag set if any of the DIE's children are template arguments. */
578 unsigned int has_template_arguments
: 1;
580 /* The name of this DIE. Normally the value of DW_AT_name, but
581 sometimes a default name for unnamed DIEs. */
584 /* The scope to prepend to our children. This is generally
585 allocated on the comp_unit_obstack, so will disappear
586 when this compilation unit leaves the cache. */
589 /* The location description associated with this DIE, if any. */
590 struct dwarf_block
*locdesc
;
592 /* If HAS_PC_INFO, the PC range associated with this DIE. */
596 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
597 DW_AT_sibling, if any. */
600 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
601 DW_AT_specification (or DW_AT_abstract_origin or
603 unsigned int spec_offset
;
605 /* Pointers to this DIE's parent, first child, and next sibling,
607 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
610 /* This data structure holds the information of an abbrev. */
613 unsigned int number
; /* number identifying abbrev */
614 enum dwarf_tag tag
; /* dwarf tag */
615 unsigned short has_children
; /* boolean */
616 unsigned short num_attrs
; /* number of attributes */
617 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
618 struct abbrev_info
*next
; /* next in chain */
623 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
624 ENUM_BITFIELD(dwarf_form
) form
: 16;
627 /* Attributes have a name and a value */
630 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
631 ENUM_BITFIELD(dwarf_form
) form
: 15;
633 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
634 field should be in u.str (existing only for DW_STRING) but it is kept
635 here for better struct attribute alignment. */
636 unsigned int string_is_canonical
: 1;
641 struct dwarf_block
*blk
;
645 struct signatured_type
*signatured_type
;
650 /* This data structure holds a complete die structure. */
653 /* DWARF-2 tag for this DIE. */
654 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
656 /* Number of attributes */
657 unsigned char num_attrs
;
659 /* True if we're presently building the full type name for the
660 type derived from this DIE. */
661 unsigned char building_fullname
: 1;
666 /* Offset in .debug_info or .debug_types section. */
669 /* The dies in a compilation unit form an n-ary tree. PARENT
670 points to this die's parent; CHILD points to the first child of
671 this node; and all the children of a given node are chained
672 together via their SIBLING fields, terminated by a die whose
674 struct die_info
*child
; /* Its first child, if any. */
675 struct die_info
*sibling
; /* Its next sibling, if any. */
676 struct die_info
*parent
; /* Its parent, if any. */
678 /* An array of attributes, with NUM_ATTRS elements. There may be
679 zero, but it's not common and zero-sized arrays are not
680 sufficiently portable C. */
681 struct attribute attrs
[1];
684 struct function_range
687 CORE_ADDR lowpc
, highpc
;
689 struct function_range
*next
;
692 /* Get at parts of an attribute structure */
694 #define DW_STRING(attr) ((attr)->u.str)
695 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
696 #define DW_UNSND(attr) ((attr)->u.unsnd)
697 #define DW_BLOCK(attr) ((attr)->u.blk)
698 #define DW_SND(attr) ((attr)->u.snd)
699 #define DW_ADDR(attr) ((attr)->u.addr)
700 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
702 /* Blocks are a bunch of untyped bytes. */
709 #ifndef ATTR_ALLOC_CHUNK
710 #define ATTR_ALLOC_CHUNK 4
713 /* Allocate fields for structs, unions and enums in this size. */
714 #ifndef DW_FIELD_ALLOC_CHUNK
715 #define DW_FIELD_ALLOC_CHUNK 4
718 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
719 but this would require a corresponding change in unpack_field_as_long
721 static int bits_per_byte
= 8;
723 /* The routines that read and process dies for a C struct or C++ class
724 pass lists of data member fields and lists of member function fields
725 in an instance of a field_info structure, as defined below. */
728 /* List of data member and baseclasses fields. */
731 struct nextfield
*next
;
736 *fields
, *baseclasses
;
738 /* Number of fields (including baseclasses). */
741 /* Number of baseclasses. */
744 /* Set if the accesibility of one of the fields is not public. */
745 int non_public_fields
;
747 /* Member function fields array, entries are allocated in the order they
748 are encountered in the object file. */
751 struct nextfnfield
*next
;
752 struct fn_field fnfield
;
756 /* Member function fieldlist array, contains name of possibly overloaded
757 member function, number of overloaded member functions and a pointer
758 to the head of the member function field chain. */
763 struct nextfnfield
*head
;
767 /* Number of entries in the fnfieldlists array. */
770 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
771 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
772 struct typedef_field_list
774 struct typedef_field field
;
775 struct typedef_field_list
*next
;
778 unsigned typedef_field_list_count
;
781 /* One item on the queue of compilation units to read in full symbols
783 struct dwarf2_queue_item
785 struct dwarf2_per_cu_data
*per_cu
;
786 struct dwarf2_queue_item
*next
;
789 /* The current queue. */
790 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
792 /* Loaded secondary compilation units are kept in memory until they
793 have not been referenced for the processing of this many
794 compilation units. Set this to zero to disable caching. Cache
795 sizes of up to at least twenty will improve startup time for
796 typical inter-CU-reference binaries, at an obvious memory cost. */
797 static int dwarf2_max_cache_age
= 5;
799 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
800 struct cmd_list_element
*c
, const char *value
)
802 fprintf_filtered (file
, _("\
803 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
808 /* Various complaints about symbol reading that don't abort the process */
811 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
813 complaint (&symfile_complaints
,
814 _("statement list doesn't fit in .debug_line section"));
818 dwarf2_debug_line_missing_file_complaint (void)
820 complaint (&symfile_complaints
,
821 _(".debug_line section has line data without a file"));
825 dwarf2_debug_line_missing_end_sequence_complaint (void)
827 complaint (&symfile_complaints
,
828 _(".debug_line section has line program sequence without an end"));
832 dwarf2_complex_location_expr_complaint (void)
834 complaint (&symfile_complaints
, _("location expression too complex"));
838 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
841 complaint (&symfile_complaints
,
842 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
847 dwarf2_macros_too_long_complaint (void)
849 complaint (&symfile_complaints
,
850 _("macro info runs off end of `.debug_macinfo' section"));
854 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
856 complaint (&symfile_complaints
,
857 _("macro debug info contains a malformed macro definition:\n`%s'"),
862 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
864 complaint (&symfile_complaints
,
865 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
868 /* local function prototypes */
870 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
872 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
875 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
877 struct partial_symtab
*);
879 static void dwarf2_build_psymtabs_hard (struct objfile
*);
881 static void scan_partial_symbols (struct partial_die_info
*,
882 CORE_ADDR
*, CORE_ADDR
*,
883 int, struct dwarf2_cu
*);
885 static void add_partial_symbol (struct partial_die_info
*,
888 static void add_partial_namespace (struct partial_die_info
*pdi
,
889 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
890 int need_pc
, struct dwarf2_cu
*cu
);
892 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
893 CORE_ADDR
*highpc
, int need_pc
,
894 struct dwarf2_cu
*cu
);
896 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
897 struct dwarf2_cu
*cu
);
899 static void add_partial_subprogram (struct partial_die_info
*pdi
,
900 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
901 int need_pc
, struct dwarf2_cu
*cu
);
903 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
904 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
905 bfd
*abfd
, struct dwarf2_cu
*cu
);
907 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
909 static void psymtab_to_symtab_1 (struct partial_symtab
*);
911 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
913 static void dwarf2_free_abbrev_table (void *);
915 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
918 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
921 static struct partial_die_info
*load_partial_dies (bfd
*,
922 gdb_byte
*, gdb_byte
*,
923 int, struct dwarf2_cu
*);
925 static gdb_byte
*read_partial_die (struct partial_die_info
*,
926 struct abbrev_info
*abbrev
,
928 gdb_byte
*, gdb_byte
*,
931 static struct partial_die_info
*find_partial_die (unsigned int,
934 static void fixup_partial_die (struct partial_die_info
*,
937 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
938 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
940 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
941 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
943 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
945 static int read_1_signed_byte (bfd
*, gdb_byte
*);
947 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
949 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
951 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
953 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
956 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
958 static LONGEST read_checked_initial_length_and_offset
959 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
960 unsigned int *, unsigned int *);
962 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
965 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
967 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
969 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
971 static char *read_indirect_string (bfd
*, gdb_byte
*,
972 const struct comp_unit_head
*,
975 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
977 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
979 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
981 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
983 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
986 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
990 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
991 struct dwarf2_cu
*cu
);
993 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
995 static struct die_info
*die_specification (struct die_info
*die
,
996 struct dwarf2_cu
**);
998 static void free_line_header (struct line_header
*lh
);
1000 static void add_file_name (struct line_header
*, char *, unsigned int,
1001 unsigned int, unsigned int);
1003 static struct line_header
*(dwarf_decode_line_header
1004 (unsigned int offset
,
1005 bfd
*abfd
, struct dwarf2_cu
*cu
));
1007 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
1008 struct dwarf2_cu
*, struct partial_symtab
*);
1010 static void dwarf2_start_subfile (char *, char *, char *);
1012 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1013 struct dwarf2_cu
*);
1015 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1016 struct dwarf2_cu
*, struct symbol
*);
1018 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1019 struct dwarf2_cu
*);
1021 static void dwarf2_const_value_attr (struct attribute
*attr
,
1024 struct obstack
*obstack
,
1025 struct dwarf2_cu
*cu
, long *value
,
1027 struct dwarf2_locexpr_baton
**baton
);
1029 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1031 static int need_gnat_info (struct dwarf2_cu
*);
1033 static struct type
*die_descriptive_type (struct die_info
*, struct dwarf2_cu
*);
1035 static void set_descriptive_type (struct type
*, struct die_info
*,
1036 struct dwarf2_cu
*);
1038 static struct type
*die_containing_type (struct die_info
*,
1039 struct dwarf2_cu
*);
1041 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1042 struct dwarf2_cu
*);
1044 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1046 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1048 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1050 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1051 const char *suffix
, int physname
,
1052 struct dwarf2_cu
*cu
);
1054 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1056 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1058 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1060 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1062 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1063 struct dwarf2_cu
*, struct partial_symtab
*);
1065 static int dwarf2_get_pc_bounds (struct die_info
*,
1066 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1067 struct partial_symtab
*);
1069 static void get_scope_pc_bounds (struct die_info
*,
1070 CORE_ADDR
*, CORE_ADDR
*,
1071 struct dwarf2_cu
*);
1073 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1074 CORE_ADDR
, struct dwarf2_cu
*);
1076 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1077 struct dwarf2_cu
*);
1079 static void dwarf2_attach_fields_to_type (struct field_info
*,
1080 struct type
*, struct dwarf2_cu
*);
1082 static void dwarf2_add_member_fn (struct field_info
*,
1083 struct die_info
*, struct type
*,
1084 struct dwarf2_cu
*);
1086 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1087 struct type
*, struct dwarf2_cu
*);
1089 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1091 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1093 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1095 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1097 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1099 static struct type
*read_module_type (struct die_info
*die
,
1100 struct dwarf2_cu
*cu
);
1102 static const char *namespace_name (struct die_info
*die
,
1103 int *is_anonymous
, struct dwarf2_cu
*);
1105 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1107 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1109 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1110 struct dwarf2_cu
*);
1112 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
1114 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
1116 gdb_byte
**new_info_ptr
,
1117 struct die_info
*parent
);
1119 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
1121 gdb_byte
**new_info_ptr
,
1122 struct die_info
*parent
);
1124 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
1126 gdb_byte
**new_info_ptr
,
1127 struct die_info
*parent
);
1129 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
1130 struct die_info
**, gdb_byte
*,
1133 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1135 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1138 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1140 static const char *dwarf2_full_name (char *name
,
1141 struct die_info
*die
,
1142 struct dwarf2_cu
*cu
);
1144 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1145 struct dwarf2_cu
**);
1147 static char *dwarf_tag_name (unsigned int);
1149 static char *dwarf_attr_name (unsigned int);
1151 static char *dwarf_form_name (unsigned int);
1153 static char *dwarf_bool_name (unsigned int);
1155 static char *dwarf_type_encoding_name (unsigned int);
1158 static char *dwarf_cfi_name (unsigned int);
1161 static struct die_info
*sibling_die (struct die_info
*);
1163 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1165 static void dump_die_for_error (struct die_info
*);
1167 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1170 /*static*/ void dump_die (struct die_info
*, int max_level
);
1172 static void store_in_ref_table (struct die_info
*,
1173 struct dwarf2_cu
*);
1175 static int is_ref_attr (struct attribute
*);
1177 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1179 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1181 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1183 struct dwarf2_cu
**);
1185 static struct die_info
*follow_die_ref (struct die_info
*,
1187 struct dwarf2_cu
**);
1189 static struct die_info
*follow_die_sig (struct die_info
*,
1191 struct dwarf2_cu
**);
1193 static void read_signatured_type_at_offset (struct objfile
*objfile
,
1194 unsigned int offset
);
1196 static void read_signatured_type (struct objfile
*,
1197 struct signatured_type
*type_sig
);
1199 /* memory allocation interface */
1201 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1203 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1205 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1207 static void initialize_cu_func_list (struct dwarf2_cu
*);
1209 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1210 struct dwarf2_cu
*);
1212 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1213 char *, bfd
*, struct dwarf2_cu
*);
1215 static int attr_form_is_block (struct attribute
*);
1217 static int attr_form_is_section_offset (struct attribute
*);
1219 static int attr_form_is_constant (struct attribute
*);
1221 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1223 struct dwarf2_cu
*cu
);
1225 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1226 struct abbrev_info
*abbrev
,
1227 struct dwarf2_cu
*cu
);
1229 static void free_stack_comp_unit (void *);
1231 static hashval_t
partial_die_hash (const void *item
);
1233 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1235 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1236 (unsigned int offset
, struct objfile
*objfile
);
1238 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1239 (unsigned int offset
, struct objfile
*objfile
);
1241 static struct dwarf2_cu
*alloc_one_comp_unit (struct objfile
*objfile
);
1243 static void free_one_comp_unit (void *);
1245 static void free_cached_comp_units (void *);
1247 static void age_cached_comp_units (void);
1249 static void free_one_cached_comp_unit (void *);
1251 static struct type
*set_die_type (struct die_info
*, struct type
*,
1252 struct dwarf2_cu
*);
1254 static void create_all_comp_units (struct objfile
*);
1256 static int create_debug_types_hash_table (struct objfile
*objfile
);
1258 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1261 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1263 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1264 struct dwarf2_per_cu_data
*);
1266 static void dwarf2_mark (struct dwarf2_cu
*);
1268 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1270 static struct type
*get_die_type_at_offset (unsigned int,
1271 struct dwarf2_per_cu_data
*per_cu
);
1273 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1275 static void dwarf2_release_queue (void *dummy
);
1277 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1278 struct objfile
*objfile
);
1280 static void process_queue (struct objfile
*objfile
);
1282 static void find_file_and_directory (struct die_info
*die
,
1283 struct dwarf2_cu
*cu
,
1284 char **name
, char **comp_dir
);
1286 static char *file_full_name (int file
, struct line_header
*lh
,
1287 const char *comp_dir
);
1289 static gdb_byte
*partial_read_comp_unit_head (struct comp_unit_head
*header
,
1292 unsigned int buffer_size
,
1295 static void init_cu_die_reader (struct die_reader_specs
*reader
,
1296 struct dwarf2_cu
*cu
);
1298 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1302 /* Convert VALUE between big- and little-endian. */
1304 byte_swap (offset_type value
)
1308 result
= (value
& 0xff) << 24;
1309 result
|= (value
& 0xff00) << 8;
1310 result
|= (value
& 0xff0000) >> 8;
1311 result
|= (value
& 0xff000000) >> 24;
1315 #define MAYBE_SWAP(V) byte_swap (V)
1318 #define MAYBE_SWAP(V) (V)
1319 #endif /* WORDS_BIGENDIAN */
1321 /* The suffix for an index file. */
1322 #define INDEX_SUFFIX ".gdb-index"
1324 static const char *dwarf2_physname (char *name
, struct die_info
*die
,
1325 struct dwarf2_cu
*cu
);
1327 /* Try to locate the sections we need for DWARF 2 debugging
1328 information and return true if we have enough to do something. */
1331 dwarf2_has_info (struct objfile
*objfile
)
1333 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1334 if (!dwarf2_per_objfile
)
1336 /* Initialize per-objfile state. */
1337 struct dwarf2_per_objfile
*data
1338 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1340 memset (data
, 0, sizeof (*data
));
1341 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1342 dwarf2_per_objfile
= data
;
1344 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1345 dwarf2_per_objfile
->objfile
= objfile
;
1347 return (dwarf2_per_objfile
->info
.asection
!= NULL
1348 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1351 /* When loading sections, we can either look for ".<name>", or for
1352 * ".z<name>", which indicates a compressed section. */
1355 section_is_p (const char *section_name
, const char *name
)
1357 return (section_name
[0] == '.'
1358 && (strcmp (section_name
+ 1, name
) == 0
1359 || (section_name
[1] == 'z'
1360 && strcmp (section_name
+ 2, name
) == 0)));
1363 /* This function is mapped across the sections and remembers the
1364 offset and size of each of the debugging sections we are interested
1368 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1370 if (section_is_p (sectp
->name
, INFO_SECTION
))
1372 dwarf2_per_objfile
->info
.asection
= sectp
;
1373 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1375 else if (section_is_p (sectp
->name
, ABBREV_SECTION
))
1377 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1378 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1380 else if (section_is_p (sectp
->name
, LINE_SECTION
))
1382 dwarf2_per_objfile
->line
.asection
= sectp
;
1383 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1385 else if (section_is_p (sectp
->name
, LOC_SECTION
))
1387 dwarf2_per_objfile
->loc
.asection
= sectp
;
1388 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1390 else if (section_is_p (sectp
->name
, MACINFO_SECTION
))
1392 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1393 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1395 else if (section_is_p (sectp
->name
, STR_SECTION
))
1397 dwarf2_per_objfile
->str
.asection
= sectp
;
1398 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1400 else if (section_is_p (sectp
->name
, FRAME_SECTION
))
1402 dwarf2_per_objfile
->frame
.asection
= sectp
;
1403 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1405 else if (section_is_p (sectp
->name
, EH_FRAME_SECTION
))
1407 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1409 if (aflag
& SEC_HAS_CONTENTS
)
1411 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1412 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1415 else if (section_is_p (sectp
->name
, RANGES_SECTION
))
1417 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1418 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1420 else if (section_is_p (sectp
->name
, TYPES_SECTION
))
1422 dwarf2_per_objfile
->types
.asection
= sectp
;
1423 dwarf2_per_objfile
->types
.size
= bfd_get_section_size (sectp
);
1425 else if (section_is_p (sectp
->name
, GDB_INDEX_SECTION
))
1427 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1428 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1431 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1432 && bfd_section_vma (abfd
, sectp
) == 0)
1433 dwarf2_per_objfile
->has_section_at_zero
= 1;
1436 /* Decompress a section that was compressed using zlib. Store the
1437 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1440 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1441 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1443 bfd
*abfd
= objfile
->obfd
;
1445 error (_("Support for zlib-compressed DWARF data (from '%s') "
1446 "is disabled in this copy of GDB"),
1447 bfd_get_filename (abfd
));
1449 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1450 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1451 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1452 bfd_size_type uncompressed_size
;
1453 gdb_byte
*uncompressed_buffer
;
1456 int header_size
= 12;
1458 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1459 || bfd_bread (compressed_buffer
, compressed_size
, abfd
) != compressed_size
)
1460 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1461 bfd_get_filename (abfd
));
1463 /* Read the zlib header. In this case, it should be "ZLIB" followed
1464 by the uncompressed section size, 8 bytes in big-endian order. */
1465 if (compressed_size
< header_size
1466 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1467 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1468 bfd_get_filename (abfd
));
1469 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1470 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1471 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1472 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1473 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1474 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1475 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1476 uncompressed_size
+= compressed_buffer
[11];
1478 /* It is possible the section consists of several compressed
1479 buffers concatenated together, so we uncompress in a loop. */
1483 strm
.avail_in
= compressed_size
- header_size
;
1484 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1485 strm
.avail_out
= uncompressed_size
;
1486 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1488 rc
= inflateInit (&strm
);
1489 while (strm
.avail_in
> 0)
1492 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1493 bfd_get_filename (abfd
), rc
);
1494 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1495 + (uncompressed_size
- strm
.avail_out
));
1496 rc
= inflate (&strm
, Z_FINISH
);
1497 if (rc
!= Z_STREAM_END
)
1498 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1499 bfd_get_filename (abfd
), rc
);
1500 rc
= inflateReset (&strm
);
1502 rc
= inflateEnd (&strm
);
1504 || strm
.avail_out
!= 0)
1505 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1506 bfd_get_filename (abfd
), rc
);
1508 do_cleanups (cleanup
);
1509 *outbuf
= uncompressed_buffer
;
1510 *outsize
= uncompressed_size
;
1514 /* Read the contents of the section SECTP from object file specified by
1515 OBJFILE, store info about the section into INFO.
1516 If the section is compressed, uncompress it before returning. */
1519 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1521 bfd
*abfd
= objfile
->obfd
;
1522 asection
*sectp
= info
->asection
;
1523 gdb_byte
*buf
, *retbuf
;
1524 unsigned char header
[4];
1528 info
->buffer
= NULL
;
1529 info
->was_mmapped
= 0;
1532 if (info
->asection
== NULL
|| info
->size
== 0)
1535 /* Check if the file has a 4-byte header indicating compression. */
1536 if (info
->size
> sizeof (header
)
1537 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1538 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1540 /* Upon decompression, update the buffer and its size. */
1541 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1543 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1551 pagesize
= getpagesize ();
1553 /* Only try to mmap sections which are large enough: we don't want to
1554 waste space due to fragmentation. Also, only try mmap for sections
1555 without relocations. */
1557 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1559 off_t pg_offset
= sectp
->filepos
& ~(pagesize
- 1);
1560 size_t map_length
= info
->size
+ sectp
->filepos
- pg_offset
;
1561 caddr_t retbuf
= bfd_mmap (abfd
, 0, map_length
, PROT_READ
,
1562 MAP_PRIVATE
, pg_offset
);
1564 if (retbuf
!= MAP_FAILED
)
1566 info
->was_mmapped
= 1;
1567 info
->buffer
= retbuf
+ (sectp
->filepos
& (pagesize
- 1)) ;
1568 #if HAVE_POSIX_MADVISE
1569 posix_madvise (retbuf
, map_length
, POSIX_MADV_WILLNEED
);
1576 /* If we get here, we are a normal, not-compressed section. */
1578 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1580 /* When debugging .o files, we may need to apply relocations; see
1581 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1582 We never compress sections in .o files, so we only need to
1583 try this when the section is not compressed. */
1584 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1587 info
->buffer
= retbuf
;
1591 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1592 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1593 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1594 bfd_get_filename (abfd
));
1597 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1601 dwarf2_get_section_info (struct objfile
*objfile
, const char *section_name
,
1602 asection
**sectp
, gdb_byte
**bufp
,
1603 bfd_size_type
*sizep
)
1605 struct dwarf2_per_objfile
*data
1606 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1607 struct dwarf2_section_info
*info
;
1609 /* We may see an objfile without any DWARF, in which case we just
1618 if (section_is_p (section_name
, EH_FRAME_SECTION
))
1619 info
= &data
->eh_frame
;
1620 else if (section_is_p (section_name
, FRAME_SECTION
))
1621 info
= &data
->frame
;
1623 gdb_assert_not_reached ("unexpected section");
1625 if (info
->asection
!= NULL
&& info
->size
!= 0 && info
->buffer
== NULL
)
1626 /* We haven't read this section in yet. Do it now. */
1627 dwarf2_read_section (objfile
, info
);
1629 *sectp
= info
->asection
;
1630 *bufp
= info
->buffer
;
1631 *sizep
= info
->size
;
1636 /* Read in the symbols for PER_CU. OBJFILE is the objfile from which
1639 dw2_do_instantiate_symtab (struct objfile
*objfile
,
1640 struct dwarf2_per_cu_data
*per_cu
)
1642 struct cleanup
*back_to
;
1644 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
1646 queue_comp_unit (per_cu
, objfile
);
1648 if (per_cu
->from_debug_types
)
1649 read_signatured_type_at_offset (objfile
, per_cu
->offset
);
1651 load_full_comp_unit (per_cu
, objfile
);
1653 process_queue (objfile
);
1655 /* Age the cache, releasing compilation units that have not
1656 been used recently. */
1657 age_cached_comp_units ();
1659 do_cleanups (back_to
);
1662 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1663 the objfile from which this CU came. Returns the resulting symbol
1665 static struct symtab
*
1666 dw2_instantiate_symtab (struct objfile
*objfile
,
1667 struct dwarf2_per_cu_data
*per_cu
)
1669 if (!per_cu
->v
.quick
->symtab
)
1671 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1672 increment_reading_symtab ();
1673 dw2_do_instantiate_symtab (objfile
, per_cu
);
1674 do_cleanups (back_to
);
1676 return per_cu
->v
.quick
->symtab
;
1679 /* Return the CU given its index. */
1680 static struct dwarf2_per_cu_data
*
1681 dw2_get_cu (int index
)
1683 if (index
>= dwarf2_per_objfile
->n_comp_units
)
1685 index
-= dwarf2_per_objfile
->n_comp_units
;
1686 return dwarf2_per_objfile
->type_comp_units
[index
];
1688 return dwarf2_per_objfile
->all_comp_units
[index
];
1691 /* A helper function that knows how to read a 64-bit value in a way
1692 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1695 extract_cu_value (const char *bytes
, ULONGEST
*result
)
1697 if (sizeof (ULONGEST
) < 8)
1701 /* Ignore the upper 4 bytes if they are all zero. */
1702 for (i
= 0; i
< 4; ++i
)
1703 if (bytes
[i
+ 4] != 0)
1706 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
1709 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
1713 /* Read the CU list from the mapped index, and use it to create all
1714 the CU objects for this objfile. Return 0 if something went wrong,
1715 1 if everything went ok. */
1717 create_cus_from_index (struct objfile
*objfile
, const gdb_byte
*cu_list
,
1718 offset_type cu_list_elements
)
1722 dwarf2_per_objfile
->n_comp_units
= cu_list_elements
/ 2;
1723 dwarf2_per_objfile
->all_comp_units
1724 = obstack_alloc (&objfile
->objfile_obstack
,
1725 dwarf2_per_objfile
->n_comp_units
1726 * sizeof (struct dwarf2_per_cu_data
*));
1728 for (i
= 0; i
< cu_list_elements
; i
+= 2)
1730 struct dwarf2_per_cu_data
*the_cu
;
1731 ULONGEST offset
, length
;
1733 if (!extract_cu_value (cu_list
, &offset
)
1734 || !extract_cu_value (cu_list
+ 8, &length
))
1738 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1739 struct dwarf2_per_cu_data
);
1740 the_cu
->offset
= offset
;
1741 the_cu
->length
= length
;
1742 the_cu
->objfile
= objfile
;
1743 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1744 struct dwarf2_per_cu_quick_data
);
1745 dwarf2_per_objfile
->all_comp_units
[i
/ 2] = the_cu
;
1751 /* Create the signatured type hash table from the index. */
1754 create_signatured_type_table_from_index (struct objfile
*objfile
,
1755 const gdb_byte
*bytes
,
1756 offset_type elements
)
1759 htab_t sig_types_hash
;
1761 dwarf2_per_objfile
->n_type_comp_units
= elements
/ 3;
1762 dwarf2_per_objfile
->type_comp_units
1763 = obstack_alloc (&objfile
->objfile_obstack
,
1764 dwarf2_per_objfile
->n_type_comp_units
1765 * sizeof (struct dwarf2_per_cu_data
*));
1767 sig_types_hash
= allocate_signatured_type_table (objfile
);
1769 for (i
= 0; i
< elements
; i
+= 3)
1771 struct signatured_type
*type_sig
;
1772 ULONGEST offset
, type_offset
, signature
;
1775 if (!extract_cu_value (bytes
, &offset
)
1776 || !extract_cu_value (bytes
+ 8, &type_offset
))
1778 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
1781 type_sig
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1782 struct signatured_type
);
1783 type_sig
->signature
= signature
;
1784 type_sig
->offset
= offset
;
1785 type_sig
->type_offset
= type_offset
;
1786 type_sig
->per_cu
.from_debug_types
= 1;
1787 type_sig
->per_cu
.offset
= offset
;
1788 type_sig
->per_cu
.objfile
= objfile
;
1789 type_sig
->per_cu
.v
.quick
1790 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1791 struct dwarf2_per_cu_quick_data
);
1793 slot
= htab_find_slot (sig_types_hash
, type_sig
, INSERT
);
1796 dwarf2_per_objfile
->type_comp_units
[i
/ 3] = &type_sig
->per_cu
;
1799 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
1804 /* Read the address map data from the mapped index, and use it to
1805 populate the objfile's psymtabs_addrmap. */
1807 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
1809 const gdb_byte
*iter
, *end
;
1810 struct obstack temp_obstack
;
1811 struct addrmap
*mutable_map
;
1812 struct cleanup
*cleanup
;
1815 obstack_init (&temp_obstack
);
1816 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
1817 mutable_map
= addrmap_create_mutable (&temp_obstack
);
1819 iter
= index
->address_table
;
1820 end
= iter
+ index
->address_table_size
;
1822 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1826 ULONGEST hi
, lo
, cu_index
;
1827 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
1829 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
1831 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
1834 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
1835 dw2_get_cu (cu_index
));
1838 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
1839 &objfile
->objfile_obstack
);
1840 do_cleanups (cleanup
);
1843 /* The hash function for strings in the mapped index. This is the
1844 same as the hashtab.c hash function, but we keep a separate copy to
1845 maintain control over the implementation. This is necessary
1846 because the hash function is tied to the format of the mapped index
1849 mapped_index_string_hash (const void *p
)
1851 const unsigned char *str
= (const unsigned char *) p
;
1855 while ((c
= *str
++) != 0)
1856 r
= r
* 67 + c
- 113;
1861 /* Find a slot in the mapped index INDEX for the object named NAME.
1862 If NAME is found, set *VEC_OUT to point to the CU vector in the
1863 constant pool and return 1. If NAME cannot be found, return 0. */
1865 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
1866 offset_type
**vec_out
)
1868 offset_type hash
= mapped_index_string_hash (name
);
1869 offset_type slot
, step
;
1871 slot
= hash
& (index
->index_table_slots
- 1);
1872 step
= ((hash
* 17) & (index
->index_table_slots
- 1)) | 1;
1876 /* Convert a slot number to an offset into the table. */
1877 offset_type i
= 2 * slot
;
1879 if (index
->index_table
[i
] == 0 && index
->index_table
[i
+ 1] == 0)
1882 str
= index
->constant_pool
+ MAYBE_SWAP (index
->index_table
[i
]);
1883 if (!strcmp (name
, str
))
1885 *vec_out
= (offset_type
*) (index
->constant_pool
1886 + MAYBE_SWAP (index
->index_table
[i
+ 1]));
1890 slot
= (slot
+ step
) & (index
->index_table_slots
- 1);
1894 /* Read the index file. If everything went ok, initialize the "quick"
1895 elements of all the CUs and return 1. Otherwise, return 0. */
1897 dwarf2_read_index (struct objfile
*objfile
)
1900 struct mapped_index
*map
;
1901 offset_type
*metadata
;
1902 const gdb_byte
*cu_list
;
1903 const gdb_byte
*types_list
= NULL
;
1904 offset_type version
, cu_list_elements
;
1905 offset_type types_list_elements
= 0;
1908 if (dwarf2_per_objfile
->gdb_index
.asection
== NULL
1909 || dwarf2_per_objfile
->gdb_index
.size
== 0)
1911 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->gdb_index
);
1913 addr
= dwarf2_per_objfile
->gdb_index
.buffer
;
1914 /* Version check. */
1915 version
= MAYBE_SWAP (*(offset_type
*) addr
);
1918 /* Index version 1 neglected to account for .debug_types. So,
1919 if we see .debug_types, we cannot use this index. */
1920 if (dwarf2_per_objfile
->types
.asection
!= NULL
1921 && dwarf2_per_objfile
->types
.size
!= 0)
1924 else if (version
!= 2)
1927 map
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct mapped_index
);
1928 map
->total_size
= dwarf2_per_objfile
->gdb_index
.size
;
1930 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
1933 cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
1934 cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
1940 types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
1941 types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
1942 - MAYBE_SWAP (metadata
[i
]))
1947 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
1948 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
1949 - MAYBE_SWAP (metadata
[i
]));
1952 map
->index_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
1953 map
->index_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
1954 - MAYBE_SWAP (metadata
[i
]))
1955 / (2 * sizeof (offset_type
)));
1958 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
1960 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
))
1964 && types_list_elements
1965 && !create_signatured_type_table_from_index (objfile
, types_list
,
1966 types_list_elements
))
1969 create_addrmap_from_index (objfile
, map
);
1971 dwarf2_per_objfile
->index_table
= map
;
1972 dwarf2_per_objfile
->using_index
= 1;
1977 /* A helper for the "quick" functions which sets the global
1978 dwarf2_per_objfile according to OBJFILE. */
1980 dw2_setup (struct objfile
*objfile
)
1982 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1983 gdb_assert (dwarf2_per_objfile
);
1986 /* A helper for the "quick" functions which attempts to read the line
1987 table for THIS_CU. */
1989 dw2_require_line_header (struct objfile
*objfile
,
1990 struct dwarf2_per_cu_data
*this_cu
)
1992 bfd
*abfd
= objfile
->obfd
;
1993 struct line_header
*lh
= NULL
;
1994 struct attribute
*attr
;
1995 struct cleanup
*cleanups
;
1996 struct die_info
*comp_unit_die
;
1997 gdb_byte
*beg_of_comp_unit
, *info_ptr
, *buffer
;
1998 int has_children
, i
;
1999 struct dwarf2_cu cu
;
2000 unsigned int bytes_read
, buffer_size
;
2001 struct die_reader_specs reader_specs
;
2002 char *name
, *comp_dir
;
2004 if (this_cu
->v
.quick
->read_lines
)
2006 this_cu
->v
.quick
->read_lines
= 1;
2008 memset (&cu
, 0, sizeof (cu
));
2009 cu
.objfile
= objfile
;
2010 obstack_init (&cu
.comp_unit_obstack
);
2012 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
2014 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
2015 buffer_size
= dwarf2_per_objfile
->info
.size
;
2016 buffer
= dwarf2_per_objfile
->info
.buffer
;
2017 info_ptr
= buffer
+ this_cu
->offset
;
2018 beg_of_comp_unit
= info_ptr
;
2020 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
2021 buffer
, buffer_size
,
2024 /* Complete the cu_header. */
2025 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
2026 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
2029 cu
.per_cu
= this_cu
;
2031 dwarf2_read_abbrevs (abfd
, &cu
);
2032 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
2034 if (this_cu
->from_debug_types
)
2035 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
2036 init_cu_die_reader (&reader_specs
, &cu
);
2037 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2040 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, &cu
);
2043 unsigned int line_offset
= DW_UNSND (attr
);
2044 lh
= dwarf_decode_line_header (line_offset
, abfd
, &cu
);
2048 do_cleanups (cleanups
);
2052 find_file_and_directory (comp_unit_die
, &cu
, &name
, &comp_dir
);
2054 this_cu
->v
.quick
->lines
= lh
;
2056 this_cu
->v
.quick
->file_names
2057 = obstack_alloc (&objfile
->objfile_obstack
,
2058 lh
->num_file_names
* sizeof (char *));
2059 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2060 this_cu
->v
.quick
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2062 do_cleanups (cleanups
);
2065 /* A helper for the "quick" functions which computes and caches the
2066 real path for a given file name from the line table.
2067 dw2_require_line_header must have been called before this is
2070 dw2_require_full_path (struct objfile
*objfile
,
2071 struct dwarf2_per_cu_data
*cu
,
2074 if (!cu
->v
.quick
->full_names
)
2075 cu
->v
.quick
->full_names
2076 = OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2077 cu
->v
.quick
->lines
->num_file_names
,
2080 if (!cu
->v
.quick
->full_names
[index
])
2081 cu
->v
.quick
->full_names
[index
]
2082 = gdb_realpath (cu
->v
.quick
->file_names
[index
]);
2084 return cu
->v
.quick
->full_names
[index
];
2087 static struct symtab
*
2088 dw2_find_last_source_symtab (struct objfile
*objfile
)
2091 dw2_setup (objfile
);
2092 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2093 return dw2_instantiate_symtab (objfile
, dw2_get_cu (index
));
2097 dw2_forget_cached_source_info (struct objfile
*objfile
)
2101 dw2_setup (objfile
);
2102 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2103 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2105 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2107 if (cu
->v
.quick
->full_names
)
2111 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2112 xfree ((void *) cu
->v
.quick
->full_names
[j
]);
2118 dw2_lookup_symtab (struct objfile
*objfile
, const char *name
,
2119 const char *full_path
, const char *real_path
,
2120 struct symtab
**result
)
2123 int check_basename
= lbasename (name
) == name
;
2124 struct dwarf2_per_cu_data
*base_cu
= NULL
;
2126 dw2_setup (objfile
);
2127 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2128 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2131 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2133 if (cu
->v
.quick
->symtab
)
2136 dw2_require_line_header (objfile
, cu
);
2137 if (!cu
->v
.quick
->lines
)
2140 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2142 const char *this_name
= cu
->v
.quick
->file_names
[j
];
2144 if (FILENAME_CMP (name
, this_name
) == 0)
2146 *result
= dw2_instantiate_symtab (objfile
, cu
);
2150 if (check_basename
&& ! base_cu
2151 && FILENAME_CMP (lbasename (this_name
), name
) == 0)
2154 if (full_path
!= NULL
)
2156 const char *this_full_name
= dw2_require_full_path (objfile
,
2160 && FILENAME_CMP (full_path
, this_full_name
) == 0)
2162 *result
= dw2_instantiate_symtab (objfile
, cu
);
2167 if (real_path
!= NULL
)
2169 const char *this_full_name
= dw2_require_full_path (objfile
,
2172 if (this_full_name
!= NULL
)
2174 char *rp
= gdb_realpath (this_full_name
);
2175 if (rp
!= NULL
&& FILENAME_CMP (real_path
, rp
) == 0)
2178 *result
= dw2_instantiate_symtab (objfile
, cu
);
2189 *result
= dw2_instantiate_symtab (objfile
, base_cu
);
2196 static struct symtab
*
2197 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
2198 const char *name
, domain_enum domain
)
2200 /* We do all the work in the pre_expand_symtabs_matching hook
2205 /* A helper function that expands all symtabs that hold an object
2208 dw2_do_expand_symtabs_matching (struct objfile
*objfile
, const char *name
)
2210 dw2_setup (objfile
);
2212 if (dwarf2_per_objfile
->index_table
)
2216 if (find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2219 offset_type i
, len
= MAYBE_SWAP (*vec
);
2220 for (i
= 0; i
< len
; ++i
)
2222 offset_type cu_index
= MAYBE_SWAP (vec
[i
+ 1]);
2223 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (cu_index
);
2225 dw2_instantiate_symtab (objfile
, cu
);
2232 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
2233 int kind
, const char *name
,
2236 dw2_do_expand_symtabs_matching (objfile
, name
);
2240 dw2_print_stats (struct objfile
*objfile
)
2244 dw2_setup (objfile
);
2246 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2247 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2249 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2251 if (!cu
->v
.quick
->symtab
)
2254 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
2258 dw2_dump (struct objfile
*objfile
)
2260 /* Nothing worth printing. */
2264 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
2265 struct section_offsets
*delta
)
2267 /* There's nothing to relocate here. */
2271 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
2272 const char *func_name
)
2274 dw2_do_expand_symtabs_matching (objfile
, func_name
);
2278 dw2_expand_all_symtabs (struct objfile
*objfile
)
2282 dw2_setup (objfile
);
2284 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2285 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2287 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2289 dw2_instantiate_symtab (objfile
, cu
);
2294 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
2295 const char *filename
)
2299 dw2_setup (objfile
);
2300 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2301 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2304 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2306 if (cu
->v
.quick
->symtab
)
2309 dw2_require_line_header (objfile
, cu
);
2310 if (!cu
->v
.quick
->lines
)
2313 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2315 const char *this_name
= cu
->v
.quick
->file_names
[j
];
2316 if (strcmp (this_name
, filename
) == 0)
2318 dw2_instantiate_symtab (objfile
, cu
);
2326 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
2328 struct dwarf2_per_cu_data
*cu
;
2331 dw2_setup (objfile
);
2333 if (!dwarf2_per_objfile
->index_table
)
2336 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2340 /* Note that this just looks at the very first one named NAME -- but
2341 actually we are looking for a function. find_main_filename
2342 should be rewritten so that it doesn't require a custom hook. It
2343 could just use the ordinary symbol tables. */
2344 /* vec[0] is the length, which must always be >0. */
2345 cu
= dw2_get_cu (MAYBE_SWAP (vec
[1]));
2347 dw2_require_line_header (objfile
, cu
);
2348 if (!cu
->v
.quick
->lines
)
2351 return cu
->v
.quick
->file_names
[cu
->v
.quick
->lines
->num_file_names
- 1];
2355 dw2_map_ada_symtabs (struct objfile
*objfile
,
2356 int (*wild_match
) (const char *, int, const char *),
2357 int (*is_name_suffix
) (const char *),
2358 void (*callback
) (struct objfile
*,
2359 struct symtab
*, void *),
2360 const char *name
, int global
,
2361 domain_enum
namespace, int wild
,
2364 /* For now, we don't support Ada, so this function can't be
2366 internal_error (__FILE__
, __LINE__
,
2367 _("map_ada_symtabs called via index method"));
2371 dw2_expand_symtabs_matching (struct objfile
*objfile
,
2372 int (*file_matcher
) (const char *, void *),
2373 int (*name_matcher
) (const char *, void *),
2380 dw2_setup (objfile
);
2381 if (!dwarf2_per_objfile
->index_table
)
2384 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2385 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2388 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2390 cu
->v
.quick
->mark
= 0;
2391 if (cu
->v
.quick
->symtab
)
2394 dw2_require_line_header (objfile
, cu
);
2395 if (!cu
->v
.quick
->lines
)
2398 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2400 if (file_matcher (cu
->v
.quick
->file_names
[j
], data
))
2402 cu
->v
.quick
->mark
= 1;
2409 iter
< dwarf2_per_objfile
->index_table
->index_table_slots
;
2412 offset_type idx
= 2 * iter
;
2414 offset_type
*vec
, vec_len
, vec_idx
;
2416 if (dwarf2_per_objfile
->index_table
->index_table
[idx
] == 0
2417 && dwarf2_per_objfile
->index_table
->index_table
[idx
+ 1] == 0)
2420 name
= (dwarf2_per_objfile
->index_table
->constant_pool
2421 + dwarf2_per_objfile
->index_table
->index_table
[idx
]);
2423 if (! (*name_matcher
) (name
, data
))
2426 /* The name was matched, now expand corresponding CUs that were
2428 vec
= (offset_type
*) (dwarf2_per_objfile
->index_table
->constant_pool
2429 + dwarf2_per_objfile
->index_table
->index_table
[idx
+ 1]);
2430 vec_len
= MAYBE_SWAP (vec
[0]);
2431 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
2433 struct dwarf2_per_cu_data
*cu
;
2435 cu
= dw2_get_cu (MAYBE_SWAP (vec
[vec_idx
+ 1]));
2436 if (cu
->v
.quick
->mark
)
2437 dw2_instantiate_symtab (objfile
, cu
);
2442 static struct symtab
*
2443 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
2444 struct minimal_symbol
*msymbol
,
2446 struct obj_section
*section
,
2449 struct dwarf2_per_cu_data
*data
;
2451 dw2_setup (objfile
);
2453 if (!objfile
->psymtabs_addrmap
)
2456 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
2460 if (warn_if_readin
&& data
->v
.quick
->symtab
)
2461 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2462 paddress (get_objfile_arch (objfile
), pc
));
2464 return dw2_instantiate_symtab (objfile
, data
);
2468 dw2_map_symbol_names (struct objfile
*objfile
,
2469 void (*fun
) (const char *, void *),
2473 dw2_setup (objfile
);
2475 if (!dwarf2_per_objfile
->index_table
)
2479 iter
< dwarf2_per_objfile
->index_table
->index_table_slots
;
2482 offset_type idx
= 2 * iter
;
2484 offset_type
*vec
, vec_len
, vec_idx
;
2486 if (dwarf2_per_objfile
->index_table
->index_table
[idx
] == 0
2487 && dwarf2_per_objfile
->index_table
->index_table
[idx
+ 1] == 0)
2490 name
= (dwarf2_per_objfile
->index_table
->constant_pool
2491 + dwarf2_per_objfile
->index_table
->index_table
[idx
]);
2493 (*fun
) (name
, data
);
2498 dw2_map_symbol_filenames (struct objfile
*objfile
,
2499 void (*fun
) (const char *, const char *, void *),
2504 dw2_setup (objfile
);
2505 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2506 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2509 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2511 if (cu
->v
.quick
->symtab
)
2514 dw2_require_line_header (objfile
, cu
);
2515 if (!cu
->v
.quick
->lines
)
2518 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2520 const char *this_full_name
= dw2_require_full_path (objfile
, cu
, j
);
2521 (*fun
) (cu
->v
.quick
->file_names
[j
], this_full_name
, data
);
2527 dw2_has_symbols (struct objfile
*objfile
)
2532 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
2535 dw2_find_last_source_symtab
,
2536 dw2_forget_cached_source_info
,
2539 dw2_pre_expand_symtabs_matching
,
2543 dw2_expand_symtabs_for_function
,
2544 dw2_expand_all_symtabs
,
2545 dw2_expand_symtabs_with_filename
,
2546 dw2_find_symbol_file
,
2547 dw2_map_ada_symtabs
,
2548 dw2_expand_symtabs_matching
,
2549 dw2_find_pc_sect_symtab
,
2550 dw2_map_symbol_names
,
2551 dw2_map_symbol_filenames
2554 /* Initialize for reading DWARF for this objfile. Return 0 if this
2555 file will use psymtabs, or 1 if using the GNU index. */
2558 dwarf2_initialize_objfile (struct objfile
*objfile
)
2560 /* If we're about to read full symbols, don't bother with the
2561 indices. In this case we also don't care if some other debug
2562 format is making psymtabs, because they are all about to be
2564 if ((objfile
->flags
& OBJF_READNOW
))
2568 dwarf2_per_objfile
->using_index
= 1;
2569 create_all_comp_units (objfile
);
2570 create_debug_types_hash_table (objfile
);
2572 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2573 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2575 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2577 cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2578 struct dwarf2_per_cu_quick_data
);
2581 /* Return 1 so that gdb sees the "quick" functions. However,
2582 these functions will be no-ops because we will have expanded
2587 if (dwarf2_read_index (objfile
))
2590 dwarf2_build_psymtabs (objfile
);
2596 /* Build a partial symbol table. */
2599 dwarf2_build_psymtabs (struct objfile
*objfile
)
2601 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
2603 init_psymbol_list (objfile
, 1024);
2606 dwarf2_build_psymtabs_hard (objfile
);
2609 /* Return TRUE if OFFSET is within CU_HEADER. */
2612 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
2614 unsigned int bottom
= cu_header
->offset
;
2615 unsigned int top
= (cu_header
->offset
2617 + cu_header
->initial_length_size
);
2619 return (offset
>= bottom
&& offset
< top
);
2622 /* Read in the comp unit header information from the debug_info at info_ptr.
2623 NOTE: This leaves members offset, first_die_offset to be filled in
2627 read_comp_unit_head (struct comp_unit_head
*cu_header
,
2628 gdb_byte
*info_ptr
, bfd
*abfd
)
2631 unsigned int bytes_read
;
2633 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
2634 cu_header
->initial_length_size
= bytes_read
;
2635 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
2636 info_ptr
+= bytes_read
;
2637 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
2639 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
2641 info_ptr
+= bytes_read
;
2642 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
2644 signed_addr
= bfd_get_sign_extend_vma (abfd
);
2645 if (signed_addr
< 0)
2646 internal_error (__FILE__
, __LINE__
,
2647 _("read_comp_unit_head: dwarf from non elf file"));
2648 cu_header
->signed_addr_p
= signed_addr
;
2654 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
2655 gdb_byte
*buffer
, unsigned int buffer_size
,
2658 gdb_byte
*beg_of_comp_unit
= info_ptr
;
2660 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
2662 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
2663 error (_("Dwarf Error: wrong version in compilation unit header "
2664 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
2665 bfd_get_filename (abfd
));
2667 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev
.size
)
2668 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
2669 "(offset 0x%lx + 6) [in module %s]"),
2670 (long) header
->abbrev_offset
,
2671 (long) (beg_of_comp_unit
- buffer
),
2672 bfd_get_filename (abfd
));
2674 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
2675 > buffer
+ buffer_size
)
2676 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
2677 "(offset 0x%lx + 0) [in module %s]"),
2678 (long) header
->length
,
2679 (long) (beg_of_comp_unit
- buffer
),
2680 bfd_get_filename (abfd
));
2685 /* Read in the types comp unit header information from .debug_types entry at
2686 types_ptr. The result is a pointer to one past the end of the header. */
2689 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
2690 ULONGEST
*signature
,
2691 gdb_byte
*types_ptr
, bfd
*abfd
)
2693 gdb_byte
*initial_types_ptr
= types_ptr
;
2695 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
2696 &dwarf2_per_objfile
->types
);
2697 cu_header
->offset
= types_ptr
- dwarf2_per_objfile
->types
.buffer
;
2699 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
2701 *signature
= read_8_bytes (abfd
, types_ptr
);
2703 types_ptr
+= cu_header
->offset_size
;
2704 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
2709 /* Allocate a new partial symtab for file named NAME and mark this new
2710 partial symtab as being an include of PST. */
2713 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
2714 struct objfile
*objfile
)
2716 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
2718 subpst
->section_offsets
= pst
->section_offsets
;
2719 subpst
->textlow
= 0;
2720 subpst
->texthigh
= 0;
2722 subpst
->dependencies
= (struct partial_symtab
**)
2723 obstack_alloc (&objfile
->objfile_obstack
,
2724 sizeof (struct partial_symtab
*));
2725 subpst
->dependencies
[0] = pst
;
2726 subpst
->number_of_dependencies
= 1;
2728 subpst
->globals_offset
= 0;
2729 subpst
->n_global_syms
= 0;
2730 subpst
->statics_offset
= 0;
2731 subpst
->n_static_syms
= 0;
2732 subpst
->symtab
= NULL
;
2733 subpst
->read_symtab
= pst
->read_symtab
;
2736 /* No private part is necessary for include psymtabs. This property
2737 can be used to differentiate between such include psymtabs and
2738 the regular ones. */
2739 subpst
->read_symtab_private
= NULL
;
2742 /* Read the Line Number Program data and extract the list of files
2743 included by the source file represented by PST. Build an include
2744 partial symtab for each of these included files. */
2747 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
2748 struct die_info
*die
,
2749 struct partial_symtab
*pst
)
2751 struct objfile
*objfile
= cu
->objfile
;
2752 bfd
*abfd
= objfile
->obfd
;
2753 struct line_header
*lh
= NULL
;
2754 struct attribute
*attr
;
2756 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2759 unsigned int line_offset
= DW_UNSND (attr
);
2761 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2764 return; /* No linetable, so no includes. */
2766 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
2768 free_line_header (lh
);
2772 hash_type_signature (const void *item
)
2774 const struct signatured_type
*type_sig
= item
;
2776 /* This drops the top 32 bits of the signature, but is ok for a hash. */
2777 return type_sig
->signature
;
2781 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
2783 const struct signatured_type
*lhs
= item_lhs
;
2784 const struct signatured_type
*rhs
= item_rhs
;
2786 return lhs
->signature
== rhs
->signature
;
2789 /* Allocate a hash table for signatured types. */
2792 allocate_signatured_type_table (struct objfile
*objfile
)
2794 return htab_create_alloc_ex (41,
2795 hash_type_signature
,
2798 &objfile
->objfile_obstack
,
2799 hashtab_obstack_allocate
,
2800 dummy_obstack_deallocate
);
2803 /* A helper function to add a signatured type CU to a list. */
2806 add_signatured_type_cu_to_list (void **slot
, void *datum
)
2808 struct signatured_type
*sigt
= *slot
;
2809 struct dwarf2_per_cu_data
***datap
= datum
;
2811 **datap
= &sigt
->per_cu
;
2817 /* Create the hash table of all entries in the .debug_types section.
2818 The result is zero if there is an error (e.g. missing .debug_types section),
2819 otherwise non-zero. */
2822 create_debug_types_hash_table (struct objfile
*objfile
)
2826 struct dwarf2_per_cu_data
**iter
;
2828 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
2829 info_ptr
= dwarf2_per_objfile
->types
.buffer
;
2831 if (info_ptr
== NULL
)
2833 dwarf2_per_objfile
->signatured_types
= NULL
;
2837 types_htab
= allocate_signatured_type_table (objfile
);
2839 if (dwarf2_die_debug
)
2840 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
2842 while (info_ptr
< dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
2844 unsigned int offset
;
2845 unsigned int offset_size
;
2846 unsigned int type_offset
;
2847 unsigned int length
, initial_length_size
;
2848 unsigned short version
;
2850 struct signatured_type
*type_sig
;
2852 gdb_byte
*ptr
= info_ptr
;
2854 offset
= ptr
- dwarf2_per_objfile
->types
.buffer
;
2856 /* We need to read the type's signature in order to build the hash
2857 table, but we don't need to read anything else just yet. */
2859 /* Sanity check to ensure entire cu is present. */
2860 length
= read_initial_length (objfile
->obfd
, ptr
, &initial_length_size
);
2861 if (ptr
+ length
+ initial_length_size
2862 > dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
2864 complaint (&symfile_complaints
,
2865 _("debug type entry runs off end of `.debug_types' section, ignored"));
2869 offset_size
= initial_length_size
== 4 ? 4 : 8;
2870 ptr
+= initial_length_size
;
2871 version
= bfd_get_16 (objfile
->obfd
, ptr
);
2873 ptr
+= offset_size
; /* abbrev offset */
2874 ptr
+= 1; /* address size */
2875 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
2877 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
2879 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
2880 memset (type_sig
, 0, sizeof (*type_sig
));
2881 type_sig
->signature
= signature
;
2882 type_sig
->offset
= offset
;
2883 type_sig
->type_offset
= type_offset
;
2884 type_sig
->per_cu
.objfile
= objfile
;
2885 type_sig
->per_cu
.from_debug_types
= 1;
2887 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
2888 gdb_assert (slot
!= NULL
);
2891 if (dwarf2_die_debug
)
2892 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
2893 offset
, phex (signature
, sizeof (signature
)));
2895 info_ptr
= info_ptr
+ initial_length_size
+ length
;
2898 dwarf2_per_objfile
->signatured_types
= types_htab
;
2900 dwarf2_per_objfile
->n_type_comp_units
= htab_elements (types_htab
);
2901 dwarf2_per_objfile
->type_comp_units
2902 = obstack_alloc (&objfile
->objfile_obstack
,
2903 dwarf2_per_objfile
->n_type_comp_units
2904 * sizeof (struct dwarf2_per_cu_data
*));
2905 iter
= &dwarf2_per_objfile
->type_comp_units
[0];
2906 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_list
, &iter
);
2907 gdb_assert (iter
- &dwarf2_per_objfile
->type_comp_units
[0]
2908 == dwarf2_per_objfile
->n_type_comp_units
);
2913 /* Lookup a signature based type.
2914 Returns NULL if SIG is not present in the table. */
2916 static struct signatured_type
*
2917 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
2919 struct signatured_type find_entry
, *entry
;
2921 if (dwarf2_per_objfile
->signatured_types
== NULL
)
2923 complaint (&symfile_complaints
,
2924 _("missing `.debug_types' section for DW_FORM_sig8 die"));
2928 find_entry
.signature
= sig
;
2929 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
2933 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
2936 init_cu_die_reader (struct die_reader_specs
*reader
,
2937 struct dwarf2_cu
*cu
)
2939 reader
->abfd
= cu
->objfile
->obfd
;
2941 if (cu
->per_cu
->from_debug_types
)
2943 gdb_assert (dwarf2_per_objfile
->types
.readin
);
2944 reader
->buffer
= dwarf2_per_objfile
->types
.buffer
;
2948 gdb_assert (dwarf2_per_objfile
->info
.readin
);
2949 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
2953 /* Find the base address of the compilation unit for range lists and
2954 location lists. It will normally be specified by DW_AT_low_pc.
2955 In DWARF-3 draft 4, the base address could be overridden by
2956 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2957 compilation units with discontinuous ranges. */
2960 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
2962 struct attribute
*attr
;
2965 cu
->base_address
= 0;
2967 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
2970 cu
->base_address
= DW_ADDR (attr
);
2975 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
2978 cu
->base_address
= DW_ADDR (attr
);
2984 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
2985 to combine the common parts.
2986 Process a compilation unit for a psymtab.
2987 BUFFER is a pointer to the beginning of the dwarf section buffer,
2988 either .debug_info or debug_types.
2989 INFO_PTR is a pointer to the start of the CU.
2990 Returns a pointer to the next CU. */
2993 process_psymtab_comp_unit (struct objfile
*objfile
,
2994 struct dwarf2_per_cu_data
*this_cu
,
2995 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
2996 unsigned int buffer_size
)
2998 bfd
*abfd
= objfile
->obfd
;
2999 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3000 struct die_info
*comp_unit_die
;
3001 struct partial_symtab
*pst
;
3003 struct cleanup
*back_to_inner
;
3004 struct dwarf2_cu cu
;
3005 int has_children
, has_pc_info
;
3006 struct attribute
*attr
;
3007 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
3008 struct die_reader_specs reader_specs
;
3010 memset (&cu
, 0, sizeof (cu
));
3011 cu
.objfile
= objfile
;
3012 obstack_init (&cu
.comp_unit_obstack
);
3014 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
3016 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
3017 buffer
, buffer_size
,
3020 /* Complete the cu_header. */
3021 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
3022 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3024 cu
.list_in_scope
= &file_symbols
;
3026 /* If this compilation unit was already read in, free the
3027 cached copy in order to read it in again. This is
3028 necessary because we skipped some symbols when we first
3029 read in the compilation unit (see load_partial_dies).
3030 This problem could be avoided, but the benefit is
3032 if (this_cu
->cu
!= NULL
)
3033 free_one_cached_comp_unit (this_cu
->cu
);
3035 /* Note that this is a pointer to our stack frame, being
3036 added to a global data structure. It will be cleaned up
3037 in free_stack_comp_unit when we finish with this
3038 compilation unit. */
3040 cu
.per_cu
= this_cu
;
3042 /* Read the abbrevs for this compilation unit into a table. */
3043 dwarf2_read_abbrevs (abfd
, &cu
);
3044 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
3046 /* Read the compilation unit die. */
3047 if (this_cu
->from_debug_types
)
3048 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
3049 init_cu_die_reader (&reader_specs
, &cu
);
3050 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3053 if (this_cu
->from_debug_types
)
3055 /* offset,length haven't been set yet for type units. */
3056 this_cu
->offset
= cu
.header
.offset
;
3057 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
3059 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3061 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3062 + cu
.header
.initial_length_size
);
3063 do_cleanups (back_to_inner
);
3067 /* Set the language we're debugging. */
3068 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, &cu
);
3070 set_cu_language (DW_UNSND (attr
), &cu
);
3072 set_cu_language (language_minimal
, &cu
);
3074 /* Allocate a new partial symbol table structure. */
3075 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
3076 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
3077 (attr
!= NULL
) ? DW_STRING (attr
) : "",
3078 /* TEXTLOW and TEXTHIGH are set below. */
3080 objfile
->global_psymbols
.next
,
3081 objfile
->static_psymbols
.next
);
3083 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
3085 pst
->dirname
= DW_STRING (attr
);
3087 pst
->read_symtab_private
= this_cu
;
3089 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3091 /* Store the function that reads in the rest of the symbol table */
3092 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
3094 this_cu
->v
.psymtab
= pst
;
3096 dwarf2_find_base_address (comp_unit_die
, &cu
);
3098 /* Possibly set the default values of LOWPC and HIGHPC from
3100 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
3101 &best_highpc
, &cu
, pst
);
3102 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
3103 /* Store the contiguous range if it is not empty; it can be empty for
3104 CUs with no code. */
3105 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3106 best_lowpc
+ baseaddr
,
3107 best_highpc
+ baseaddr
- 1, pst
);
3109 /* Check if comp unit has_children.
3110 If so, read the rest of the partial symbols from this comp unit.
3111 If not, there's no more debug_info for this comp unit. */
3114 struct partial_die_info
*first_die
;
3115 CORE_ADDR lowpc
, highpc
;
3117 lowpc
= ((CORE_ADDR
) -1);
3118 highpc
= ((CORE_ADDR
) 0);
3120 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
3122 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
3123 ! has_pc_info
, &cu
);
3125 /* If we didn't find a lowpc, set it to highpc to avoid
3126 complaints from `maint check'. */
3127 if (lowpc
== ((CORE_ADDR
) -1))
3130 /* If the compilation unit didn't have an explicit address range,
3131 then use the information extracted from its child dies. */
3135 best_highpc
= highpc
;
3138 pst
->textlow
= best_lowpc
+ baseaddr
;
3139 pst
->texthigh
= best_highpc
+ baseaddr
;
3141 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
3142 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
3143 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
3144 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
3145 sort_pst_symbols (pst
);
3147 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3148 + cu
.header
.initial_length_size
);
3150 if (this_cu
->from_debug_types
)
3152 /* It's not clear we want to do anything with stmt lists here.
3153 Waiting to see what gcc ultimately does. */
3157 /* Get the list of files included in the current compilation unit,
3158 and build a psymtab for each of them. */
3159 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
3162 do_cleanups (back_to_inner
);
3167 /* Traversal function for htab_traverse_noresize.
3168 Process one .debug_types comp-unit. */
3171 process_type_comp_unit (void **slot
, void *info
)
3173 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
3174 struct objfile
*objfile
= (struct objfile
*) info
;
3175 struct dwarf2_per_cu_data
*this_cu
;
3177 this_cu
= &entry
->per_cu
;
3179 gdb_assert (dwarf2_per_objfile
->types
.readin
);
3180 process_psymtab_comp_unit (objfile
, this_cu
,
3181 dwarf2_per_objfile
->types
.buffer
,
3182 dwarf2_per_objfile
->types
.buffer
+ entry
->offset
,
3183 dwarf2_per_objfile
->types
.size
);
3188 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3189 Build partial symbol tables for the .debug_types comp-units. */
3192 build_type_psymtabs (struct objfile
*objfile
)
3194 if (! create_debug_types_hash_table (objfile
))
3197 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
3198 process_type_comp_unit
, objfile
);
3201 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3204 psymtabs_addrmap_cleanup (void *o
)
3206 struct objfile
*objfile
= o
;
3208 objfile
->psymtabs_addrmap
= NULL
;
3211 /* Build the partial symbol table by doing a quick pass through the
3212 .debug_info and .debug_abbrev sections. */
3215 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
3218 struct cleanup
*back_to
, *addrmap_cleanup
;
3219 struct obstack temp_obstack
;
3221 dwarf2_per_objfile
->reading_partial_symbols
= 1;
3223 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3224 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3226 /* Any cached compilation units will be linked by the per-objfile
3227 read_in_chain. Make sure to free them when we're done. */
3228 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
3230 build_type_psymtabs (objfile
);
3232 create_all_comp_units (objfile
);
3234 /* Create a temporary address map on a temporary obstack. We later
3235 copy this to the final obstack. */
3236 obstack_init (&temp_obstack
);
3237 make_cleanup_obstack_free (&temp_obstack
);
3238 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
3239 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
3241 /* Since the objects we're extracting from .debug_info vary in
3242 length, only the individual functions to extract them (like
3243 read_comp_unit_head and load_partial_die) can really know whether
3244 the buffer is large enough to hold another complete object.
3246 At the moment, they don't actually check that. If .debug_info
3247 holds just one extra byte after the last compilation unit's dies,
3248 then read_comp_unit_head will happily read off the end of the
3249 buffer. read_partial_die is similarly casual. Those functions
3252 For this loop condition, simply checking whether there's any data
3253 left at all should be sufficient. */
3255 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
3256 + dwarf2_per_objfile
->info
.size
))
3258 struct dwarf2_per_cu_data
*this_cu
;
3260 this_cu
= dwarf2_find_comp_unit (info_ptr
- dwarf2_per_objfile
->info
.buffer
,
3263 info_ptr
= process_psymtab_comp_unit (objfile
, this_cu
,
3264 dwarf2_per_objfile
->info
.buffer
,
3266 dwarf2_per_objfile
->info
.size
);
3269 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
3270 &objfile
->objfile_obstack
);
3271 discard_cleanups (addrmap_cleanup
);
3273 do_cleanups (back_to
);
3276 /* Load the partial DIEs for a secondary CU into memory. */
3279 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
3280 struct objfile
*objfile
)
3282 bfd
*abfd
= objfile
->obfd
;
3283 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
3284 struct die_info
*comp_unit_die
;
3285 struct dwarf2_cu
*cu
;
3286 struct cleanup
*free_abbrevs_cleanup
, *free_cu_cleanup
= NULL
;
3287 struct attribute
*attr
;
3289 struct die_reader_specs reader_specs
;
3292 gdb_assert (! this_cu
->from_debug_types
);
3294 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3295 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
3296 beg_of_comp_unit
= info_ptr
;
3298 if (this_cu
->cu
== NULL
)
3300 cu
= alloc_one_comp_unit (objfile
);
3304 /* If an error occurs while loading, release our storage. */
3305 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
3307 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
3308 dwarf2_per_objfile
->info
.buffer
,
3309 dwarf2_per_objfile
->info
.size
,
3312 /* Complete the cu_header. */
3313 cu
->header
.offset
= this_cu
->offset
;
3314 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3316 /* Link this compilation unit into the compilation unit tree. */
3318 cu
->per_cu
= this_cu
;
3320 /* Link this CU into read_in_chain. */
3321 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3322 dwarf2_per_objfile
->read_in_chain
= this_cu
;
3327 info_ptr
+= cu
->header
.first_die_offset
;
3330 /* Read the abbrevs for this compilation unit into a table. */
3331 gdb_assert (cu
->dwarf2_abbrevs
== NULL
);
3332 dwarf2_read_abbrevs (abfd
, cu
);
3333 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3335 /* Read the compilation unit die. */
3336 init_cu_die_reader (&reader_specs
, cu
);
3337 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3340 /* Set the language we're debugging. */
3341 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
3343 set_cu_language (DW_UNSND (attr
), cu
);
3345 set_cu_language (language_minimal
, cu
);
3347 /* Check if comp unit has_children.
3348 If so, read the rest of the partial symbols from this comp unit.
3349 If not, there's no more debug_info for this comp unit. */
3351 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
3353 do_cleanups (free_abbrevs_cleanup
);
3357 /* We've successfully allocated this compilation unit. Let our
3358 caller clean it up when finished with it. */
3359 discard_cleanups (free_cu_cleanup
);
3363 /* Create a list of all compilation units in OBJFILE. We do this only
3364 if an inter-comp-unit reference is found; presumably if there is one,
3365 there will be many, and one will occur early in the .debug_info section.
3366 So there's no point in building this list incrementally. */
3369 create_all_comp_units (struct objfile
*objfile
)
3373 struct dwarf2_per_cu_data
**all_comp_units
;
3376 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3377 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3381 all_comp_units
= xmalloc (n_allocated
3382 * sizeof (struct dwarf2_per_cu_data
*));
3384 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
+ dwarf2_per_objfile
->info
.size
)
3386 unsigned int length
, initial_length_size
;
3387 struct dwarf2_per_cu_data
*this_cu
;
3388 unsigned int offset
;
3390 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
3392 /* Read just enough information to find out where the next
3393 compilation unit is. */
3394 length
= read_initial_length (objfile
->obfd
, info_ptr
,
3395 &initial_length_size
);
3397 /* Save the compilation unit for later lookup. */
3398 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
3399 sizeof (struct dwarf2_per_cu_data
));
3400 memset (this_cu
, 0, sizeof (*this_cu
));
3401 this_cu
->offset
= offset
;
3402 this_cu
->length
= length
+ initial_length_size
;
3403 this_cu
->objfile
= objfile
;
3405 if (n_comp_units
== n_allocated
)
3408 all_comp_units
= xrealloc (all_comp_units
,
3410 * sizeof (struct dwarf2_per_cu_data
*));
3412 all_comp_units
[n_comp_units
++] = this_cu
;
3414 info_ptr
= info_ptr
+ this_cu
->length
;
3417 dwarf2_per_objfile
->all_comp_units
3418 = obstack_alloc (&objfile
->objfile_obstack
,
3419 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3420 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
3421 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3422 xfree (all_comp_units
);
3423 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
3426 /* Process all loaded DIEs for compilation unit CU, starting at
3427 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3428 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3429 DW_AT_ranges). If NEED_PC is set, then this function will set
3430 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3431 and record the covered ranges in the addrmap. */
3434 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
3435 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3437 struct partial_die_info
*pdi
;
3439 /* Now, march along the PDI's, descending into ones which have
3440 interesting children but skipping the children of the other ones,
3441 until we reach the end of the compilation unit. */
3447 fixup_partial_die (pdi
, cu
);
3449 /* Anonymous namespaces or modules have no name but have interesting
3450 children, so we need to look at them. Ditto for anonymous
3453 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
3454 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
)
3458 case DW_TAG_subprogram
:
3459 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3461 case DW_TAG_variable
:
3462 case DW_TAG_typedef
:
3463 case DW_TAG_union_type
:
3464 if (!pdi
->is_declaration
)
3466 add_partial_symbol (pdi
, cu
);
3469 case DW_TAG_class_type
:
3470 case DW_TAG_interface_type
:
3471 case DW_TAG_structure_type
:
3472 if (!pdi
->is_declaration
)
3474 add_partial_symbol (pdi
, cu
);
3477 case DW_TAG_enumeration_type
:
3478 if (!pdi
->is_declaration
)
3479 add_partial_enumeration (pdi
, cu
);
3481 case DW_TAG_base_type
:
3482 case DW_TAG_subrange_type
:
3483 /* File scope base type definitions are added to the partial
3485 add_partial_symbol (pdi
, cu
);
3487 case DW_TAG_namespace
:
3488 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
3491 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
3498 /* If the die has a sibling, skip to the sibling. */
3500 pdi
= pdi
->die_sibling
;
3504 /* Functions used to compute the fully scoped name of a partial DIE.
3506 Normally, this is simple. For C++, the parent DIE's fully scoped
3507 name is concatenated with "::" and the partial DIE's name. For
3508 Java, the same thing occurs except that "." is used instead of "::".
3509 Enumerators are an exception; they use the scope of their parent
3510 enumeration type, i.e. the name of the enumeration type is not
3511 prepended to the enumerator.
3513 There are two complexities. One is DW_AT_specification; in this
3514 case "parent" means the parent of the target of the specification,
3515 instead of the direct parent of the DIE. The other is compilers
3516 which do not emit DW_TAG_namespace; in this case we try to guess
3517 the fully qualified name of structure types from their members'
3518 linkage names. This must be done using the DIE's children rather
3519 than the children of any DW_AT_specification target. We only need
3520 to do this for structures at the top level, i.e. if the target of
3521 any DW_AT_specification (if any; otherwise the DIE itself) does not
3524 /* Compute the scope prefix associated with PDI's parent, in
3525 compilation unit CU. The result will be allocated on CU's
3526 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3527 field. NULL is returned if no prefix is necessary. */
3529 partial_die_parent_scope (struct partial_die_info
*pdi
,
3530 struct dwarf2_cu
*cu
)
3532 char *grandparent_scope
;
3533 struct partial_die_info
*parent
, *real_pdi
;
3535 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3536 then this means the parent of the specification DIE. */
3539 while (real_pdi
->has_specification
)
3540 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3542 parent
= real_pdi
->die_parent
;
3546 if (parent
->scope_set
)
3547 return parent
->scope
;
3549 fixup_partial_die (parent
, cu
);
3551 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
3553 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3554 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3555 Work around this problem here. */
3556 if (cu
->language
== language_cplus
3557 && parent
->tag
== DW_TAG_namespace
3558 && strcmp (parent
->name
, "::") == 0
3559 && grandparent_scope
== NULL
)
3561 parent
->scope
= NULL
;
3562 parent
->scope_set
= 1;
3566 if (parent
->tag
== DW_TAG_namespace
3567 || parent
->tag
== DW_TAG_module
3568 || parent
->tag
== DW_TAG_structure_type
3569 || parent
->tag
== DW_TAG_class_type
3570 || parent
->tag
== DW_TAG_interface_type
3571 || parent
->tag
== DW_TAG_union_type
3572 || parent
->tag
== DW_TAG_enumeration_type
)
3574 if (grandparent_scope
== NULL
)
3575 parent
->scope
= parent
->name
;
3577 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
3578 parent
->name
, 0, cu
);
3580 else if (parent
->tag
== DW_TAG_enumerator
)
3581 /* Enumerators should not get the name of the enumeration as a prefix. */
3582 parent
->scope
= grandparent_scope
;
3585 /* FIXME drow/2004-04-01: What should we be doing with
3586 function-local names? For partial symbols, we should probably be
3588 complaint (&symfile_complaints
,
3589 _("unhandled containing DIE tag %d for DIE at %d"),
3590 parent
->tag
, pdi
->offset
);
3591 parent
->scope
= grandparent_scope
;
3594 parent
->scope_set
= 1;
3595 return parent
->scope
;
3598 /* Return the fully scoped name associated with PDI, from compilation unit
3599 CU. The result will be allocated with malloc. */
3601 partial_die_full_name (struct partial_die_info
*pdi
,
3602 struct dwarf2_cu
*cu
)
3606 /* If this is a template instantiation, we can not work out the
3607 template arguments from partial DIEs. So, unfortunately, we have
3608 to go through the full DIEs. At least any work we do building
3609 types here will be reused if full symbols are loaded later. */
3610 if (pdi
->has_template_arguments
)
3612 fixup_partial_die (pdi
, cu
);
3614 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
3616 struct die_info
*die
;
3617 struct attribute attr
;
3618 struct dwarf2_cu
*ref_cu
= cu
;
3621 attr
.form
= DW_FORM_ref_addr
;
3622 attr
.u
.addr
= pdi
->offset
;
3623 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
3625 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
3629 parent_scope
= partial_die_parent_scope (pdi
, cu
);
3630 if (parent_scope
== NULL
)
3633 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
3637 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
3639 struct objfile
*objfile
= cu
->objfile
;
3641 char *actual_name
= NULL
;
3642 const struct partial_symbol
*psym
= NULL
;
3644 int built_actual_name
= 0;
3646 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3648 actual_name
= partial_die_full_name (pdi
, cu
);
3650 built_actual_name
= 1;
3652 if (actual_name
== NULL
)
3653 actual_name
= pdi
->name
;
3657 case DW_TAG_subprogram
:
3658 if (pdi
->is_external
|| cu
->language
== language_ada
)
3660 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
3661 of the global scope. But in Ada, we want to be able to access
3662 nested procedures globally. So all Ada subprograms are stored
3663 in the global scope. */
3664 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3665 mst_text, objfile); */
3666 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
3668 VAR_DOMAIN
, LOC_BLOCK
,
3669 &objfile
->global_psymbols
,
3670 0, pdi
->lowpc
+ baseaddr
,
3671 cu
->language
, objfile
);
3675 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3676 mst_file_text, objfile); */
3677 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
3679 VAR_DOMAIN
, LOC_BLOCK
,
3680 &objfile
->static_psymbols
,
3681 0, pdi
->lowpc
+ baseaddr
,
3682 cu
->language
, objfile
);
3685 case DW_TAG_variable
:
3687 addr
= decode_locdesc (pdi
->locdesc
, cu
);
3691 && !dwarf2_per_objfile
->has_section_at_zero
)
3693 /* A global or static variable may also have been stripped
3694 out by the linker if unused, in which case its address
3695 will be nullified; do not add such variables into partial
3696 symbol table then. */
3698 else if (pdi
->is_external
)
3701 Don't enter into the minimal symbol tables as there is
3702 a minimal symbol table entry from the ELF symbols already.
3703 Enter into partial symbol table if it has a location
3704 descriptor or a type.
3705 If the location descriptor is missing, new_symbol will create
3706 a LOC_UNRESOLVED symbol, the address of the variable will then
3707 be determined from the minimal symbol table whenever the variable
3709 The address for the partial symbol table entry is not
3710 used by GDB, but it comes in handy for debugging partial symbol
3713 if (pdi
->locdesc
|| pdi
->has_type
)
3714 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
3716 VAR_DOMAIN
, LOC_STATIC
,
3717 &objfile
->global_psymbols
,
3719 cu
->language
, objfile
);
3723 /* Static Variable. Skip symbols without location descriptors. */
3724 if (pdi
->locdesc
== NULL
)
3726 if (built_actual_name
)
3727 xfree (actual_name
);
3730 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
3731 mst_file_data, objfile); */
3732 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
3734 VAR_DOMAIN
, LOC_STATIC
,
3735 &objfile
->static_psymbols
,
3737 cu
->language
, objfile
);
3740 case DW_TAG_typedef
:
3741 case DW_TAG_base_type
:
3742 case DW_TAG_subrange_type
:
3743 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3745 VAR_DOMAIN
, LOC_TYPEDEF
,
3746 &objfile
->static_psymbols
,
3747 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3749 case DW_TAG_namespace
:
3750 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3752 VAR_DOMAIN
, LOC_TYPEDEF
,
3753 &objfile
->global_psymbols
,
3754 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3756 case DW_TAG_class_type
:
3757 case DW_TAG_interface_type
:
3758 case DW_TAG_structure_type
:
3759 case DW_TAG_union_type
:
3760 case DW_TAG_enumeration_type
:
3761 /* Skip external references. The DWARF standard says in the section
3762 about "Structure, Union, and Class Type Entries": "An incomplete
3763 structure, union or class type is represented by a structure,
3764 union or class entry that does not have a byte size attribute
3765 and that has a DW_AT_declaration attribute." */
3766 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
3768 if (built_actual_name
)
3769 xfree (actual_name
);
3773 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
3774 static vs. global. */
3775 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3777 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3778 (cu
->language
== language_cplus
3779 || cu
->language
== language_java
)
3780 ? &objfile
->global_psymbols
3781 : &objfile
->static_psymbols
,
3782 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3785 case DW_TAG_enumerator
:
3786 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3788 VAR_DOMAIN
, LOC_CONST
,
3789 (cu
->language
== language_cplus
3790 || cu
->language
== language_java
)
3791 ? &objfile
->global_psymbols
3792 : &objfile
->static_psymbols
,
3793 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3799 if (built_actual_name
)
3800 xfree (actual_name
);
3803 /* Read a partial die corresponding to a namespace; also, add a symbol
3804 corresponding to that namespace to the symbol table. NAMESPACE is
3805 the name of the enclosing namespace. */
3808 add_partial_namespace (struct partial_die_info
*pdi
,
3809 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3810 int need_pc
, struct dwarf2_cu
*cu
)
3812 /* Add a symbol for the namespace. */
3814 add_partial_symbol (pdi
, cu
);
3816 /* Now scan partial symbols in that namespace. */
3818 if (pdi
->has_children
)
3819 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
3822 /* Read a partial die corresponding to a Fortran module. */
3825 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
3826 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3828 /* Now scan partial symbols in that module. */
3830 if (pdi
->has_children
)
3831 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
3834 /* Read a partial die corresponding to a subprogram and create a partial
3835 symbol for that subprogram. When the CU language allows it, this
3836 routine also defines a partial symbol for each nested subprogram
3837 that this subprogram contains.
3839 DIE my also be a lexical block, in which case we simply search
3840 recursively for suprograms defined inside that lexical block.
3841 Again, this is only performed when the CU language allows this
3842 type of definitions. */
3845 add_partial_subprogram (struct partial_die_info
*pdi
,
3846 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3847 int need_pc
, struct dwarf2_cu
*cu
)
3849 if (pdi
->tag
== DW_TAG_subprogram
)
3851 if (pdi
->has_pc_info
)
3853 if (pdi
->lowpc
< *lowpc
)
3854 *lowpc
= pdi
->lowpc
;
3855 if (pdi
->highpc
> *highpc
)
3856 *highpc
= pdi
->highpc
;
3860 struct objfile
*objfile
= cu
->objfile
;
3862 baseaddr
= ANOFFSET (objfile
->section_offsets
,
3863 SECT_OFF_TEXT (objfile
));
3864 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3865 pdi
->lowpc
+ baseaddr
,
3866 pdi
->highpc
- 1 + baseaddr
,
3867 cu
->per_cu
->v
.psymtab
);
3869 if (!pdi
->is_declaration
)
3870 /* Ignore subprogram DIEs that do not have a name, they are
3871 illegal. Do not emit a complaint at this point, we will
3872 do so when we convert this psymtab into a symtab. */
3874 add_partial_symbol (pdi
, cu
);
3878 if (! pdi
->has_children
)
3881 if (cu
->language
== language_ada
)
3883 pdi
= pdi
->die_child
;
3886 fixup_partial_die (pdi
, cu
);
3887 if (pdi
->tag
== DW_TAG_subprogram
3888 || pdi
->tag
== DW_TAG_lexical_block
)
3889 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3890 pdi
= pdi
->die_sibling
;
3895 /* See if we can figure out if the class lives in a namespace. We do
3896 this by looking for a member function; its demangled name will
3897 contain namespace info, if there is any. */
3900 guess_structure_name (struct partial_die_info
*struct_pdi
,
3901 struct dwarf2_cu
*cu
)
3903 if ((cu
->language
== language_cplus
3904 || cu
->language
== language_java
)
3905 && cu
->has_namespace_info
== 0
3906 && struct_pdi
->has_children
)
3908 /* NOTE: carlton/2003-10-07: Getting the info this way changes
3909 what template types look like, because the demangler
3910 frequently doesn't give the same name as the debug info. We
3911 could fix this by only using the demangled name to get the
3912 prefix (but see comment in read_structure_type). */
3914 struct partial_die_info
*real_pdi
;
3916 /* If this DIE (this DIE's specification, if any) has a parent, then
3917 we should not do this. We'll prepend the parent's fully qualified
3918 name when we create the partial symbol. */
3920 real_pdi
= struct_pdi
;
3921 while (real_pdi
->has_specification
)
3922 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3924 if (real_pdi
->die_parent
!= NULL
)
3929 /* Read a partial die corresponding to an enumeration type. */
3932 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
3933 struct dwarf2_cu
*cu
)
3935 struct partial_die_info
*pdi
;
3937 if (enum_pdi
->name
!= NULL
)
3938 add_partial_symbol (enum_pdi
, cu
);
3940 pdi
= enum_pdi
->die_child
;
3943 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
3944 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
3946 add_partial_symbol (pdi
, cu
);
3947 pdi
= pdi
->die_sibling
;
3951 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
3952 Return the corresponding abbrev, or NULL if the number is zero (indicating
3953 an empty DIE). In either case *BYTES_READ will be set to the length of
3954 the initial number. */
3956 static struct abbrev_info
*
3957 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
3958 struct dwarf2_cu
*cu
)
3960 bfd
*abfd
= cu
->objfile
->obfd
;
3961 unsigned int abbrev_number
;
3962 struct abbrev_info
*abbrev
;
3964 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
3966 if (abbrev_number
== 0)
3969 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
3972 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
3973 bfd_get_filename (abfd
));
3979 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
3980 Returns a pointer to the end of a series of DIEs, terminated by an empty
3981 DIE. Any children of the skipped DIEs will also be skipped. */
3984 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
3986 struct abbrev_info
*abbrev
;
3987 unsigned int bytes_read
;
3991 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
3993 return info_ptr
+ bytes_read
;
3995 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
3999 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4000 INFO_PTR should point just after the initial uleb128 of a DIE, and the
4001 abbrev corresponding to that skipped uleb128 should be passed in
4002 ABBREV. Returns a pointer to this DIE's sibling, skipping any
4006 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4007 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
4009 unsigned int bytes_read
;
4010 struct attribute attr
;
4011 bfd
*abfd
= cu
->objfile
->obfd
;
4012 unsigned int form
, i
;
4014 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
4016 /* The only abbrev we care about is DW_AT_sibling. */
4017 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
4019 read_attribute (&attr
, &abbrev
->attrs
[i
],
4020 abfd
, info_ptr
, cu
);
4021 if (attr
.form
== DW_FORM_ref_addr
)
4022 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
4024 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
4027 /* If it isn't DW_AT_sibling, skip this attribute. */
4028 form
= abbrev
->attrs
[i
].form
;
4032 case DW_FORM_ref_addr
:
4033 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
4034 and later it is offset sized. */
4035 if (cu
->header
.version
== 2)
4036 info_ptr
+= cu
->header
.addr_size
;
4038 info_ptr
+= cu
->header
.offset_size
;
4041 info_ptr
+= cu
->header
.addr_size
;
4048 case DW_FORM_flag_present
:
4063 case DW_FORM_string
:
4064 read_direct_string (abfd
, info_ptr
, &bytes_read
);
4065 info_ptr
+= bytes_read
;
4067 case DW_FORM_sec_offset
:
4069 info_ptr
+= cu
->header
.offset_size
;
4071 case DW_FORM_exprloc
:
4073 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4074 info_ptr
+= bytes_read
;
4076 case DW_FORM_block1
:
4077 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
4079 case DW_FORM_block2
:
4080 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
4082 case DW_FORM_block4
:
4083 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
4087 case DW_FORM_ref_udata
:
4088 info_ptr
= skip_leb128 (abfd
, info_ptr
);
4090 case DW_FORM_indirect
:
4091 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4092 info_ptr
+= bytes_read
;
4093 /* We need to continue parsing from here, so just go back to
4095 goto skip_attribute
;
4098 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
4099 dwarf_form_name (form
),
4100 bfd_get_filename (abfd
));
4104 if (abbrev
->has_children
)
4105 return skip_children (buffer
, info_ptr
, cu
);
4110 /* Locate ORIG_PDI's sibling.
4111 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4115 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
4116 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4117 bfd
*abfd
, struct dwarf2_cu
*cu
)
4119 /* Do we know the sibling already? */
4121 if (orig_pdi
->sibling
)
4122 return orig_pdi
->sibling
;
4124 /* Are there any children to deal with? */
4126 if (!orig_pdi
->has_children
)
4129 /* Skip the children the long way. */
4131 return skip_children (buffer
, info_ptr
, cu
);
4134 /* Expand this partial symbol table into a full symbol table. */
4137 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
4143 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
4149 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
4150 gdb_flush (gdb_stdout
);
4153 /* Restore our global data. */
4154 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
4155 dwarf2_objfile_data_key
);
4157 /* If this psymtab is constructed from a debug-only objfile, the
4158 has_section_at_zero flag will not necessarily be correct. We
4159 can get the correct value for this flag by looking at the data
4160 associated with the (presumably stripped) associated objfile. */
4161 if (pst
->objfile
->separate_debug_objfile_backlink
)
4163 struct dwarf2_per_objfile
*dpo_backlink
4164 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
4165 dwarf2_objfile_data_key
);
4167 dwarf2_per_objfile
->has_section_at_zero
4168 = dpo_backlink
->has_section_at_zero
;
4171 dwarf2_per_objfile
->reading_partial_symbols
= 0;
4173 psymtab_to_symtab_1 (pst
);
4175 /* Finish up the debug error message. */
4177 printf_filtered (_("done.\n"));
4182 /* Add PER_CU to the queue. */
4185 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
4187 struct dwarf2_queue_item
*item
;
4190 item
= xmalloc (sizeof (*item
));
4191 item
->per_cu
= per_cu
;
4194 if (dwarf2_queue
== NULL
)
4195 dwarf2_queue
= item
;
4197 dwarf2_queue_tail
->next
= item
;
4199 dwarf2_queue_tail
= item
;
4202 /* Process the queue. */
4205 process_queue (struct objfile
*objfile
)
4207 struct dwarf2_queue_item
*item
, *next_item
;
4209 /* The queue starts out with one item, but following a DIE reference
4210 may load a new CU, adding it to the end of the queue. */
4211 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
4213 if (dwarf2_per_objfile
->using_index
4214 ? !item
->per_cu
->v
.quick
->symtab
4215 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
4216 process_full_comp_unit (item
->per_cu
);
4218 item
->per_cu
->queued
= 0;
4219 next_item
= item
->next
;
4223 dwarf2_queue_tail
= NULL
;
4226 /* Free all allocated queue entries. This function only releases anything if
4227 an error was thrown; if the queue was processed then it would have been
4228 freed as we went along. */
4231 dwarf2_release_queue (void *dummy
)
4233 struct dwarf2_queue_item
*item
, *last
;
4235 item
= dwarf2_queue
;
4238 /* Anything still marked queued is likely to be in an
4239 inconsistent state, so discard it. */
4240 if (item
->per_cu
->queued
)
4242 if (item
->per_cu
->cu
!= NULL
)
4243 free_one_cached_comp_unit (item
->per_cu
->cu
);
4244 item
->per_cu
->queued
= 0;
4252 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
4255 /* Read in full symbols for PST, and anything it depends on. */
4258 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
4260 struct dwarf2_per_cu_data
*per_cu
;
4261 struct cleanup
*back_to
;
4264 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
4265 if (!pst
->dependencies
[i
]->readin
)
4267 /* Inform about additional files that need to be read in. */
4270 /* FIXME: i18n: Need to make this a single string. */
4271 fputs_filtered (" ", gdb_stdout
);
4273 fputs_filtered ("and ", gdb_stdout
);
4275 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
4276 wrap_here (""); /* Flush output */
4277 gdb_flush (gdb_stdout
);
4279 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
4282 per_cu
= pst
->read_symtab_private
;
4286 /* It's an include file, no symbols to read for it.
4287 Everything is in the parent symtab. */
4292 dw2_do_instantiate_symtab (pst
->objfile
, per_cu
);
4295 /* Load the DIEs associated with PER_CU into memory. */
4298 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
4300 bfd
*abfd
= objfile
->obfd
;
4301 struct dwarf2_cu
*cu
;
4302 unsigned int offset
;
4303 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
4304 struct cleanup
*free_abbrevs_cleanup
= NULL
, *free_cu_cleanup
= NULL
;
4305 struct attribute
*attr
;
4308 gdb_assert (! per_cu
->from_debug_types
);
4310 /* Set local variables from the partial symbol table info. */
4311 offset
= per_cu
->offset
;
4313 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4314 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
4315 beg_of_comp_unit
= info_ptr
;
4317 if (per_cu
->cu
== NULL
)
4319 cu
= alloc_one_comp_unit (objfile
);
4323 /* If an error occurs while loading, release our storage. */
4324 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
4326 /* Read in the comp_unit header. */
4327 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
4329 /* Complete the cu_header. */
4330 cu
->header
.offset
= offset
;
4331 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
4333 /* Read the abbrevs for this compilation unit. */
4334 dwarf2_read_abbrevs (abfd
, cu
);
4335 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
4337 /* Link this compilation unit into the compilation unit tree. */
4339 cu
->per_cu
= per_cu
;
4341 /* Link this CU into read_in_chain. */
4342 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4343 dwarf2_per_objfile
->read_in_chain
= per_cu
;
4348 info_ptr
+= cu
->header
.first_die_offset
;
4351 cu
->dies
= read_comp_unit (info_ptr
, cu
);
4353 /* We try not to read any attributes in this function, because not
4354 all objfiles needed for references have been loaded yet, and symbol
4355 table processing isn't initialized. But we have to set the CU language,
4356 or we won't be able to build types correctly. */
4357 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
4359 set_cu_language (DW_UNSND (attr
), cu
);
4361 set_cu_language (language_minimal
, cu
);
4363 /* Similarly, if we do not read the producer, we can not apply
4364 producer-specific interpretation. */
4365 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
4367 cu
->producer
= DW_STRING (attr
);
4371 do_cleanups (free_abbrevs_cleanup
);
4373 /* We've successfully allocated this compilation unit. Let our
4374 caller clean it up when finished with it. */
4375 discard_cleanups (free_cu_cleanup
);
4379 /* Add a DIE to the delayed physname list. */
4382 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
4383 const char *name
, struct die_info
*die
,
4384 struct dwarf2_cu
*cu
)
4386 struct delayed_method_info mi
;
4388 mi
.fnfield_index
= fnfield_index
;
4392 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
4395 /* A cleanup for freeing the delayed method list. */
4398 free_delayed_list (void *ptr
)
4400 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
4401 if (cu
->method_list
!= NULL
)
4403 VEC_free (delayed_method_info
, cu
->method_list
);
4404 cu
->method_list
= NULL
;
4408 /* Compute the physnames of any methods on the CU's method list.
4410 The computation of method physnames is delayed in order to avoid the
4411 (bad) condition that one of the method's formal parameters is of an as yet
4415 compute_delayed_physnames (struct dwarf2_cu
*cu
)
4418 struct delayed_method_info
*mi
;
4419 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
4422 struct fn_fieldlist
*fn_flp
4423 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
4424 physname
= (char *) dwarf2_physname ((char *) mi
->name
, mi
->die
, cu
);
4425 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
4429 /* Generate full symbol information for PST and CU, whose DIEs have
4430 already been loaded into memory. */
4433 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4435 struct dwarf2_cu
*cu
= per_cu
->cu
;
4436 struct objfile
*objfile
= per_cu
->objfile
;
4437 CORE_ADDR lowpc
, highpc
;
4438 struct symtab
*symtab
;
4439 struct cleanup
*back_to
, *delayed_list_cleanup
;
4442 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4445 back_to
= make_cleanup (really_free_pendings
, NULL
);
4446 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
4448 cu
->list_in_scope
= &file_symbols
;
4450 dwarf2_find_base_address (cu
->dies
, cu
);
4452 /* Do line number decoding in read_file_scope () */
4453 process_die (cu
->dies
, cu
);
4455 /* Now that we have processed all the DIEs in the CU, all the types
4456 should be complete, and it should now be safe to compute all of the
4458 compute_delayed_physnames (cu
);
4459 do_cleanups (delayed_list_cleanup
);
4461 /* Some compilers don't define a DW_AT_high_pc attribute for the
4462 compilation unit. If the DW_AT_high_pc is missing, synthesize
4463 it, by scanning the DIE's below the compilation unit. */
4464 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
4466 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
4468 /* Set symtab language to language from DW_AT_language.
4469 If the compilation is from a C file generated by language preprocessors,
4470 do not set the language if it was already deduced by start_subfile. */
4472 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
4474 symtab
->language
= cu
->language
;
4477 if (dwarf2_per_objfile
->using_index
)
4478 per_cu
->v
.quick
->symtab
= symtab
;
4481 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
4482 pst
->symtab
= symtab
;
4486 do_cleanups (back_to
);
4489 /* Process a die and its children. */
4492 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
4496 case DW_TAG_padding
:
4498 case DW_TAG_compile_unit
:
4499 read_file_scope (die
, cu
);
4501 case DW_TAG_type_unit
:
4502 read_type_unit_scope (die
, cu
);
4504 case DW_TAG_subprogram
:
4505 case DW_TAG_inlined_subroutine
:
4506 read_func_scope (die
, cu
);
4508 case DW_TAG_lexical_block
:
4509 case DW_TAG_try_block
:
4510 case DW_TAG_catch_block
:
4511 read_lexical_block_scope (die
, cu
);
4513 case DW_TAG_class_type
:
4514 case DW_TAG_interface_type
:
4515 case DW_TAG_structure_type
:
4516 case DW_TAG_union_type
:
4517 process_structure_scope (die
, cu
);
4519 case DW_TAG_enumeration_type
:
4520 process_enumeration_scope (die
, cu
);
4523 /* These dies have a type, but processing them does not create
4524 a symbol or recurse to process the children. Therefore we can
4525 read them on-demand through read_type_die. */
4526 case DW_TAG_subroutine_type
:
4527 case DW_TAG_set_type
:
4528 case DW_TAG_array_type
:
4529 case DW_TAG_pointer_type
:
4530 case DW_TAG_ptr_to_member_type
:
4531 case DW_TAG_reference_type
:
4532 case DW_TAG_string_type
:
4535 case DW_TAG_base_type
:
4536 case DW_TAG_subrange_type
:
4537 case DW_TAG_typedef
:
4538 /* Add a typedef symbol for the type definition, if it has a
4540 new_symbol (die
, read_type_die (die
, cu
), cu
);
4542 case DW_TAG_common_block
:
4543 read_common_block (die
, cu
);
4545 case DW_TAG_common_inclusion
:
4547 case DW_TAG_namespace
:
4548 processing_has_namespace_info
= 1;
4549 read_namespace (die
, cu
);
4552 processing_has_namespace_info
= 1;
4553 read_module (die
, cu
);
4555 case DW_TAG_imported_declaration
:
4556 case DW_TAG_imported_module
:
4557 processing_has_namespace_info
= 1;
4558 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
4559 || cu
->language
!= language_fortran
))
4560 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
4561 dwarf_tag_name (die
->tag
));
4562 read_import_statement (die
, cu
);
4565 new_symbol (die
, NULL
, cu
);
4570 /* A helper function for dwarf2_compute_name which determines whether DIE
4571 needs to have the name of the scope prepended to the name listed in the
4575 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4577 struct attribute
*attr
;
4581 case DW_TAG_namespace
:
4582 case DW_TAG_typedef
:
4583 case DW_TAG_class_type
:
4584 case DW_TAG_interface_type
:
4585 case DW_TAG_structure_type
:
4586 case DW_TAG_union_type
:
4587 case DW_TAG_enumeration_type
:
4588 case DW_TAG_enumerator
:
4589 case DW_TAG_subprogram
:
4593 case DW_TAG_variable
:
4594 /* We only need to prefix "globally" visible variables. These include
4595 any variable marked with DW_AT_external or any variable that
4596 lives in a namespace. [Variables in anonymous namespaces
4597 require prefixing, but they are not DW_AT_external.] */
4599 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
4601 struct dwarf2_cu
*spec_cu
= cu
;
4603 return die_needs_namespace (die_specification (die
, &spec_cu
),
4607 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
4608 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
4609 && die
->parent
->tag
!= DW_TAG_module
)
4611 /* A variable in a lexical block of some kind does not need a
4612 namespace, even though in C++ such variables may be external
4613 and have a mangled name. */
4614 if (die
->parent
->tag
== DW_TAG_lexical_block
4615 || die
->parent
->tag
== DW_TAG_try_block
4616 || die
->parent
->tag
== DW_TAG_catch_block
4617 || die
->parent
->tag
== DW_TAG_subprogram
)
4626 /* Retrieve the last character from a mem_file. */
4629 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
4631 char *last_char_p
= (char *) object
;
4634 *last_char_p
= buffer
[length
- 1];
4637 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
4638 compute the physname for the object, which include a method's
4639 formal parameters (C++/Java) and return type (Java).
4641 For Ada, return the DIE's linkage name rather than the fully qualified
4642 name. PHYSNAME is ignored..
4644 The result is allocated on the objfile_obstack and canonicalized. */
4647 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
4651 name
= dwarf2_name (die
, cu
);
4653 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
4654 compute it by typename_concat inside GDB. */
4655 if (cu
->language
== language_ada
4656 || (cu
->language
== language_fortran
&& physname
))
4658 /* For Ada unit, we prefer the linkage name over the name, as
4659 the former contains the exported name, which the user expects
4660 to be able to reference. Ideally, we want the user to be able
4661 to reference this entity using either natural or linkage name,
4662 but we haven't started looking at this enhancement yet. */
4663 struct attribute
*attr
;
4665 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
4667 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
4668 if (attr
&& DW_STRING (attr
))
4669 return DW_STRING (attr
);
4672 /* These are the only languages we know how to qualify names in. */
4674 && (cu
->language
== language_cplus
|| cu
->language
== language_java
4675 || cu
->language
== language_fortran
))
4677 if (die_needs_namespace (die
, cu
))
4681 struct ui_file
*buf
;
4683 prefix
= determine_prefix (die
, cu
);
4684 buf
= mem_fileopen ();
4685 if (*prefix
!= '\0')
4687 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
4690 fputs_unfiltered (prefixed_name
, buf
);
4691 xfree (prefixed_name
);
4694 fputs_unfiltered (name
? name
: "", buf
);
4696 /* Template parameters may be specified in the DIE's DW_AT_name, or
4697 as children with DW_TAG_template_type_param or
4698 DW_TAG_value_type_param. If the latter, add them to the name
4699 here. If the name already has template parameters, then
4700 skip this step; some versions of GCC emit both, and
4701 it is more efficient to use the pre-computed name.
4703 Something to keep in mind about this process: it is very
4704 unlikely, or in some cases downright impossible, to produce
4705 something that will match the mangled name of a function.
4706 If the definition of the function has the same debug info,
4707 we should be able to match up with it anyway. But fallbacks
4708 using the minimal symbol, for instance to find a method
4709 implemented in a stripped copy of libstdc++, will not work.
4710 If we do not have debug info for the definition, we will have to
4711 match them up some other way.
4713 When we do name matching there is a related problem with function
4714 templates; two instantiated function templates are allowed to
4715 differ only by their return types, which we do not add here. */
4717 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
4719 struct attribute
*attr
;
4720 struct die_info
*child
;
4723 die
->building_fullname
= 1;
4725 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
4730 struct dwarf2_locexpr_baton
*baton
;
4733 if (child
->tag
!= DW_TAG_template_type_param
4734 && child
->tag
!= DW_TAG_template_value_param
)
4739 fputs_unfiltered ("<", buf
);
4743 fputs_unfiltered (", ", buf
);
4745 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
4748 complaint (&symfile_complaints
,
4749 _("template parameter missing DW_AT_type"));
4750 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
4753 type
= die_type (child
, cu
);
4755 if (child
->tag
== DW_TAG_template_type_param
)
4757 c_print_type (type
, "", buf
, -1, 0);
4761 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
4764 complaint (&symfile_complaints
,
4765 _("template parameter missing DW_AT_const_value"));
4766 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
4770 dwarf2_const_value_attr (attr
, type
, name
,
4771 &cu
->comp_unit_obstack
, cu
,
4772 &value
, &bytes
, &baton
);
4774 if (TYPE_NOSIGN (type
))
4775 /* GDB prints characters as NUMBER 'CHAR'. If that's
4776 changed, this can use value_print instead. */
4777 c_printchar (value
, type
, buf
);
4780 struct value_print_options opts
;
4783 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
4787 else if (bytes
!= NULL
)
4789 v
= allocate_value (type
);
4790 memcpy (value_contents_writeable (v
), bytes
,
4791 TYPE_LENGTH (type
));
4794 v
= value_from_longest (type
, value
);
4796 /* Specify decimal so that we do not depend on the radix. */
4797 get_formatted_print_options (&opts
, 'd');
4799 value_print (v
, buf
, &opts
);
4805 die
->building_fullname
= 0;
4809 /* Close the argument list, with a space if necessary
4810 (nested templates). */
4811 char last_char
= '\0';
4812 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
4813 if (last_char
== '>')
4814 fputs_unfiltered (" >", buf
);
4816 fputs_unfiltered (">", buf
);
4820 /* For Java and C++ methods, append formal parameter type
4821 information, if PHYSNAME. */
4823 if (physname
&& die
->tag
== DW_TAG_subprogram
4824 && (cu
->language
== language_cplus
4825 || cu
->language
== language_java
))
4827 struct type
*type
= read_type_die (die
, cu
);
4829 c_type_print_args (type
, buf
, 0, cu
->language
);
4831 if (cu
->language
== language_java
)
4833 /* For java, we must append the return type to method
4835 if (die
->tag
== DW_TAG_subprogram
)
4836 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
4839 else if (cu
->language
== language_cplus
)
4841 if (TYPE_NFIELDS (type
) > 0
4842 && TYPE_FIELD_ARTIFICIAL (type
, 0)
4843 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0))))
4844 fputs_unfiltered (" const", buf
);
4848 name
= ui_file_obsavestring (buf
, &cu
->objfile
->objfile_obstack
,
4850 ui_file_delete (buf
);
4852 if (cu
->language
== language_cplus
)
4855 = dwarf2_canonicalize_name (name
, cu
,
4856 &cu
->objfile
->objfile_obstack
);
4867 /* Return the fully qualified name of DIE, based on its DW_AT_name.
4868 If scope qualifiers are appropriate they will be added. The result
4869 will be allocated on the objfile_obstack, or NULL if the DIE does
4870 not have a name. NAME may either be from a previous call to
4871 dwarf2_name or NULL.
4873 The output string will be canonicalized (if C++/Java). */
4876 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
4878 return dwarf2_compute_name (name
, die
, cu
, 0);
4881 /* Construct a physname for the given DIE in CU. NAME may either be
4882 from a previous call to dwarf2_name or NULL. The result will be
4883 allocated on the objfile_objstack or NULL if the DIE does not have a
4886 The output string will be canonicalized (if C++/Java). */
4889 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
4891 return dwarf2_compute_name (name
, die
, cu
, 1);
4894 /* Read the import statement specified by the given die and record it. */
4897 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
4899 struct attribute
*import_attr
;
4900 struct die_info
*imported_die
;
4901 struct dwarf2_cu
*imported_cu
;
4902 const char *imported_name
;
4903 const char *imported_name_prefix
;
4904 const char *canonical_name
;
4905 const char *import_alias
;
4906 const char *imported_declaration
= NULL
;
4907 const char *import_prefix
;
4911 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
4912 if (import_attr
== NULL
)
4914 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
4915 dwarf_tag_name (die
->tag
));
4920 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
4921 imported_name
= dwarf2_name (imported_die
, imported_cu
);
4922 if (imported_name
== NULL
)
4924 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
4926 The import in the following code:
4940 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
4941 <52> DW_AT_decl_file : 1
4942 <53> DW_AT_decl_line : 6
4943 <54> DW_AT_import : <0x75>
4944 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
4946 <5b> DW_AT_decl_file : 1
4947 <5c> DW_AT_decl_line : 2
4948 <5d> DW_AT_type : <0x6e>
4950 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
4951 <76> DW_AT_byte_size : 4
4952 <77> DW_AT_encoding : 5 (signed)
4954 imports the wrong die ( 0x75 instead of 0x58 ).
4955 This case will be ignored until the gcc bug is fixed. */
4959 /* Figure out the local name after import. */
4960 import_alias
= dwarf2_name (die
, cu
);
4962 /* Figure out where the statement is being imported to. */
4963 import_prefix
= determine_prefix (die
, cu
);
4965 /* Figure out what the scope of the imported die is and prepend it
4966 to the name of the imported die. */
4967 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
4969 if (imported_die
->tag
!= DW_TAG_namespace
4970 && imported_die
->tag
!= DW_TAG_module
)
4972 imported_declaration
= imported_name
;
4973 canonical_name
= imported_name_prefix
;
4975 else if (strlen (imported_name_prefix
) > 0)
4977 temp
= alloca (strlen (imported_name_prefix
)
4978 + 2 + strlen (imported_name
) + 1);
4979 strcpy (temp
, imported_name_prefix
);
4980 strcat (temp
, "::");
4981 strcat (temp
, imported_name
);
4982 canonical_name
= temp
;
4985 canonical_name
= imported_name
;
4987 cp_add_using_directive (import_prefix
,
4990 imported_declaration
,
4991 &cu
->objfile
->objfile_obstack
);
4995 initialize_cu_func_list (struct dwarf2_cu
*cu
)
4997 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
5001 free_cu_line_header (void *arg
)
5003 struct dwarf2_cu
*cu
= arg
;
5005 free_line_header (cu
->line_header
);
5006 cu
->line_header
= NULL
;
5010 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
5011 char **name
, char **comp_dir
)
5013 struct attribute
*attr
;
5018 /* Find the filename. Do not use dwarf2_name here, since the filename
5019 is not a source language identifier. */
5020 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5023 *name
= DW_STRING (attr
);
5026 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5028 *comp_dir
= DW_STRING (attr
);
5029 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
5031 *comp_dir
= ldirname (*name
);
5032 if (*comp_dir
!= NULL
)
5033 make_cleanup (xfree
, *comp_dir
);
5035 if (*comp_dir
!= NULL
)
5037 /* Irix 6.2 native cc prepends <machine>.: to the compilation
5038 directory, get rid of it. */
5039 char *cp
= strchr (*comp_dir
, ':');
5041 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
5046 *name
= "<unknown>";
5050 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5052 struct objfile
*objfile
= cu
->objfile
;
5053 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5054 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
5055 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
5056 struct attribute
*attr
;
5058 char *comp_dir
= NULL
;
5059 struct die_info
*child_die
;
5060 bfd
*abfd
= objfile
->obfd
;
5061 struct line_header
*line_header
= 0;
5064 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5066 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
5068 /* If we didn't find a lowpc, set it to highpc to avoid complaints
5069 from finish_block. */
5070 if (lowpc
== ((CORE_ADDR
) -1))
5075 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
5077 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5080 set_cu_language (DW_UNSND (attr
), cu
);
5083 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5085 cu
->producer
= DW_STRING (attr
);
5087 /* We assume that we're processing GCC output. */
5088 processing_gcc_compilation
= 2;
5090 processing_has_namespace_info
= 0;
5092 start_symtab (name
, comp_dir
, lowpc
);
5093 record_debugformat ("DWARF 2");
5094 record_producer (cu
->producer
);
5096 initialize_cu_func_list (cu
);
5098 /* Decode line number information if present. We do this before
5099 processing child DIEs, so that the line header table is available
5100 for DW_AT_decl_file. */
5101 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5104 unsigned int line_offset
= DW_UNSND (attr
);
5105 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
5108 cu
->line_header
= line_header
;
5109 make_cleanup (free_cu_line_header
, cu
);
5110 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
5114 /* Process all dies in compilation unit. */
5115 if (die
->child
!= NULL
)
5117 child_die
= die
->child
;
5118 while (child_die
&& child_die
->tag
)
5120 process_die (child_die
, cu
);
5121 child_die
= sibling_die (child_die
);
5125 /* Decode macro information, if present. Dwarf 2 macro information
5126 refers to information in the line number info statement program
5127 header, so we can only read it if we've read the header
5129 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
5130 if (attr
&& line_header
)
5132 unsigned int macro_offset
= DW_UNSND (attr
);
5134 dwarf_decode_macros (line_header
, macro_offset
,
5135 comp_dir
, abfd
, cu
);
5137 do_cleanups (back_to
);
5140 /* For TUs we want to skip the first top level sibling if it's not the
5141 actual type being defined by this TU. In this case the first top
5142 level sibling is there to provide context only. */
5145 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5147 struct objfile
*objfile
= cu
->objfile
;
5148 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5150 struct attribute
*attr
;
5152 char *comp_dir
= NULL
;
5153 struct die_info
*child_die
;
5154 bfd
*abfd
= objfile
->obfd
;
5156 /* start_symtab needs a low pc, but we don't really have one.
5157 Do what read_file_scope would do in the absence of such info. */
5158 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5160 /* Find the filename. Do not use dwarf2_name here, since the filename
5161 is not a source language identifier. */
5162 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5164 name
= DW_STRING (attr
);
5166 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5168 comp_dir
= DW_STRING (attr
);
5169 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
5171 comp_dir
= ldirname (name
);
5172 if (comp_dir
!= NULL
)
5173 make_cleanup (xfree
, comp_dir
);
5179 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5181 set_cu_language (DW_UNSND (attr
), cu
);
5183 /* This isn't technically needed today. It is done for symmetry
5184 with read_file_scope. */
5185 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5187 cu
->producer
= DW_STRING (attr
);
5189 /* We assume that we're processing GCC output. */
5190 processing_gcc_compilation
= 2;
5192 processing_has_namespace_info
= 0;
5194 start_symtab (name
, comp_dir
, lowpc
);
5195 record_debugformat ("DWARF 2");
5196 record_producer (cu
->producer
);
5198 /* Process the dies in the type unit. */
5199 if (die
->child
== NULL
)
5201 dump_die_for_error (die
);
5202 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
5203 bfd_get_filename (abfd
));
5206 child_die
= die
->child
;
5208 while (child_die
&& child_die
->tag
)
5210 process_die (child_die
, cu
);
5212 child_die
= sibling_die (child_die
);
5215 do_cleanups (back_to
);
5219 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
5220 struct dwarf2_cu
*cu
)
5222 struct function_range
*thisfn
;
5224 thisfn
= (struct function_range
*)
5225 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
5226 thisfn
->name
= name
;
5227 thisfn
->lowpc
= lowpc
;
5228 thisfn
->highpc
= highpc
;
5229 thisfn
->seen_line
= 0;
5230 thisfn
->next
= NULL
;
5232 if (cu
->last_fn
== NULL
)
5233 cu
->first_fn
= thisfn
;
5235 cu
->last_fn
->next
= thisfn
;
5237 cu
->last_fn
= thisfn
;
5240 /* qsort helper for inherit_abstract_dies. */
5243 unsigned_int_compar (const void *ap
, const void *bp
)
5245 unsigned int a
= *(unsigned int *) ap
;
5246 unsigned int b
= *(unsigned int *) bp
;
5248 return (a
> b
) - (b
> a
);
5251 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
5252 Inherit only the children of the DW_AT_abstract_origin DIE not being already
5253 referenced by DW_AT_abstract_origin from the children of the current DIE. */
5256 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
5258 struct die_info
*child_die
;
5259 unsigned die_children_count
;
5260 /* CU offsets which were referenced by children of the current DIE. */
5262 unsigned *offsets_end
, *offsetp
;
5263 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
5264 struct die_info
*origin_die
;
5265 /* Iterator of the ORIGIN_DIE children. */
5266 struct die_info
*origin_child_die
;
5267 struct cleanup
*cleanups
;
5268 struct attribute
*attr
;
5269 struct dwarf2_cu
*origin_cu
;
5270 struct pending
**origin_previous_list_in_scope
;
5272 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
5276 /* Note that following die references may follow to a die in a
5280 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
5282 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
5284 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
5285 origin_cu
->list_in_scope
= cu
->list_in_scope
;
5287 if (die
->tag
!= origin_die
->tag
5288 && !(die
->tag
== DW_TAG_inlined_subroutine
5289 && origin_die
->tag
== DW_TAG_subprogram
))
5290 complaint (&symfile_complaints
,
5291 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
5292 die
->offset
, origin_die
->offset
);
5294 child_die
= die
->child
;
5295 die_children_count
= 0;
5296 while (child_die
&& child_die
->tag
)
5298 child_die
= sibling_die (child_die
);
5299 die_children_count
++;
5301 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
5302 cleanups
= make_cleanup (xfree
, offsets
);
5304 offsets_end
= offsets
;
5305 child_die
= die
->child
;
5306 while (child_die
&& child_die
->tag
)
5308 /* For each CHILD_DIE, find the corresponding child of
5309 ORIGIN_DIE. If there is more than one layer of
5310 DW_AT_abstract_origin, follow them all; there shouldn't be,
5311 but GCC versions at least through 4.4 generate this (GCC PR
5313 struct die_info
*child_origin_die
= child_die
;
5314 struct dwarf2_cu
*child_origin_cu
= cu
;
5318 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
5322 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
5326 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5327 counterpart may exist. */
5328 if (child_origin_die
!= child_die
)
5330 if (child_die
->tag
!= child_origin_die
->tag
5331 && !(child_die
->tag
== DW_TAG_inlined_subroutine
5332 && child_origin_die
->tag
== DW_TAG_subprogram
))
5333 complaint (&symfile_complaints
,
5334 _("Child DIE 0x%x and its abstract origin 0x%x have "
5335 "different tags"), child_die
->offset
,
5336 child_origin_die
->offset
);
5337 if (child_origin_die
->parent
!= origin_die
)
5338 complaint (&symfile_complaints
,
5339 _("Child DIE 0x%x and its abstract origin 0x%x have "
5340 "different parents"), child_die
->offset
,
5341 child_origin_die
->offset
);
5343 *offsets_end
++ = child_origin_die
->offset
;
5345 child_die
= sibling_die (child_die
);
5347 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
5348 unsigned_int_compar
);
5349 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
5350 if (offsetp
[-1] == *offsetp
)
5351 complaint (&symfile_complaints
, _("Multiple children of DIE 0x%x refer "
5352 "to DIE 0x%x as their abstract origin"),
5353 die
->offset
, *offsetp
);
5356 origin_child_die
= origin_die
->child
;
5357 while (origin_child_die
&& origin_child_die
->tag
)
5359 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5360 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
5362 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
5364 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
5365 process_die (origin_child_die
, origin_cu
);
5367 origin_child_die
= sibling_die (origin_child_die
);
5369 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
5371 do_cleanups (cleanups
);
5375 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5377 struct objfile
*objfile
= cu
->objfile
;
5378 struct context_stack
*new;
5381 struct die_info
*child_die
;
5382 struct attribute
*attr
, *call_line
, *call_file
;
5385 struct block
*block
;
5386 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
5387 VEC (symbolp
) *template_args
= NULL
;
5388 struct template_symbol
*templ_func
= NULL
;
5392 /* If we do not have call site information, we can't show the
5393 caller of this inlined function. That's too confusing, so
5394 only use the scope for local variables. */
5395 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
5396 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
5397 if (call_line
== NULL
|| call_file
== NULL
)
5399 read_lexical_block_scope (die
, cu
);
5404 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5406 name
= dwarf2_name (die
, cu
);
5408 /* Ignore functions with missing or empty names. These are actually
5409 illegal according to the DWARF standard. */
5412 complaint (&symfile_complaints
,
5413 _("missing name for subprogram DIE at %d"), die
->offset
);
5417 /* Ignore functions with missing or invalid low and high pc attributes. */
5418 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5420 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5421 if (!attr
|| !DW_UNSND (attr
))
5422 complaint (&symfile_complaints
,
5423 _("cannot get low and high bounds for subprogram DIE at %d"),
5431 /* Record the function range for dwarf_decode_lines. */
5432 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
5434 /* If we have any template arguments, then we must allocate a
5435 different sort of symbol. */
5436 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
5438 if (child_die
->tag
== DW_TAG_template_type_param
5439 || child_die
->tag
== DW_TAG_template_value_param
)
5441 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5442 struct template_symbol
);
5443 templ_func
->base
.is_cplus_template_function
= 1;
5448 new = push_context (0, lowpc
);
5449 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
5450 (struct symbol
*) templ_func
);
5452 /* If there is a location expression for DW_AT_frame_base, record
5454 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
5456 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
5457 expression is being recorded directly in the function's symbol
5458 and not in a separate frame-base object. I guess this hack is
5459 to avoid adding some sort of frame-base adjunct/annex to the
5460 function's symbol :-(. The problem with doing this is that it
5461 results in a function symbol with a location expression that
5462 has nothing to do with the location of the function, ouch! The
5463 relationship should be: a function's symbol has-a frame base; a
5464 frame-base has-a location expression. */
5465 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
5467 cu
->list_in_scope
= &local_symbols
;
5469 if (die
->child
!= NULL
)
5471 child_die
= die
->child
;
5472 while (child_die
&& child_die
->tag
)
5474 if (child_die
->tag
== DW_TAG_template_type_param
5475 || child_die
->tag
== DW_TAG_template_value_param
)
5477 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
5479 VEC_safe_push (symbolp
, template_args
, arg
);
5482 process_die (child_die
, cu
);
5483 child_die
= sibling_die (child_die
);
5487 inherit_abstract_dies (die
, cu
);
5489 /* If we have a DW_AT_specification, we might need to import using
5490 directives from the context of the specification DIE. See the
5491 comment in determine_prefix. */
5492 if (cu
->language
== language_cplus
5493 && dwarf2_attr (die
, DW_AT_specification
, cu
))
5495 struct dwarf2_cu
*spec_cu
= cu
;
5496 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
5500 child_die
= spec_die
->child
;
5501 while (child_die
&& child_die
->tag
)
5503 if (child_die
->tag
== DW_TAG_imported_module
)
5504 process_die (child_die
, spec_cu
);
5505 child_die
= sibling_die (child_die
);
5508 /* In some cases, GCC generates specification DIEs that
5509 themselves contain DW_AT_specification attributes. */
5510 spec_die
= die_specification (spec_die
, &spec_cu
);
5514 new = pop_context ();
5515 /* Make a block for the local symbols within. */
5516 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
5517 lowpc
, highpc
, objfile
);
5519 /* For C++, set the block's scope. */
5520 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
5521 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
5522 determine_prefix (die
, cu
),
5523 processing_has_namespace_info
);
5525 /* If we have address ranges, record them. */
5526 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
5528 /* Attach template arguments to function. */
5529 if (! VEC_empty (symbolp
, template_args
))
5531 gdb_assert (templ_func
!= NULL
);
5533 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
5534 templ_func
->template_arguments
5535 = obstack_alloc (&objfile
->objfile_obstack
,
5536 (templ_func
->n_template_arguments
5537 * sizeof (struct symbol
*)));
5538 memcpy (templ_func
->template_arguments
,
5539 VEC_address (symbolp
, template_args
),
5540 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
5541 VEC_free (symbolp
, template_args
);
5544 /* In C++, we can have functions nested inside functions (e.g., when
5545 a function declares a class that has methods). This means that
5546 when we finish processing a function scope, we may need to go
5547 back to building a containing block's symbol lists. */
5548 local_symbols
= new->locals
;
5549 param_symbols
= new->params
;
5550 using_directives
= new->using_directives
;
5552 /* If we've finished processing a top-level function, subsequent
5553 symbols go in the file symbol list. */
5554 if (outermost_context_p ())
5555 cu
->list_in_scope
= &file_symbols
;
5558 /* Process all the DIES contained within a lexical block scope. Start
5559 a new scope, process the dies, and then close the scope. */
5562 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5564 struct objfile
*objfile
= cu
->objfile
;
5565 struct context_stack
*new;
5566 CORE_ADDR lowpc
, highpc
;
5567 struct die_info
*child_die
;
5570 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5572 /* Ignore blocks with missing or invalid low and high pc attributes. */
5573 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
5574 as multiple lexical blocks? Handling children in a sane way would
5575 be nasty. Might be easier to properly extend generic blocks to
5577 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5582 push_context (0, lowpc
);
5583 if (die
->child
!= NULL
)
5585 child_die
= die
->child
;
5586 while (child_die
&& child_die
->tag
)
5588 process_die (child_die
, cu
);
5589 child_die
= sibling_die (child_die
);
5592 new = pop_context ();
5594 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
5597 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
5600 /* Note that recording ranges after traversing children, as we
5601 do here, means that recording a parent's ranges entails
5602 walking across all its children's ranges as they appear in
5603 the address map, which is quadratic behavior.
5605 It would be nicer to record the parent's ranges before
5606 traversing its children, simply overriding whatever you find
5607 there. But since we don't even decide whether to create a
5608 block until after we've traversed its children, that's hard
5610 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
5612 local_symbols
= new->locals
;
5613 using_directives
= new->using_directives
;
5616 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
5617 Return 1 if the attributes are present and valid, otherwise, return 0.
5618 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
5621 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
5622 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
5623 struct partial_symtab
*ranges_pst
)
5625 struct objfile
*objfile
= cu
->objfile
;
5626 struct comp_unit_head
*cu_header
= &cu
->header
;
5627 bfd
*obfd
= objfile
->obfd
;
5628 unsigned int addr_size
= cu_header
->addr_size
;
5629 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
5630 /* Base address selection entry. */
5641 found_base
= cu
->base_known
;
5642 base
= cu
->base_address
;
5644 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
5645 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
5647 complaint (&symfile_complaints
,
5648 _("Offset %d out of bounds for DW_AT_ranges attribute"),
5652 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
5654 /* Read in the largest possible address. */
5655 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
5656 if ((marker
& mask
) == mask
)
5658 /* If we found the largest possible address, then
5659 read the base address. */
5660 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
5661 buffer
+= 2 * addr_size
;
5662 offset
+= 2 * addr_size
;
5668 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5672 CORE_ADDR range_beginning
, range_end
;
5674 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
5675 buffer
+= addr_size
;
5676 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
5677 buffer
+= addr_size
;
5678 offset
+= 2 * addr_size
;
5680 /* An end of list marker is a pair of zero addresses. */
5681 if (range_beginning
== 0 && range_end
== 0)
5682 /* Found the end of list entry. */
5685 /* Each base address selection entry is a pair of 2 values.
5686 The first is the largest possible address, the second is
5687 the base address. Check for a base address here. */
5688 if ((range_beginning
& mask
) == mask
)
5690 /* If we found the largest possible address, then
5691 read the base address. */
5692 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
5699 /* We have no valid base address for the ranges
5701 complaint (&symfile_complaints
,
5702 _("Invalid .debug_ranges data (no base address)"));
5706 range_beginning
+= base
;
5709 if (ranges_pst
!= NULL
&& range_beginning
< range_end
)
5710 addrmap_set_empty (objfile
->psymtabs_addrmap
,
5711 range_beginning
+ baseaddr
, range_end
- 1 + baseaddr
,
5714 /* FIXME: This is recording everything as a low-high
5715 segment of consecutive addresses. We should have a
5716 data structure for discontiguous block ranges
5720 low
= range_beginning
;
5726 if (range_beginning
< low
)
5727 low
= range_beginning
;
5728 if (range_end
> high
)
5734 /* If the first entry is an end-of-list marker, the range
5735 describes an empty scope, i.e. no instructions. */
5741 *high_return
= high
;
5745 /* Get low and high pc attributes from a die. Return 1 if the attributes
5746 are present and valid, otherwise, return 0. Return -1 if the range is
5747 discontinuous, i.e. derived from DW_AT_ranges information. */
5749 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
5750 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
5751 struct partial_symtab
*pst
)
5753 struct attribute
*attr
;
5758 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
5761 high
= DW_ADDR (attr
);
5762 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5764 low
= DW_ADDR (attr
);
5766 /* Found high w/o low attribute. */
5769 /* Found consecutive range of addresses. */
5774 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
5777 /* Value of the DW_AT_ranges attribute is the offset in the
5778 .debug_ranges section. */
5779 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
5781 /* Found discontinuous range of addresses. */
5789 /* When using the GNU linker, .gnu.linkonce. sections are used to
5790 eliminate duplicate copies of functions and vtables and such.
5791 The linker will arbitrarily choose one and discard the others.
5792 The AT_*_pc values for such functions refer to local labels in
5793 these sections. If the section from that file was discarded, the
5794 labels are not in the output, so the relocs get a value of 0.
5795 If this is a discarded function, mark the pc bounds as invalid,
5796 so that GDB will ignore it. */
5797 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
5805 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
5806 its low and high PC addresses. Do nothing if these addresses could not
5807 be determined. Otherwise, set LOWPC to the low address if it is smaller,
5808 and HIGHPC to the high address if greater than HIGHPC. */
5811 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
5812 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
5813 struct dwarf2_cu
*cu
)
5815 CORE_ADDR low
, high
;
5816 struct die_info
*child
= die
->child
;
5818 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
5820 *lowpc
= min (*lowpc
, low
);
5821 *highpc
= max (*highpc
, high
);
5824 /* If the language does not allow nested subprograms (either inside
5825 subprograms or lexical blocks), we're done. */
5826 if (cu
->language
!= language_ada
)
5829 /* Check all the children of the given DIE. If it contains nested
5830 subprograms, then check their pc bounds. Likewise, we need to
5831 check lexical blocks as well, as they may also contain subprogram
5833 while (child
&& child
->tag
)
5835 if (child
->tag
== DW_TAG_subprogram
5836 || child
->tag
== DW_TAG_lexical_block
)
5837 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
5838 child
= sibling_die (child
);
5842 /* Get the low and high pc's represented by the scope DIE, and store
5843 them in *LOWPC and *HIGHPC. If the correct values can't be
5844 determined, set *LOWPC to -1 and *HIGHPC to 0. */
5847 get_scope_pc_bounds (struct die_info
*die
,
5848 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
5849 struct dwarf2_cu
*cu
)
5851 CORE_ADDR best_low
= (CORE_ADDR
) -1;
5852 CORE_ADDR best_high
= (CORE_ADDR
) 0;
5853 CORE_ADDR current_low
, current_high
;
5855 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
5857 best_low
= current_low
;
5858 best_high
= current_high
;
5862 struct die_info
*child
= die
->child
;
5864 while (child
&& child
->tag
)
5866 switch (child
->tag
) {
5867 case DW_TAG_subprogram
:
5868 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
5870 case DW_TAG_namespace
:
5872 /* FIXME: carlton/2004-01-16: Should we do this for
5873 DW_TAG_class_type/DW_TAG_structure_type, too? I think
5874 that current GCC's always emit the DIEs corresponding
5875 to definitions of methods of classes as children of a
5876 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
5877 the DIEs giving the declarations, which could be
5878 anywhere). But I don't see any reason why the
5879 standards says that they have to be there. */
5880 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
5882 if (current_low
!= ((CORE_ADDR
) -1))
5884 best_low
= min (best_low
, current_low
);
5885 best_high
= max (best_high
, current_high
);
5893 child
= sibling_die (child
);
5898 *highpc
= best_high
;
5901 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
5904 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
5905 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
5907 struct attribute
*attr
;
5909 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
5912 CORE_ADDR high
= DW_ADDR (attr
);
5914 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5917 CORE_ADDR low
= DW_ADDR (attr
);
5919 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
5923 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
5926 bfd
*obfd
= cu
->objfile
->obfd
;
5928 /* The value of the DW_AT_ranges attribute is the offset of the
5929 address range list in the .debug_ranges section. */
5930 unsigned long offset
= DW_UNSND (attr
);
5931 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
5933 /* For some target architectures, but not others, the
5934 read_address function sign-extends the addresses it returns.
5935 To recognize base address selection entries, we need a
5937 unsigned int addr_size
= cu
->header
.addr_size
;
5938 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
5940 /* The base address, to which the next pair is relative. Note
5941 that this 'base' is a DWARF concept: most entries in a range
5942 list are relative, to reduce the number of relocs against the
5943 debugging information. This is separate from this function's
5944 'baseaddr' argument, which GDB uses to relocate debugging
5945 information from a shared library based on the address at
5946 which the library was loaded. */
5947 CORE_ADDR base
= cu
->base_address
;
5948 int base_known
= cu
->base_known
;
5950 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
5951 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
5953 complaint (&symfile_complaints
,
5954 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
5961 unsigned int bytes_read
;
5962 CORE_ADDR start
, end
;
5964 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
5965 buffer
+= bytes_read
;
5966 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
5967 buffer
+= bytes_read
;
5969 /* Did we find the end of the range list? */
5970 if (start
== 0 && end
== 0)
5973 /* Did we find a base address selection entry? */
5974 else if ((start
& base_select_mask
) == base_select_mask
)
5980 /* We found an ordinary address range. */
5985 complaint (&symfile_complaints
,
5986 _("Invalid .debug_ranges data (no base address)"));
5990 record_block_range (block
,
5991 baseaddr
+ base
+ start
,
5992 baseaddr
+ base
+ end
- 1);
5998 /* Add an aggregate field to the field list. */
6001 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
6002 struct dwarf2_cu
*cu
)
6004 struct objfile
*objfile
= cu
->objfile
;
6005 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6006 struct nextfield
*new_field
;
6007 struct attribute
*attr
;
6009 char *fieldname
= "";
6011 /* Allocate a new field list entry and link it in. */
6012 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
6013 make_cleanup (xfree
, new_field
);
6014 memset (new_field
, 0, sizeof (struct nextfield
));
6016 if (die
->tag
== DW_TAG_inheritance
)
6018 new_field
->next
= fip
->baseclasses
;
6019 fip
->baseclasses
= new_field
;
6023 new_field
->next
= fip
->fields
;
6024 fip
->fields
= new_field
;
6028 /* Handle accessibility and virtuality of field.
6029 The default accessibility for members is public, the default
6030 accessibility for inheritance is private. */
6031 if (die
->tag
!= DW_TAG_inheritance
)
6032 new_field
->accessibility
= DW_ACCESS_public
;
6034 new_field
->accessibility
= DW_ACCESS_private
;
6035 new_field
->virtuality
= DW_VIRTUALITY_none
;
6037 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
6039 new_field
->accessibility
= DW_UNSND (attr
);
6040 if (new_field
->accessibility
!= DW_ACCESS_public
)
6041 fip
->non_public_fields
= 1;
6042 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
6044 new_field
->virtuality
= DW_UNSND (attr
);
6046 fp
= &new_field
->field
;
6048 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
6050 /* Data member other than a C++ static data member. */
6052 /* Get type of field. */
6053 fp
->type
= die_type (die
, cu
);
6055 SET_FIELD_BITPOS (*fp
, 0);
6057 /* Get bit size of field (zero if none). */
6058 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
6061 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
6065 FIELD_BITSIZE (*fp
) = 0;
6068 /* Get bit offset of field. */
6069 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
6072 int byte_offset
= 0;
6074 if (attr_form_is_section_offset (attr
))
6075 dwarf2_complex_location_expr_complaint ();
6076 else if (attr_form_is_constant (attr
))
6077 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
6078 else if (attr_form_is_block (attr
))
6079 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6081 dwarf2_complex_location_expr_complaint ();
6083 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
6085 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
6088 if (gdbarch_bits_big_endian (gdbarch
))
6090 /* For big endian bits, the DW_AT_bit_offset gives the
6091 additional bit offset from the MSB of the containing
6092 anonymous object to the MSB of the field. We don't
6093 have to do anything special since we don't need to
6094 know the size of the anonymous object. */
6095 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
6099 /* For little endian bits, compute the bit offset to the
6100 MSB of the anonymous object, subtract off the number of
6101 bits from the MSB of the field to the MSB of the
6102 object, and then subtract off the number of bits of
6103 the field itself. The result is the bit offset of
6104 the LSB of the field. */
6106 int bit_offset
= DW_UNSND (attr
);
6108 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6111 /* The size of the anonymous object containing
6112 the bit field is explicit, so use the
6113 indicated size (in bytes). */
6114 anonymous_size
= DW_UNSND (attr
);
6118 /* The size of the anonymous object containing
6119 the bit field must be inferred from the type
6120 attribute of the data member containing the
6122 anonymous_size
= TYPE_LENGTH (fp
->type
);
6124 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
6125 - bit_offset
- FIELD_BITSIZE (*fp
);
6129 /* Get name of field. */
6130 fieldname
= dwarf2_name (die
, cu
);
6131 if (fieldname
== NULL
)
6134 /* The name is already allocated along with this objfile, so we don't
6135 need to duplicate it for the type. */
6136 fp
->name
= fieldname
;
6138 /* Change accessibility for artificial fields (e.g. virtual table
6139 pointer or virtual base class pointer) to private. */
6140 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
6142 FIELD_ARTIFICIAL (*fp
) = 1;
6143 new_field
->accessibility
= DW_ACCESS_private
;
6144 fip
->non_public_fields
= 1;
6147 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
6149 /* C++ static member. */
6151 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
6152 is a declaration, but all versions of G++ as of this writing
6153 (so through at least 3.2.1) incorrectly generate
6154 DW_TAG_variable tags. */
6158 /* Get name of field. */
6159 fieldname
= dwarf2_name (die
, cu
);
6160 if (fieldname
== NULL
)
6163 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6165 /* Only create a symbol if this is an external value.
6166 new_symbol checks this and puts the value in the global symbol
6167 table, which we want. If it is not external, new_symbol
6168 will try to put the value in cu->list_in_scope which is wrong. */
6169 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
6171 /* A static const member, not much different than an enum as far as
6172 we're concerned, except that we can support more types. */
6173 new_symbol (die
, NULL
, cu
);
6176 /* Get physical name. */
6177 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
6179 /* The name is already allocated along with this objfile, so we don't
6180 need to duplicate it for the type. */
6181 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
6182 FIELD_TYPE (*fp
) = die_type (die
, cu
);
6183 FIELD_NAME (*fp
) = fieldname
;
6185 else if (die
->tag
== DW_TAG_inheritance
)
6187 /* C++ base class field. */
6188 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
6191 int byte_offset
= 0;
6193 if (attr_form_is_section_offset (attr
))
6194 dwarf2_complex_location_expr_complaint ();
6195 else if (attr_form_is_constant (attr
))
6196 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
6197 else if (attr_form_is_block (attr
))
6198 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6200 dwarf2_complex_location_expr_complaint ();
6202 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
6204 FIELD_BITSIZE (*fp
) = 0;
6205 FIELD_TYPE (*fp
) = die_type (die
, cu
);
6206 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
6207 fip
->nbaseclasses
++;
6211 /* Add a typedef defined in the scope of the FIP's class. */
6214 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
6215 struct dwarf2_cu
*cu
)
6217 struct objfile
*objfile
= cu
->objfile
;
6218 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6219 struct typedef_field_list
*new_field
;
6220 struct attribute
*attr
;
6221 struct typedef_field
*fp
;
6222 char *fieldname
= "";
6224 /* Allocate a new field list entry and link it in. */
6225 new_field
= xzalloc (sizeof (*new_field
));
6226 make_cleanup (xfree
, new_field
);
6228 gdb_assert (die
->tag
== DW_TAG_typedef
);
6230 fp
= &new_field
->field
;
6232 /* Get name of field. */
6233 fp
->name
= dwarf2_name (die
, cu
);
6234 if (fp
->name
== NULL
)
6237 fp
->type
= read_type_die (die
, cu
);
6239 new_field
->next
= fip
->typedef_field_list
;
6240 fip
->typedef_field_list
= new_field
;
6241 fip
->typedef_field_list_count
++;
6244 /* Create the vector of fields, and attach it to the type. */
6247 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
6248 struct dwarf2_cu
*cu
)
6250 int nfields
= fip
->nfields
;
6252 /* Record the field count, allocate space for the array of fields,
6253 and create blank accessibility bitfields if necessary. */
6254 TYPE_NFIELDS (type
) = nfields
;
6255 TYPE_FIELDS (type
) = (struct field
*)
6256 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
6257 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
6259 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
6261 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6263 TYPE_FIELD_PRIVATE_BITS (type
) =
6264 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
6265 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
6267 TYPE_FIELD_PROTECTED_BITS (type
) =
6268 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
6269 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
6271 TYPE_FIELD_IGNORE_BITS (type
) =
6272 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
6273 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
6276 /* If the type has baseclasses, allocate and clear a bit vector for
6277 TYPE_FIELD_VIRTUAL_BITS. */
6278 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
6280 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
6281 unsigned char *pointer
;
6283 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6284 pointer
= TYPE_ALLOC (type
, num_bytes
);
6285 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
6286 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
6287 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
6290 /* Copy the saved-up fields into the field vector. Start from the head
6291 of the list, adding to the tail of the field array, so that they end
6292 up in the same order in the array in which they were added to the list. */
6293 while (nfields
-- > 0)
6295 struct nextfield
*fieldp
;
6299 fieldp
= fip
->fields
;
6300 fip
->fields
= fieldp
->next
;
6304 fieldp
= fip
->baseclasses
;
6305 fip
->baseclasses
= fieldp
->next
;
6308 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
6309 switch (fieldp
->accessibility
)
6311 case DW_ACCESS_private
:
6312 if (cu
->language
!= language_ada
)
6313 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
6316 case DW_ACCESS_protected
:
6317 if (cu
->language
!= language_ada
)
6318 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
6321 case DW_ACCESS_public
:
6325 /* Unknown accessibility. Complain and treat it as public. */
6327 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
6328 fieldp
->accessibility
);
6332 if (nfields
< fip
->nbaseclasses
)
6334 switch (fieldp
->virtuality
)
6336 case DW_VIRTUALITY_virtual
:
6337 case DW_VIRTUALITY_pure_virtual
:
6338 if (cu
->language
== language_ada
)
6339 error ("unexpected virtuality in component of Ada type");
6340 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
6347 /* Add a member function to the proper fieldlist. */
6350 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
6351 struct type
*type
, struct dwarf2_cu
*cu
)
6353 struct objfile
*objfile
= cu
->objfile
;
6354 struct attribute
*attr
;
6355 struct fnfieldlist
*flp
;
6357 struct fn_field
*fnp
;
6359 struct nextfnfield
*new_fnfield
;
6360 struct type
*this_type
;
6362 if (cu
->language
== language_ada
)
6363 error ("unexpected member function in Ada type");
6365 /* Get name of member function. */
6366 fieldname
= dwarf2_name (die
, cu
);
6367 if (fieldname
== NULL
)
6370 /* Look up member function name in fieldlist. */
6371 for (i
= 0; i
< fip
->nfnfields
; i
++)
6373 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
6377 /* Create new list element if necessary. */
6378 if (i
< fip
->nfnfields
)
6379 flp
= &fip
->fnfieldlists
[i
];
6382 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
6384 fip
->fnfieldlists
= (struct fnfieldlist
*)
6385 xrealloc (fip
->fnfieldlists
,
6386 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
6387 * sizeof (struct fnfieldlist
));
6388 if (fip
->nfnfields
== 0)
6389 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
6391 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
6392 flp
->name
= fieldname
;
6395 i
= fip
->nfnfields
++;
6398 /* Create a new member function field and chain it to the field list
6400 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
6401 make_cleanup (xfree
, new_fnfield
);
6402 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
6403 new_fnfield
->next
= flp
->head
;
6404 flp
->head
= new_fnfield
;
6407 /* Fill in the member function field info. */
6408 fnp
= &new_fnfield
->fnfield
;
6410 /* Delay processing of the physname until later. */
6411 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
6413 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
6418 char *physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
6419 fnp
->physname
= physname
? physname
: "";
6422 fnp
->type
= alloc_type (objfile
);
6423 this_type
= read_type_die (die
, cu
);
6424 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
6426 int nparams
= TYPE_NFIELDS (this_type
);
6428 /* TYPE is the domain of this method, and THIS_TYPE is the type
6429 of the method itself (TYPE_CODE_METHOD). */
6430 smash_to_method_type (fnp
->type
, type
,
6431 TYPE_TARGET_TYPE (this_type
),
6432 TYPE_FIELDS (this_type
),
6433 TYPE_NFIELDS (this_type
),
6434 TYPE_VARARGS (this_type
));
6436 /* Handle static member functions.
6437 Dwarf2 has no clean way to discern C++ static and non-static
6438 member functions. G++ helps GDB by marking the first
6439 parameter for non-static member functions (which is the
6440 this pointer) as artificial. We obtain this information
6441 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
6442 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
6443 fnp
->voffset
= VOFFSET_STATIC
;
6446 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
6447 dwarf2_full_name (fieldname
, die
, cu
));
6449 /* Get fcontext from DW_AT_containing_type if present. */
6450 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
6451 fnp
->fcontext
= die_containing_type (die
, cu
);
6453 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
6454 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
6456 /* Get accessibility. */
6457 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
6460 switch (DW_UNSND (attr
))
6462 case DW_ACCESS_private
:
6463 fnp
->is_private
= 1;
6465 case DW_ACCESS_protected
:
6466 fnp
->is_protected
= 1;
6471 /* Check for artificial methods. */
6472 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
6473 if (attr
&& DW_UNSND (attr
) != 0)
6474 fnp
->is_artificial
= 1;
6476 /* Get index in virtual function table if it is a virtual member
6477 function. For older versions of GCC, this is an offset in the
6478 appropriate virtual table, as specified by DW_AT_containing_type.
6479 For everyone else, it is an expression to be evaluated relative
6480 to the object address. */
6482 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
6485 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
6487 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
6489 /* Old-style GCC. */
6490 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
6492 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
6493 || (DW_BLOCK (attr
)->size
> 1
6494 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
6495 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
6497 struct dwarf_block blk
;
6500 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
6502 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
6503 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
6504 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6505 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
6506 dwarf2_complex_location_expr_complaint ();
6508 fnp
->voffset
/= cu
->header
.addr_size
;
6512 dwarf2_complex_location_expr_complaint ();
6515 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
6517 else if (attr_form_is_section_offset (attr
))
6519 dwarf2_complex_location_expr_complaint ();
6523 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
6529 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
6530 if (attr
&& DW_UNSND (attr
))
6532 /* GCC does this, as of 2008-08-25; PR debug/37237. */
6533 complaint (&symfile_complaints
,
6534 _("Member function \"%s\" (offset %d) is virtual but the vtable offset is not specified"),
6535 fieldname
, die
->offset
);
6536 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6537 TYPE_CPLUS_DYNAMIC (type
) = 1;
6542 /* Create the vector of member function fields, and attach it to the type. */
6545 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
6546 struct dwarf2_cu
*cu
)
6548 struct fnfieldlist
*flp
;
6549 int total_length
= 0;
6552 if (cu
->language
== language_ada
)
6553 error ("unexpected member functions in Ada type");
6555 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6556 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
6557 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
6559 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
6561 struct nextfnfield
*nfp
= flp
->head
;
6562 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
6565 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
6566 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
6567 fn_flp
->fn_fields
= (struct fn_field
*)
6568 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
6569 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
6570 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
6572 total_length
+= flp
->length
;
6575 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
6576 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
6579 /* Returns non-zero if NAME is the name of a vtable member in CU's
6580 language, zero otherwise. */
6582 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
6584 static const char vptr
[] = "_vptr";
6585 static const char vtable
[] = "vtable";
6587 /* Look for the C++ and Java forms of the vtable. */
6588 if ((cu
->language
== language_java
6589 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
6590 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
6591 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
6597 /* GCC outputs unnamed structures that are really pointers to member
6598 functions, with the ABI-specified layout. If TYPE describes
6599 such a structure, smash it into a member function type.
6601 GCC shouldn't do this; it should just output pointer to member DIEs.
6602 This is GCC PR debug/28767. */
6605 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
6607 struct type
*pfn_type
, *domain_type
, *new_type
;
6609 /* Check for a structure with no name and two children. */
6610 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
6613 /* Check for __pfn and __delta members. */
6614 if (TYPE_FIELD_NAME (type
, 0) == NULL
6615 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
6616 || TYPE_FIELD_NAME (type
, 1) == NULL
6617 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
6620 /* Find the type of the method. */
6621 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
6622 if (pfn_type
== NULL
6623 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
6624 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
6627 /* Look for the "this" argument. */
6628 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
6629 if (TYPE_NFIELDS (pfn_type
) == 0
6630 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
6631 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
6634 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
6635 new_type
= alloc_type (objfile
);
6636 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
6637 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
6638 TYPE_VARARGS (pfn_type
));
6639 smash_to_methodptr_type (type
, new_type
);
6642 /* Called when we find the DIE that starts a structure or union scope
6643 (definition) to process all dies that define the members of the
6646 NOTE: we need to call struct_type regardless of whether or not the
6647 DIE has an at_name attribute, since it might be an anonymous
6648 structure or union. This gets the type entered into our set of
6651 However, if the structure is incomplete (an opaque struct/union)
6652 then suppress creating a symbol table entry for it since gdb only
6653 wants to find the one with the complete definition. Note that if
6654 it is complete, we just call new_symbol, which does it's own
6655 checking about whether the struct/union is anonymous or not (and
6656 suppresses creating a symbol table entry itself). */
6658 static struct type
*
6659 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6661 struct objfile
*objfile
= cu
->objfile
;
6663 struct attribute
*attr
;
6665 struct cleanup
*back_to
;
6667 /* If the definition of this type lives in .debug_types, read that type.
6668 Don't follow DW_AT_specification though, that will take us back up
6669 the chain and we want to go down. */
6670 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
6673 struct dwarf2_cu
*type_cu
= cu
;
6674 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
6676 /* We could just recurse on read_structure_type, but we need to call
6677 get_die_type to ensure only one type for this DIE is created.
6678 This is important, for example, because for c++ classes we need
6679 TYPE_NAME set which is only done by new_symbol. Blech. */
6680 type
= read_type_die (type_die
, type_cu
);
6682 /* TYPE_CU may not be the same as CU.
6683 Ensure TYPE is recorded in CU's type_hash table. */
6684 return set_die_type (die
, type
, cu
);
6687 back_to
= make_cleanup (null_cleanup
, 0);
6689 type
= alloc_type (objfile
);
6690 INIT_CPLUS_SPECIFIC (type
);
6692 name
= dwarf2_name (die
, cu
);
6695 if (cu
->language
== language_cplus
6696 || cu
->language
== language_java
)
6698 char *full_name
= (char *) dwarf2_full_name (name
, die
, cu
);
6700 /* dwarf2_full_name might have already finished building the DIE's
6701 type. If so, there is no need to continue. */
6702 if (get_die_type (die
, cu
) != NULL
)
6703 return get_die_type (die
, cu
);
6705 TYPE_TAG_NAME (type
) = full_name
;
6706 if (die
->tag
== DW_TAG_structure_type
6707 || die
->tag
== DW_TAG_class_type
)
6708 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
6712 /* The name is already allocated along with this objfile, so
6713 we don't need to duplicate it for the type. */
6714 TYPE_TAG_NAME (type
) = (char *) name
;
6715 if (die
->tag
== DW_TAG_class_type
)
6716 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
6720 if (die
->tag
== DW_TAG_structure_type
)
6722 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
6724 else if (die
->tag
== DW_TAG_union_type
)
6726 TYPE_CODE (type
) = TYPE_CODE_UNION
;
6730 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
6733 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
6734 TYPE_DECLARED_CLASS (type
) = 1;
6736 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6739 TYPE_LENGTH (type
) = DW_UNSND (attr
);
6743 TYPE_LENGTH (type
) = 0;
6746 TYPE_STUB_SUPPORTED (type
) = 1;
6747 if (die_is_declaration (die
, cu
))
6748 TYPE_STUB (type
) = 1;
6749 else if (attr
== NULL
&& die
->child
== NULL
6750 && producer_is_realview (cu
->producer
))
6751 /* RealView does not output the required DW_AT_declaration
6752 on incomplete types. */
6753 TYPE_STUB (type
) = 1;
6755 /* We need to add the type field to the die immediately so we don't
6756 infinitely recurse when dealing with pointers to the structure
6757 type within the structure itself. */
6758 set_die_type (die
, type
, cu
);
6760 /* set_die_type should be already done. */
6761 set_descriptive_type (type
, die
, cu
);
6763 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
6765 struct field_info fi
;
6766 struct die_info
*child_die
;
6767 VEC (symbolp
) *template_args
= NULL
;
6769 memset (&fi
, 0, sizeof (struct field_info
));
6771 child_die
= die
->child
;
6773 while (child_die
&& child_die
->tag
)
6775 if (child_die
->tag
== DW_TAG_member
6776 || child_die
->tag
== DW_TAG_variable
)
6778 /* NOTE: carlton/2002-11-05: A C++ static data member
6779 should be a DW_TAG_member that is a declaration, but
6780 all versions of G++ as of this writing (so through at
6781 least 3.2.1) incorrectly generate DW_TAG_variable
6782 tags for them instead. */
6783 dwarf2_add_field (&fi
, child_die
, cu
);
6785 else if (child_die
->tag
== DW_TAG_subprogram
)
6787 /* C++ member function. */
6788 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
6790 else if (child_die
->tag
== DW_TAG_inheritance
)
6792 /* C++ base class field. */
6793 dwarf2_add_field (&fi
, child_die
, cu
);
6795 else if (child_die
->tag
== DW_TAG_typedef
)
6796 dwarf2_add_typedef (&fi
, child_die
, cu
);
6797 else if (child_die
->tag
== DW_TAG_template_type_param
6798 || child_die
->tag
== DW_TAG_template_value_param
)
6800 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
6802 VEC_safe_push (symbolp
, template_args
, arg
);
6805 child_die
= sibling_die (child_die
);
6808 /* Attach template arguments to type. */
6809 if (! VEC_empty (symbolp
, template_args
))
6811 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6812 TYPE_N_TEMPLATE_ARGUMENTS (type
)
6813 = VEC_length (symbolp
, template_args
);
6814 TYPE_TEMPLATE_ARGUMENTS (type
)
6815 = obstack_alloc (&objfile
->objfile_obstack
,
6816 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
6817 * sizeof (struct symbol
*)));
6818 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
6819 VEC_address (symbolp
, template_args
),
6820 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
6821 * sizeof (struct symbol
*)));
6822 VEC_free (symbolp
, template_args
);
6825 /* Attach fields and member functions to the type. */
6827 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
6830 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
6832 /* Get the type which refers to the base class (possibly this
6833 class itself) which contains the vtable pointer for the current
6834 class from the DW_AT_containing_type attribute. This use of
6835 DW_AT_containing_type is a GNU extension. */
6837 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
6839 struct type
*t
= die_containing_type (die
, cu
);
6841 TYPE_VPTR_BASETYPE (type
) = t
;
6846 /* Our own class provides vtbl ptr. */
6847 for (i
= TYPE_NFIELDS (t
) - 1;
6848 i
>= TYPE_N_BASECLASSES (t
);
6851 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
6853 if (is_vtable_name (fieldname
, cu
))
6855 TYPE_VPTR_FIELDNO (type
) = i
;
6860 /* Complain if virtual function table field not found. */
6861 if (i
< TYPE_N_BASECLASSES (t
))
6862 complaint (&symfile_complaints
,
6863 _("virtual function table pointer not found when defining class '%s'"),
6864 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
6869 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
6872 else if (cu
->producer
6873 && strncmp (cu
->producer
,
6874 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
6876 /* The IBM XLC compiler does not provide direct indication
6877 of the containing type, but the vtable pointer is
6878 always named __vfp. */
6882 for (i
= TYPE_NFIELDS (type
) - 1;
6883 i
>= TYPE_N_BASECLASSES (type
);
6886 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
6888 TYPE_VPTR_FIELDNO (type
) = i
;
6889 TYPE_VPTR_BASETYPE (type
) = type
;
6896 /* Copy fi.typedef_field_list linked list elements content into the
6897 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
6898 if (fi
.typedef_field_list
)
6900 int i
= fi
.typedef_field_list_count
;
6902 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6903 TYPE_TYPEDEF_FIELD_ARRAY (type
)
6904 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
6905 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
6907 /* Reverse the list order to keep the debug info elements order. */
6910 struct typedef_field
*dest
, *src
;
6912 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
6913 src
= &fi
.typedef_field_list
->field
;
6914 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
6920 quirk_gcc_member_function_pointer (type
, cu
->objfile
);
6922 do_cleanups (back_to
);
6927 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6929 struct die_info
*child_die
= die
->child
;
6930 struct type
*this_type
;
6932 this_type
= get_die_type (die
, cu
);
6933 if (this_type
== NULL
)
6934 this_type
= read_structure_type (die
, cu
);
6936 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
6937 snapshots) has been known to create a die giving a declaration
6938 for a class that has, as a child, a die giving a definition for a
6939 nested class. So we have to process our children even if the
6940 current die is a declaration. Normally, of course, a declaration
6941 won't have any children at all. */
6943 while (child_die
!= NULL
&& child_die
->tag
)
6945 if (child_die
->tag
== DW_TAG_member
6946 || child_die
->tag
== DW_TAG_variable
6947 || child_die
->tag
== DW_TAG_inheritance
6948 || child_die
->tag
== DW_TAG_template_value_param
6949 || child_die
->tag
== DW_TAG_template_type_param
)
6954 process_die (child_die
, cu
);
6956 child_die
= sibling_die (child_die
);
6959 /* Do not consider external references. According to the DWARF standard,
6960 these DIEs are identified by the fact that they have no byte_size
6961 attribute, and a declaration attribute. */
6962 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
6963 || !die_is_declaration (die
, cu
))
6964 new_symbol (die
, this_type
, cu
);
6967 /* Given a DW_AT_enumeration_type die, set its type. We do not
6968 complete the type's fields yet, or create any symbols. */
6970 static struct type
*
6971 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6973 struct objfile
*objfile
= cu
->objfile
;
6975 struct attribute
*attr
;
6978 /* If the definition of this type lives in .debug_types, read that type.
6979 Don't follow DW_AT_specification though, that will take us back up
6980 the chain and we want to go down. */
6981 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
6984 struct dwarf2_cu
*type_cu
= cu
;
6985 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
6987 type
= read_type_die (type_die
, type_cu
);
6989 /* TYPE_CU may not be the same as CU.
6990 Ensure TYPE is recorded in CU's type_hash table. */
6991 return set_die_type (die
, type
, cu
);
6994 type
= alloc_type (objfile
);
6996 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
6997 name
= dwarf2_full_name (NULL
, die
, cu
);
6999 TYPE_TAG_NAME (type
) = (char *) name
;
7001 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7004 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7008 TYPE_LENGTH (type
) = 0;
7011 /* The enumeration DIE can be incomplete. In Ada, any type can be
7012 declared as private in the package spec, and then defined only
7013 inside the package body. Such types are known as Taft Amendment
7014 Types. When another package uses such a type, an incomplete DIE
7015 may be generated by the compiler. */
7016 if (die_is_declaration (die
, cu
))
7017 TYPE_STUB (type
) = 1;
7019 return set_die_type (die
, type
, cu
);
7022 /* Given a pointer to a die which begins an enumeration, process all
7023 the dies that define the members of the enumeration, and create the
7024 symbol for the enumeration type.
7026 NOTE: We reverse the order of the element list. */
7029 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7031 struct type
*this_type
;
7033 this_type
= get_die_type (die
, cu
);
7034 if (this_type
== NULL
)
7035 this_type
= read_enumeration_type (die
, cu
);
7037 if (die
->child
!= NULL
)
7039 struct die_info
*child_die
;
7041 struct field
*fields
= NULL
;
7043 int unsigned_enum
= 1;
7046 child_die
= die
->child
;
7047 while (child_die
&& child_die
->tag
)
7049 if (child_die
->tag
!= DW_TAG_enumerator
)
7051 process_die (child_die
, cu
);
7055 name
= dwarf2_name (child_die
, cu
);
7058 sym
= new_symbol (child_die
, this_type
, cu
);
7059 if (SYMBOL_VALUE (sym
) < 0)
7062 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7064 fields
= (struct field
*)
7066 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
7067 * sizeof (struct field
));
7070 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
7071 FIELD_TYPE (fields
[num_fields
]) = NULL
;
7072 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
7073 FIELD_BITSIZE (fields
[num_fields
]) = 0;
7079 child_die
= sibling_die (child_die
);
7084 TYPE_NFIELDS (this_type
) = num_fields
;
7085 TYPE_FIELDS (this_type
) = (struct field
*)
7086 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
7087 memcpy (TYPE_FIELDS (this_type
), fields
,
7088 sizeof (struct field
) * num_fields
);
7092 TYPE_UNSIGNED (this_type
) = 1;
7095 new_symbol (die
, this_type
, cu
);
7098 /* Extract all information from a DW_TAG_array_type DIE and put it in
7099 the DIE's type field. For now, this only handles one dimensional
7102 static struct type
*
7103 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7105 struct objfile
*objfile
= cu
->objfile
;
7106 struct die_info
*child_die
;
7108 struct type
*element_type
, *range_type
, *index_type
;
7109 struct type
**range_types
= NULL
;
7110 struct attribute
*attr
;
7112 struct cleanup
*back_to
;
7115 element_type
= die_type (die
, cu
);
7117 /* The die_type call above may have already set the type for this DIE. */
7118 type
= get_die_type (die
, cu
);
7122 /* Irix 6.2 native cc creates array types without children for
7123 arrays with unspecified length. */
7124 if (die
->child
== NULL
)
7126 index_type
= objfile_type (objfile
)->builtin_int
;
7127 range_type
= create_range_type (NULL
, index_type
, 0, -1);
7128 type
= create_array_type (NULL
, element_type
, range_type
);
7129 return set_die_type (die
, type
, cu
);
7132 back_to
= make_cleanup (null_cleanup
, NULL
);
7133 child_die
= die
->child
;
7134 while (child_die
&& child_die
->tag
)
7136 if (child_die
->tag
== DW_TAG_subrange_type
)
7138 struct type
*child_type
= read_type_die (child_die
, cu
);
7140 if (child_type
!= NULL
)
7142 /* The range type was succesfully read. Save it for
7143 the array type creation. */
7144 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
7146 range_types
= (struct type
**)
7147 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
7148 * sizeof (struct type
*));
7150 make_cleanup (free_current_contents
, &range_types
);
7152 range_types
[ndim
++] = child_type
;
7155 child_die
= sibling_die (child_die
);
7158 /* Dwarf2 dimensions are output from left to right, create the
7159 necessary array types in backwards order. */
7161 type
= element_type
;
7163 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
7168 type
= create_array_type (NULL
, type
, range_types
[i
++]);
7173 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
7176 /* Understand Dwarf2 support for vector types (like they occur on
7177 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
7178 array type. This is not part of the Dwarf2/3 standard yet, but a
7179 custom vendor extension. The main difference between a regular
7180 array and the vector variant is that vectors are passed by value
7182 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
7184 make_vector_type (type
);
7186 name
= dwarf2_name (die
, cu
);
7188 TYPE_NAME (type
) = name
;
7190 /* Install the type in the die. */
7191 set_die_type (die
, type
, cu
);
7193 /* set_die_type should be already done. */
7194 set_descriptive_type (type
, die
, cu
);
7196 do_cleanups (back_to
);
7201 static enum dwarf_array_dim_ordering
7202 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
7204 struct attribute
*attr
;
7206 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
7208 if (attr
) return DW_SND (attr
);
7211 GNU F77 is a special case, as at 08/2004 array type info is the
7212 opposite order to the dwarf2 specification, but data is still
7213 laid out as per normal fortran.
7215 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
7219 if (cu
->language
== language_fortran
7220 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
7222 return DW_ORD_row_major
;
7225 switch (cu
->language_defn
->la_array_ordering
)
7227 case array_column_major
:
7228 return DW_ORD_col_major
;
7229 case array_row_major
:
7231 return DW_ORD_row_major
;
7235 /* Extract all information from a DW_TAG_set_type DIE and put it in
7236 the DIE's type field. */
7238 static struct type
*
7239 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7241 struct type
*domain_type
, *set_type
;
7242 struct attribute
*attr
;
7244 domain_type
= die_type (die
, cu
);
7246 /* The die_type call above may have already set the type for this DIE. */
7247 set_type
= get_die_type (die
, cu
);
7251 set_type
= create_set_type (NULL
, domain_type
);
7253 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7255 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
7257 return set_die_type (die
, set_type
, cu
);
7260 /* First cut: install each common block member as a global variable. */
7263 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
7265 struct die_info
*child_die
;
7266 struct attribute
*attr
;
7268 CORE_ADDR base
= (CORE_ADDR
) 0;
7270 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7273 /* Support the .debug_loc offsets */
7274 if (attr_form_is_block (attr
))
7276 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
7278 else if (attr_form_is_section_offset (attr
))
7280 dwarf2_complex_location_expr_complaint ();
7284 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
7285 "common block member");
7288 if (die
->child
!= NULL
)
7290 child_die
= die
->child
;
7291 while (child_die
&& child_die
->tag
)
7293 sym
= new_symbol (child_die
, NULL
, cu
);
7294 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
7297 CORE_ADDR byte_offset
= 0;
7299 if (attr_form_is_section_offset (attr
))
7300 dwarf2_complex_location_expr_complaint ();
7301 else if (attr_form_is_constant (attr
))
7302 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
7303 else if (attr_form_is_block (attr
))
7304 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
7306 dwarf2_complex_location_expr_complaint ();
7308 SYMBOL_VALUE_ADDRESS (sym
) = base
+ byte_offset
;
7309 add_symbol_to_list (sym
, &global_symbols
);
7311 child_die
= sibling_die (child_die
);
7316 /* Create a type for a C++ namespace. */
7318 static struct type
*
7319 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7321 struct objfile
*objfile
= cu
->objfile
;
7322 const char *previous_prefix
, *name
;
7326 /* For extensions, reuse the type of the original namespace. */
7327 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
7329 struct die_info
*ext_die
;
7330 struct dwarf2_cu
*ext_cu
= cu
;
7332 ext_die
= dwarf2_extension (die
, &ext_cu
);
7333 type
= read_type_die (ext_die
, ext_cu
);
7335 /* EXT_CU may not be the same as CU.
7336 Ensure TYPE is recorded in CU's type_hash table. */
7337 return set_die_type (die
, type
, cu
);
7340 name
= namespace_name (die
, &is_anonymous
, cu
);
7342 /* Now build the name of the current namespace. */
7344 previous_prefix
= determine_prefix (die
, cu
);
7345 if (previous_prefix
[0] != '\0')
7346 name
= typename_concat (&objfile
->objfile_obstack
,
7347 previous_prefix
, name
, 0, cu
);
7349 /* Create the type. */
7350 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
7352 TYPE_NAME (type
) = (char *) name
;
7353 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7355 return set_die_type (die
, type
, cu
);
7358 /* Read a C++ namespace. */
7361 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
7363 struct objfile
*objfile
= cu
->objfile
;
7367 /* Add a symbol associated to this if we haven't seen the namespace
7368 before. Also, add a using directive if it's an anonymous
7371 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
7375 type
= read_type_die (die
, cu
);
7376 new_symbol (die
, type
, cu
);
7378 name
= namespace_name (die
, &is_anonymous
, cu
);
7381 const char *previous_prefix
= determine_prefix (die
, cu
);
7383 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
7384 NULL
, &objfile
->objfile_obstack
);
7388 if (die
->child
!= NULL
)
7390 struct die_info
*child_die
= die
->child
;
7392 while (child_die
&& child_die
->tag
)
7394 process_die (child_die
, cu
);
7395 child_die
= sibling_die (child_die
);
7400 /* Read a Fortran module as type. This DIE can be only a declaration used for
7401 imported module. Still we need that type as local Fortran "use ... only"
7402 declaration imports depend on the created type in determine_prefix. */
7404 static struct type
*
7405 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7407 struct objfile
*objfile
= cu
->objfile
;
7411 module_name
= dwarf2_name (die
, cu
);
7413 complaint (&symfile_complaints
, _("DW_TAG_module has no name, offset 0x%x"),
7415 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
7417 /* determine_prefix uses TYPE_TAG_NAME. */
7418 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7420 return set_die_type (die
, type
, cu
);
7423 /* Read a Fortran module. */
7426 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
7428 struct die_info
*child_die
= die
->child
;
7430 while (child_die
&& child_die
->tag
)
7432 process_die (child_die
, cu
);
7433 child_die
= sibling_die (child_die
);
7437 /* Return the name of the namespace represented by DIE. Set
7438 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
7442 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
7444 struct die_info
*current_die
;
7445 const char *name
= NULL
;
7447 /* Loop through the extensions until we find a name. */
7449 for (current_die
= die
;
7450 current_die
!= NULL
;
7451 current_die
= dwarf2_extension (die
, &cu
))
7453 name
= dwarf2_name (current_die
, cu
);
7458 /* Is it an anonymous namespace? */
7460 *is_anonymous
= (name
== NULL
);
7462 name
= "(anonymous namespace)";
7467 /* Extract all information from a DW_TAG_pointer_type DIE and add to
7468 the user defined type vector. */
7470 static struct type
*
7471 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7473 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
7474 struct comp_unit_head
*cu_header
= &cu
->header
;
7476 struct attribute
*attr_byte_size
;
7477 struct attribute
*attr_address_class
;
7478 int byte_size
, addr_class
;
7479 struct type
*target_type
;
7481 target_type
= die_type (die
, cu
);
7483 /* The die_type call above may have already set the type for this DIE. */
7484 type
= get_die_type (die
, cu
);
7488 type
= lookup_pointer_type (target_type
);
7490 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7492 byte_size
= DW_UNSND (attr_byte_size
);
7494 byte_size
= cu_header
->addr_size
;
7496 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
7497 if (attr_address_class
)
7498 addr_class
= DW_UNSND (attr_address_class
);
7500 addr_class
= DW_ADDR_none
;
7502 /* If the pointer size or address class is different than the
7503 default, create a type variant marked as such and set the
7504 length accordingly. */
7505 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
7507 if (gdbarch_address_class_type_flags_p (gdbarch
))
7511 type_flags
= gdbarch_address_class_type_flags
7512 (gdbarch
, byte_size
, addr_class
);
7513 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
7515 type
= make_type_with_address_space (type
, type_flags
);
7517 else if (TYPE_LENGTH (type
) != byte_size
)
7519 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
7523 /* Should we also complain about unhandled address classes? */
7527 TYPE_LENGTH (type
) = byte_size
;
7528 return set_die_type (die
, type
, cu
);
7531 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
7532 the user defined type vector. */
7534 static struct type
*
7535 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7538 struct type
*to_type
;
7539 struct type
*domain
;
7541 to_type
= die_type (die
, cu
);
7542 domain
= die_containing_type (die
, cu
);
7544 /* The calls above may have already set the type for this DIE. */
7545 type
= get_die_type (die
, cu
);
7549 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
7550 type
= lookup_methodptr_type (to_type
);
7552 type
= lookup_memberptr_type (to_type
, domain
);
7554 return set_die_type (die
, type
, cu
);
7557 /* Extract all information from a DW_TAG_reference_type DIE and add to
7558 the user defined type vector. */
7560 static struct type
*
7561 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7563 struct comp_unit_head
*cu_header
= &cu
->header
;
7564 struct type
*type
, *target_type
;
7565 struct attribute
*attr
;
7567 target_type
= die_type (die
, cu
);
7569 /* The die_type call above may have already set the type for this DIE. */
7570 type
= get_die_type (die
, cu
);
7574 type
= lookup_reference_type (target_type
);
7575 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7578 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7582 TYPE_LENGTH (type
) = cu_header
->addr_size
;
7584 return set_die_type (die
, type
, cu
);
7587 static struct type
*
7588 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7590 struct type
*base_type
, *cv_type
;
7592 base_type
= die_type (die
, cu
);
7594 /* The die_type call above may have already set the type for this DIE. */
7595 cv_type
= get_die_type (die
, cu
);
7599 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
7600 return set_die_type (die
, cv_type
, cu
);
7603 static struct type
*
7604 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7606 struct type
*base_type
, *cv_type
;
7608 base_type
= die_type (die
, cu
);
7610 /* The die_type call above may have already set the type for this DIE. */
7611 cv_type
= get_die_type (die
, cu
);
7615 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
7616 return set_die_type (die
, cv_type
, cu
);
7619 /* Extract all information from a DW_TAG_string_type DIE and add to
7620 the user defined type vector. It isn't really a user defined type,
7621 but it behaves like one, with other DIE's using an AT_user_def_type
7622 attribute to reference it. */
7624 static struct type
*
7625 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7627 struct objfile
*objfile
= cu
->objfile
;
7628 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7629 struct type
*type
, *range_type
, *index_type
, *char_type
;
7630 struct attribute
*attr
;
7631 unsigned int length
;
7633 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
7636 length
= DW_UNSND (attr
);
7640 /* check for the DW_AT_byte_size attribute */
7641 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7644 length
= DW_UNSND (attr
);
7652 index_type
= objfile_type (objfile
)->builtin_int
;
7653 range_type
= create_range_type (NULL
, index_type
, 1, length
);
7654 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
7655 type
= create_string_type (NULL
, char_type
, range_type
);
7657 return set_die_type (die
, type
, cu
);
7660 /* Handle DIES due to C code like:
7664 int (*funcp)(int a, long l);
7668 ('funcp' generates a DW_TAG_subroutine_type DIE)
7671 static struct type
*
7672 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7674 struct type
*type
; /* Type that this function returns */
7675 struct type
*ftype
; /* Function that returns above type */
7676 struct attribute
*attr
;
7678 type
= die_type (die
, cu
);
7680 /* The die_type call above may have already set the type for this DIE. */
7681 ftype
= get_die_type (die
, cu
);
7685 ftype
= lookup_function_type (type
);
7687 /* All functions in C++, Pascal and Java have prototypes. */
7688 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
7689 if ((attr
&& (DW_UNSND (attr
) != 0))
7690 || cu
->language
== language_cplus
7691 || cu
->language
== language_java
7692 || cu
->language
== language_pascal
)
7693 TYPE_PROTOTYPED (ftype
) = 1;
7694 else if (producer_is_realview (cu
->producer
))
7695 /* RealView does not emit DW_AT_prototyped. We can not
7696 distinguish prototyped and unprototyped functions; default to
7697 prototyped, since that is more common in modern code (and
7698 RealView warns about unprototyped functions). */
7699 TYPE_PROTOTYPED (ftype
) = 1;
7701 /* Store the calling convention in the type if it's available in
7702 the subroutine die. Otherwise set the calling convention to
7703 the default value DW_CC_normal. */
7704 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
7705 TYPE_CALLING_CONVENTION (ftype
) = attr
? DW_UNSND (attr
) : DW_CC_normal
;
7707 /* We need to add the subroutine type to the die immediately so
7708 we don't infinitely recurse when dealing with parameters
7709 declared as the same subroutine type. */
7710 set_die_type (die
, ftype
, cu
);
7712 if (die
->child
!= NULL
)
7714 struct type
*void_type
= objfile_type (cu
->objfile
)->builtin_void
;
7715 struct die_info
*child_die
;
7716 int nparams
, iparams
;
7718 /* Count the number of parameters.
7719 FIXME: GDB currently ignores vararg functions, but knows about
7720 vararg member functions. */
7722 child_die
= die
->child
;
7723 while (child_die
&& child_die
->tag
)
7725 if (child_die
->tag
== DW_TAG_formal_parameter
)
7727 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
7728 TYPE_VARARGS (ftype
) = 1;
7729 child_die
= sibling_die (child_die
);
7732 /* Allocate storage for parameters and fill them in. */
7733 TYPE_NFIELDS (ftype
) = nparams
;
7734 TYPE_FIELDS (ftype
) = (struct field
*)
7735 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
7737 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
7738 even if we error out during the parameters reading below. */
7739 for (iparams
= 0; iparams
< nparams
; iparams
++)
7740 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
7743 child_die
= die
->child
;
7744 while (child_die
&& child_die
->tag
)
7746 if (child_die
->tag
== DW_TAG_formal_parameter
)
7748 struct type
*arg_type
;
7750 /* DWARF version 2 has no clean way to discern C++
7751 static and non-static member functions. G++ helps
7752 GDB by marking the first parameter for non-static
7753 member functions (which is the this pointer) as
7754 artificial. We pass this information to
7755 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
7757 DWARF version 3 added DW_AT_object_pointer, which GCC
7758 4.5 does not yet generate. */
7759 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
7761 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
7764 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
7766 /* GCC/43521: In java, the formal parameter
7767 "this" is sometimes not marked with DW_AT_artificial. */
7768 if (cu
->language
== language_java
)
7770 const char *name
= dwarf2_name (child_die
, cu
);
7772 if (name
&& !strcmp (name
, "this"))
7773 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
7776 arg_type
= die_type (child_die
, cu
);
7778 /* RealView does not mark THIS as const, which the testsuite
7779 expects. GCC marks THIS as const in method definitions,
7780 but not in the class specifications (GCC PR 43053). */
7781 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
7782 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
7785 struct dwarf2_cu
*arg_cu
= cu
;
7786 const char *name
= dwarf2_name (child_die
, cu
);
7788 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
7791 /* If the compiler emits this, use it. */
7792 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
7795 else if (name
&& strcmp (name
, "this") == 0)
7796 /* Function definitions will have the argument names. */
7798 else if (name
== NULL
&& iparams
== 0)
7799 /* Declarations may not have the names, so like
7800 elsewhere in GDB, assume an artificial first
7801 argument is "this". */
7805 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
7809 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
7812 child_die
= sibling_die (child_die
);
7819 static struct type
*
7820 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
7822 struct objfile
*objfile
= cu
->objfile
;
7823 const char *name
= NULL
;
7824 struct type
*this_type
;
7826 name
= dwarf2_full_name (NULL
, die
, cu
);
7827 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
7828 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
7829 TYPE_NAME (this_type
) = (char *) name
;
7830 set_die_type (die
, this_type
, cu
);
7831 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
7835 /* Find a representation of a given base type and install
7836 it in the TYPE field of the die. */
7838 static struct type
*
7839 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7841 struct objfile
*objfile
= cu
->objfile
;
7843 struct attribute
*attr
;
7844 int encoding
= 0, size
= 0;
7846 enum type_code code
= TYPE_CODE_INT
;
7848 struct type
*target_type
= NULL
;
7850 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
7853 encoding
= DW_UNSND (attr
);
7855 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7858 size
= DW_UNSND (attr
);
7860 name
= dwarf2_name (die
, cu
);
7863 complaint (&symfile_complaints
,
7864 _("DW_AT_name missing from DW_TAG_base_type"));
7869 case DW_ATE_address
:
7870 /* Turn DW_ATE_address into a void * pointer. */
7871 code
= TYPE_CODE_PTR
;
7872 type_flags
|= TYPE_FLAG_UNSIGNED
;
7873 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
7875 case DW_ATE_boolean
:
7876 code
= TYPE_CODE_BOOL
;
7877 type_flags
|= TYPE_FLAG_UNSIGNED
;
7879 case DW_ATE_complex_float
:
7880 code
= TYPE_CODE_COMPLEX
;
7881 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
7883 case DW_ATE_decimal_float
:
7884 code
= TYPE_CODE_DECFLOAT
;
7887 code
= TYPE_CODE_FLT
;
7891 case DW_ATE_unsigned
:
7892 type_flags
|= TYPE_FLAG_UNSIGNED
;
7894 case DW_ATE_signed_char
:
7895 if (cu
->language
== language_ada
|| cu
->language
== language_m2
7896 || cu
->language
== language_pascal
)
7897 code
= TYPE_CODE_CHAR
;
7899 case DW_ATE_unsigned_char
:
7900 if (cu
->language
== language_ada
|| cu
->language
== language_m2
7901 || cu
->language
== language_pascal
)
7902 code
= TYPE_CODE_CHAR
;
7903 type_flags
|= TYPE_FLAG_UNSIGNED
;
7906 /* We just treat this as an integer and then recognize the
7907 type by name elsewhere. */
7911 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
7912 dwarf_type_encoding_name (encoding
));
7916 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
7917 TYPE_NAME (type
) = name
;
7918 TYPE_TARGET_TYPE (type
) = target_type
;
7920 if (name
&& strcmp (name
, "char") == 0)
7921 TYPE_NOSIGN (type
) = 1;
7923 return set_die_type (die
, type
, cu
);
7926 /* Read the given DW_AT_subrange DIE. */
7928 static struct type
*
7929 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7931 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
7932 struct type
*base_type
;
7933 struct type
*range_type
;
7934 struct attribute
*attr
;
7938 LONGEST negative_mask
;
7940 base_type
= die_type (die
, cu
);
7941 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
7942 check_typedef (base_type
);
7944 /* The die_type call above may have already set the type for this DIE. */
7945 range_type
= get_die_type (die
, cu
);
7949 if (cu
->language
== language_fortran
)
7951 /* FORTRAN implies a lower bound of 1, if not given. */
7955 /* FIXME: For variable sized arrays either of these could be
7956 a variable rather than a constant value. We'll allow it,
7957 but we don't know how to handle it. */
7958 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
7960 low
= dwarf2_get_attr_constant_value (attr
, 0);
7962 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
7965 if (attr
->form
== DW_FORM_block1
|| is_ref_attr (attr
))
7967 /* GCC encodes arrays with unspecified or dynamic length
7968 with a DW_FORM_block1 attribute or a reference attribute.
7969 FIXME: GDB does not yet know how to handle dynamic
7970 arrays properly, treat them as arrays with unspecified
7973 FIXME: jimb/2003-09-22: GDB does not really know
7974 how to handle arrays of unspecified length
7975 either; we just represent them as zero-length
7976 arrays. Choose an appropriate upper bound given
7977 the lower bound we've computed above. */
7981 high
= dwarf2_get_attr_constant_value (attr
, 1);
7985 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
7988 int count
= dwarf2_get_attr_constant_value (attr
, 1);
7989 high
= low
+ count
- 1;
7993 /* Dwarf-2 specifications explicitly allows to create subrange types
7994 without specifying a base type.
7995 In that case, the base type must be set to the type of
7996 the lower bound, upper bound or count, in that order, if any of these
7997 three attributes references an object that has a type.
7998 If no base type is found, the Dwarf-2 specifications say that
7999 a signed integer type of size equal to the size of an address should
8001 For the following C code: `extern char gdb_int [];'
8002 GCC produces an empty range DIE.
8003 FIXME: muller/2010-05-28: Possible references to object for low bound,
8004 high bound or count are not yet handled by this code.
8006 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
8008 struct objfile
*objfile
= cu
->objfile
;
8009 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8010 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
8011 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
8013 /* Test "int", "long int", and "long long int" objfile types,
8014 and select the first one having a size above or equal to the
8015 architecture address size. */
8016 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8017 base_type
= int_type
;
8020 int_type
= objfile_type (objfile
)->builtin_long
;
8021 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8022 base_type
= int_type
;
8025 int_type
= objfile_type (objfile
)->builtin_long_long
;
8026 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8027 base_type
= int_type
;
8033 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
8034 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
8035 low
|= negative_mask
;
8036 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
8037 high
|= negative_mask
;
8039 range_type
= create_range_type (NULL
, base_type
, low
, high
);
8041 /* Mark arrays with dynamic length at least as an array of unspecified
8042 length. GDB could check the boundary but before it gets implemented at
8043 least allow accessing the array elements. */
8044 if (attr
&& attr
->form
== DW_FORM_block1
)
8045 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
8047 name
= dwarf2_name (die
, cu
);
8049 TYPE_NAME (range_type
) = name
;
8051 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8053 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
8055 set_die_type (die
, range_type
, cu
);
8057 /* set_die_type should be already done. */
8058 set_descriptive_type (range_type
, die
, cu
);
8063 static struct type
*
8064 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8068 /* For now, we only support the C meaning of an unspecified type: void. */
8070 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
8071 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
8073 return set_die_type (die
, type
, cu
);
8076 /* Trivial hash function for die_info: the hash value of a DIE
8077 is its offset in .debug_info for this objfile. */
8080 die_hash (const void *item
)
8082 const struct die_info
*die
= item
;
8087 /* Trivial comparison function for die_info structures: two DIEs
8088 are equal if they have the same offset. */
8091 die_eq (const void *item_lhs
, const void *item_rhs
)
8093 const struct die_info
*die_lhs
= item_lhs
;
8094 const struct die_info
*die_rhs
= item_rhs
;
8096 return die_lhs
->offset
== die_rhs
->offset
;
8099 /* Read a whole compilation unit into a linked list of dies. */
8101 static struct die_info
*
8102 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
8104 struct die_reader_specs reader_specs
;
8105 int read_abbrevs
= 0;
8106 struct cleanup
*back_to
= NULL
;
8107 struct die_info
*die
;
8109 if (cu
->dwarf2_abbrevs
== NULL
)
8111 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
8112 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
8116 gdb_assert (cu
->die_hash
== NULL
);
8118 = htab_create_alloc_ex (cu
->header
.length
/ 12,
8122 &cu
->comp_unit_obstack
,
8123 hashtab_obstack_allocate
,
8124 dummy_obstack_deallocate
);
8126 init_cu_die_reader (&reader_specs
, cu
);
8128 die
= read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
8131 do_cleanups (back_to
);
8136 /* Main entry point for reading a DIE and all children.
8137 Read the DIE and dump it if requested. */
8139 static struct die_info
*
8140 read_die_and_children (const struct die_reader_specs
*reader
,
8142 gdb_byte
**new_info_ptr
,
8143 struct die_info
*parent
)
8145 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
8146 new_info_ptr
, parent
);
8148 if (dwarf2_die_debug
)
8150 fprintf_unfiltered (gdb_stdlog
,
8151 "\nRead die from %s of %s:\n",
8152 reader
->buffer
== dwarf2_per_objfile
->info
.buffer
8154 : reader
->buffer
== dwarf2_per_objfile
->types
.buffer
8156 : "unknown section",
8157 reader
->abfd
->filename
);
8158 dump_die (result
, dwarf2_die_debug
);
8164 /* Read a single die and all its descendents. Set the die's sibling
8165 field to NULL; set other fields in the die correctly, and set all
8166 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
8167 location of the info_ptr after reading all of those dies. PARENT
8168 is the parent of the die in question. */
8170 static struct die_info
*
8171 read_die_and_children_1 (const struct die_reader_specs
*reader
,
8173 gdb_byte
**new_info_ptr
,
8174 struct die_info
*parent
)
8176 struct die_info
*die
;
8180 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
8183 *new_info_ptr
= cur_ptr
;
8186 store_in_ref_table (die
, reader
->cu
);
8189 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
8193 *new_info_ptr
= cur_ptr
;
8196 die
->sibling
= NULL
;
8197 die
->parent
= parent
;
8201 /* Read a die, all of its descendents, and all of its siblings; set
8202 all of the fields of all of the dies correctly. Arguments are as
8203 in read_die_and_children. */
8205 static struct die_info
*
8206 read_die_and_siblings (const struct die_reader_specs
*reader
,
8208 gdb_byte
**new_info_ptr
,
8209 struct die_info
*parent
)
8211 struct die_info
*first_die
, *last_sibling
;
8215 first_die
= last_sibling
= NULL
;
8219 struct die_info
*die
8220 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
8224 *new_info_ptr
= cur_ptr
;
8231 last_sibling
->sibling
= die
;
8237 /* Read the die from the .debug_info section buffer. Set DIEP to
8238 point to a newly allocated die with its information, except for its
8239 child, sibling, and parent fields. Set HAS_CHILDREN to tell
8240 whether the die has children or not. */
8243 read_full_die (const struct die_reader_specs
*reader
,
8244 struct die_info
**diep
, gdb_byte
*info_ptr
,
8247 unsigned int abbrev_number
, bytes_read
, i
, offset
;
8248 struct abbrev_info
*abbrev
;
8249 struct die_info
*die
;
8250 struct dwarf2_cu
*cu
= reader
->cu
;
8251 bfd
*abfd
= reader
->abfd
;
8253 offset
= info_ptr
- reader
->buffer
;
8254 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8255 info_ptr
+= bytes_read
;
8263 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
8265 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
8267 bfd_get_filename (abfd
));
8269 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
8270 die
->offset
= offset
;
8271 die
->tag
= abbrev
->tag
;
8272 die
->abbrev
= abbrev_number
;
8274 die
->num_attrs
= abbrev
->num_attrs
;
8276 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
8277 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
8278 abfd
, info_ptr
, cu
);
8281 *has_children
= abbrev
->has_children
;
8285 /* In DWARF version 2, the description of the debugging information is
8286 stored in a separate .debug_abbrev section. Before we read any
8287 dies from a section we read in all abbreviations and install them
8288 in a hash table. This function also sets flags in CU describing
8289 the data found in the abbrev table. */
8292 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
8294 struct comp_unit_head
*cu_header
= &cu
->header
;
8295 gdb_byte
*abbrev_ptr
;
8296 struct abbrev_info
*cur_abbrev
;
8297 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
8298 unsigned int abbrev_form
, hash_number
;
8299 struct attr_abbrev
*cur_attrs
;
8300 unsigned int allocated_attrs
;
8302 /* Initialize dwarf2 abbrevs */
8303 obstack_init (&cu
->abbrev_obstack
);
8304 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
8306 * sizeof (struct abbrev_info
*)));
8307 memset (cu
->dwarf2_abbrevs
, 0,
8308 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
8310 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
8311 &dwarf2_per_objfile
->abbrev
);
8312 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
8313 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8314 abbrev_ptr
+= bytes_read
;
8316 allocated_attrs
= ATTR_ALLOC_CHUNK
;
8317 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
8319 /* loop until we reach an abbrev number of 0 */
8320 while (abbrev_number
)
8322 cur_abbrev
= dwarf_alloc_abbrev (cu
);
8324 /* read in abbrev header */
8325 cur_abbrev
->number
= abbrev_number
;
8326 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8327 abbrev_ptr
+= bytes_read
;
8328 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
8331 if (cur_abbrev
->tag
== DW_TAG_namespace
)
8332 cu
->has_namespace_info
= 1;
8334 /* now read in declarations */
8335 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8336 abbrev_ptr
+= bytes_read
;
8337 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8338 abbrev_ptr
+= bytes_read
;
8341 if (cur_abbrev
->num_attrs
== allocated_attrs
)
8343 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
8345 = xrealloc (cur_attrs
, (allocated_attrs
8346 * sizeof (struct attr_abbrev
)));
8349 /* Record whether this compilation unit might have
8350 inter-compilation-unit references. If we don't know what form
8351 this attribute will have, then it might potentially be a
8352 DW_FORM_ref_addr, so we conservatively expect inter-CU
8355 if (abbrev_form
== DW_FORM_ref_addr
8356 || abbrev_form
== DW_FORM_indirect
)
8357 cu
->has_form_ref_addr
= 1;
8359 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
8360 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
8361 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8362 abbrev_ptr
+= bytes_read
;
8363 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8364 abbrev_ptr
+= bytes_read
;
8367 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
8368 (cur_abbrev
->num_attrs
8369 * sizeof (struct attr_abbrev
)));
8370 memcpy (cur_abbrev
->attrs
, cur_attrs
,
8371 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
8373 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
8374 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
8375 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
8377 /* Get next abbreviation.
8378 Under Irix6 the abbreviations for a compilation unit are not
8379 always properly terminated with an abbrev number of 0.
8380 Exit loop if we encounter an abbreviation which we have
8381 already read (which means we are about to read the abbreviations
8382 for the next compile unit) or if the end of the abbreviation
8383 table is reached. */
8384 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
8385 >= dwarf2_per_objfile
->abbrev
.size
)
8387 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8388 abbrev_ptr
+= bytes_read
;
8389 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
8396 /* Release the memory used by the abbrev table for a compilation unit. */
8399 dwarf2_free_abbrev_table (void *ptr_to_cu
)
8401 struct dwarf2_cu
*cu
= ptr_to_cu
;
8403 obstack_free (&cu
->abbrev_obstack
, NULL
);
8404 cu
->dwarf2_abbrevs
= NULL
;
8407 /* Lookup an abbrev_info structure in the abbrev hash table. */
8409 static struct abbrev_info
*
8410 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
8412 unsigned int hash_number
;
8413 struct abbrev_info
*abbrev
;
8415 hash_number
= number
% ABBREV_HASH_SIZE
;
8416 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
8420 if (abbrev
->number
== number
)
8423 abbrev
= abbrev
->next
;
8428 /* Returns nonzero if TAG represents a type that we might generate a partial
8432 is_type_tag_for_partial (int tag
)
8437 /* Some types that would be reasonable to generate partial symbols for,
8438 that we don't at present. */
8439 case DW_TAG_array_type
:
8440 case DW_TAG_file_type
:
8441 case DW_TAG_ptr_to_member_type
:
8442 case DW_TAG_set_type
:
8443 case DW_TAG_string_type
:
8444 case DW_TAG_subroutine_type
:
8446 case DW_TAG_base_type
:
8447 case DW_TAG_class_type
:
8448 case DW_TAG_interface_type
:
8449 case DW_TAG_enumeration_type
:
8450 case DW_TAG_structure_type
:
8451 case DW_TAG_subrange_type
:
8452 case DW_TAG_typedef
:
8453 case DW_TAG_union_type
:
8460 /* Load all DIEs that are interesting for partial symbols into memory. */
8462 static struct partial_die_info
*
8463 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
8464 int building_psymtab
, struct dwarf2_cu
*cu
)
8466 struct partial_die_info
*part_die
;
8467 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
8468 struct abbrev_info
*abbrev
;
8469 unsigned int bytes_read
;
8470 unsigned int load_all
= 0;
8472 int nesting_level
= 1;
8477 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
8481 = htab_create_alloc_ex (cu
->header
.length
/ 12,
8485 &cu
->comp_unit_obstack
,
8486 hashtab_obstack_allocate
,
8487 dummy_obstack_deallocate
);
8489 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
8490 sizeof (struct partial_die_info
));
8494 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
8496 /* A NULL abbrev means the end of a series of children. */
8499 if (--nesting_level
== 0)
8501 /* PART_DIE was probably the last thing allocated on the
8502 comp_unit_obstack, so we could call obstack_free
8503 here. We don't do that because the waste is small,
8504 and will be cleaned up when we're done with this
8505 compilation unit. This way, we're also more robust
8506 against other users of the comp_unit_obstack. */
8509 info_ptr
+= bytes_read
;
8510 last_die
= parent_die
;
8511 parent_die
= parent_die
->die_parent
;
8515 /* Check for template arguments. We never save these; if
8516 they're seen, we just mark the parent, and go on our way. */
8517 if (parent_die
!= NULL
8518 && cu
->language
== language_cplus
8519 && (abbrev
->tag
== DW_TAG_template_type_param
8520 || abbrev
->tag
== DW_TAG_template_value_param
))
8522 parent_die
->has_template_arguments
= 1;
8526 /* We don't need a partial DIE for the template argument. */
8527 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
,
8533 /* We only recurse into subprograms looking for template arguments.
8534 Skip their other children. */
8536 && cu
->language
== language_cplus
8537 && parent_die
!= NULL
8538 && parent_die
->tag
== DW_TAG_subprogram
)
8540 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
8544 /* Check whether this DIE is interesting enough to save. Normally
8545 we would not be interested in members here, but there may be
8546 later variables referencing them via DW_AT_specification (for
8549 && !is_type_tag_for_partial (abbrev
->tag
)
8550 && abbrev
->tag
!= DW_TAG_enumerator
8551 && abbrev
->tag
!= DW_TAG_subprogram
8552 && abbrev
->tag
!= DW_TAG_lexical_block
8553 && abbrev
->tag
!= DW_TAG_variable
8554 && abbrev
->tag
!= DW_TAG_namespace
8555 && abbrev
->tag
!= DW_TAG_module
8556 && abbrev
->tag
!= DW_TAG_member
)
8558 /* Otherwise we skip to the next sibling, if any. */
8559 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
8563 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
8564 buffer
, info_ptr
, cu
);
8566 /* This two-pass algorithm for processing partial symbols has a
8567 high cost in cache pressure. Thus, handle some simple cases
8568 here which cover the majority of C partial symbols. DIEs
8569 which neither have specification tags in them, nor could have
8570 specification tags elsewhere pointing at them, can simply be
8571 processed and discarded.
8573 This segment is also optional; scan_partial_symbols and
8574 add_partial_symbol will handle these DIEs if we chain
8575 them in normally. When compilers which do not emit large
8576 quantities of duplicate debug information are more common,
8577 this code can probably be removed. */
8579 /* Any complete simple types at the top level (pretty much all
8580 of them, for a language without namespaces), can be processed
8582 if (parent_die
== NULL
8583 && part_die
->has_specification
== 0
8584 && part_die
->is_declaration
== 0
8585 && (part_die
->tag
== DW_TAG_typedef
8586 || part_die
->tag
== DW_TAG_base_type
8587 || part_die
->tag
== DW_TAG_subrange_type
))
8589 if (building_psymtab
&& part_die
->name
!= NULL
)
8590 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
8591 VAR_DOMAIN
, LOC_TYPEDEF
,
8592 &cu
->objfile
->static_psymbols
,
8593 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
8594 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
8598 /* If we're at the second level, and we're an enumerator, and
8599 our parent has no specification (meaning possibly lives in a
8600 namespace elsewhere), then we can add the partial symbol now
8601 instead of queueing it. */
8602 if (part_die
->tag
== DW_TAG_enumerator
8603 && parent_die
!= NULL
8604 && parent_die
->die_parent
== NULL
8605 && parent_die
->tag
== DW_TAG_enumeration_type
8606 && parent_die
->has_specification
== 0)
8608 if (part_die
->name
== NULL
)
8609 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
8610 else if (building_psymtab
)
8611 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
8612 VAR_DOMAIN
, LOC_CONST
,
8613 (cu
->language
== language_cplus
8614 || cu
->language
== language_java
)
8615 ? &cu
->objfile
->global_psymbols
8616 : &cu
->objfile
->static_psymbols
,
8617 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
8619 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
8623 /* We'll save this DIE so link it in. */
8624 part_die
->die_parent
= parent_die
;
8625 part_die
->die_sibling
= NULL
;
8626 part_die
->die_child
= NULL
;
8628 if (last_die
&& last_die
== parent_die
)
8629 last_die
->die_child
= part_die
;
8631 last_die
->die_sibling
= part_die
;
8633 last_die
= part_die
;
8635 if (first_die
== NULL
)
8636 first_die
= part_die
;
8638 /* Maybe add the DIE to the hash table. Not all DIEs that we
8639 find interesting need to be in the hash table, because we
8640 also have the parent/sibling/child chains; only those that we
8641 might refer to by offset later during partial symbol reading.
8643 For now this means things that might have be the target of a
8644 DW_AT_specification, DW_AT_abstract_origin, or
8645 DW_AT_extension. DW_AT_extension will refer only to
8646 namespaces; DW_AT_abstract_origin refers to functions (and
8647 many things under the function DIE, but we do not recurse
8648 into function DIEs during partial symbol reading) and
8649 possibly variables as well; DW_AT_specification refers to
8650 declarations. Declarations ought to have the DW_AT_declaration
8651 flag. It happens that GCC forgets to put it in sometimes, but
8652 only for functions, not for types.
8654 Adding more things than necessary to the hash table is harmless
8655 except for the performance cost. Adding too few will result in
8656 wasted time in find_partial_die, when we reread the compilation
8657 unit with load_all_dies set. */
8660 || abbrev
->tag
== DW_TAG_subprogram
8661 || abbrev
->tag
== DW_TAG_variable
8662 || abbrev
->tag
== DW_TAG_namespace
8663 || part_die
->is_declaration
)
8667 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
8668 part_die
->offset
, INSERT
);
8672 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
8673 sizeof (struct partial_die_info
));
8675 /* For some DIEs we want to follow their children (if any). For C
8676 we have no reason to follow the children of structures; for other
8677 languages we have to, so that we can get at method physnames
8678 to infer fully qualified class names, for DW_AT_specification,
8679 and for C++ template arguments. For C++, we also look one level
8680 inside functions to find template arguments (if the name of the
8681 function does not already contain the template arguments).
8683 For Ada, we need to scan the children of subprograms and lexical
8684 blocks as well because Ada allows the definition of nested
8685 entities that could be interesting for the debugger, such as
8686 nested subprograms for instance. */
8687 if (last_die
->has_children
8689 || last_die
->tag
== DW_TAG_namespace
8690 || last_die
->tag
== DW_TAG_module
8691 || last_die
->tag
== DW_TAG_enumeration_type
8692 || (cu
->language
== language_cplus
8693 && last_die
->tag
== DW_TAG_subprogram
8694 && (last_die
->name
== NULL
8695 || strchr (last_die
->name
, '<') == NULL
))
8696 || (cu
->language
!= language_c
8697 && (last_die
->tag
== DW_TAG_class_type
8698 || last_die
->tag
== DW_TAG_interface_type
8699 || last_die
->tag
== DW_TAG_structure_type
8700 || last_die
->tag
== DW_TAG_union_type
))
8701 || (cu
->language
== language_ada
8702 && (last_die
->tag
== DW_TAG_subprogram
8703 || last_die
->tag
== DW_TAG_lexical_block
))))
8706 parent_die
= last_die
;
8710 /* Otherwise we skip to the next sibling, if any. */
8711 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
8713 /* Back to the top, do it again. */
8717 /* Read a minimal amount of information into the minimal die structure. */
8720 read_partial_die (struct partial_die_info
*part_die
,
8721 struct abbrev_info
*abbrev
,
8722 unsigned int abbrev_len
, bfd
*abfd
,
8723 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
8724 struct dwarf2_cu
*cu
)
8727 struct attribute attr
;
8728 int has_low_pc_attr
= 0;
8729 int has_high_pc_attr
= 0;
8731 memset (part_die
, 0, sizeof (struct partial_die_info
));
8733 part_die
->offset
= info_ptr
- buffer
;
8735 info_ptr
+= abbrev_len
;
8740 part_die
->tag
= abbrev
->tag
;
8741 part_die
->has_children
= abbrev
->has_children
;
8743 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
8745 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
8747 /* Store the data if it is of an attribute we want to keep in a
8748 partial symbol table. */
8752 switch (part_die
->tag
)
8754 case DW_TAG_compile_unit
:
8755 case DW_TAG_type_unit
:
8756 /* Compilation units have a DW_AT_name that is a filename, not
8757 a source language identifier. */
8758 case DW_TAG_enumeration_type
:
8759 case DW_TAG_enumerator
:
8760 /* These tags always have simple identifiers already; no need
8761 to canonicalize them. */
8762 part_die
->name
= DW_STRING (&attr
);
8766 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
8767 &cu
->objfile
->objfile_obstack
);
8771 case DW_AT_linkage_name
:
8772 case DW_AT_MIPS_linkage_name
:
8773 /* Note that both forms of linkage name might appear. We
8774 assume they will be the same, and we only store the last
8776 if (cu
->language
== language_ada
)
8777 part_die
->name
= DW_STRING (&attr
);
8780 has_low_pc_attr
= 1;
8781 part_die
->lowpc
= DW_ADDR (&attr
);
8784 has_high_pc_attr
= 1;
8785 part_die
->highpc
= DW_ADDR (&attr
);
8787 case DW_AT_location
:
8788 /* Support the .debug_loc offsets */
8789 if (attr_form_is_block (&attr
))
8791 part_die
->locdesc
= DW_BLOCK (&attr
);
8793 else if (attr_form_is_section_offset (&attr
))
8795 dwarf2_complex_location_expr_complaint ();
8799 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
8800 "partial symbol information");
8803 case DW_AT_external
:
8804 part_die
->is_external
= DW_UNSND (&attr
);
8806 case DW_AT_declaration
:
8807 part_die
->is_declaration
= DW_UNSND (&attr
);
8810 part_die
->has_type
= 1;
8812 case DW_AT_abstract_origin
:
8813 case DW_AT_specification
:
8814 case DW_AT_extension
:
8815 part_die
->has_specification
= 1;
8816 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
8819 /* Ignore absolute siblings, they might point outside of
8820 the current compile unit. */
8821 if (attr
.form
== DW_FORM_ref_addr
)
8822 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
8824 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
8826 case DW_AT_byte_size
:
8827 part_die
->has_byte_size
= 1;
8829 case DW_AT_calling_convention
:
8830 /* DWARF doesn't provide a way to identify a program's source-level
8831 entry point. DW_AT_calling_convention attributes are only meant
8832 to describe functions' calling conventions.
8834 However, because it's a necessary piece of information in
8835 Fortran, and because DW_CC_program is the only piece of debugging
8836 information whose definition refers to a 'main program' at all,
8837 several compilers have begun marking Fortran main programs with
8838 DW_CC_program --- even when those functions use the standard
8839 calling conventions.
8841 So until DWARF specifies a way to provide this information and
8842 compilers pick up the new representation, we'll support this
8844 if (DW_UNSND (&attr
) == DW_CC_program
8845 && cu
->language
== language_fortran
)
8846 set_main_name (part_die
->name
);
8853 /* When using the GNU linker, .gnu.linkonce. sections are used to
8854 eliminate duplicate copies of functions and vtables and such.
8855 The linker will arbitrarily choose one and discard the others.
8856 The AT_*_pc values for such functions refer to local labels in
8857 these sections. If the section from that file was discarded, the
8858 labels are not in the output, so the relocs get a value of 0.
8859 If this is a discarded function, mark the pc bounds as invalid,
8860 so that GDB will ignore it. */
8861 if (has_low_pc_attr
&& has_high_pc_attr
8862 && part_die
->lowpc
< part_die
->highpc
8863 && (part_die
->lowpc
!= 0
8864 || dwarf2_per_objfile
->has_section_at_zero
))
8865 part_die
->has_pc_info
= 1;
8870 /* Find a cached partial DIE at OFFSET in CU. */
8872 static struct partial_die_info
*
8873 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
8875 struct partial_die_info
*lookup_die
= NULL
;
8876 struct partial_die_info part_die
;
8878 part_die
.offset
= offset
;
8879 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
8884 /* Find a partial DIE at OFFSET, which may or may not be in CU,
8885 except in the case of .debug_types DIEs which do not reference
8886 outside their CU (they do however referencing other types via
8889 static struct partial_die_info
*
8890 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
8892 struct dwarf2_per_cu_data
*per_cu
= NULL
;
8893 struct partial_die_info
*pd
= NULL
;
8895 if (cu
->per_cu
->from_debug_types
)
8897 pd
= find_partial_die_in_comp_unit (offset
, cu
);
8903 if (offset_in_cu_p (&cu
->header
, offset
))
8905 pd
= find_partial_die_in_comp_unit (offset
, cu
);
8910 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
8912 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
8913 load_partial_comp_unit (per_cu
, cu
->objfile
);
8915 per_cu
->cu
->last_used
= 0;
8916 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
8918 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
8920 struct cleanup
*back_to
;
8921 struct partial_die_info comp_unit_die
;
8922 struct abbrev_info
*abbrev
;
8923 unsigned int bytes_read
;
8926 per_cu
->load_all_dies
= 1;
8928 /* Re-read the DIEs. */
8929 back_to
= make_cleanup (null_cleanup
, 0);
8930 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
8932 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
8933 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
8935 info_ptr
= (dwarf2_per_objfile
->info
.buffer
8936 + per_cu
->cu
->header
.offset
8937 + per_cu
->cu
->header
.first_die_offset
);
8938 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
8939 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
8940 per_cu
->cu
->objfile
->obfd
,
8941 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
8943 if (comp_unit_die
.has_children
)
8944 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
8945 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
8947 do_cleanups (back_to
);
8949 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
8955 internal_error (__FILE__
, __LINE__
,
8956 _("could not find partial DIE 0x%x in cache [from module %s]\n"),
8957 offset
, bfd_get_filename (cu
->objfile
->obfd
));
8961 /* Adjust PART_DIE before generating a symbol for it. This function
8962 may set the is_external flag or change the DIE's name. */
8965 fixup_partial_die (struct partial_die_info
*part_die
,
8966 struct dwarf2_cu
*cu
)
8968 /* If we found a reference attribute and the DIE has no name, try
8969 to find a name in the referred to DIE. */
8971 if (part_die
->name
== NULL
&& part_die
->has_specification
)
8973 struct partial_die_info
*spec_die
;
8975 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
8977 fixup_partial_die (spec_die
, cu
);
8981 part_die
->name
= spec_die
->name
;
8983 /* Copy DW_AT_external attribute if it is set. */
8984 if (spec_die
->is_external
)
8985 part_die
->is_external
= spec_die
->is_external
;
8989 /* Set default names for some unnamed DIEs. */
8990 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
8991 || part_die
->tag
== DW_TAG_class_type
))
8992 part_die
->name
= "(anonymous class)";
8994 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
8995 part_die
->name
= "(anonymous namespace)";
8997 if (part_die
->tag
== DW_TAG_structure_type
8998 || part_die
->tag
== DW_TAG_class_type
8999 || part_die
->tag
== DW_TAG_union_type
)
9000 guess_structure_name (part_die
, cu
);
9003 /* Read an attribute value described by an attribute form. */
9006 read_attribute_value (struct attribute
*attr
, unsigned form
,
9007 bfd
*abfd
, gdb_byte
*info_ptr
,
9008 struct dwarf2_cu
*cu
)
9010 struct comp_unit_head
*cu_header
= &cu
->header
;
9011 unsigned int bytes_read
;
9012 struct dwarf_block
*blk
;
9017 case DW_FORM_ref_addr
:
9018 if (cu
->header
.version
== 2)
9019 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
9021 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
9022 info_ptr
+= bytes_read
;
9025 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
9026 info_ptr
+= bytes_read
;
9028 case DW_FORM_block2
:
9029 blk
= dwarf_alloc_block (cu
);
9030 blk
->size
= read_2_bytes (abfd
, info_ptr
);
9032 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9033 info_ptr
+= blk
->size
;
9034 DW_BLOCK (attr
) = blk
;
9036 case DW_FORM_block4
:
9037 blk
= dwarf_alloc_block (cu
);
9038 blk
->size
= read_4_bytes (abfd
, info_ptr
);
9040 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9041 info_ptr
+= blk
->size
;
9042 DW_BLOCK (attr
) = blk
;
9045 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
9049 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
9053 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
9056 case DW_FORM_sec_offset
:
9057 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
9058 info_ptr
+= bytes_read
;
9060 case DW_FORM_string
:
9061 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
9062 DW_STRING_IS_CANONICAL (attr
) = 0;
9063 info_ptr
+= bytes_read
;
9066 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
9068 DW_STRING_IS_CANONICAL (attr
) = 0;
9069 info_ptr
+= bytes_read
;
9071 case DW_FORM_exprloc
:
9073 blk
= dwarf_alloc_block (cu
);
9074 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9075 info_ptr
+= bytes_read
;
9076 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9077 info_ptr
+= blk
->size
;
9078 DW_BLOCK (attr
) = blk
;
9080 case DW_FORM_block1
:
9081 blk
= dwarf_alloc_block (cu
);
9082 blk
->size
= read_1_byte (abfd
, info_ptr
);
9084 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9085 info_ptr
+= blk
->size
;
9086 DW_BLOCK (attr
) = blk
;
9089 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
9093 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
9096 case DW_FORM_flag_present
:
9097 DW_UNSND (attr
) = 1;
9100 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
9101 info_ptr
+= bytes_read
;
9104 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9105 info_ptr
+= bytes_read
;
9108 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
9112 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
9116 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
9120 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
9124 /* Convert the signature to something we can record in DW_UNSND
9126 NOTE: This is NULL if the type wasn't found. */
9127 DW_SIGNATURED_TYPE (attr
) =
9128 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
9131 case DW_FORM_ref_udata
:
9132 DW_ADDR (attr
) = (cu
->header
.offset
9133 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
9134 info_ptr
+= bytes_read
;
9136 case DW_FORM_indirect
:
9137 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9138 info_ptr
+= bytes_read
;
9139 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
9142 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
9143 dwarf_form_name (form
),
9144 bfd_get_filename (abfd
));
9147 /* We have seen instances where the compiler tried to emit a byte
9148 size attribute of -1 which ended up being encoded as an unsigned
9149 0xffffffff. Although 0xffffffff is technically a valid size value,
9150 an object of this size seems pretty unlikely so we can relatively
9151 safely treat these cases as if the size attribute was invalid and
9152 treat them as zero by default. */
9153 if (attr
->name
== DW_AT_byte_size
9154 && form
== DW_FORM_data4
9155 && DW_UNSND (attr
) >= 0xffffffff)
9158 (&symfile_complaints
,
9159 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
9160 hex_string (DW_UNSND (attr
)));
9161 DW_UNSND (attr
) = 0;
9167 /* Read an attribute described by an abbreviated attribute. */
9170 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
9171 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
9173 attr
->name
= abbrev
->name
;
9174 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
9177 /* read dwarf information from a buffer */
9180 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
9182 return bfd_get_8 (abfd
, buf
);
9186 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
9188 return bfd_get_signed_8 (abfd
, buf
);
9192 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
9194 return bfd_get_16 (abfd
, buf
);
9198 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
9200 return bfd_get_signed_16 (abfd
, buf
);
9204 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
9206 return bfd_get_32 (abfd
, buf
);
9210 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
9212 return bfd_get_signed_32 (abfd
, buf
);
9216 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
9218 return bfd_get_64 (abfd
, buf
);
9222 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
9223 unsigned int *bytes_read
)
9225 struct comp_unit_head
*cu_header
= &cu
->header
;
9226 CORE_ADDR retval
= 0;
9228 if (cu_header
->signed_addr_p
)
9230 switch (cu_header
->addr_size
)
9233 retval
= bfd_get_signed_16 (abfd
, buf
);
9236 retval
= bfd_get_signed_32 (abfd
, buf
);
9239 retval
= bfd_get_signed_64 (abfd
, buf
);
9242 internal_error (__FILE__
, __LINE__
,
9243 _("read_address: bad switch, signed [in module %s]"),
9244 bfd_get_filename (abfd
));
9249 switch (cu_header
->addr_size
)
9252 retval
= bfd_get_16 (abfd
, buf
);
9255 retval
= bfd_get_32 (abfd
, buf
);
9258 retval
= bfd_get_64 (abfd
, buf
);
9261 internal_error (__FILE__
, __LINE__
,
9262 _("read_address: bad switch, unsigned [in module %s]"),
9263 bfd_get_filename (abfd
));
9267 *bytes_read
= cu_header
->addr_size
;
9271 /* Read the initial length from a section. The (draft) DWARF 3
9272 specification allows the initial length to take up either 4 bytes
9273 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
9274 bytes describe the length and all offsets will be 8 bytes in length
9277 An older, non-standard 64-bit format is also handled by this
9278 function. The older format in question stores the initial length
9279 as an 8-byte quantity without an escape value. Lengths greater
9280 than 2^32 aren't very common which means that the initial 4 bytes
9281 is almost always zero. Since a length value of zero doesn't make
9282 sense for the 32-bit format, this initial zero can be considered to
9283 be an escape value which indicates the presence of the older 64-bit
9284 format. As written, the code can't detect (old format) lengths
9285 greater than 4GB. If it becomes necessary to handle lengths
9286 somewhat larger than 4GB, we could allow other small values (such
9287 as the non-sensical values of 1, 2, and 3) to also be used as
9288 escape values indicating the presence of the old format.
9290 The value returned via bytes_read should be used to increment the
9291 relevant pointer after calling read_initial_length().
9293 [ Note: read_initial_length() and read_offset() are based on the
9294 document entitled "DWARF Debugging Information Format", revision
9295 3, draft 8, dated November 19, 2001. This document was obtained
9298 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
9300 This document is only a draft and is subject to change. (So beware.)
9302 Details regarding the older, non-standard 64-bit format were
9303 determined empirically by examining 64-bit ELF files produced by
9304 the SGI toolchain on an IRIX 6.5 machine.
9306 - Kevin, July 16, 2002
9310 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
9312 LONGEST length
= bfd_get_32 (abfd
, buf
);
9314 if (length
== 0xffffffff)
9316 length
= bfd_get_64 (abfd
, buf
+ 4);
9319 else if (length
== 0)
9321 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
9322 length
= bfd_get_64 (abfd
, buf
);
9333 /* Cover function for read_initial_length.
9334 Returns the length of the object at BUF, and stores the size of the
9335 initial length in *BYTES_READ and stores the size that offsets will be in
9337 If the initial length size is not equivalent to that specified in
9338 CU_HEADER then issue a complaint.
9339 This is useful when reading non-comp-unit headers. */
9342 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
9343 const struct comp_unit_head
*cu_header
,
9344 unsigned int *bytes_read
,
9345 unsigned int *offset_size
)
9347 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
9349 gdb_assert (cu_header
->initial_length_size
== 4
9350 || cu_header
->initial_length_size
== 8
9351 || cu_header
->initial_length_size
== 12);
9353 if (cu_header
->initial_length_size
!= *bytes_read
)
9354 complaint (&symfile_complaints
,
9355 _("intermixed 32-bit and 64-bit DWARF sections"));
9357 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
9361 /* Read an offset from the data stream. The size of the offset is
9362 given by cu_header->offset_size. */
9365 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
9366 unsigned int *bytes_read
)
9368 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
9370 *bytes_read
= cu_header
->offset_size
;
9374 /* Read an offset from the data stream. */
9377 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
9381 switch (offset_size
)
9384 retval
= bfd_get_32 (abfd
, buf
);
9387 retval
= bfd_get_64 (abfd
, buf
);
9390 internal_error (__FILE__
, __LINE__
,
9391 _("read_offset_1: bad switch [in module %s]"),
9392 bfd_get_filename (abfd
));
9399 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
9401 /* If the size of a host char is 8 bits, we can return a pointer
9402 to the buffer, otherwise we have to copy the data to a buffer
9403 allocated on the temporary obstack. */
9404 gdb_assert (HOST_CHAR_BIT
== 8);
9409 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9411 /* If the size of a host char is 8 bits, we can return a pointer
9412 to the string, otherwise we have to copy the string to a buffer
9413 allocated on the temporary obstack. */
9414 gdb_assert (HOST_CHAR_BIT
== 8);
9417 *bytes_read_ptr
= 1;
9420 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
9421 return (char *) buf
;
9425 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
9426 const struct comp_unit_head
*cu_header
,
9427 unsigned int *bytes_read_ptr
)
9429 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
9431 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
9432 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
9434 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
9435 bfd_get_filename (abfd
));
9438 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
9440 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
9441 bfd_get_filename (abfd
));
9444 gdb_assert (HOST_CHAR_BIT
== 8);
9445 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
9447 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
9450 static unsigned long
9451 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9453 unsigned long result
;
9454 unsigned int num_read
;
9464 byte
= bfd_get_8 (abfd
, buf
);
9467 result
|= ((unsigned long)(byte
& 127) << shift
);
9468 if ((byte
& 128) == 0)
9474 *bytes_read_ptr
= num_read
;
9479 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9482 int i
, shift
, num_read
;
9491 byte
= bfd_get_8 (abfd
, buf
);
9494 result
|= ((long)(byte
& 127) << shift
);
9496 if ((byte
& 128) == 0)
9501 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
9502 result
|= -(((long)1) << shift
);
9503 *bytes_read_ptr
= num_read
;
9507 /* Return a pointer to just past the end of an LEB128 number in BUF. */
9510 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
9516 byte
= bfd_get_8 (abfd
, buf
);
9518 if ((byte
& 128) == 0)
9524 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
9531 cu
->language
= language_c
;
9533 case DW_LANG_C_plus_plus
:
9534 cu
->language
= language_cplus
;
9537 cu
->language
= language_d
;
9539 case DW_LANG_Fortran77
:
9540 case DW_LANG_Fortran90
:
9541 case DW_LANG_Fortran95
:
9542 cu
->language
= language_fortran
;
9544 case DW_LANG_Mips_Assembler
:
9545 cu
->language
= language_asm
;
9548 cu
->language
= language_java
;
9552 cu
->language
= language_ada
;
9554 case DW_LANG_Modula2
:
9555 cu
->language
= language_m2
;
9557 case DW_LANG_Pascal83
:
9558 cu
->language
= language_pascal
;
9561 cu
->language
= language_objc
;
9563 case DW_LANG_Cobol74
:
9564 case DW_LANG_Cobol85
:
9566 cu
->language
= language_minimal
;
9569 cu
->language_defn
= language_def (cu
->language
);
9572 /* Return the named attribute or NULL if not there. */
9574 static struct attribute
*
9575 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
9578 struct attribute
*spec
= NULL
;
9580 for (i
= 0; i
< die
->num_attrs
; ++i
)
9582 if (die
->attrs
[i
].name
== name
)
9583 return &die
->attrs
[i
];
9584 if (die
->attrs
[i
].name
== DW_AT_specification
9585 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
9586 spec
= &die
->attrs
[i
];
9591 die
= follow_die_ref (die
, spec
, &cu
);
9592 return dwarf2_attr (die
, name
, cu
);
9598 /* Return the named attribute or NULL if not there,
9599 but do not follow DW_AT_specification, etc.
9600 This is for use in contexts where we're reading .debug_types dies.
9601 Following DW_AT_specification, DW_AT_abstract_origin will take us
9602 back up the chain, and we want to go down. */
9604 static struct attribute
*
9605 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
9606 struct dwarf2_cu
*cu
)
9610 for (i
= 0; i
< die
->num_attrs
; ++i
)
9611 if (die
->attrs
[i
].name
== name
)
9612 return &die
->attrs
[i
];
9617 /* Return non-zero iff the attribute NAME is defined for the given DIE,
9618 and holds a non-zero value. This function should only be used for
9619 DW_FORM_flag or DW_FORM_flag_present attributes. */
9622 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
9624 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
9626 return (attr
&& DW_UNSND (attr
));
9630 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
9632 /* A DIE is a declaration if it has a DW_AT_declaration attribute
9633 which value is non-zero. However, we have to be careful with
9634 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
9635 (via dwarf2_flag_true_p) follows this attribute. So we may
9636 end up accidently finding a declaration attribute that belongs
9637 to a different DIE referenced by the specification attribute,
9638 even though the given DIE does not have a declaration attribute. */
9639 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
9640 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
9643 /* Return the die giving the specification for DIE, if there is
9644 one. *SPEC_CU is the CU containing DIE on input, and the CU
9645 containing the return value on output. If there is no
9646 specification, but there is an abstract origin, that is
9649 static struct die_info
*
9650 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
9652 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
9655 if (spec_attr
== NULL
)
9656 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
9658 if (spec_attr
== NULL
)
9661 return follow_die_ref (die
, spec_attr
, spec_cu
);
9664 /* Free the line_header structure *LH, and any arrays and strings it
9667 free_line_header (struct line_header
*lh
)
9669 if (lh
->standard_opcode_lengths
)
9670 xfree (lh
->standard_opcode_lengths
);
9672 /* Remember that all the lh->file_names[i].name pointers are
9673 pointers into debug_line_buffer, and don't need to be freed. */
9675 xfree (lh
->file_names
);
9677 /* Similarly for the include directory names. */
9678 if (lh
->include_dirs
)
9679 xfree (lh
->include_dirs
);
9685 /* Add an entry to LH's include directory table. */
9687 add_include_dir (struct line_header
*lh
, char *include_dir
)
9689 /* Grow the array if necessary. */
9690 if (lh
->include_dirs_size
== 0)
9692 lh
->include_dirs_size
= 1; /* for testing */
9693 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
9694 * sizeof (*lh
->include_dirs
));
9696 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
9698 lh
->include_dirs_size
*= 2;
9699 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
9700 (lh
->include_dirs_size
9701 * sizeof (*lh
->include_dirs
)));
9704 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
9708 /* Add an entry to LH's file name table. */
9710 add_file_name (struct line_header
*lh
,
9712 unsigned int dir_index
,
9713 unsigned int mod_time
,
9714 unsigned int length
)
9716 struct file_entry
*fe
;
9718 /* Grow the array if necessary. */
9719 if (lh
->file_names_size
== 0)
9721 lh
->file_names_size
= 1; /* for testing */
9722 lh
->file_names
= xmalloc (lh
->file_names_size
9723 * sizeof (*lh
->file_names
));
9725 else if (lh
->num_file_names
>= lh
->file_names_size
)
9727 lh
->file_names_size
*= 2;
9728 lh
->file_names
= xrealloc (lh
->file_names
,
9729 (lh
->file_names_size
9730 * sizeof (*lh
->file_names
)));
9733 fe
= &lh
->file_names
[lh
->num_file_names
++];
9735 fe
->dir_index
= dir_index
;
9736 fe
->mod_time
= mod_time
;
9737 fe
->length
= length
;
9743 /* Read the statement program header starting at OFFSET in
9744 .debug_line, according to the endianness of ABFD. Return a pointer
9745 to a struct line_header, allocated using xmalloc.
9747 NOTE: the strings in the include directory and file name tables of
9748 the returned object point into debug_line_buffer, and must not be
9750 static struct line_header
*
9751 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
9752 struct dwarf2_cu
*cu
)
9754 struct cleanup
*back_to
;
9755 struct line_header
*lh
;
9757 unsigned int bytes_read
, offset_size
;
9759 char *cur_dir
, *cur_file
;
9761 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
9762 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
9764 complaint (&symfile_complaints
, _("missing .debug_line section"));
9768 /* Make sure that at least there's room for the total_length field.
9769 That could be 12 bytes long, but we're just going to fudge that. */
9770 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
9772 dwarf2_statement_list_fits_in_line_number_section_complaint ();
9776 lh
= xmalloc (sizeof (*lh
));
9777 memset (lh
, 0, sizeof (*lh
));
9778 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
9781 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
9783 /* Read in the header. */
9785 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
9786 &bytes_read
, &offset_size
);
9787 line_ptr
+= bytes_read
;
9788 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
9789 + dwarf2_per_objfile
->line
.size
))
9791 dwarf2_statement_list_fits_in_line_number_section_complaint ();
9794 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
9795 lh
->version
= read_2_bytes (abfd
, line_ptr
);
9797 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
9798 line_ptr
+= offset_size
;
9799 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
9801 if (lh
->version
>= 4)
9803 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
9807 lh
->maximum_ops_per_instruction
= 1;
9809 if (lh
->maximum_ops_per_instruction
== 0)
9811 lh
->maximum_ops_per_instruction
= 1;
9812 complaint (&symfile_complaints
,
9813 _("invalid maximum_ops_per_instruction in `.debug_line' section"));
9816 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
9818 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
9820 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
9822 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
9824 lh
->standard_opcode_lengths
9825 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
9827 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
9828 for (i
= 1; i
< lh
->opcode_base
; ++i
)
9830 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
9834 /* Read directory table. */
9835 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
9837 line_ptr
+= bytes_read
;
9838 add_include_dir (lh
, cur_dir
);
9840 line_ptr
+= bytes_read
;
9842 /* Read file name table. */
9843 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
9845 unsigned int dir_index
, mod_time
, length
;
9847 line_ptr
+= bytes_read
;
9848 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9849 line_ptr
+= bytes_read
;
9850 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9851 line_ptr
+= bytes_read
;
9852 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9853 line_ptr
+= bytes_read
;
9855 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
9857 line_ptr
+= bytes_read
;
9858 lh
->statement_program_start
= line_ptr
;
9860 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
9861 + dwarf2_per_objfile
->line
.size
))
9862 complaint (&symfile_complaints
,
9863 _("line number info header doesn't fit in `.debug_line' section"));
9865 discard_cleanups (back_to
);
9869 /* This function exists to work around a bug in certain compilers
9870 (particularly GCC 2.95), in which the first line number marker of a
9871 function does not show up until after the prologue, right before
9872 the second line number marker. This function shifts ADDRESS down
9873 to the beginning of the function if necessary, and is called on
9874 addresses passed to record_line. */
9877 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
9879 struct function_range
*fn
;
9881 /* Find the function_range containing address. */
9886 cu
->cached_fn
= cu
->first_fn
;
9890 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
9896 while (fn
&& fn
!= cu
->cached_fn
)
9897 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
9907 if (address
!= fn
->lowpc
)
9908 complaint (&symfile_complaints
,
9909 _("misplaced first line number at 0x%lx for '%s'"),
9910 (unsigned long) address
, fn
->name
);
9915 /* Decode the Line Number Program (LNP) for the given line_header
9916 structure and CU. The actual information extracted and the type
9917 of structures created from the LNP depends on the value of PST.
9919 1. If PST is NULL, then this procedure uses the data from the program
9920 to create all necessary symbol tables, and their linetables.
9921 The compilation directory of the file is passed in COMP_DIR,
9922 and must not be NULL.
9924 2. If PST is not NULL, this procedure reads the program to determine
9925 the list of files included by the unit represented by PST, and
9926 builds all the associated partial symbol tables. In this case,
9927 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
9928 is not used to compute the full name of the symtab, and therefore
9929 omitting it when building the partial symtab does not introduce
9930 the potential for inconsistency - a partial symtab and its associated
9931 symbtab having a different fullname -). */
9934 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
9935 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
9937 gdb_byte
*line_ptr
, *extended_end
;
9939 unsigned int bytes_read
, extended_len
;
9940 unsigned char op_code
, extended_op
, adj_opcode
;
9942 struct objfile
*objfile
= cu
->objfile
;
9943 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9944 const int decode_for_pst_p
= (pst
!= NULL
);
9945 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
9947 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9949 line_ptr
= lh
->statement_program_start
;
9950 line_end
= lh
->statement_program_end
;
9952 /* Read the statement sequences until there's nothing left. */
9953 while (line_ptr
< line_end
)
9955 /* state machine registers */
9956 CORE_ADDR address
= 0;
9957 unsigned int file
= 1;
9958 unsigned int line
= 1;
9959 unsigned int column
= 0;
9960 int is_stmt
= lh
->default_is_stmt
;
9961 int basic_block
= 0;
9962 int end_sequence
= 0;
9964 unsigned char op_index
= 0;
9966 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
9968 /* Start a subfile for the current file of the state machine. */
9969 /* lh->include_dirs and lh->file_names are 0-based, but the
9970 directory and file name numbers in the statement program
9972 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9976 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9978 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
9981 /* Decode the table. */
9982 while (!end_sequence
)
9984 op_code
= read_1_byte (abfd
, line_ptr
);
9986 if (line_ptr
> line_end
)
9988 dwarf2_debug_line_missing_end_sequence_complaint ();
9992 if (op_code
>= lh
->opcode_base
)
9994 /* Special operand. */
9995 adj_opcode
= op_code
- lh
->opcode_base
;
9996 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
9997 / lh
->maximum_ops_per_instruction
)
9998 * lh
->minimum_instruction_length
);
9999 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
10000 % lh
->maximum_ops_per_instruction
);
10001 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
10002 if (lh
->num_file_names
< file
|| file
== 0)
10003 dwarf2_debug_line_missing_file_complaint ();
10004 /* For now we ignore lines not starting on an
10005 instruction boundary. */
10006 else if (op_index
== 0)
10008 lh
->file_names
[file
- 1].included_p
= 1;
10009 if (!decode_for_pst_p
&& is_stmt
)
10011 if (last_subfile
!= current_subfile
)
10013 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
10015 record_line (last_subfile
, 0, addr
);
10016 last_subfile
= current_subfile
;
10018 /* Append row to matrix using current values. */
10019 addr
= check_cu_functions (address
, cu
);
10020 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
10021 record_line (current_subfile
, line
, addr
);
10026 else switch (op_code
)
10028 case DW_LNS_extended_op
:
10029 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10030 line_ptr
+= bytes_read
;
10031 extended_end
= line_ptr
+ extended_len
;
10032 extended_op
= read_1_byte (abfd
, line_ptr
);
10034 switch (extended_op
)
10036 case DW_LNE_end_sequence
:
10039 case DW_LNE_set_address
:
10040 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
10042 line_ptr
+= bytes_read
;
10043 address
+= baseaddr
;
10045 case DW_LNE_define_file
:
10048 unsigned int dir_index
, mod_time
, length
;
10050 cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
);
10051 line_ptr
+= bytes_read
;
10053 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10054 line_ptr
+= bytes_read
;
10056 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10057 line_ptr
+= bytes_read
;
10059 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10060 line_ptr
+= bytes_read
;
10061 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
10064 case DW_LNE_set_discriminator
:
10065 /* The discriminator is not interesting to the debugger;
10067 line_ptr
= extended_end
;
10070 complaint (&symfile_complaints
,
10071 _("mangled .debug_line section"));
10074 /* Make sure that we parsed the extended op correctly. If e.g.
10075 we expected a different address size than the producer used,
10076 we may have read the wrong number of bytes. */
10077 if (line_ptr
!= extended_end
)
10079 complaint (&symfile_complaints
,
10080 _("mangled .debug_line section"));
10085 if (lh
->num_file_names
< file
|| file
== 0)
10086 dwarf2_debug_line_missing_file_complaint ();
10089 lh
->file_names
[file
- 1].included_p
= 1;
10090 if (!decode_for_pst_p
&& is_stmt
)
10092 if (last_subfile
!= current_subfile
)
10094 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
10096 record_line (last_subfile
, 0, addr
);
10097 last_subfile
= current_subfile
;
10099 addr
= check_cu_functions (address
, cu
);
10100 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
10101 record_line (current_subfile
, line
, addr
);
10106 case DW_LNS_advance_pc
:
10109 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10111 address
+= (((op_index
+ adjust
)
10112 / lh
->maximum_ops_per_instruction
)
10113 * lh
->minimum_instruction_length
);
10114 op_index
= ((op_index
+ adjust
)
10115 % lh
->maximum_ops_per_instruction
);
10116 line_ptr
+= bytes_read
;
10119 case DW_LNS_advance_line
:
10120 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
10121 line_ptr
+= bytes_read
;
10123 case DW_LNS_set_file
:
10125 /* The arrays lh->include_dirs and lh->file_names are
10126 0-based, but the directory and file name numbers in
10127 the statement program are 1-based. */
10128 struct file_entry
*fe
;
10131 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10132 line_ptr
+= bytes_read
;
10133 if (lh
->num_file_names
< file
|| file
== 0)
10134 dwarf2_debug_line_missing_file_complaint ();
10137 fe
= &lh
->file_names
[file
- 1];
10139 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
10140 if (!decode_for_pst_p
)
10142 last_subfile
= current_subfile
;
10143 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
10148 case DW_LNS_set_column
:
10149 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10150 line_ptr
+= bytes_read
;
10152 case DW_LNS_negate_stmt
:
10153 is_stmt
= (!is_stmt
);
10155 case DW_LNS_set_basic_block
:
10158 /* Add to the address register of the state machine the
10159 address increment value corresponding to special opcode
10160 255. I.e., this value is scaled by the minimum
10161 instruction length since special opcode 255 would have
10162 scaled the the increment. */
10163 case DW_LNS_const_add_pc
:
10165 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
10167 address
+= (((op_index
+ adjust
)
10168 / lh
->maximum_ops_per_instruction
)
10169 * lh
->minimum_instruction_length
);
10170 op_index
= ((op_index
+ adjust
)
10171 % lh
->maximum_ops_per_instruction
);
10174 case DW_LNS_fixed_advance_pc
:
10175 address
+= read_2_bytes (abfd
, line_ptr
);
10181 /* Unknown standard opcode, ignore it. */
10184 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
10186 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10187 line_ptr
+= bytes_read
;
10192 if (lh
->num_file_names
< file
|| file
== 0)
10193 dwarf2_debug_line_missing_file_complaint ();
10196 lh
->file_names
[file
- 1].included_p
= 1;
10197 if (!decode_for_pst_p
)
10199 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
10200 record_line (current_subfile
, 0, addr
);
10205 if (decode_for_pst_p
)
10209 /* Now that we're done scanning the Line Header Program, we can
10210 create the psymtab of each included file. */
10211 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
10212 if (lh
->file_names
[file_index
].included_p
== 1)
10214 const struct file_entry fe
= lh
->file_names
[file_index
];
10215 char *include_name
= fe
.name
;
10216 char *dir_name
= NULL
;
10217 char *pst_filename
= pst
->filename
;
10220 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
10222 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
10224 include_name
= concat (dir_name
, SLASH_STRING
,
10225 include_name
, (char *)NULL
);
10226 make_cleanup (xfree
, include_name
);
10229 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
10231 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
10232 pst_filename
, (char *)NULL
);
10233 make_cleanup (xfree
, pst_filename
);
10236 if (strcmp (include_name
, pst_filename
) != 0)
10237 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
10242 /* Make sure a symtab is created for every file, even files
10243 which contain only variables (i.e. no code with associated
10247 struct file_entry
*fe
;
10249 for (i
= 0; i
< lh
->num_file_names
; i
++)
10253 fe
= &lh
->file_names
[i
];
10255 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
10256 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
10258 /* Skip the main file; we don't need it, and it must be
10259 allocated last, so that it will show up before the
10260 non-primary symtabs in the objfile's symtab list. */
10261 if (current_subfile
== first_subfile
)
10264 if (current_subfile
->symtab
== NULL
)
10265 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
10267 fe
->symtab
= current_subfile
->symtab
;
10272 /* Start a subfile for DWARF. FILENAME is the name of the file and
10273 DIRNAME the name of the source directory which contains FILENAME
10274 or NULL if not known. COMP_DIR is the compilation directory for the
10275 linetable's compilation unit or NULL if not known.
10276 This routine tries to keep line numbers from identical absolute and
10277 relative file names in a common subfile.
10279 Using the `list' example from the GDB testsuite, which resides in
10280 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
10281 of /srcdir/list0.c yields the following debugging information for list0.c:
10283 DW_AT_name: /srcdir/list0.c
10284 DW_AT_comp_dir: /compdir
10285 files.files[0].name: list0.h
10286 files.files[0].dir: /srcdir
10287 files.files[1].name: list0.c
10288 files.files[1].dir: /srcdir
10290 The line number information for list0.c has to end up in a single
10291 subfile, so that `break /srcdir/list0.c:1' works as expected.
10292 start_subfile will ensure that this happens provided that we pass the
10293 concatenation of files.files[1].dir and files.files[1].name as the
10297 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
10301 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
10302 `start_symtab' will always pass the contents of DW_AT_comp_dir as
10303 second argument to start_subfile. To be consistent, we do the
10304 same here. In order not to lose the line information directory,
10305 we concatenate it to the filename when it makes sense.
10306 Note that the Dwarf3 standard says (speaking of filenames in line
10307 information): ``The directory index is ignored for file names
10308 that represent full path names''. Thus ignoring dirname in the
10309 `else' branch below isn't an issue. */
10311 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
10312 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
10314 fullname
= filename
;
10316 start_subfile (fullname
, comp_dir
);
10318 if (fullname
!= filename
)
10323 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
10324 struct dwarf2_cu
*cu
)
10326 struct objfile
*objfile
= cu
->objfile
;
10327 struct comp_unit_head
*cu_header
= &cu
->header
;
10329 /* NOTE drow/2003-01-30: There used to be a comment and some special
10330 code here to turn a symbol with DW_AT_external and a
10331 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
10332 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
10333 with some versions of binutils) where shared libraries could have
10334 relocations against symbols in their debug information - the
10335 minimal symbol would have the right address, but the debug info
10336 would not. It's no longer necessary, because we will explicitly
10337 apply relocations when we read in the debug information now. */
10339 /* A DW_AT_location attribute with no contents indicates that a
10340 variable has been optimized away. */
10341 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
10343 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
10347 /* Handle one degenerate form of location expression specially, to
10348 preserve GDB's previous behavior when section offsets are
10349 specified. If this is just a DW_OP_addr then mark this symbol
10352 if (attr_form_is_block (attr
)
10353 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
10354 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
10356 unsigned int dummy
;
10358 SYMBOL_VALUE_ADDRESS (sym
) =
10359 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
10360 SYMBOL_CLASS (sym
) = LOC_STATIC
;
10361 fixup_symbol_section (sym
, objfile
);
10362 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
10363 SYMBOL_SECTION (sym
));
10367 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
10368 expression evaluator, and use LOC_COMPUTED only when necessary
10369 (i.e. when the value of a register or memory location is
10370 referenced, or a thread-local block, etc.). Then again, it might
10371 not be worthwhile. I'm assuming that it isn't unless performance
10372 or memory numbers show me otherwise. */
10374 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
10375 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
10378 /* Given a pointer to a DWARF information entry, figure out if we need
10379 to make a symbol table entry for it, and if so, create a new entry
10380 and return a pointer to it.
10381 If TYPE is NULL, determine symbol type from the die, otherwise
10382 used the passed type.
10383 If SPACE is not NULL, use it to hold the new symbol. If it is
10384 NULL, allocate a new symbol on the objfile's obstack. */
10386 static struct symbol
*
10387 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
10388 struct symbol
*space
)
10390 struct objfile
*objfile
= cu
->objfile
;
10391 struct symbol
*sym
= NULL
;
10393 struct attribute
*attr
= NULL
;
10394 struct attribute
*attr2
= NULL
;
10395 CORE_ADDR baseaddr
;
10396 struct pending
**list_to_add
= NULL
;
10398 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
10400 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10402 name
= dwarf2_name (die
, cu
);
10405 const char *linkagename
;
10406 int suppress_add
= 0;
10411 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
10412 OBJSTAT (objfile
, n_syms
++);
10414 /* Cache this symbol's name and the name's demangled form (if any). */
10415 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
10416 linkagename
= dwarf2_physname (name
, die
, cu
);
10417 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
10419 /* Fortran does not have mangling standard and the mangling does differ
10420 between gfortran, iFort etc. */
10421 if (cu
->language
== language_fortran
10422 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
10423 symbol_set_demangled_name (&(sym
->ginfo
),
10424 (char *) dwarf2_full_name (name
, die
, cu
),
10427 /* Default assumptions.
10428 Use the passed type or decode it from the die. */
10429 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
10430 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
10432 SYMBOL_TYPE (sym
) = type
;
10434 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
10435 attr
= dwarf2_attr (die
,
10436 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
10440 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
10443 attr
= dwarf2_attr (die
,
10444 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
10448 int file_index
= DW_UNSND (attr
);
10450 if (cu
->line_header
== NULL
10451 || file_index
> cu
->line_header
->num_file_names
)
10452 complaint (&symfile_complaints
,
10453 _("file index out of range"));
10454 else if (file_index
> 0)
10456 struct file_entry
*fe
;
10458 fe
= &cu
->line_header
->file_names
[file_index
- 1];
10459 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
10466 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
10469 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
10471 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
10472 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
10473 SYMBOL_CLASS (sym
) = LOC_LABEL
;
10474 add_symbol_to_list (sym
, cu
->list_in_scope
);
10476 case DW_TAG_subprogram
:
10477 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
10479 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
10480 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10481 if ((attr2
&& (DW_UNSND (attr2
) != 0))
10482 || cu
->language
== language_ada
)
10484 /* Subprograms marked external are stored as a global symbol.
10485 Ada subprograms, whether marked external or not, are always
10486 stored as a global symbol, because we want to be able to
10487 access them globally. For instance, we want to be able
10488 to break on a nested subprogram without having to
10489 specify the context. */
10490 list_to_add
= &global_symbols
;
10494 list_to_add
= cu
->list_in_scope
;
10497 case DW_TAG_inlined_subroutine
:
10498 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
10500 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
10501 SYMBOL_INLINED (sym
) = 1;
10502 /* Do not add the symbol to any lists. It will be found via
10503 BLOCK_FUNCTION from the blockvector. */
10505 case DW_TAG_template_value_param
:
10507 /* Fall through. */
10508 case DW_TAG_variable
:
10509 case DW_TAG_member
:
10510 /* Compilation with minimal debug info may result in variables
10511 with missing type entries. Change the misleading `void' type
10512 to something sensible. */
10513 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
10515 = objfile_type (objfile
)->nodebug_data_symbol
;
10517 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10518 /* In the case of DW_TAG_member, we should only be called for
10519 static const members. */
10520 if (die
->tag
== DW_TAG_member
)
10522 /* dwarf2_add_field uses die_is_declaration,
10523 so we do the same. */
10524 gdb_assert (die_is_declaration (die
, cu
));
10529 dwarf2_const_value (attr
, sym
, cu
);
10530 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10533 if (attr2
&& (DW_UNSND (attr2
) != 0))
10534 list_to_add
= &global_symbols
;
10536 list_to_add
= cu
->list_in_scope
;
10540 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
10543 var_decode_location (attr
, sym
, cu
);
10544 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10545 if (SYMBOL_CLASS (sym
) == LOC_STATIC
10546 && SYMBOL_VALUE_ADDRESS (sym
) == 0
10547 && !dwarf2_per_objfile
->has_section_at_zero
)
10549 /* When a static variable is eliminated by the linker,
10550 the corresponding debug information is not stripped
10551 out, but the variable address is set to null;
10552 do not add such variables into symbol table. */
10554 else if (attr2
&& (DW_UNSND (attr2
) != 0))
10556 /* Workaround gfortran PR debug/40040 - it uses
10557 DW_AT_location for variables in -fPIC libraries which may
10558 get overriden by other libraries/executable and get
10559 a different address. Resolve it by the minimal symbol
10560 which may come from inferior's executable using copy
10561 relocation. Make this workaround only for gfortran as for
10562 other compilers GDB cannot guess the minimal symbol
10563 Fortran mangling kind. */
10564 if (cu
->language
== language_fortran
&& die
->parent
10565 && die
->parent
->tag
== DW_TAG_module
10567 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
10568 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
10570 /* A variable with DW_AT_external is never static,
10571 but it may be block-scoped. */
10572 list_to_add
= (cu
->list_in_scope
== &file_symbols
10573 ? &global_symbols
: cu
->list_in_scope
);
10576 list_to_add
= cu
->list_in_scope
;
10580 /* We do not know the address of this symbol.
10581 If it is an external symbol and we have type information
10582 for it, enter the symbol as a LOC_UNRESOLVED symbol.
10583 The address of the variable will then be determined from
10584 the minimal symbol table whenever the variable is
10586 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10587 if (attr2
&& (DW_UNSND (attr2
) != 0)
10588 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
10590 /* A variable with DW_AT_external is never static, but it
10591 may be block-scoped. */
10592 list_to_add
= (cu
->list_in_scope
== &file_symbols
10593 ? &global_symbols
: cu
->list_in_scope
);
10595 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
10597 else if (!die_is_declaration (die
, cu
))
10599 /* Use the default LOC_OPTIMIZED_OUT class. */
10600 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
10602 list_to_add
= cu
->list_in_scope
;
10606 case DW_TAG_formal_parameter
:
10607 /* If we are inside a function, mark this as an argument. If
10608 not, we might be looking at an argument to an inlined function
10609 when we do not have enough information to show inlined frames;
10610 pretend it's a local variable in that case so that the user can
10612 if (context_stack_depth
> 0
10613 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
10614 SYMBOL_IS_ARGUMENT (sym
) = 1;
10615 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
10618 var_decode_location (attr
, sym
, cu
);
10620 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10623 dwarf2_const_value (attr
, sym
, cu
);
10625 attr
= dwarf2_attr (die
, DW_AT_variable_parameter
, cu
);
10626 if (attr
&& DW_UNSND (attr
))
10628 struct type
*ref_type
;
10630 ref_type
= lookup_reference_type (SYMBOL_TYPE (sym
));
10631 SYMBOL_TYPE (sym
) = ref_type
;
10634 list_to_add
= cu
->list_in_scope
;
10636 case DW_TAG_unspecified_parameters
:
10637 /* From varargs functions; gdb doesn't seem to have any
10638 interest in this information, so just ignore it for now.
10641 case DW_TAG_template_type_param
:
10643 /* Fall through. */
10644 case DW_TAG_class_type
:
10645 case DW_TAG_interface_type
:
10646 case DW_TAG_structure_type
:
10647 case DW_TAG_union_type
:
10648 case DW_TAG_set_type
:
10649 case DW_TAG_enumeration_type
:
10650 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10651 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
10654 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
10655 really ever be static objects: otherwise, if you try
10656 to, say, break of a class's method and you're in a file
10657 which doesn't mention that class, it won't work unless
10658 the check for all static symbols in lookup_symbol_aux
10659 saves you. See the OtherFileClass tests in
10660 gdb.c++/namespace.exp. */
10664 list_to_add
= (cu
->list_in_scope
== &file_symbols
10665 && (cu
->language
== language_cplus
10666 || cu
->language
== language_java
)
10667 ? &global_symbols
: cu
->list_in_scope
);
10670 /* The semantics of C++ state that "struct foo { ... }" also
10671 defines a typedef for "foo". A Java class declaration also
10672 defines a typedef for the class. */
10673 if (cu
->language
== language_cplus
10674 || cu
->language
== language_java
10675 || cu
->language
== language_ada
)
10677 /* The symbol's name is already allocated along with
10678 this objfile, so we don't need to duplicate it for
10680 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
10681 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
10685 case DW_TAG_typedef
:
10686 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10687 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
10688 list_to_add
= cu
->list_in_scope
;
10690 case DW_TAG_base_type
:
10691 case DW_TAG_subrange_type
:
10692 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10693 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
10694 list_to_add
= cu
->list_in_scope
;
10696 case DW_TAG_enumerator
:
10697 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10700 dwarf2_const_value (attr
, sym
, cu
);
10703 /* NOTE: carlton/2003-11-10: See comment above in the
10704 DW_TAG_class_type, etc. block. */
10706 list_to_add
= (cu
->list_in_scope
== &file_symbols
10707 && (cu
->language
== language_cplus
10708 || cu
->language
== language_java
)
10709 ? &global_symbols
: cu
->list_in_scope
);
10712 case DW_TAG_namespace
:
10713 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10714 list_to_add
= &global_symbols
;
10717 /* Not a tag we recognize. Hopefully we aren't processing
10718 trash data, but since we must specifically ignore things
10719 we don't recognize, there is nothing else we should do at
10721 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
10722 dwarf_tag_name (die
->tag
));
10728 sym
->hash_next
= objfile
->template_symbols
;
10729 objfile
->template_symbols
= sym
;
10730 list_to_add
= NULL
;
10733 if (list_to_add
!= NULL
)
10734 add_symbol_to_list (sym
, list_to_add
);
10736 /* For the benefit of old versions of GCC, check for anonymous
10737 namespaces based on the demangled name. */
10738 if (!processing_has_namespace_info
10739 && cu
->language
== language_cplus
)
10740 cp_scan_for_anonymous_namespaces (sym
);
10745 /* A wrapper for new_symbol_full that always allocates a new symbol. */
10747 static struct symbol
*
10748 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
10750 return new_symbol_full (die
, type
, cu
, NULL
);
10753 /* Given an attr with a DW_FORM_dataN value in host byte order,
10754 zero-extend it as appropriate for the symbol's type. The DWARF
10755 standard (v4) is not entirely clear about the meaning of using
10756 DW_FORM_dataN for a constant with a signed type, where the type is
10757 wider than the data. The conclusion of a discussion on the DWARF
10758 list was that this is unspecified. We choose to always zero-extend
10759 because that is the interpretation long in use by GCC. */
10762 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
10763 const char *name
, struct obstack
*obstack
,
10764 struct dwarf2_cu
*cu
, long *value
, int bits
)
10766 struct objfile
*objfile
= cu
->objfile
;
10767 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
10768 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
10769 LONGEST l
= DW_UNSND (attr
);
10771 if (bits
< sizeof (*value
) * 8)
10773 l
&= ((LONGEST
) 1 << bits
) - 1;
10776 else if (bits
== sizeof (*value
) * 8)
10780 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
10781 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
10788 /* Read a constant value from an attribute. Either set *VALUE, or if
10789 the value does not fit in *VALUE, set *BYTES - either already
10790 allocated on the objfile obstack, or newly allocated on OBSTACK,
10791 or, set *BATON, if we translated the constant to a location
10795 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
10796 const char *name
, struct obstack
*obstack
,
10797 struct dwarf2_cu
*cu
,
10798 long *value
, gdb_byte
**bytes
,
10799 struct dwarf2_locexpr_baton
**baton
)
10801 struct objfile
*objfile
= cu
->objfile
;
10802 struct comp_unit_head
*cu_header
= &cu
->header
;
10803 struct dwarf_block
*blk
;
10804 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
10805 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
10811 switch (attr
->form
)
10817 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
10818 dwarf2_const_value_length_mismatch_complaint (name
,
10819 cu_header
->addr_size
,
10820 TYPE_LENGTH (type
));
10821 /* Symbols of this form are reasonably rare, so we just
10822 piggyback on the existing location code rather than writing
10823 a new implementation of symbol_computed_ops. */
10824 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
10825 sizeof (struct dwarf2_locexpr_baton
));
10826 (*baton
)->per_cu
= cu
->per_cu
;
10827 gdb_assert ((*baton
)->per_cu
);
10829 (*baton
)->size
= 2 + cu_header
->addr_size
;
10830 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
10831 (*baton
)->data
= data
;
10833 data
[0] = DW_OP_addr
;
10834 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
10835 byte_order
, DW_ADDR (attr
));
10836 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
10839 case DW_FORM_string
:
10841 /* DW_STRING is already allocated on the objfile obstack, point
10843 *bytes
= (gdb_byte
*) DW_STRING (attr
);
10845 case DW_FORM_block1
:
10846 case DW_FORM_block2
:
10847 case DW_FORM_block4
:
10848 case DW_FORM_block
:
10849 case DW_FORM_exprloc
:
10850 blk
= DW_BLOCK (attr
);
10851 if (TYPE_LENGTH (type
) != blk
->size
)
10852 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
10853 TYPE_LENGTH (type
));
10854 *bytes
= blk
->data
;
10857 /* The DW_AT_const_value attributes are supposed to carry the
10858 symbol's value "represented as it would be on the target
10859 architecture." By the time we get here, it's already been
10860 converted to host endianness, so we just need to sign- or
10861 zero-extend it as appropriate. */
10862 case DW_FORM_data1
:
10863 *bytes
= dwarf2_const_value_data (attr
, type
, name
, obstack
, cu
, value
, 8);
10865 case DW_FORM_data2
:
10866 *bytes
= dwarf2_const_value_data (attr
, type
, name
, obstack
, cu
, value
, 16);
10868 case DW_FORM_data4
:
10869 *bytes
= dwarf2_const_value_data (attr
, type
, name
, obstack
, cu
, value
, 32);
10871 case DW_FORM_data8
:
10872 *bytes
= dwarf2_const_value_data (attr
, type
, name
, obstack
, cu
, value
, 64);
10875 case DW_FORM_sdata
:
10876 *value
= DW_SND (attr
);
10879 case DW_FORM_udata
:
10880 *value
= DW_UNSND (attr
);
10884 complaint (&symfile_complaints
,
10885 _("unsupported const value attribute form: '%s'"),
10886 dwarf_form_name (attr
->form
));
10893 /* Copy constant value from an attribute to a symbol. */
10896 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
10897 struct dwarf2_cu
*cu
)
10899 struct objfile
*objfile
= cu
->objfile
;
10900 struct comp_unit_head
*cu_header
= &cu
->header
;
10903 struct dwarf2_locexpr_baton
*baton
;
10905 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
10906 SYMBOL_PRINT_NAME (sym
),
10907 &objfile
->objfile_obstack
, cu
,
10908 &value
, &bytes
, &baton
);
10912 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
10913 SYMBOL_LOCATION_BATON (sym
) = baton
;
10914 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
10916 else if (bytes
!= NULL
)
10918 SYMBOL_VALUE_BYTES (sym
) = bytes
;
10919 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
10923 SYMBOL_VALUE (sym
) = value
;
10924 SYMBOL_CLASS (sym
) = LOC_CONST
;
10928 /* Return the type of the die in question using its DW_AT_type attribute. */
10930 static struct type
*
10931 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10933 struct attribute
*type_attr
;
10935 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
10938 /* A missing DW_AT_type represents a void type. */
10939 return objfile_type (cu
->objfile
)->builtin_void
;
10942 return lookup_die_type (die
, type_attr
, cu
);
10945 /* True iff CU's producer generates GNAT Ada auxiliary information
10946 that allows to find parallel types through that information instead
10947 of having to do expensive parallel lookups by type name. */
10950 need_gnat_info (struct dwarf2_cu
*cu
)
10952 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
10953 of GNAT produces this auxiliary information, without any indication
10954 that it is produced. Part of enhancing the FSF version of GNAT
10955 to produce that information will be to put in place an indicator
10956 that we can use in order to determine whether the descriptive type
10957 info is available or not. One suggestion that has been made is
10958 to use a new attribute, attached to the CU die. For now, assume
10959 that the descriptive type info is not available. */
10963 /* Return the auxiliary type of the die in question using its
10964 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
10965 attribute is not present. */
10967 static struct type
*
10968 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10970 struct attribute
*type_attr
;
10972 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
10976 return lookup_die_type (die
, type_attr
, cu
);
10979 /* If DIE has a descriptive_type attribute, then set the TYPE's
10980 descriptive type accordingly. */
10983 set_descriptive_type (struct type
*type
, struct die_info
*die
,
10984 struct dwarf2_cu
*cu
)
10986 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
10988 if (descriptive_type
)
10990 ALLOCATE_GNAT_AUX_TYPE (type
);
10991 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
10995 /* Return the containing type of the die in question using its
10996 DW_AT_containing_type attribute. */
10998 static struct type
*
10999 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11001 struct attribute
*type_attr
;
11003 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
11005 error (_("Dwarf Error: Problem turning containing type into gdb type "
11006 "[in module %s]"), cu
->objfile
->name
);
11008 return lookup_die_type (die
, type_attr
, cu
);
11011 /* Look up the type of DIE in CU using its type attribute ATTR.
11012 If there is no type substitute an error marker. */
11014 static struct type
*
11015 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
11016 struct dwarf2_cu
*cu
)
11018 struct type
*this_type
;
11020 /* First see if we have it cached. */
11022 if (is_ref_attr (attr
))
11024 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
11026 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
11028 else if (attr
->form
== DW_FORM_sig8
)
11030 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
11031 struct dwarf2_cu
*sig_cu
;
11032 unsigned int offset
;
11034 /* sig_type will be NULL if the signatured type is missing from
11036 if (sig_type
== NULL
)
11037 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
11038 "at 0x%x [in module %s]"),
11039 die
->offset
, cu
->objfile
->name
);
11041 gdb_assert (sig_type
->per_cu
.from_debug_types
);
11042 offset
= sig_type
->offset
+ sig_type
->type_offset
;
11043 this_type
= get_die_type_at_offset (offset
, &sig_type
->per_cu
);
11047 dump_die_for_error (die
);
11048 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
11049 dwarf_attr_name (attr
->name
), cu
->objfile
->name
);
11052 /* If not cached we need to read it in. */
11054 if (this_type
== NULL
)
11056 struct die_info
*type_die
;
11057 struct dwarf2_cu
*type_cu
= cu
;
11059 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
11060 /* If the type is cached, we should have found it above. */
11061 gdb_assert (get_die_type (type_die
, type_cu
) == NULL
);
11062 this_type
= read_type_die_1 (type_die
, type_cu
);
11065 /* If we still don't have a type use an error marker. */
11067 if (this_type
== NULL
)
11069 char *message
, *saved
;
11071 /* read_type_die already issued a complaint. */
11072 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
11076 saved
= obstack_copy0 (&cu
->objfile
->objfile_obstack
,
11077 message
, strlen (message
));
11080 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, cu
->objfile
);
11086 /* Return the type in DIE, CU.
11087 Returns NULL for invalid types.
11089 This first does a lookup in the appropriate type_hash table,
11090 and only reads the die in if necessary.
11092 NOTE: This can be called when reading in partial or full symbols. */
11094 static struct type
*
11095 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
11097 struct type
*this_type
;
11099 this_type
= get_die_type (die
, cu
);
11103 return read_type_die_1 (die
, cu
);
11106 /* Read the type in DIE, CU.
11107 Returns NULL for invalid types. */
11109 static struct type
*
11110 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
11112 struct type
*this_type
= NULL
;
11116 case DW_TAG_class_type
:
11117 case DW_TAG_interface_type
:
11118 case DW_TAG_structure_type
:
11119 case DW_TAG_union_type
:
11120 this_type
= read_structure_type (die
, cu
);
11122 case DW_TAG_enumeration_type
:
11123 this_type
= read_enumeration_type (die
, cu
);
11125 case DW_TAG_subprogram
:
11126 case DW_TAG_subroutine_type
:
11127 case DW_TAG_inlined_subroutine
:
11128 this_type
= read_subroutine_type (die
, cu
);
11130 case DW_TAG_array_type
:
11131 this_type
= read_array_type (die
, cu
);
11133 case DW_TAG_set_type
:
11134 this_type
= read_set_type (die
, cu
);
11136 case DW_TAG_pointer_type
:
11137 this_type
= read_tag_pointer_type (die
, cu
);
11139 case DW_TAG_ptr_to_member_type
:
11140 this_type
= read_tag_ptr_to_member_type (die
, cu
);
11142 case DW_TAG_reference_type
:
11143 this_type
= read_tag_reference_type (die
, cu
);
11145 case DW_TAG_const_type
:
11146 this_type
= read_tag_const_type (die
, cu
);
11148 case DW_TAG_volatile_type
:
11149 this_type
= read_tag_volatile_type (die
, cu
);
11151 case DW_TAG_string_type
:
11152 this_type
= read_tag_string_type (die
, cu
);
11154 case DW_TAG_typedef
:
11155 this_type
= read_typedef (die
, cu
);
11157 case DW_TAG_subrange_type
:
11158 this_type
= read_subrange_type (die
, cu
);
11160 case DW_TAG_base_type
:
11161 this_type
= read_base_type (die
, cu
);
11163 case DW_TAG_unspecified_type
:
11164 this_type
= read_unspecified_type (die
, cu
);
11166 case DW_TAG_namespace
:
11167 this_type
= read_namespace_type (die
, cu
);
11169 case DW_TAG_module
:
11170 this_type
= read_module_type (die
, cu
);
11173 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
11174 dwarf_tag_name (die
->tag
));
11181 /* Return the name of the namespace/class that DIE is defined within,
11182 or "" if we can't tell. The caller should not xfree the result.
11184 For example, if we're within the method foo() in the following
11194 then determine_prefix on foo's die will return "N::C". */
11197 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
11199 struct die_info
*parent
, *spec_die
;
11200 struct dwarf2_cu
*spec_cu
;
11201 struct type
*parent_type
;
11203 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
11204 && cu
->language
!= language_fortran
)
11207 /* We have to be careful in the presence of DW_AT_specification.
11208 For example, with GCC 3.4, given the code
11212 // Definition of N::foo.
11216 then we'll have a tree of DIEs like this:
11218 1: DW_TAG_compile_unit
11219 2: DW_TAG_namespace // N
11220 3: DW_TAG_subprogram // declaration of N::foo
11221 4: DW_TAG_subprogram // definition of N::foo
11222 DW_AT_specification // refers to die #3
11224 Thus, when processing die #4, we have to pretend that we're in
11225 the context of its DW_AT_specification, namely the contex of die
11228 spec_die
= die_specification (die
, &spec_cu
);
11229 if (spec_die
== NULL
)
11230 parent
= die
->parent
;
11233 parent
= spec_die
->parent
;
11237 if (parent
== NULL
)
11239 else if (parent
->building_fullname
)
11242 const char *parent_name
;
11244 /* It has been seen on RealView 2.2 built binaries,
11245 DW_TAG_template_type_param types actually _defined_ as
11246 children of the parent class:
11249 template class <class Enum> Class{};
11250 Class<enum E> class_e;
11252 1: DW_TAG_class_type (Class)
11253 2: DW_TAG_enumeration_type (E)
11254 3: DW_TAG_enumerator (enum1:0)
11255 3: DW_TAG_enumerator (enum2:1)
11257 2: DW_TAG_template_type_param
11258 DW_AT_type DW_FORM_ref_udata (E)
11260 Besides being broken debug info, it can put GDB into an
11261 infinite loop. Consider:
11263 When we're building the full name for Class<E>, we'll start
11264 at Class, and go look over its template type parameters,
11265 finding E. We'll then try to build the full name of E, and
11266 reach here. We're now trying to build the full name of E,
11267 and look over the parent DIE for containing scope. In the
11268 broken case, if we followed the parent DIE of E, we'd again
11269 find Class, and once again go look at its template type
11270 arguments, etc., etc. Simply don't consider such parent die
11271 as source-level parent of this die (it can't be, the language
11272 doesn't allow it), and break the loop here. */
11273 name
= dwarf2_name (die
, cu
);
11274 parent_name
= dwarf2_name (parent
, cu
);
11275 complaint (&symfile_complaints
,
11276 _("template param type '%s' defined within parent '%s'"),
11277 name
? name
: "<unknown>",
11278 parent_name
? parent_name
: "<unknown>");
11282 switch (parent
->tag
)
11284 case DW_TAG_namespace
:
11285 parent_type
= read_type_die (parent
, cu
);
11286 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
11287 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
11288 Work around this problem here. */
11289 if (cu
->language
== language_cplus
11290 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
11292 /* We give a name to even anonymous namespaces. */
11293 return TYPE_TAG_NAME (parent_type
);
11294 case DW_TAG_class_type
:
11295 case DW_TAG_interface_type
:
11296 case DW_TAG_structure_type
:
11297 case DW_TAG_union_type
:
11298 case DW_TAG_module
:
11299 parent_type
= read_type_die (parent
, cu
);
11300 if (TYPE_TAG_NAME (parent_type
) != NULL
)
11301 return TYPE_TAG_NAME (parent_type
);
11303 /* An anonymous structure is only allowed non-static data
11304 members; no typedefs, no member functions, et cetera.
11305 So it does not need a prefix. */
11308 return determine_prefix (parent
, cu
);
11312 /* Return a newly-allocated string formed by concatenating PREFIX and
11313 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
11314 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
11315 perform an obconcat, otherwise allocate storage for the result. The CU argument
11316 is used to determine the language and hence, the appropriate separator. */
11318 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
11321 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
11322 int physname
, struct dwarf2_cu
*cu
)
11324 const char *lead
= "";
11327 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
11329 else if (cu
->language
== language_java
)
11331 else if (cu
->language
== language_fortran
&& physname
)
11333 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
11334 DW_AT_MIPS_linkage_name is preferred and used instead. */
11342 if (prefix
== NULL
)
11344 if (suffix
== NULL
)
11349 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
11351 strcpy (retval
, lead
);
11352 strcat (retval
, prefix
);
11353 strcat (retval
, sep
);
11354 strcat (retval
, suffix
);
11359 /* We have an obstack. */
11360 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
11364 /* Return sibling of die, NULL if no sibling. */
11366 static struct die_info
*
11367 sibling_die (struct die_info
*die
)
11369 return die
->sibling
;
11372 /* Get name of a die, return NULL if not found. */
11375 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
11376 struct obstack
*obstack
)
11378 if (name
&& cu
->language
== language_cplus
)
11380 char *canon_name
= cp_canonicalize_string (name
);
11382 if (canon_name
!= NULL
)
11384 if (strcmp (canon_name
, name
) != 0)
11385 name
= obsavestring (canon_name
, strlen (canon_name
),
11387 xfree (canon_name
);
11394 /* Get name of a die, return NULL if not found. */
11397 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
11399 struct attribute
*attr
;
11401 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
11402 if (!attr
|| !DW_STRING (attr
))
11407 case DW_TAG_compile_unit
:
11408 /* Compilation units have a DW_AT_name that is a filename, not
11409 a source language identifier. */
11410 case DW_TAG_enumeration_type
:
11411 case DW_TAG_enumerator
:
11412 /* These tags always have simple identifiers already; no need
11413 to canonicalize them. */
11414 return DW_STRING (attr
);
11416 case DW_TAG_subprogram
:
11417 /* Java constructors will all be named "<init>", so return
11418 the class name when we see this special case. */
11419 if (cu
->language
== language_java
11420 && DW_STRING (attr
) != NULL
11421 && strcmp (DW_STRING (attr
), "<init>") == 0)
11423 struct dwarf2_cu
*spec_cu
= cu
;
11424 struct die_info
*spec_die
;
11426 /* GCJ will output '<init>' for Java constructor names.
11427 For this special case, return the name of the parent class. */
11429 /* GCJ may output suprogram DIEs with AT_specification set.
11430 If so, use the name of the specified DIE. */
11431 spec_die
= die_specification (die
, &spec_cu
);
11432 if (spec_die
!= NULL
)
11433 return dwarf2_name (spec_die
, spec_cu
);
11438 if (die
->tag
== DW_TAG_class_type
)
11439 return dwarf2_name (die
, cu
);
11441 while (die
->tag
!= DW_TAG_compile_unit
);
11445 case DW_TAG_class_type
:
11446 case DW_TAG_interface_type
:
11447 case DW_TAG_structure_type
:
11448 case DW_TAG_union_type
:
11449 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
11450 structures or unions. These were of the form "._%d" in GCC 4.1,
11451 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
11452 and GCC 4.4. We work around this problem by ignoring these. */
11453 if (strncmp (DW_STRING (attr
), "._", 2) == 0
11454 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0)
11462 if (!DW_STRING_IS_CANONICAL (attr
))
11465 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
11466 &cu
->objfile
->objfile_obstack
);
11467 DW_STRING_IS_CANONICAL (attr
) = 1;
11469 return DW_STRING (attr
);
11472 /* Return the die that this die in an extension of, or NULL if there
11473 is none. *EXT_CU is the CU containing DIE on input, and the CU
11474 containing the return value on output. */
11476 static struct die_info
*
11477 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
11479 struct attribute
*attr
;
11481 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
11485 return follow_die_ref (die
, attr
, ext_cu
);
11488 /* Convert a DIE tag into its string name. */
11491 dwarf_tag_name (unsigned tag
)
11495 case DW_TAG_padding
:
11496 return "DW_TAG_padding";
11497 case DW_TAG_array_type
:
11498 return "DW_TAG_array_type";
11499 case DW_TAG_class_type
:
11500 return "DW_TAG_class_type";
11501 case DW_TAG_entry_point
:
11502 return "DW_TAG_entry_point";
11503 case DW_TAG_enumeration_type
:
11504 return "DW_TAG_enumeration_type";
11505 case DW_TAG_formal_parameter
:
11506 return "DW_TAG_formal_parameter";
11507 case DW_TAG_imported_declaration
:
11508 return "DW_TAG_imported_declaration";
11510 return "DW_TAG_label";
11511 case DW_TAG_lexical_block
:
11512 return "DW_TAG_lexical_block";
11513 case DW_TAG_member
:
11514 return "DW_TAG_member";
11515 case DW_TAG_pointer_type
:
11516 return "DW_TAG_pointer_type";
11517 case DW_TAG_reference_type
:
11518 return "DW_TAG_reference_type";
11519 case DW_TAG_compile_unit
:
11520 return "DW_TAG_compile_unit";
11521 case DW_TAG_string_type
:
11522 return "DW_TAG_string_type";
11523 case DW_TAG_structure_type
:
11524 return "DW_TAG_structure_type";
11525 case DW_TAG_subroutine_type
:
11526 return "DW_TAG_subroutine_type";
11527 case DW_TAG_typedef
:
11528 return "DW_TAG_typedef";
11529 case DW_TAG_union_type
:
11530 return "DW_TAG_union_type";
11531 case DW_TAG_unspecified_parameters
:
11532 return "DW_TAG_unspecified_parameters";
11533 case DW_TAG_variant
:
11534 return "DW_TAG_variant";
11535 case DW_TAG_common_block
:
11536 return "DW_TAG_common_block";
11537 case DW_TAG_common_inclusion
:
11538 return "DW_TAG_common_inclusion";
11539 case DW_TAG_inheritance
:
11540 return "DW_TAG_inheritance";
11541 case DW_TAG_inlined_subroutine
:
11542 return "DW_TAG_inlined_subroutine";
11543 case DW_TAG_module
:
11544 return "DW_TAG_module";
11545 case DW_TAG_ptr_to_member_type
:
11546 return "DW_TAG_ptr_to_member_type";
11547 case DW_TAG_set_type
:
11548 return "DW_TAG_set_type";
11549 case DW_TAG_subrange_type
:
11550 return "DW_TAG_subrange_type";
11551 case DW_TAG_with_stmt
:
11552 return "DW_TAG_with_stmt";
11553 case DW_TAG_access_declaration
:
11554 return "DW_TAG_access_declaration";
11555 case DW_TAG_base_type
:
11556 return "DW_TAG_base_type";
11557 case DW_TAG_catch_block
:
11558 return "DW_TAG_catch_block";
11559 case DW_TAG_const_type
:
11560 return "DW_TAG_const_type";
11561 case DW_TAG_constant
:
11562 return "DW_TAG_constant";
11563 case DW_TAG_enumerator
:
11564 return "DW_TAG_enumerator";
11565 case DW_TAG_file_type
:
11566 return "DW_TAG_file_type";
11567 case DW_TAG_friend
:
11568 return "DW_TAG_friend";
11569 case DW_TAG_namelist
:
11570 return "DW_TAG_namelist";
11571 case DW_TAG_namelist_item
:
11572 return "DW_TAG_namelist_item";
11573 case DW_TAG_packed_type
:
11574 return "DW_TAG_packed_type";
11575 case DW_TAG_subprogram
:
11576 return "DW_TAG_subprogram";
11577 case DW_TAG_template_type_param
:
11578 return "DW_TAG_template_type_param";
11579 case DW_TAG_template_value_param
:
11580 return "DW_TAG_template_value_param";
11581 case DW_TAG_thrown_type
:
11582 return "DW_TAG_thrown_type";
11583 case DW_TAG_try_block
:
11584 return "DW_TAG_try_block";
11585 case DW_TAG_variant_part
:
11586 return "DW_TAG_variant_part";
11587 case DW_TAG_variable
:
11588 return "DW_TAG_variable";
11589 case DW_TAG_volatile_type
:
11590 return "DW_TAG_volatile_type";
11591 case DW_TAG_dwarf_procedure
:
11592 return "DW_TAG_dwarf_procedure";
11593 case DW_TAG_restrict_type
:
11594 return "DW_TAG_restrict_type";
11595 case DW_TAG_interface_type
:
11596 return "DW_TAG_interface_type";
11597 case DW_TAG_namespace
:
11598 return "DW_TAG_namespace";
11599 case DW_TAG_imported_module
:
11600 return "DW_TAG_imported_module";
11601 case DW_TAG_unspecified_type
:
11602 return "DW_TAG_unspecified_type";
11603 case DW_TAG_partial_unit
:
11604 return "DW_TAG_partial_unit";
11605 case DW_TAG_imported_unit
:
11606 return "DW_TAG_imported_unit";
11607 case DW_TAG_condition
:
11608 return "DW_TAG_condition";
11609 case DW_TAG_shared_type
:
11610 return "DW_TAG_shared_type";
11611 case DW_TAG_type_unit
:
11612 return "DW_TAG_type_unit";
11613 case DW_TAG_MIPS_loop
:
11614 return "DW_TAG_MIPS_loop";
11615 case DW_TAG_HP_array_descriptor
:
11616 return "DW_TAG_HP_array_descriptor";
11617 case DW_TAG_format_label
:
11618 return "DW_TAG_format_label";
11619 case DW_TAG_function_template
:
11620 return "DW_TAG_function_template";
11621 case DW_TAG_class_template
:
11622 return "DW_TAG_class_template";
11623 case DW_TAG_GNU_BINCL
:
11624 return "DW_TAG_GNU_BINCL";
11625 case DW_TAG_GNU_EINCL
:
11626 return "DW_TAG_GNU_EINCL";
11627 case DW_TAG_upc_shared_type
:
11628 return "DW_TAG_upc_shared_type";
11629 case DW_TAG_upc_strict_type
:
11630 return "DW_TAG_upc_strict_type";
11631 case DW_TAG_upc_relaxed_type
:
11632 return "DW_TAG_upc_relaxed_type";
11633 case DW_TAG_PGI_kanji_type
:
11634 return "DW_TAG_PGI_kanji_type";
11635 case DW_TAG_PGI_interface_block
:
11636 return "DW_TAG_PGI_interface_block";
11638 return "DW_TAG_<unknown>";
11642 /* Convert a DWARF attribute code into its string name. */
11645 dwarf_attr_name (unsigned attr
)
11649 case DW_AT_sibling
:
11650 return "DW_AT_sibling";
11651 case DW_AT_location
:
11652 return "DW_AT_location";
11654 return "DW_AT_name";
11655 case DW_AT_ordering
:
11656 return "DW_AT_ordering";
11657 case DW_AT_subscr_data
:
11658 return "DW_AT_subscr_data";
11659 case DW_AT_byte_size
:
11660 return "DW_AT_byte_size";
11661 case DW_AT_bit_offset
:
11662 return "DW_AT_bit_offset";
11663 case DW_AT_bit_size
:
11664 return "DW_AT_bit_size";
11665 case DW_AT_element_list
:
11666 return "DW_AT_element_list";
11667 case DW_AT_stmt_list
:
11668 return "DW_AT_stmt_list";
11670 return "DW_AT_low_pc";
11671 case DW_AT_high_pc
:
11672 return "DW_AT_high_pc";
11673 case DW_AT_language
:
11674 return "DW_AT_language";
11676 return "DW_AT_member";
11678 return "DW_AT_discr";
11679 case DW_AT_discr_value
:
11680 return "DW_AT_discr_value";
11681 case DW_AT_visibility
:
11682 return "DW_AT_visibility";
11684 return "DW_AT_import";
11685 case DW_AT_string_length
:
11686 return "DW_AT_string_length";
11687 case DW_AT_common_reference
:
11688 return "DW_AT_common_reference";
11689 case DW_AT_comp_dir
:
11690 return "DW_AT_comp_dir";
11691 case DW_AT_const_value
:
11692 return "DW_AT_const_value";
11693 case DW_AT_containing_type
:
11694 return "DW_AT_containing_type";
11695 case DW_AT_default_value
:
11696 return "DW_AT_default_value";
11698 return "DW_AT_inline";
11699 case DW_AT_is_optional
:
11700 return "DW_AT_is_optional";
11701 case DW_AT_lower_bound
:
11702 return "DW_AT_lower_bound";
11703 case DW_AT_producer
:
11704 return "DW_AT_producer";
11705 case DW_AT_prototyped
:
11706 return "DW_AT_prototyped";
11707 case DW_AT_return_addr
:
11708 return "DW_AT_return_addr";
11709 case DW_AT_start_scope
:
11710 return "DW_AT_start_scope";
11711 case DW_AT_bit_stride
:
11712 return "DW_AT_bit_stride";
11713 case DW_AT_upper_bound
:
11714 return "DW_AT_upper_bound";
11715 case DW_AT_abstract_origin
:
11716 return "DW_AT_abstract_origin";
11717 case DW_AT_accessibility
:
11718 return "DW_AT_accessibility";
11719 case DW_AT_address_class
:
11720 return "DW_AT_address_class";
11721 case DW_AT_artificial
:
11722 return "DW_AT_artificial";
11723 case DW_AT_base_types
:
11724 return "DW_AT_base_types";
11725 case DW_AT_calling_convention
:
11726 return "DW_AT_calling_convention";
11728 return "DW_AT_count";
11729 case DW_AT_data_member_location
:
11730 return "DW_AT_data_member_location";
11731 case DW_AT_decl_column
:
11732 return "DW_AT_decl_column";
11733 case DW_AT_decl_file
:
11734 return "DW_AT_decl_file";
11735 case DW_AT_decl_line
:
11736 return "DW_AT_decl_line";
11737 case DW_AT_declaration
:
11738 return "DW_AT_declaration";
11739 case DW_AT_discr_list
:
11740 return "DW_AT_discr_list";
11741 case DW_AT_encoding
:
11742 return "DW_AT_encoding";
11743 case DW_AT_external
:
11744 return "DW_AT_external";
11745 case DW_AT_frame_base
:
11746 return "DW_AT_frame_base";
11748 return "DW_AT_friend";
11749 case DW_AT_identifier_case
:
11750 return "DW_AT_identifier_case";
11751 case DW_AT_macro_info
:
11752 return "DW_AT_macro_info";
11753 case DW_AT_namelist_items
:
11754 return "DW_AT_namelist_items";
11755 case DW_AT_priority
:
11756 return "DW_AT_priority";
11757 case DW_AT_segment
:
11758 return "DW_AT_segment";
11759 case DW_AT_specification
:
11760 return "DW_AT_specification";
11761 case DW_AT_static_link
:
11762 return "DW_AT_static_link";
11764 return "DW_AT_type";
11765 case DW_AT_use_location
:
11766 return "DW_AT_use_location";
11767 case DW_AT_variable_parameter
:
11768 return "DW_AT_variable_parameter";
11769 case DW_AT_virtuality
:
11770 return "DW_AT_virtuality";
11771 case DW_AT_vtable_elem_location
:
11772 return "DW_AT_vtable_elem_location";
11773 /* DWARF 3 values. */
11774 case DW_AT_allocated
:
11775 return "DW_AT_allocated";
11776 case DW_AT_associated
:
11777 return "DW_AT_associated";
11778 case DW_AT_data_location
:
11779 return "DW_AT_data_location";
11780 case DW_AT_byte_stride
:
11781 return "DW_AT_byte_stride";
11782 case DW_AT_entry_pc
:
11783 return "DW_AT_entry_pc";
11784 case DW_AT_use_UTF8
:
11785 return "DW_AT_use_UTF8";
11786 case DW_AT_extension
:
11787 return "DW_AT_extension";
11789 return "DW_AT_ranges";
11790 case DW_AT_trampoline
:
11791 return "DW_AT_trampoline";
11792 case DW_AT_call_column
:
11793 return "DW_AT_call_column";
11794 case DW_AT_call_file
:
11795 return "DW_AT_call_file";
11796 case DW_AT_call_line
:
11797 return "DW_AT_call_line";
11798 case DW_AT_description
:
11799 return "DW_AT_description";
11800 case DW_AT_binary_scale
:
11801 return "DW_AT_binary_scale";
11802 case DW_AT_decimal_scale
:
11803 return "DW_AT_decimal_scale";
11805 return "DW_AT_small";
11806 case DW_AT_decimal_sign
:
11807 return "DW_AT_decimal_sign";
11808 case DW_AT_digit_count
:
11809 return "DW_AT_digit_count";
11810 case DW_AT_picture_string
:
11811 return "DW_AT_picture_string";
11812 case DW_AT_mutable
:
11813 return "DW_AT_mutable";
11814 case DW_AT_threads_scaled
:
11815 return "DW_AT_threads_scaled";
11816 case DW_AT_explicit
:
11817 return "DW_AT_explicit";
11818 case DW_AT_object_pointer
:
11819 return "DW_AT_object_pointer";
11820 case DW_AT_endianity
:
11821 return "DW_AT_endianity";
11822 case DW_AT_elemental
:
11823 return "DW_AT_elemental";
11825 return "DW_AT_pure";
11826 case DW_AT_recursive
:
11827 return "DW_AT_recursive";
11828 /* DWARF 4 values. */
11829 case DW_AT_signature
:
11830 return "DW_AT_signature";
11831 case DW_AT_linkage_name
:
11832 return "DW_AT_linkage_name";
11833 /* SGI/MIPS extensions. */
11834 #ifdef MIPS /* collides with DW_AT_HP_block_index */
11835 case DW_AT_MIPS_fde
:
11836 return "DW_AT_MIPS_fde";
11838 case DW_AT_MIPS_loop_begin
:
11839 return "DW_AT_MIPS_loop_begin";
11840 case DW_AT_MIPS_tail_loop_begin
:
11841 return "DW_AT_MIPS_tail_loop_begin";
11842 case DW_AT_MIPS_epilog_begin
:
11843 return "DW_AT_MIPS_epilog_begin";
11844 case DW_AT_MIPS_loop_unroll_factor
:
11845 return "DW_AT_MIPS_loop_unroll_factor";
11846 case DW_AT_MIPS_software_pipeline_depth
:
11847 return "DW_AT_MIPS_software_pipeline_depth";
11848 case DW_AT_MIPS_linkage_name
:
11849 return "DW_AT_MIPS_linkage_name";
11850 case DW_AT_MIPS_stride
:
11851 return "DW_AT_MIPS_stride";
11852 case DW_AT_MIPS_abstract_name
:
11853 return "DW_AT_MIPS_abstract_name";
11854 case DW_AT_MIPS_clone_origin
:
11855 return "DW_AT_MIPS_clone_origin";
11856 case DW_AT_MIPS_has_inlines
:
11857 return "DW_AT_MIPS_has_inlines";
11858 /* HP extensions. */
11859 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
11860 case DW_AT_HP_block_index
:
11861 return "DW_AT_HP_block_index";
11863 case DW_AT_HP_unmodifiable
:
11864 return "DW_AT_HP_unmodifiable";
11865 case DW_AT_HP_actuals_stmt_list
:
11866 return "DW_AT_HP_actuals_stmt_list";
11867 case DW_AT_HP_proc_per_section
:
11868 return "DW_AT_HP_proc_per_section";
11869 case DW_AT_HP_raw_data_ptr
:
11870 return "DW_AT_HP_raw_data_ptr";
11871 case DW_AT_HP_pass_by_reference
:
11872 return "DW_AT_HP_pass_by_reference";
11873 case DW_AT_HP_opt_level
:
11874 return "DW_AT_HP_opt_level";
11875 case DW_AT_HP_prof_version_id
:
11876 return "DW_AT_HP_prof_version_id";
11877 case DW_AT_HP_opt_flags
:
11878 return "DW_AT_HP_opt_flags";
11879 case DW_AT_HP_cold_region_low_pc
:
11880 return "DW_AT_HP_cold_region_low_pc";
11881 case DW_AT_HP_cold_region_high_pc
:
11882 return "DW_AT_HP_cold_region_high_pc";
11883 case DW_AT_HP_all_variables_modifiable
:
11884 return "DW_AT_HP_all_variables_modifiable";
11885 case DW_AT_HP_linkage_name
:
11886 return "DW_AT_HP_linkage_name";
11887 case DW_AT_HP_prof_flags
:
11888 return "DW_AT_HP_prof_flags";
11889 /* GNU extensions. */
11890 case DW_AT_sf_names
:
11891 return "DW_AT_sf_names";
11892 case DW_AT_src_info
:
11893 return "DW_AT_src_info";
11894 case DW_AT_mac_info
:
11895 return "DW_AT_mac_info";
11896 case DW_AT_src_coords
:
11897 return "DW_AT_src_coords";
11898 case DW_AT_body_begin
:
11899 return "DW_AT_body_begin";
11900 case DW_AT_body_end
:
11901 return "DW_AT_body_end";
11902 case DW_AT_GNU_vector
:
11903 return "DW_AT_GNU_vector";
11904 case DW_AT_GNU_odr_signature
:
11905 return "DW_AT_GNU_odr_signature";
11906 /* VMS extensions. */
11907 case DW_AT_VMS_rtnbeg_pd_address
:
11908 return "DW_AT_VMS_rtnbeg_pd_address";
11909 /* UPC extension. */
11910 case DW_AT_upc_threads_scaled
:
11911 return "DW_AT_upc_threads_scaled";
11912 /* PGI (STMicroelectronics) extensions. */
11913 case DW_AT_PGI_lbase
:
11914 return "DW_AT_PGI_lbase";
11915 case DW_AT_PGI_soffset
:
11916 return "DW_AT_PGI_soffset";
11917 case DW_AT_PGI_lstride
:
11918 return "DW_AT_PGI_lstride";
11920 return "DW_AT_<unknown>";
11924 /* Convert a DWARF value form code into its string name. */
11927 dwarf_form_name (unsigned form
)
11932 return "DW_FORM_addr";
11933 case DW_FORM_block2
:
11934 return "DW_FORM_block2";
11935 case DW_FORM_block4
:
11936 return "DW_FORM_block4";
11937 case DW_FORM_data2
:
11938 return "DW_FORM_data2";
11939 case DW_FORM_data4
:
11940 return "DW_FORM_data4";
11941 case DW_FORM_data8
:
11942 return "DW_FORM_data8";
11943 case DW_FORM_string
:
11944 return "DW_FORM_string";
11945 case DW_FORM_block
:
11946 return "DW_FORM_block";
11947 case DW_FORM_block1
:
11948 return "DW_FORM_block1";
11949 case DW_FORM_data1
:
11950 return "DW_FORM_data1";
11952 return "DW_FORM_flag";
11953 case DW_FORM_sdata
:
11954 return "DW_FORM_sdata";
11956 return "DW_FORM_strp";
11957 case DW_FORM_udata
:
11958 return "DW_FORM_udata";
11959 case DW_FORM_ref_addr
:
11960 return "DW_FORM_ref_addr";
11962 return "DW_FORM_ref1";
11964 return "DW_FORM_ref2";
11966 return "DW_FORM_ref4";
11968 return "DW_FORM_ref8";
11969 case DW_FORM_ref_udata
:
11970 return "DW_FORM_ref_udata";
11971 case DW_FORM_indirect
:
11972 return "DW_FORM_indirect";
11973 case DW_FORM_sec_offset
:
11974 return "DW_FORM_sec_offset";
11975 case DW_FORM_exprloc
:
11976 return "DW_FORM_exprloc";
11977 case DW_FORM_flag_present
:
11978 return "DW_FORM_flag_present";
11980 return "DW_FORM_sig8";
11982 return "DW_FORM_<unknown>";
11986 /* Convert a DWARF stack opcode into its string name. */
11989 dwarf_stack_op_name (unsigned op
, int def
)
11994 return "DW_OP_addr";
11996 return "DW_OP_deref";
11997 case DW_OP_const1u
:
11998 return "DW_OP_const1u";
11999 case DW_OP_const1s
:
12000 return "DW_OP_const1s";
12001 case DW_OP_const2u
:
12002 return "DW_OP_const2u";
12003 case DW_OP_const2s
:
12004 return "DW_OP_const2s";
12005 case DW_OP_const4u
:
12006 return "DW_OP_const4u";
12007 case DW_OP_const4s
:
12008 return "DW_OP_const4s";
12009 case DW_OP_const8u
:
12010 return "DW_OP_const8u";
12011 case DW_OP_const8s
:
12012 return "DW_OP_const8s";
12014 return "DW_OP_constu";
12016 return "DW_OP_consts";
12018 return "DW_OP_dup";
12020 return "DW_OP_drop";
12022 return "DW_OP_over";
12024 return "DW_OP_pick";
12026 return "DW_OP_swap";
12028 return "DW_OP_rot";
12030 return "DW_OP_xderef";
12032 return "DW_OP_abs";
12034 return "DW_OP_and";
12036 return "DW_OP_div";
12038 return "DW_OP_minus";
12040 return "DW_OP_mod";
12042 return "DW_OP_mul";
12044 return "DW_OP_neg";
12046 return "DW_OP_not";
12050 return "DW_OP_plus";
12051 case DW_OP_plus_uconst
:
12052 return "DW_OP_plus_uconst";
12054 return "DW_OP_shl";
12056 return "DW_OP_shr";
12058 return "DW_OP_shra";
12060 return "DW_OP_xor";
12062 return "DW_OP_bra";
12076 return "DW_OP_skip";
12078 return "DW_OP_lit0";
12080 return "DW_OP_lit1";
12082 return "DW_OP_lit2";
12084 return "DW_OP_lit3";
12086 return "DW_OP_lit4";
12088 return "DW_OP_lit5";
12090 return "DW_OP_lit6";
12092 return "DW_OP_lit7";
12094 return "DW_OP_lit8";
12096 return "DW_OP_lit9";
12098 return "DW_OP_lit10";
12100 return "DW_OP_lit11";
12102 return "DW_OP_lit12";
12104 return "DW_OP_lit13";
12106 return "DW_OP_lit14";
12108 return "DW_OP_lit15";
12110 return "DW_OP_lit16";
12112 return "DW_OP_lit17";
12114 return "DW_OP_lit18";
12116 return "DW_OP_lit19";
12118 return "DW_OP_lit20";
12120 return "DW_OP_lit21";
12122 return "DW_OP_lit22";
12124 return "DW_OP_lit23";
12126 return "DW_OP_lit24";
12128 return "DW_OP_lit25";
12130 return "DW_OP_lit26";
12132 return "DW_OP_lit27";
12134 return "DW_OP_lit28";
12136 return "DW_OP_lit29";
12138 return "DW_OP_lit30";
12140 return "DW_OP_lit31";
12142 return "DW_OP_reg0";
12144 return "DW_OP_reg1";
12146 return "DW_OP_reg2";
12148 return "DW_OP_reg3";
12150 return "DW_OP_reg4";
12152 return "DW_OP_reg5";
12154 return "DW_OP_reg6";
12156 return "DW_OP_reg7";
12158 return "DW_OP_reg8";
12160 return "DW_OP_reg9";
12162 return "DW_OP_reg10";
12164 return "DW_OP_reg11";
12166 return "DW_OP_reg12";
12168 return "DW_OP_reg13";
12170 return "DW_OP_reg14";
12172 return "DW_OP_reg15";
12174 return "DW_OP_reg16";
12176 return "DW_OP_reg17";
12178 return "DW_OP_reg18";
12180 return "DW_OP_reg19";
12182 return "DW_OP_reg20";
12184 return "DW_OP_reg21";
12186 return "DW_OP_reg22";
12188 return "DW_OP_reg23";
12190 return "DW_OP_reg24";
12192 return "DW_OP_reg25";
12194 return "DW_OP_reg26";
12196 return "DW_OP_reg27";
12198 return "DW_OP_reg28";
12200 return "DW_OP_reg29";
12202 return "DW_OP_reg30";
12204 return "DW_OP_reg31";
12206 return "DW_OP_breg0";
12208 return "DW_OP_breg1";
12210 return "DW_OP_breg2";
12212 return "DW_OP_breg3";
12214 return "DW_OP_breg4";
12216 return "DW_OP_breg5";
12218 return "DW_OP_breg6";
12220 return "DW_OP_breg7";
12222 return "DW_OP_breg8";
12224 return "DW_OP_breg9";
12226 return "DW_OP_breg10";
12228 return "DW_OP_breg11";
12230 return "DW_OP_breg12";
12232 return "DW_OP_breg13";
12234 return "DW_OP_breg14";
12236 return "DW_OP_breg15";
12238 return "DW_OP_breg16";
12240 return "DW_OP_breg17";
12242 return "DW_OP_breg18";
12244 return "DW_OP_breg19";
12246 return "DW_OP_breg20";
12248 return "DW_OP_breg21";
12250 return "DW_OP_breg22";
12252 return "DW_OP_breg23";
12254 return "DW_OP_breg24";
12256 return "DW_OP_breg25";
12258 return "DW_OP_breg26";
12260 return "DW_OP_breg27";
12262 return "DW_OP_breg28";
12264 return "DW_OP_breg29";
12266 return "DW_OP_breg30";
12268 return "DW_OP_breg31";
12270 return "DW_OP_regx";
12272 return "DW_OP_fbreg";
12274 return "DW_OP_bregx";
12276 return "DW_OP_piece";
12277 case DW_OP_deref_size
:
12278 return "DW_OP_deref_size";
12279 case DW_OP_xderef_size
:
12280 return "DW_OP_xderef_size";
12282 return "DW_OP_nop";
12283 /* DWARF 3 extensions. */
12284 case DW_OP_push_object_address
:
12285 return "DW_OP_push_object_address";
12287 return "DW_OP_call2";
12289 return "DW_OP_call4";
12290 case DW_OP_call_ref
:
12291 return "DW_OP_call_ref";
12292 case DW_OP_form_tls_address
:
12293 return "DW_OP_form_tls_address";
12294 case DW_OP_call_frame_cfa
:
12295 return "DW_OP_call_frame_cfa";
12296 case DW_OP_bit_piece
:
12297 return "DW_OP_bit_piece";
12298 /* DWARF 4 extensions. */
12299 case DW_OP_implicit_value
:
12300 return "DW_OP_implicit_value";
12301 case DW_OP_stack_value
:
12302 return "DW_OP_stack_value";
12303 /* GNU extensions. */
12304 case DW_OP_GNU_push_tls_address
:
12305 return "DW_OP_GNU_push_tls_address";
12306 case DW_OP_GNU_uninit
:
12307 return "DW_OP_GNU_uninit";
12309 return def
? "OP_<unknown>" : NULL
;
12314 dwarf_bool_name (unsigned mybool
)
12322 /* Convert a DWARF type code into its string name. */
12325 dwarf_type_encoding_name (unsigned enc
)
12330 return "DW_ATE_void";
12331 case DW_ATE_address
:
12332 return "DW_ATE_address";
12333 case DW_ATE_boolean
:
12334 return "DW_ATE_boolean";
12335 case DW_ATE_complex_float
:
12336 return "DW_ATE_complex_float";
12338 return "DW_ATE_float";
12339 case DW_ATE_signed
:
12340 return "DW_ATE_signed";
12341 case DW_ATE_signed_char
:
12342 return "DW_ATE_signed_char";
12343 case DW_ATE_unsigned
:
12344 return "DW_ATE_unsigned";
12345 case DW_ATE_unsigned_char
:
12346 return "DW_ATE_unsigned_char";
12348 case DW_ATE_imaginary_float
:
12349 return "DW_ATE_imaginary_float";
12350 case DW_ATE_packed_decimal
:
12351 return "DW_ATE_packed_decimal";
12352 case DW_ATE_numeric_string
:
12353 return "DW_ATE_numeric_string";
12354 case DW_ATE_edited
:
12355 return "DW_ATE_edited";
12356 case DW_ATE_signed_fixed
:
12357 return "DW_ATE_signed_fixed";
12358 case DW_ATE_unsigned_fixed
:
12359 return "DW_ATE_unsigned_fixed";
12360 case DW_ATE_decimal_float
:
12361 return "DW_ATE_decimal_float";
12364 return "DW_ATE_UTF";
12365 /* HP extensions. */
12366 case DW_ATE_HP_float80
:
12367 return "DW_ATE_HP_float80";
12368 case DW_ATE_HP_complex_float80
:
12369 return "DW_ATE_HP_complex_float80";
12370 case DW_ATE_HP_float128
:
12371 return "DW_ATE_HP_float128";
12372 case DW_ATE_HP_complex_float128
:
12373 return "DW_ATE_HP_complex_float128";
12374 case DW_ATE_HP_floathpintel
:
12375 return "DW_ATE_HP_floathpintel";
12376 case DW_ATE_HP_imaginary_float80
:
12377 return "DW_ATE_HP_imaginary_float80";
12378 case DW_ATE_HP_imaginary_float128
:
12379 return "DW_ATE_HP_imaginary_float128";
12381 return "DW_ATE_<unknown>";
12385 /* Convert a DWARF call frame info operation to its string name. */
12389 dwarf_cfi_name (unsigned cfi_opc
)
12393 case DW_CFA_advance_loc
:
12394 return "DW_CFA_advance_loc";
12395 case DW_CFA_offset
:
12396 return "DW_CFA_offset";
12397 case DW_CFA_restore
:
12398 return "DW_CFA_restore";
12400 return "DW_CFA_nop";
12401 case DW_CFA_set_loc
:
12402 return "DW_CFA_set_loc";
12403 case DW_CFA_advance_loc1
:
12404 return "DW_CFA_advance_loc1";
12405 case DW_CFA_advance_loc2
:
12406 return "DW_CFA_advance_loc2";
12407 case DW_CFA_advance_loc4
:
12408 return "DW_CFA_advance_loc4";
12409 case DW_CFA_offset_extended
:
12410 return "DW_CFA_offset_extended";
12411 case DW_CFA_restore_extended
:
12412 return "DW_CFA_restore_extended";
12413 case DW_CFA_undefined
:
12414 return "DW_CFA_undefined";
12415 case DW_CFA_same_value
:
12416 return "DW_CFA_same_value";
12417 case DW_CFA_register
:
12418 return "DW_CFA_register";
12419 case DW_CFA_remember_state
:
12420 return "DW_CFA_remember_state";
12421 case DW_CFA_restore_state
:
12422 return "DW_CFA_restore_state";
12423 case DW_CFA_def_cfa
:
12424 return "DW_CFA_def_cfa";
12425 case DW_CFA_def_cfa_register
:
12426 return "DW_CFA_def_cfa_register";
12427 case DW_CFA_def_cfa_offset
:
12428 return "DW_CFA_def_cfa_offset";
12430 case DW_CFA_def_cfa_expression
:
12431 return "DW_CFA_def_cfa_expression";
12432 case DW_CFA_expression
:
12433 return "DW_CFA_expression";
12434 case DW_CFA_offset_extended_sf
:
12435 return "DW_CFA_offset_extended_sf";
12436 case DW_CFA_def_cfa_sf
:
12437 return "DW_CFA_def_cfa_sf";
12438 case DW_CFA_def_cfa_offset_sf
:
12439 return "DW_CFA_def_cfa_offset_sf";
12440 case DW_CFA_val_offset
:
12441 return "DW_CFA_val_offset";
12442 case DW_CFA_val_offset_sf
:
12443 return "DW_CFA_val_offset_sf";
12444 case DW_CFA_val_expression
:
12445 return "DW_CFA_val_expression";
12446 /* SGI/MIPS specific. */
12447 case DW_CFA_MIPS_advance_loc8
:
12448 return "DW_CFA_MIPS_advance_loc8";
12449 /* GNU extensions. */
12450 case DW_CFA_GNU_window_save
:
12451 return "DW_CFA_GNU_window_save";
12452 case DW_CFA_GNU_args_size
:
12453 return "DW_CFA_GNU_args_size";
12454 case DW_CFA_GNU_negative_offset_extended
:
12455 return "DW_CFA_GNU_negative_offset_extended";
12457 return "DW_CFA_<unknown>";
12463 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
12467 print_spaces (indent
, f
);
12468 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
12469 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
12471 if (die
->parent
!= NULL
)
12473 print_spaces (indent
, f
);
12474 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
12475 die
->parent
->offset
);
12478 print_spaces (indent
, f
);
12479 fprintf_unfiltered (f
, " has children: %s\n",
12480 dwarf_bool_name (die
->child
!= NULL
));
12482 print_spaces (indent
, f
);
12483 fprintf_unfiltered (f
, " attributes:\n");
12485 for (i
= 0; i
< die
->num_attrs
; ++i
)
12487 print_spaces (indent
, f
);
12488 fprintf_unfiltered (f
, " %s (%s) ",
12489 dwarf_attr_name (die
->attrs
[i
].name
),
12490 dwarf_form_name (die
->attrs
[i
].form
));
12492 switch (die
->attrs
[i
].form
)
12494 case DW_FORM_ref_addr
:
12496 fprintf_unfiltered (f
, "address: ");
12497 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
12499 case DW_FORM_block2
:
12500 case DW_FORM_block4
:
12501 case DW_FORM_block
:
12502 case DW_FORM_block1
:
12503 fprintf_unfiltered (f
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
12505 case DW_FORM_exprloc
:
12506 fprintf_unfiltered (f
, "expression: size %u",
12507 DW_BLOCK (&die
->attrs
[i
])->size
);
12512 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
12513 (long) (DW_ADDR (&die
->attrs
[i
])));
12515 case DW_FORM_data1
:
12516 case DW_FORM_data2
:
12517 case DW_FORM_data4
:
12518 case DW_FORM_data8
:
12519 case DW_FORM_udata
:
12520 case DW_FORM_sdata
:
12521 fprintf_unfiltered (f
, "constant: %s",
12522 pulongest (DW_UNSND (&die
->attrs
[i
])));
12524 case DW_FORM_sec_offset
:
12525 fprintf_unfiltered (f
, "section offset: %s",
12526 pulongest (DW_UNSND (&die
->attrs
[i
])));
12529 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
12530 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
12531 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->offset
);
12533 fprintf_unfiltered (f
, "signatured type, offset: unknown");
12535 case DW_FORM_string
:
12537 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
12538 DW_STRING (&die
->attrs
[i
])
12539 ? DW_STRING (&die
->attrs
[i
]) : "",
12540 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
12543 if (DW_UNSND (&die
->attrs
[i
]))
12544 fprintf_unfiltered (f
, "flag: TRUE");
12546 fprintf_unfiltered (f
, "flag: FALSE");
12548 case DW_FORM_flag_present
:
12549 fprintf_unfiltered (f
, "flag: TRUE");
12551 case DW_FORM_indirect
:
12552 /* the reader will have reduced the indirect form to
12553 the "base form" so this form should not occur */
12554 fprintf_unfiltered (f
, "unexpected attribute form: DW_FORM_indirect");
12557 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
12558 die
->attrs
[i
].form
);
12561 fprintf_unfiltered (f
, "\n");
12566 dump_die_for_error (struct die_info
*die
)
12568 dump_die_shallow (gdb_stderr
, 0, die
);
12572 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
12574 int indent
= level
* 4;
12576 gdb_assert (die
!= NULL
);
12578 if (level
>= max_level
)
12581 dump_die_shallow (f
, indent
, die
);
12583 if (die
->child
!= NULL
)
12585 print_spaces (indent
, f
);
12586 fprintf_unfiltered (f
, " Children:");
12587 if (level
+ 1 < max_level
)
12589 fprintf_unfiltered (f
, "\n");
12590 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
12594 fprintf_unfiltered (f
, " [not printed, max nesting level reached]\n");
12598 if (die
->sibling
!= NULL
&& level
> 0)
12600 dump_die_1 (f
, level
, max_level
, die
->sibling
);
12604 /* This is called from the pdie macro in gdbinit.in.
12605 It's not static so gcc will keep a copy callable from gdb. */
12608 dump_die (struct die_info
*die
, int max_level
)
12610 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
12614 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
12618 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
12624 is_ref_attr (struct attribute
*attr
)
12626 switch (attr
->form
)
12628 case DW_FORM_ref_addr
:
12633 case DW_FORM_ref_udata
:
12640 static unsigned int
12641 dwarf2_get_ref_die_offset (struct attribute
*attr
)
12643 if (is_ref_attr (attr
))
12644 return DW_ADDR (attr
);
12646 complaint (&symfile_complaints
,
12647 _("unsupported die ref attribute form: '%s'"),
12648 dwarf_form_name (attr
->form
));
12652 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
12653 * the value held by the attribute is not constant. */
12656 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
12658 if (attr
->form
== DW_FORM_sdata
)
12659 return DW_SND (attr
);
12660 else if (attr
->form
== DW_FORM_udata
12661 || attr
->form
== DW_FORM_data1
12662 || attr
->form
== DW_FORM_data2
12663 || attr
->form
== DW_FORM_data4
12664 || attr
->form
== DW_FORM_data8
)
12665 return DW_UNSND (attr
);
12668 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
12669 dwarf_form_name (attr
->form
));
12670 return default_value
;
12674 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
12675 unit and add it to our queue.
12676 The result is non-zero if PER_CU was queued, otherwise the result is zero
12677 meaning either PER_CU is already queued or it is already loaded. */
12680 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
12681 struct dwarf2_per_cu_data
*per_cu
)
12683 /* We may arrive here during partial symbol reading, if we need full
12684 DIEs to process an unusual case (e.g. template arguments). Do
12685 not queue PER_CU, just tell our caller to load its DIEs. */
12686 if (dwarf2_per_objfile
->reading_partial_symbols
)
12688 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
12693 /* Mark the dependence relation so that we don't flush PER_CU
12695 dwarf2_add_dependence (this_cu
, per_cu
);
12697 /* If it's already on the queue, we have nothing to do. */
12698 if (per_cu
->queued
)
12701 /* If the compilation unit is already loaded, just mark it as
12703 if (per_cu
->cu
!= NULL
)
12705 per_cu
->cu
->last_used
= 0;
12709 /* Add it to the queue. */
12710 queue_comp_unit (per_cu
, this_cu
->objfile
);
12715 /* Follow reference or signature attribute ATTR of SRC_DIE.
12716 On entry *REF_CU is the CU of SRC_DIE.
12717 On exit *REF_CU is the CU of the result. */
12719 static struct die_info
*
12720 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
12721 struct dwarf2_cu
**ref_cu
)
12723 struct die_info
*die
;
12725 if (is_ref_attr (attr
))
12726 die
= follow_die_ref (src_die
, attr
, ref_cu
);
12727 else if (attr
->form
== DW_FORM_sig8
)
12728 die
= follow_die_sig (src_die
, attr
, ref_cu
);
12731 dump_die_for_error (src_die
);
12732 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
12733 (*ref_cu
)->objfile
->name
);
12739 /* Follow reference OFFSET.
12740 On entry *REF_CU is the CU of the source die referencing OFFSET.
12741 On exit *REF_CU is the CU of the result.
12742 Returns NULL if OFFSET is invalid. */
12744 static struct die_info
*
12745 follow_die_offset (unsigned int offset
, struct dwarf2_cu
**ref_cu
)
12747 struct die_info temp_die
;
12748 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
12750 gdb_assert (cu
->per_cu
!= NULL
);
12754 if (cu
->per_cu
->from_debug_types
)
12756 /* .debug_types CUs cannot reference anything outside their CU.
12757 If they need to, they have to reference a signatured type via
12759 if (! offset_in_cu_p (&cu
->header
, offset
))
12762 else if (! offset_in_cu_p (&cu
->header
, offset
))
12764 struct dwarf2_per_cu_data
*per_cu
;
12766 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
12768 /* If necessary, add it to the queue and load its DIEs. */
12769 if (maybe_queue_comp_unit (cu
, per_cu
))
12770 load_full_comp_unit (per_cu
, cu
->objfile
);
12772 target_cu
= per_cu
->cu
;
12774 else if (cu
->dies
== NULL
)
12776 /* We're loading full DIEs during partial symbol reading. */
12777 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
12778 load_full_comp_unit (cu
->per_cu
, cu
->objfile
);
12781 *ref_cu
= target_cu
;
12782 temp_die
.offset
= offset
;
12783 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
12786 /* Follow reference attribute ATTR of SRC_DIE.
12787 On entry *REF_CU is the CU of SRC_DIE.
12788 On exit *REF_CU is the CU of the result. */
12790 static struct die_info
*
12791 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
12792 struct dwarf2_cu
**ref_cu
)
12794 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
12795 struct dwarf2_cu
*cu
= *ref_cu
;
12796 struct die_info
*die
;
12798 die
= follow_die_offset (offset
, ref_cu
);
12800 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
12801 "at 0x%x [in module %s]"),
12802 offset
, src_die
->offset
, cu
->objfile
->name
);
12807 /* Return DWARF block and its CU referenced by OFFSET at PER_CU. Returned
12808 value is intended for DW_OP_call*. */
12810 struct dwarf2_locexpr_baton
12811 dwarf2_fetch_die_location_block (unsigned int offset
,
12812 struct dwarf2_per_cu_data
*per_cu
)
12814 struct dwarf2_cu
*cu
= per_cu
->cu
;
12815 struct die_info
*die
;
12816 struct attribute
*attr
;
12817 struct dwarf2_locexpr_baton retval
;
12819 die
= follow_die_offset (offset
, &cu
);
12821 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
12822 offset
, per_cu
->cu
->objfile
->name
);
12824 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
12827 /* DWARF: "If there is no such attribute, then there is no effect.". */
12829 retval
.data
= NULL
;
12834 if (!attr_form_is_block (attr
))
12835 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
12836 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
12837 offset
, per_cu
->cu
->objfile
->name
);
12839 retval
.data
= DW_BLOCK (attr
)->data
;
12840 retval
.size
= DW_BLOCK (attr
)->size
;
12842 retval
.per_cu
= cu
->per_cu
;
12846 /* Follow the signature attribute ATTR in SRC_DIE.
12847 On entry *REF_CU is the CU of SRC_DIE.
12848 On exit *REF_CU is the CU of the result. */
12850 static struct die_info
*
12851 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
12852 struct dwarf2_cu
**ref_cu
)
12854 struct objfile
*objfile
= (*ref_cu
)->objfile
;
12855 struct die_info temp_die
;
12856 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
12857 struct dwarf2_cu
*sig_cu
;
12858 struct die_info
*die
;
12860 /* sig_type will be NULL if the signatured type is missing from
12862 if (sig_type
== NULL
)
12863 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
12864 "at 0x%x [in module %s]"),
12865 src_die
->offset
, objfile
->name
);
12867 /* If necessary, add it to the queue and load its DIEs. */
12869 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
12870 read_signatured_type (objfile
, sig_type
);
12872 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
12874 sig_cu
= sig_type
->per_cu
.cu
;
12875 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
12876 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
12883 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced from DIE "
12884 "at 0x%x [in module %s]"),
12885 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
12888 /* Given an offset of a signatured type, return its signatured_type. */
12890 static struct signatured_type
*
12891 lookup_signatured_type_at_offset (struct objfile
*objfile
, unsigned int offset
)
12893 gdb_byte
*info_ptr
= dwarf2_per_objfile
->types
.buffer
+ offset
;
12894 unsigned int length
, initial_length_size
;
12895 unsigned int sig_offset
;
12896 struct signatured_type find_entry
, *type_sig
;
12898 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
12899 sig_offset
= (initial_length_size
12901 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
12902 + 1 /*address_size*/);
12903 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
12904 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
12906 /* This is only used to lookup previously recorded types.
12907 If we didn't find it, it's our bug. */
12908 gdb_assert (type_sig
!= NULL
);
12909 gdb_assert (offset
== type_sig
->offset
);
12914 /* Read in signatured type at OFFSET and build its CU and die(s). */
12917 read_signatured_type_at_offset (struct objfile
*objfile
,
12918 unsigned int offset
)
12920 struct signatured_type
*type_sig
;
12922 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
12924 /* We have the section offset, but we need the signature to do the
12925 hash table lookup. */
12926 type_sig
= lookup_signatured_type_at_offset (objfile
, offset
);
12928 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
12930 read_signatured_type (objfile
, type_sig
);
12932 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
12935 /* Read in a signatured type and build its CU and DIEs. */
12938 read_signatured_type (struct objfile
*objfile
,
12939 struct signatured_type
*type_sig
)
12941 gdb_byte
*types_ptr
;
12942 struct die_reader_specs reader_specs
;
12943 struct dwarf2_cu
*cu
;
12944 ULONGEST signature
;
12945 struct cleanup
*back_to
, *free_cu_cleanup
;
12946 struct attribute
*attr
;
12948 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
12949 types_ptr
= dwarf2_per_objfile
->types
.buffer
+ type_sig
->offset
;
12951 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
12953 cu
= xmalloc (sizeof (struct dwarf2_cu
));
12954 memset (cu
, 0, sizeof (struct dwarf2_cu
));
12955 obstack_init (&cu
->comp_unit_obstack
);
12956 cu
->objfile
= objfile
;
12957 type_sig
->per_cu
.cu
= cu
;
12958 cu
->per_cu
= &type_sig
->per_cu
;
12960 /* If an error occurs while loading, release our storage. */
12961 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
12963 types_ptr
= read_type_comp_unit_head (&cu
->header
, &signature
,
12964 types_ptr
, objfile
->obfd
);
12965 gdb_assert (signature
== type_sig
->signature
);
12968 = htab_create_alloc_ex (cu
->header
.length
/ 12,
12972 &cu
->comp_unit_obstack
,
12973 hashtab_obstack_allocate
,
12974 dummy_obstack_deallocate
);
12976 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
12977 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
12979 init_cu_die_reader (&reader_specs
, cu
);
12981 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
12984 /* We try not to read any attributes in this function, because not
12985 all objfiles needed for references have been loaded yet, and symbol
12986 table processing isn't initialized. But we have to set the CU language,
12987 or we won't be able to build types correctly. */
12988 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
12990 set_cu_language (DW_UNSND (attr
), cu
);
12992 set_cu_language (language_minimal
, cu
);
12994 do_cleanups (back_to
);
12996 /* We've successfully allocated this compilation unit. Let our caller
12997 clean it up when finished with it. */
12998 discard_cleanups (free_cu_cleanup
);
13000 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
13001 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
13004 /* Decode simple location descriptions.
13005 Given a pointer to a dwarf block that defines a location, compute
13006 the location and return the value.
13008 NOTE drow/2003-11-18: This function is called in two situations
13009 now: for the address of static or global variables (partial symbols
13010 only) and for offsets into structures which are expected to be
13011 (more or less) constant. The partial symbol case should go away,
13012 and only the constant case should remain. That will let this
13013 function complain more accurately. A few special modes are allowed
13014 without complaint for global variables (for instance, global
13015 register values and thread-local values).
13017 A location description containing no operations indicates that the
13018 object is optimized out. The return value is 0 for that case.
13019 FIXME drow/2003-11-16: No callers check for this case any more; soon all
13020 callers will only want a very basic result and this can become a
13023 Note that stack[0] is unused except as a default error return.
13024 Note that stack overflow is not yet handled. */
13027 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
13029 struct objfile
*objfile
= cu
->objfile
;
13031 int size
= blk
->size
;
13032 gdb_byte
*data
= blk
->data
;
13033 CORE_ADDR stack
[64];
13035 unsigned int bytes_read
, unsnd
;
13079 stack
[++stacki
] = op
- DW_OP_lit0
;
13114 stack
[++stacki
] = op
- DW_OP_reg0
;
13116 dwarf2_complex_location_expr_complaint ();
13120 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
13122 stack
[++stacki
] = unsnd
;
13124 dwarf2_complex_location_expr_complaint ();
13128 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
13133 case DW_OP_const1u
:
13134 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
13138 case DW_OP_const1s
:
13139 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
13143 case DW_OP_const2u
:
13144 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
13148 case DW_OP_const2s
:
13149 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
13153 case DW_OP_const4u
:
13154 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
13158 case DW_OP_const4s
:
13159 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
13164 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
13170 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
13175 stack
[stacki
+ 1] = stack
[stacki
];
13180 stack
[stacki
- 1] += stack
[stacki
];
13184 case DW_OP_plus_uconst
:
13185 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
13190 stack
[stacki
- 1] -= stack
[stacki
];
13195 /* If we're not the last op, then we definitely can't encode
13196 this using GDB's address_class enum. This is valid for partial
13197 global symbols, although the variable's address will be bogus
13200 dwarf2_complex_location_expr_complaint ();
13203 case DW_OP_GNU_push_tls_address
:
13204 /* The top of the stack has the offset from the beginning
13205 of the thread control block at which the variable is located. */
13206 /* Nothing should follow this operator, so the top of stack would
13208 /* This is valid for partial global symbols, but the variable's
13209 address will be bogus in the psymtab. */
13211 dwarf2_complex_location_expr_complaint ();
13214 case DW_OP_GNU_uninit
:
13218 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
13219 dwarf_stack_op_name (op
, 1));
13220 return (stack
[stacki
]);
13223 return (stack
[stacki
]);
13226 /* memory allocation interface */
13228 static struct dwarf_block
*
13229 dwarf_alloc_block (struct dwarf2_cu
*cu
)
13231 struct dwarf_block
*blk
;
13233 blk
= (struct dwarf_block
*)
13234 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
13238 static struct abbrev_info
*
13239 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
13241 struct abbrev_info
*abbrev
;
13243 abbrev
= (struct abbrev_info
*)
13244 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
13245 memset (abbrev
, 0, sizeof (struct abbrev_info
));
13249 static struct die_info
*
13250 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
13252 struct die_info
*die
;
13253 size_t size
= sizeof (struct die_info
);
13256 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
13258 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
13259 memset (die
, 0, sizeof (struct die_info
));
13264 /* Macro support. */
13267 /* Return the full name of file number I in *LH's file name table.
13268 Use COMP_DIR as the name of the current directory of the
13269 compilation. The result is allocated using xmalloc; the caller is
13270 responsible for freeing it. */
13272 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
13274 /* Is the file number a valid index into the line header's file name
13275 table? Remember that file numbers start with one, not zero. */
13276 if (1 <= file
&& file
<= lh
->num_file_names
)
13278 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
13280 if (IS_ABSOLUTE_PATH (fe
->name
))
13281 return xstrdup (fe
->name
);
13289 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
13295 dir_len
= strlen (dir
);
13296 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
13297 strcpy (full_name
, dir
);
13298 full_name
[dir_len
] = '/';
13299 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
13303 return xstrdup (fe
->name
);
13308 /* The compiler produced a bogus file number. We can at least
13309 record the macro definitions made in the file, even if we
13310 won't be able to find the file by name. */
13311 char fake_name
[80];
13313 sprintf (fake_name
, "<bad macro file number %d>", file
);
13315 complaint (&symfile_complaints
,
13316 _("bad file number in macro information (%d)"),
13319 return xstrdup (fake_name
);
13324 static struct macro_source_file
*
13325 macro_start_file (int file
, int line
,
13326 struct macro_source_file
*current_file
,
13327 const char *comp_dir
,
13328 struct line_header
*lh
, struct objfile
*objfile
)
13330 /* The full name of this source file. */
13331 char *full_name
= file_full_name (file
, lh
, comp_dir
);
13333 /* We don't create a macro table for this compilation unit
13334 at all until we actually get a filename. */
13335 if (! pending_macros
)
13336 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
13337 objfile
->macro_cache
);
13339 if (! current_file
)
13340 /* If we have no current file, then this must be the start_file
13341 directive for the compilation unit's main source file. */
13342 current_file
= macro_set_main (pending_macros
, full_name
);
13344 current_file
= macro_include (current_file
, line
, full_name
);
13348 return current_file
;
13352 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
13353 followed by a null byte. */
13355 copy_string (const char *buf
, int len
)
13357 char *s
= xmalloc (len
+ 1);
13359 memcpy (s
, buf
, len
);
13365 static const char *
13366 consume_improper_spaces (const char *p
, const char *body
)
13370 complaint (&symfile_complaints
,
13371 _("macro definition contains spaces in formal argument list:\n`%s'"),
13383 parse_macro_definition (struct macro_source_file
*file
, int line
,
13388 /* The body string takes one of two forms. For object-like macro
13389 definitions, it should be:
13391 <macro name> " " <definition>
13393 For function-like macro definitions, it should be:
13395 <macro name> "() " <definition>
13397 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
13399 Spaces may appear only where explicitly indicated, and in the
13402 The Dwarf 2 spec says that an object-like macro's name is always
13403 followed by a space, but versions of GCC around March 2002 omit
13404 the space when the macro's definition is the empty string.
13406 The Dwarf 2 spec says that there should be no spaces between the
13407 formal arguments in a function-like macro's formal argument list,
13408 but versions of GCC around March 2002 include spaces after the
13412 /* Find the extent of the macro name. The macro name is terminated
13413 by either a space or null character (for an object-like macro) or
13414 an opening paren (for a function-like macro). */
13415 for (p
= body
; *p
; p
++)
13416 if (*p
== ' ' || *p
== '(')
13419 if (*p
== ' ' || *p
== '\0')
13421 /* It's an object-like macro. */
13422 int name_len
= p
- body
;
13423 char *name
= copy_string (body
, name_len
);
13424 const char *replacement
;
13427 replacement
= body
+ name_len
+ 1;
13430 dwarf2_macro_malformed_definition_complaint (body
);
13431 replacement
= body
+ name_len
;
13434 macro_define_object (file
, line
, name
, replacement
);
13438 else if (*p
== '(')
13440 /* It's a function-like macro. */
13441 char *name
= copy_string (body
, p
- body
);
13444 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
13448 p
= consume_improper_spaces (p
, body
);
13450 /* Parse the formal argument list. */
13451 while (*p
&& *p
!= ')')
13453 /* Find the extent of the current argument name. */
13454 const char *arg_start
= p
;
13456 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
13459 if (! *p
|| p
== arg_start
)
13460 dwarf2_macro_malformed_definition_complaint (body
);
13463 /* Make sure argv has room for the new argument. */
13464 if (argc
>= argv_size
)
13467 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
13470 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
13473 p
= consume_improper_spaces (p
, body
);
13475 /* Consume the comma, if present. */
13480 p
= consume_improper_spaces (p
, body
);
13489 /* Perfectly formed definition, no complaints. */
13490 macro_define_function (file
, line
, name
,
13491 argc
, (const char **) argv
,
13493 else if (*p
== '\0')
13495 /* Complain, but do define it. */
13496 dwarf2_macro_malformed_definition_complaint (body
);
13497 macro_define_function (file
, line
, name
,
13498 argc
, (const char **) argv
,
13502 /* Just complain. */
13503 dwarf2_macro_malformed_definition_complaint (body
);
13506 /* Just complain. */
13507 dwarf2_macro_malformed_definition_complaint (body
);
13513 for (i
= 0; i
< argc
; i
++)
13519 dwarf2_macro_malformed_definition_complaint (body
);
13524 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
13525 char *comp_dir
, bfd
*abfd
,
13526 struct dwarf2_cu
*cu
)
13528 gdb_byte
*mac_ptr
, *mac_end
;
13529 struct macro_source_file
*current_file
= 0;
13530 enum dwarf_macinfo_record_type macinfo_type
;
13531 int at_commandline
;
13533 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
13534 &dwarf2_per_objfile
->macinfo
);
13535 if (dwarf2_per_objfile
->macinfo
.buffer
== NULL
)
13537 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
13541 /* First pass: Find the name of the base filename.
13542 This filename is needed in order to process all macros whose definition
13543 (or undefinition) comes from the command line. These macros are defined
13544 before the first DW_MACINFO_start_file entry, and yet still need to be
13545 associated to the base file.
13547 To determine the base file name, we scan the macro definitions until we
13548 reach the first DW_MACINFO_start_file entry. We then initialize
13549 CURRENT_FILE accordingly so that any macro definition found before the
13550 first DW_MACINFO_start_file can still be associated to the base file. */
13552 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
13553 mac_end
= dwarf2_per_objfile
->macinfo
.buffer
13554 + dwarf2_per_objfile
->macinfo
.size
;
13558 /* Do we at least have room for a macinfo type byte? */
13559 if (mac_ptr
>= mac_end
)
13561 /* Complaint is printed during the second pass as GDB will probably
13562 stop the first pass earlier upon finding DW_MACINFO_start_file. */
13566 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
13569 switch (macinfo_type
)
13571 /* A zero macinfo type indicates the end of the macro
13576 case DW_MACINFO_define
:
13577 case DW_MACINFO_undef
:
13578 /* Only skip the data by MAC_PTR. */
13580 unsigned int bytes_read
;
13582 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13583 mac_ptr
+= bytes_read
;
13584 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13585 mac_ptr
+= bytes_read
;
13589 case DW_MACINFO_start_file
:
13591 unsigned int bytes_read
;
13594 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13595 mac_ptr
+= bytes_read
;
13596 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13597 mac_ptr
+= bytes_read
;
13599 current_file
= macro_start_file (file
, line
, current_file
, comp_dir
,
13604 case DW_MACINFO_end_file
:
13605 /* No data to skip by MAC_PTR. */
13608 case DW_MACINFO_vendor_ext
:
13609 /* Only skip the data by MAC_PTR. */
13611 unsigned int bytes_read
;
13613 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13614 mac_ptr
+= bytes_read
;
13615 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13616 mac_ptr
+= bytes_read
;
13623 } while (macinfo_type
!= 0 && current_file
== NULL
);
13625 /* Second pass: Process all entries.
13627 Use the AT_COMMAND_LINE flag to determine whether we are still processing
13628 command-line macro definitions/undefinitions. This flag is unset when we
13629 reach the first DW_MACINFO_start_file entry. */
13631 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
13633 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
13634 GDB is still reading the definitions from command line. First
13635 DW_MACINFO_start_file will need to be ignored as it was already executed
13636 to create CURRENT_FILE for the main source holding also the command line
13637 definitions. On first met DW_MACINFO_start_file this flag is reset to
13638 normally execute all the remaining DW_MACINFO_start_file macinfos. */
13640 at_commandline
= 1;
13644 /* Do we at least have room for a macinfo type byte? */
13645 if (mac_ptr
>= mac_end
)
13647 dwarf2_macros_too_long_complaint ();
13651 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
13654 switch (macinfo_type
)
13656 /* A zero macinfo type indicates the end of the macro
13661 case DW_MACINFO_define
:
13662 case DW_MACINFO_undef
:
13664 unsigned int bytes_read
;
13668 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13669 mac_ptr
+= bytes_read
;
13670 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13671 mac_ptr
+= bytes_read
;
13673 if (! current_file
)
13675 /* DWARF violation as no main source is present. */
13676 complaint (&symfile_complaints
,
13677 _("debug info with no main source gives macro %s "
13679 macinfo_type
== DW_MACINFO_define
?
13681 macinfo_type
== DW_MACINFO_undef
?
13682 _("undefinition") :
13683 _("something-or-other"), line
, body
);
13686 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
13687 complaint (&symfile_complaints
,
13688 _("debug info gives %s macro %s with %s line %d: %s"),
13689 at_commandline
? _("command-line") : _("in-file"),
13690 macinfo_type
== DW_MACINFO_define
?
13692 macinfo_type
== DW_MACINFO_undef
?
13693 _("undefinition") :
13694 _("something-or-other"),
13695 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
13697 if (macinfo_type
== DW_MACINFO_define
)
13698 parse_macro_definition (current_file
, line
, body
);
13699 else if (macinfo_type
== DW_MACINFO_undef
)
13700 macro_undef (current_file
, line
, body
);
13704 case DW_MACINFO_start_file
:
13706 unsigned int bytes_read
;
13709 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13710 mac_ptr
+= bytes_read
;
13711 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13712 mac_ptr
+= bytes_read
;
13714 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
13715 complaint (&symfile_complaints
,
13716 _("debug info gives source %d included "
13717 "from %s at %s line %d"),
13718 file
, at_commandline
? _("command-line") : _("file"),
13719 line
== 0 ? _("zero") : _("non-zero"), line
);
13721 if (at_commandline
)
13723 /* This DW_MACINFO_start_file was executed in the pass one. */
13724 at_commandline
= 0;
13727 current_file
= macro_start_file (file
, line
,
13728 current_file
, comp_dir
,
13733 case DW_MACINFO_end_file
:
13734 if (! current_file
)
13735 complaint (&symfile_complaints
,
13736 _("macro debug info has an unmatched `close_file' directive"));
13739 current_file
= current_file
->included_by
;
13740 if (! current_file
)
13742 enum dwarf_macinfo_record_type next_type
;
13744 /* GCC circa March 2002 doesn't produce the zero
13745 type byte marking the end of the compilation
13746 unit. Complain if it's not there, but exit no
13749 /* Do we at least have room for a macinfo type byte? */
13750 if (mac_ptr
>= mac_end
)
13752 dwarf2_macros_too_long_complaint ();
13756 /* We don't increment mac_ptr here, so this is just
13758 next_type
= read_1_byte (abfd
, mac_ptr
);
13759 if (next_type
!= 0)
13760 complaint (&symfile_complaints
,
13761 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
13768 case DW_MACINFO_vendor_ext
:
13770 unsigned int bytes_read
;
13774 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13775 mac_ptr
+= bytes_read
;
13776 string
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13777 mac_ptr
+= bytes_read
;
13779 /* We don't recognize any vendor extensions. */
13783 } while (macinfo_type
!= 0);
13786 /* Check if the attribute's form is a DW_FORM_block*
13787 if so return true else false. */
13789 attr_form_is_block (struct attribute
*attr
)
13791 return (attr
== NULL
? 0 :
13792 attr
->form
== DW_FORM_block1
13793 || attr
->form
== DW_FORM_block2
13794 || attr
->form
== DW_FORM_block4
13795 || attr
->form
== DW_FORM_block
13796 || attr
->form
== DW_FORM_exprloc
);
13799 /* Return non-zero if ATTR's value is a section offset --- classes
13800 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
13801 You may use DW_UNSND (attr) to retrieve such offsets.
13803 Section 7.5.4, "Attribute Encodings", explains that no attribute
13804 may have a value that belongs to more than one of these classes; it
13805 would be ambiguous if we did, because we use the same forms for all
13808 attr_form_is_section_offset (struct attribute
*attr
)
13810 return (attr
->form
== DW_FORM_data4
13811 || attr
->form
== DW_FORM_data8
13812 || attr
->form
== DW_FORM_sec_offset
);
13816 /* Return non-zero if ATTR's value falls in the 'constant' class, or
13817 zero otherwise. When this function returns true, you can apply
13818 dwarf2_get_attr_constant_value to it.
13820 However, note that for some attributes you must check
13821 attr_form_is_section_offset before using this test. DW_FORM_data4
13822 and DW_FORM_data8 are members of both the constant class, and of
13823 the classes that contain offsets into other debug sections
13824 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
13825 that, if an attribute's can be either a constant or one of the
13826 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
13827 taken as section offsets, not constants. */
13829 attr_form_is_constant (struct attribute
*attr
)
13831 switch (attr
->form
)
13833 case DW_FORM_sdata
:
13834 case DW_FORM_udata
:
13835 case DW_FORM_data1
:
13836 case DW_FORM_data2
:
13837 case DW_FORM_data4
:
13838 case DW_FORM_data8
:
13846 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
13847 struct dwarf2_cu
*cu
)
13849 if (attr_form_is_section_offset (attr
)
13850 /* ".debug_loc" may not exist at all, or the offset may be outside
13851 the section. If so, fall through to the complaint in the
13853 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc
.size
)
13855 struct dwarf2_loclist_baton
*baton
;
13857 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
13858 sizeof (struct dwarf2_loclist_baton
));
13859 baton
->per_cu
= cu
->per_cu
;
13860 gdb_assert (baton
->per_cu
);
13862 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
13863 &dwarf2_per_objfile
->loc
);
13865 /* We don't know how long the location list is, but make sure we
13866 don't run off the edge of the section. */
13867 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
13868 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
13869 baton
->base_address
= cu
->base_address
;
13870 if (cu
->base_known
== 0)
13871 complaint (&symfile_complaints
,
13872 _("Location list used without specifying the CU base address."));
13874 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
13875 SYMBOL_LOCATION_BATON (sym
) = baton
;
13879 struct dwarf2_locexpr_baton
*baton
;
13881 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
13882 sizeof (struct dwarf2_locexpr_baton
));
13883 baton
->per_cu
= cu
->per_cu
;
13884 gdb_assert (baton
->per_cu
);
13886 if (attr_form_is_block (attr
))
13888 /* Note that we're just copying the block's data pointer
13889 here, not the actual data. We're still pointing into the
13890 info_buffer for SYM's objfile; right now we never release
13891 that buffer, but when we do clean up properly this may
13893 baton
->size
= DW_BLOCK (attr
)->size
;
13894 baton
->data
= DW_BLOCK (attr
)->data
;
13898 dwarf2_invalid_attrib_class_complaint ("location description",
13899 SYMBOL_NATURAL_NAME (sym
));
13901 baton
->data
= NULL
;
13904 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
13905 SYMBOL_LOCATION_BATON (sym
) = baton
;
13909 /* Return the OBJFILE associated with the compilation unit CU. If CU
13910 came from a separate debuginfo file, then the master objfile is
13914 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
13916 struct objfile
*objfile
= per_cu
->objfile
;
13918 /* Return the master objfile, so that we can report and look up the
13919 correct file containing this variable. */
13920 if (objfile
->separate_debug_objfile_backlink
)
13921 objfile
= objfile
->separate_debug_objfile_backlink
;
13926 /* Return the address size given in the compilation unit header for CU. */
13929 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
13932 return per_cu
->cu
->header
.addr_size
;
13935 /* If the CU is not currently read in, we re-read its header. */
13936 struct objfile
*objfile
= per_cu
->objfile
;
13937 struct dwarf2_per_objfile
*per_objfile
13938 = objfile_data (objfile
, dwarf2_objfile_data_key
);
13939 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
13940 struct comp_unit_head cu_header
;
13942 memset (&cu_header
, 0, sizeof cu_header
);
13943 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
13944 return cu_header
.addr_size
;
13948 /* Return the offset size given in the compilation unit header for CU. */
13951 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
13954 return per_cu
->cu
->header
.offset_size
;
13957 /* If the CU is not currently read in, we re-read its header. */
13958 struct objfile
*objfile
= per_cu
->objfile
;
13959 struct dwarf2_per_objfile
*per_objfile
13960 = objfile_data (objfile
, dwarf2_objfile_data_key
);
13961 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
13962 struct comp_unit_head cu_header
;
13964 memset (&cu_header
, 0, sizeof cu_header
);
13965 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
13966 return cu_header
.offset_size
;
13970 /* Return the text offset of the CU. The returned offset comes from
13971 this CU's objfile. If this objfile came from a separate debuginfo
13972 file, then the offset may be different from the corresponding
13973 offset in the parent objfile. */
13976 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
13978 struct objfile
*objfile
= per_cu
->objfile
;
13980 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13983 /* Locate the .debug_info compilation unit from CU's objfile which contains
13984 the DIE at OFFSET. Raises an error on failure. */
13986 static struct dwarf2_per_cu_data
*
13987 dwarf2_find_containing_comp_unit (unsigned int offset
,
13988 struct objfile
*objfile
)
13990 struct dwarf2_per_cu_data
*this_cu
;
13994 high
= dwarf2_per_objfile
->n_comp_units
- 1;
13997 int mid
= low
+ (high
- low
) / 2;
13999 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
14004 gdb_assert (low
== high
);
14005 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
14008 error (_("Dwarf Error: could not find partial DIE containing "
14009 "offset 0x%lx [in module %s]"),
14010 (long) offset
, bfd_get_filename (objfile
->obfd
));
14012 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
14013 return dwarf2_per_objfile
->all_comp_units
[low
-1];
14017 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
14018 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
14019 && offset
>= this_cu
->offset
+ this_cu
->length
)
14020 error (_("invalid dwarf2 offset %u"), offset
);
14021 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
14026 /* Locate the compilation unit from OBJFILE which is located at exactly
14027 OFFSET. Raises an error on failure. */
14029 static struct dwarf2_per_cu_data
*
14030 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
14032 struct dwarf2_per_cu_data
*this_cu
;
14034 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
14035 if (this_cu
->offset
!= offset
)
14036 error (_("no compilation unit with offset %u."), offset
);
14040 /* Malloc space for a dwarf2_cu for OBJFILE and initialize it. */
14042 static struct dwarf2_cu
*
14043 alloc_one_comp_unit (struct objfile
*objfile
)
14045 struct dwarf2_cu
*cu
= xcalloc (1, sizeof (struct dwarf2_cu
));
14046 cu
->objfile
= objfile
;
14047 obstack_init (&cu
->comp_unit_obstack
);
14051 /* Release one cached compilation unit, CU. We unlink it from the tree
14052 of compilation units, but we don't remove it from the read_in_chain;
14053 the caller is responsible for that.
14054 NOTE: DATA is a void * because this function is also used as a
14055 cleanup routine. */
14058 free_one_comp_unit (void *data
)
14060 struct dwarf2_cu
*cu
= data
;
14062 if (cu
->per_cu
!= NULL
)
14063 cu
->per_cu
->cu
= NULL
;
14066 obstack_free (&cu
->comp_unit_obstack
, NULL
);
14071 /* This cleanup function is passed the address of a dwarf2_cu on the stack
14072 when we're finished with it. We can't free the pointer itself, but be
14073 sure to unlink it from the cache. Also release any associated storage
14074 and perform cache maintenance.
14076 Only used during partial symbol parsing. */
14079 free_stack_comp_unit (void *data
)
14081 struct dwarf2_cu
*cu
= data
;
14083 obstack_free (&cu
->comp_unit_obstack
, NULL
);
14084 cu
->partial_dies
= NULL
;
14086 if (cu
->per_cu
!= NULL
)
14088 /* This compilation unit is on the stack in our caller, so we
14089 should not xfree it. Just unlink it. */
14090 cu
->per_cu
->cu
= NULL
;
14093 /* If we had a per-cu pointer, then we may have other compilation
14094 units loaded, so age them now. */
14095 age_cached_comp_units ();
14099 /* Free all cached compilation units. */
14102 free_cached_comp_units (void *data
)
14104 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
14106 per_cu
= dwarf2_per_objfile
->read_in_chain
;
14107 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
14108 while (per_cu
!= NULL
)
14110 struct dwarf2_per_cu_data
*next_cu
;
14112 next_cu
= per_cu
->cu
->read_in_chain
;
14114 free_one_comp_unit (per_cu
->cu
);
14115 *last_chain
= next_cu
;
14121 /* Increase the age counter on each cached compilation unit, and free
14122 any that are too old. */
14125 age_cached_comp_units (void)
14127 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
14129 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
14130 per_cu
= dwarf2_per_objfile
->read_in_chain
;
14131 while (per_cu
!= NULL
)
14133 per_cu
->cu
->last_used
++;
14134 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
14135 dwarf2_mark (per_cu
->cu
);
14136 per_cu
= per_cu
->cu
->read_in_chain
;
14139 per_cu
= dwarf2_per_objfile
->read_in_chain
;
14140 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
14141 while (per_cu
!= NULL
)
14143 struct dwarf2_per_cu_data
*next_cu
;
14145 next_cu
= per_cu
->cu
->read_in_chain
;
14147 if (!per_cu
->cu
->mark
)
14149 free_one_comp_unit (per_cu
->cu
);
14150 *last_chain
= next_cu
;
14153 last_chain
= &per_cu
->cu
->read_in_chain
;
14159 /* Remove a single compilation unit from the cache. */
14162 free_one_cached_comp_unit (void *target_cu
)
14164 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
14166 per_cu
= dwarf2_per_objfile
->read_in_chain
;
14167 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
14168 while (per_cu
!= NULL
)
14170 struct dwarf2_per_cu_data
*next_cu
;
14172 next_cu
= per_cu
->cu
->read_in_chain
;
14174 if (per_cu
->cu
== target_cu
)
14176 free_one_comp_unit (per_cu
->cu
);
14177 *last_chain
= next_cu
;
14181 last_chain
= &per_cu
->cu
->read_in_chain
;
14187 /* Release all extra memory associated with OBJFILE. */
14190 dwarf2_free_objfile (struct objfile
*objfile
)
14192 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
14194 if (dwarf2_per_objfile
== NULL
)
14197 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
14198 free_cached_comp_units (NULL
);
14200 if (dwarf2_per_objfile
->using_index
)
14204 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
14207 struct dwarf2_per_cu_data
*cu
= dwarf2_per_objfile
->all_comp_units
[i
];
14209 if (!cu
->v
.quick
->lines
)
14212 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
14214 if (cu
->v
.quick
->file_names
)
14215 xfree ((void *) cu
->v
.quick
->file_names
[j
]);
14216 if (cu
->v
.quick
->full_names
)
14217 xfree ((void *) cu
->v
.quick
->full_names
[j
]);
14220 free_line_header (cu
->v
.quick
->lines
);
14224 /* Everything else should be on the objfile obstack. */
14227 /* A pair of DIE offset and GDB type pointer. We store these
14228 in a hash table separate from the DIEs, and preserve them
14229 when the DIEs are flushed out of cache. */
14231 struct dwarf2_offset_and_type
14233 unsigned int offset
;
14237 /* Hash function for a dwarf2_offset_and_type. */
14240 offset_and_type_hash (const void *item
)
14242 const struct dwarf2_offset_and_type
*ofs
= item
;
14244 return ofs
->offset
;
14247 /* Equality function for a dwarf2_offset_and_type. */
14250 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
14252 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
14253 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
14255 return ofs_lhs
->offset
== ofs_rhs
->offset
;
14258 /* Set the type associated with DIE to TYPE. Save it in CU's hash
14259 table if necessary. For convenience, return TYPE.
14261 The DIEs reading must have careful ordering to:
14262 * Not cause infite loops trying to read in DIEs as a prerequisite for
14263 reading current DIE.
14264 * Not trying to dereference contents of still incompletely read in types
14265 while reading in other DIEs.
14266 * Enable referencing still incompletely read in types just by a pointer to
14267 the type without accessing its fields.
14269 Therefore caller should follow these rules:
14270 * Try to fetch any prerequisite types we may need to build this DIE type
14271 before building the type and calling set_die_type.
14272 * After building type call set_die_type for current DIE as soon as
14273 possible before fetching more types to complete the current type.
14274 * Make the type as complete as possible before fetching more types. */
14276 static struct type
*
14277 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
14279 struct dwarf2_offset_and_type
**slot
, ofs
;
14280 struct objfile
*objfile
= cu
->objfile
;
14281 htab_t
*type_hash_ptr
;
14283 /* For Ada types, make sure that the gnat-specific data is always
14284 initialized (if not already set). There are a few types where
14285 we should not be doing so, because the type-specific area is
14286 already used to hold some other piece of info (eg: TYPE_CODE_FLT
14287 where the type-specific area is used to store the floatformat).
14288 But this is not a problem, because the gnat-specific information
14289 is actually not needed for these types. */
14290 if (need_gnat_info (cu
)
14291 && TYPE_CODE (type
) != TYPE_CODE_FUNC
14292 && TYPE_CODE (type
) != TYPE_CODE_FLT
14293 && !HAVE_GNAT_AUX_INFO (type
))
14294 INIT_GNAT_SPECIFIC (type
);
14296 if (cu
->per_cu
->from_debug_types
)
14297 type_hash_ptr
= &dwarf2_per_objfile
->debug_types_type_hash
;
14299 type_hash_ptr
= &dwarf2_per_objfile
->debug_info_type_hash
;
14301 if (*type_hash_ptr
== NULL
)
14304 = htab_create_alloc_ex (127,
14305 offset_and_type_hash
,
14306 offset_and_type_eq
,
14308 &objfile
->objfile_obstack
,
14309 hashtab_obstack_allocate
,
14310 dummy_obstack_deallocate
);
14313 ofs
.offset
= die
->offset
;
14315 slot
= (struct dwarf2_offset_and_type
**)
14316 htab_find_slot_with_hash (*type_hash_ptr
, &ofs
, ofs
.offset
, INSERT
);
14318 complaint (&symfile_complaints
,
14319 _("A problem internal to GDB: DIE 0x%x has type already set"),
14321 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
14326 /* Look up the type for the die at DIE_OFFSET in the appropriate type_hash
14327 table, or return NULL if the die does not have a saved type. */
14329 static struct type
*
14330 get_die_type_at_offset (unsigned int offset
,
14331 struct dwarf2_per_cu_data
*per_cu
)
14333 struct dwarf2_offset_and_type
*slot
, ofs
;
14336 if (per_cu
->from_debug_types
)
14337 type_hash
= dwarf2_per_objfile
->debug_types_type_hash
;
14339 type_hash
= dwarf2_per_objfile
->debug_info_type_hash
;
14340 if (type_hash
== NULL
)
14343 ofs
.offset
= offset
;
14344 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
14351 /* Look up the type for DIE in the appropriate type_hash table,
14352 or return NULL if DIE does not have a saved type. */
14354 static struct type
*
14355 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14357 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
14360 /* Add a dependence relationship from CU to REF_PER_CU. */
14363 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
14364 struct dwarf2_per_cu_data
*ref_per_cu
)
14368 if (cu
->dependencies
== NULL
)
14370 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
14371 NULL
, &cu
->comp_unit_obstack
,
14372 hashtab_obstack_allocate
,
14373 dummy_obstack_deallocate
);
14375 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
14377 *slot
= ref_per_cu
;
14380 /* Subroutine of dwarf2_mark to pass to htab_traverse.
14381 Set the mark field in every compilation unit in the
14382 cache that we must keep because we are keeping CU. */
14385 dwarf2_mark_helper (void **slot
, void *data
)
14387 struct dwarf2_per_cu_data
*per_cu
;
14389 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
14390 if (per_cu
->cu
->mark
)
14392 per_cu
->cu
->mark
= 1;
14394 if (per_cu
->cu
->dependencies
!= NULL
)
14395 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
14400 /* Set the mark field in CU and in every other compilation unit in the
14401 cache that we must keep because we are keeping CU. */
14404 dwarf2_mark (struct dwarf2_cu
*cu
)
14409 if (cu
->dependencies
!= NULL
)
14410 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
14414 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
14418 per_cu
->cu
->mark
= 0;
14419 per_cu
= per_cu
->cu
->read_in_chain
;
14423 /* Trivial hash function for partial_die_info: the hash value of a DIE
14424 is its offset in .debug_info for this objfile. */
14427 partial_die_hash (const void *item
)
14429 const struct partial_die_info
*part_die
= item
;
14431 return part_die
->offset
;
14434 /* Trivial comparison function for partial_die_info structures: two DIEs
14435 are equal if they have the same offset. */
14438 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
14440 const struct partial_die_info
*part_die_lhs
= item_lhs
;
14441 const struct partial_die_info
*part_die_rhs
= item_rhs
;
14443 return part_die_lhs
->offset
== part_die_rhs
->offset
;
14446 static struct cmd_list_element
*set_dwarf2_cmdlist
;
14447 static struct cmd_list_element
*show_dwarf2_cmdlist
;
14450 set_dwarf2_cmd (char *args
, int from_tty
)
14452 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
14456 show_dwarf2_cmd (char *args
, int from_tty
)
14458 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
14461 /* If section described by INFO was mmapped, munmap it now. */
14464 munmap_section_buffer (struct dwarf2_section_info
*info
)
14466 if (info
->was_mmapped
)
14469 intptr_t begin
= (intptr_t) info
->buffer
;
14470 intptr_t map_begin
= begin
& ~(pagesize
- 1);
14471 size_t map_length
= info
->size
+ begin
- map_begin
;
14473 gdb_assert (munmap ((void *) map_begin
, map_length
) == 0);
14475 /* Without HAVE_MMAP, we should never be here to begin with. */
14476 gdb_assert_not_reached ("no mmap support");
14481 /* munmap debug sections for OBJFILE, if necessary. */
14484 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
14486 struct dwarf2_per_objfile
*data
= d
;
14488 munmap_section_buffer (&data
->info
);
14489 munmap_section_buffer (&data
->abbrev
);
14490 munmap_section_buffer (&data
->line
);
14491 munmap_section_buffer (&data
->str
);
14492 munmap_section_buffer (&data
->macinfo
);
14493 munmap_section_buffer (&data
->ranges
);
14494 munmap_section_buffer (&data
->loc
);
14495 munmap_section_buffer (&data
->frame
);
14496 munmap_section_buffer (&data
->eh_frame
);
14497 munmap_section_buffer (&data
->gdb_index
);
14502 /* The contents of the hash table we create when building the string
14504 struct strtab_entry
14506 offset_type offset
;
14510 /* Hash function for a strtab_entry. */
14512 hash_strtab_entry (const void *e
)
14514 const struct strtab_entry
*entry
= e
;
14515 return mapped_index_string_hash (entry
->str
);
14518 /* Equality function for a strtab_entry. */
14520 eq_strtab_entry (const void *a
, const void *b
)
14522 const struct strtab_entry
*ea
= a
;
14523 const struct strtab_entry
*eb
= b
;
14524 return !strcmp (ea
->str
, eb
->str
);
14527 /* Create a strtab_entry hash table. */
14529 create_strtab (void)
14531 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
14532 xfree
, xcalloc
, xfree
);
14535 /* Add a string to the constant pool. Return the string's offset in
14538 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
14541 struct strtab_entry entry
;
14542 struct strtab_entry
*result
;
14545 slot
= htab_find_slot (table
, &entry
, INSERT
);
14550 result
= XNEW (struct strtab_entry
);
14551 result
->offset
= obstack_object_size (cpool
);
14553 obstack_grow_str0 (cpool
, str
);
14556 return result
->offset
;
14559 /* An entry in the symbol table. */
14560 struct symtab_index_entry
14562 /* The name of the symbol. */
14564 /* The offset of the name in the constant pool. */
14565 offset_type index_offset
;
14566 /* A sorted vector of the indices of all the CUs that hold an object
14568 VEC (offset_type
) *cu_indices
;
14571 /* The symbol table. This is a power-of-2-sized hash table. */
14572 struct mapped_symtab
14574 offset_type n_elements
;
14576 struct symtab_index_entry
**data
;
14579 /* Hash function for a symtab_index_entry. */
14581 hash_symtab_entry (const void *e
)
14583 const struct symtab_index_entry
*entry
= e
;
14584 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
14585 sizeof (offset_type
) * VEC_length (offset_type
,
14586 entry
->cu_indices
),
14590 /* Equality function for a symtab_index_entry. */
14592 eq_symtab_entry (const void *a
, const void *b
)
14594 const struct symtab_index_entry
*ea
= a
;
14595 const struct symtab_index_entry
*eb
= b
;
14596 int len
= VEC_length (offset_type
, ea
->cu_indices
);
14597 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
14599 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
14600 VEC_address (offset_type
, eb
->cu_indices
),
14601 sizeof (offset_type
) * len
);
14604 /* Destroy a symtab_index_entry. */
14606 delete_symtab_entry (void *p
)
14608 struct symtab_index_entry
*entry
= p
;
14609 VEC_free (offset_type
, entry
->cu_indices
);
14613 /* Create a hash table holding symtab_index_entry objects. */
14615 create_index_table (void)
14617 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
14618 delete_symtab_entry
, xcalloc
, xfree
);
14621 /* Create a new mapped symtab object. */
14622 static struct mapped_symtab
*
14623 create_mapped_symtab (void)
14625 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
14626 symtab
->n_elements
= 0;
14627 symtab
->size
= 1024;
14628 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
14632 /* Destroy a mapped_symtab. */
14634 cleanup_mapped_symtab (void *p
)
14636 struct mapped_symtab
*symtab
= p
;
14637 /* The contents of the array are freed when the other hash table is
14639 xfree (symtab
->data
);
14643 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
14645 static struct symtab_index_entry
**
14646 find_slot (struct mapped_symtab
*symtab
, const char *name
)
14648 offset_type index
, step
, hash
= mapped_index_string_hash (name
);
14650 index
= hash
& (symtab
->size
- 1);
14651 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
14655 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
14656 return &symtab
->data
[index
];
14657 index
= (index
+ step
) & (symtab
->size
- 1);
14661 /* Expand SYMTAB's hash table. */
14663 hash_expand (struct mapped_symtab
*symtab
)
14665 offset_type old_size
= symtab
->size
;
14667 struct symtab_index_entry
**old_entries
= symtab
->data
;
14670 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
14672 for (i
= 0; i
< old_size
; ++i
)
14674 if (old_entries
[i
])
14676 struct symtab_index_entry
**slot
= find_slot (symtab
,
14677 old_entries
[i
]->name
);
14678 *slot
= old_entries
[i
];
14682 xfree (old_entries
);
14685 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
14686 is the index of the CU in which the symbol appears. */
14688 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
14689 offset_type cu_index
)
14691 struct symtab_index_entry
**slot
;
14693 ++symtab
->n_elements
;
14694 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
14695 hash_expand (symtab
);
14697 slot
= find_slot (symtab
, name
);
14700 *slot
= XNEW (struct symtab_index_entry
);
14701 (*slot
)->name
= name
;
14702 (*slot
)->cu_indices
= NULL
;
14704 /* Don't push an index twice. Due to how we add entries we only
14705 have to check the last one. */
14706 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
14707 || VEC_length (offset_type
, (*slot
)->cu_indices
) != cu_index
)
14708 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
14711 /* Add a vector of indices to the constant pool. */
14713 add_indices_to_cpool (htab_t index_table
, struct obstack
*cpool
,
14714 struct symtab_index_entry
*entry
)
14718 slot
= htab_find_slot (index_table
, entry
, INSERT
);
14721 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
14722 offset_type val
= MAYBE_SWAP (len
);
14727 entry
->index_offset
= obstack_object_size (cpool
);
14729 obstack_grow (cpool
, &val
, sizeof (val
));
14731 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
14734 val
= MAYBE_SWAP (iter
);
14735 obstack_grow (cpool
, &val
, sizeof (val
));
14740 struct symtab_index_entry
*old_entry
= *slot
;
14741 entry
->index_offset
= old_entry
->index_offset
;
14744 return entry
->index_offset
;
14747 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
14748 constant pool entries going into the obstack CPOOL. */
14750 write_hash_table (struct mapped_symtab
*symtab
,
14751 struct obstack
*output
, struct obstack
*cpool
)
14754 htab_t index_table
;
14757 index_table
= create_index_table ();
14758 str_table
= create_strtab ();
14759 /* We add all the index vectors to the constant pool first, to
14760 ensure alignment is ok. */
14761 for (i
= 0; i
< symtab
->size
; ++i
)
14763 if (symtab
->data
[i
])
14764 add_indices_to_cpool (index_table
, cpool
, symtab
->data
[i
]);
14767 /* Now write out the hash table. */
14768 for (i
= 0; i
< symtab
->size
; ++i
)
14770 offset_type str_off
, vec_off
;
14772 if (symtab
->data
[i
])
14774 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
14775 vec_off
= symtab
->data
[i
]->index_offset
;
14779 /* While 0 is a valid constant pool index, it is not valid
14780 to have 0 for both offsets. */
14785 str_off
= MAYBE_SWAP (str_off
);
14786 vec_off
= MAYBE_SWAP (vec_off
);
14788 obstack_grow (output
, &str_off
, sizeof (str_off
));
14789 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
14792 htab_delete (str_table
);
14793 htab_delete (index_table
);
14796 /* Write an address entry to ADDR_OBSTACK. The addresses are taken
14797 from PST; CU_INDEX is the index of the CU in the vector of all
14800 add_address_entry (struct objfile
*objfile
,
14801 struct obstack
*addr_obstack
, struct partial_symtab
*pst
,
14802 unsigned int cu_index
)
14804 offset_type offset
;
14806 CORE_ADDR baseaddr
;
14808 /* Don't bother recording empty ranges. */
14809 if (pst
->textlow
== pst
->texthigh
)
14812 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14814 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, pst
->textlow
- baseaddr
);
14815 obstack_grow (addr_obstack
, addr
, 8);
14816 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, pst
->texthigh
- baseaddr
);
14817 obstack_grow (addr_obstack
, addr
, 8);
14818 offset
= MAYBE_SWAP (cu_index
);
14819 obstack_grow (addr_obstack
, &offset
, sizeof (offset_type
));
14822 /* Add a list of partial symbols to SYMTAB. */
14824 write_psymbols (struct mapped_symtab
*symtab
,
14825 struct partial_symbol
**psymp
,
14827 offset_type cu_index
)
14829 for (; count
-- > 0; ++psymp
)
14831 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
14832 error (_("Ada is not currently supported by the index"));
14833 add_index_entry (symtab
, SYMBOL_NATURAL_NAME (*psymp
), cu_index
);
14837 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
14838 exception if there is an error. */
14840 write_obstack (FILE *file
, struct obstack
*obstack
)
14842 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
14844 != obstack_object_size (obstack
))
14845 error (_("couldn't data write to file"));
14848 /* Unlink a file if the argument is not NULL. */
14850 unlink_if_set (void *p
)
14852 char **filename
= p
;
14854 unlink (*filename
);
14857 /* A helper struct used when iterating over debug_types. */
14858 struct signatured_type_index_data
14860 struct objfile
*objfile
;
14861 struct mapped_symtab
*symtab
;
14862 struct obstack
*types_list
;
14866 /* A helper function that writes a single signatured_type to an
14869 write_one_signatured_type (void **slot
, void *d
)
14871 struct signatured_type_index_data
*info
= d
;
14872 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
14873 struct dwarf2_per_cu_data
*cu
= &entry
->per_cu
;
14874 struct partial_symtab
*psymtab
= cu
->v
.psymtab
;
14877 write_psymbols (info
->symtab
,
14878 info
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
14879 psymtab
->n_global_syms
, info
->cu_index
);
14880 write_psymbols (info
->symtab
,
14881 info
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
14882 psymtab
->n_static_syms
, info
->cu_index
);
14884 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->offset
);
14885 obstack_grow (info
->types_list
, val
, 8);
14886 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->type_offset
);
14887 obstack_grow (info
->types_list
, val
, 8);
14888 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
14889 obstack_grow (info
->types_list
, val
, 8);
14896 /* Create an index file for OBJFILE in the directory DIR. */
14898 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
14900 struct cleanup
*cleanup
;
14901 char *filename
, *cleanup_filename
;
14902 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
14903 struct obstack cu_list
, types_cu_list
;
14906 struct mapped_symtab
*symtab
;
14907 offset_type val
, size_of_contents
, total_len
;
14911 if (!objfile
->psymtabs
)
14913 if (dwarf2_per_objfile
->using_index
)
14914 error (_("Cannot use an index to create the index"));
14916 if (stat (objfile
->name
, &st
) < 0)
14917 perror_with_name (_("Could not stat"));
14919 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
14920 INDEX_SUFFIX
, (char *) NULL
);
14921 cleanup
= make_cleanup (xfree
, filename
);
14923 out_file
= fopen (filename
, "wb");
14925 error (_("Can't open `%s' for writing"), filename
);
14927 cleanup_filename
= filename
;
14928 make_cleanup (unlink_if_set
, &cleanup_filename
);
14930 symtab
= create_mapped_symtab ();
14931 make_cleanup (cleanup_mapped_symtab
, symtab
);
14933 obstack_init (&addr_obstack
);
14934 make_cleanup_obstack_free (&addr_obstack
);
14936 obstack_init (&cu_list
);
14937 make_cleanup_obstack_free (&cu_list
);
14939 obstack_init (&types_cu_list
);
14940 make_cleanup_obstack_free (&types_cu_list
);
14942 /* The list is already sorted, so we don't need to do additional
14943 work here. Also, the debug_types entries do not appear in
14944 all_comp_units, but only in their own hash table. */
14945 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
14947 struct dwarf2_per_cu_data
*cu
= dwarf2_per_objfile
->all_comp_units
[i
];
14948 struct partial_symtab
*psymtab
= cu
->v
.psymtab
;
14951 write_psymbols (symtab
,
14952 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
14953 psymtab
->n_global_syms
, i
);
14954 write_psymbols (symtab
,
14955 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
14956 psymtab
->n_static_syms
, i
);
14958 add_address_entry (objfile
, &addr_obstack
, psymtab
, i
);
14960 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, cu
->offset
);
14961 obstack_grow (&cu_list
, val
, 8);
14962 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, cu
->length
);
14963 obstack_grow (&cu_list
, val
, 8);
14966 /* Write out the .debug_type entries, if any. */
14967 if (dwarf2_per_objfile
->signatured_types
)
14969 struct signatured_type_index_data sig_data
;
14971 sig_data
.objfile
= objfile
;
14972 sig_data
.symtab
= symtab
;
14973 sig_data
.types_list
= &types_cu_list
;
14974 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
14975 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
14976 write_one_signatured_type
, &sig_data
);
14979 obstack_init (&constant_pool
);
14980 make_cleanup_obstack_free (&constant_pool
);
14981 obstack_init (&symtab_obstack
);
14982 make_cleanup_obstack_free (&symtab_obstack
);
14983 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
14985 obstack_init (&contents
);
14986 make_cleanup_obstack_free (&contents
);
14987 size_of_contents
= 6 * sizeof (offset_type
);
14988 total_len
= size_of_contents
;
14990 /* The version number. */
14991 val
= MAYBE_SWAP (2);
14992 obstack_grow (&contents
, &val
, sizeof (val
));
14994 /* The offset of the CU list from the start of the file. */
14995 val
= MAYBE_SWAP (total_len
);
14996 obstack_grow (&contents
, &val
, sizeof (val
));
14997 total_len
+= obstack_object_size (&cu_list
);
14999 /* The offset of the types CU list from the start of the file. */
15000 val
= MAYBE_SWAP (total_len
);
15001 obstack_grow (&contents
, &val
, sizeof (val
));
15002 total_len
+= obstack_object_size (&types_cu_list
);
15004 /* The offset of the address table from the start of the file. */
15005 val
= MAYBE_SWAP (total_len
);
15006 obstack_grow (&contents
, &val
, sizeof (val
));
15007 total_len
+= obstack_object_size (&addr_obstack
);
15009 /* The offset of the symbol table from the start of the file. */
15010 val
= MAYBE_SWAP (total_len
);
15011 obstack_grow (&contents
, &val
, sizeof (val
));
15012 total_len
+= obstack_object_size (&symtab_obstack
);
15014 /* The offset of the constant pool from the start of the file. */
15015 val
= MAYBE_SWAP (total_len
);
15016 obstack_grow (&contents
, &val
, sizeof (val
));
15017 total_len
+= obstack_object_size (&constant_pool
);
15019 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
15021 write_obstack (out_file
, &contents
);
15022 write_obstack (out_file
, &cu_list
);
15023 write_obstack (out_file
, &types_cu_list
);
15024 write_obstack (out_file
, &addr_obstack
);
15025 write_obstack (out_file
, &symtab_obstack
);
15026 write_obstack (out_file
, &constant_pool
);
15030 /* We want to keep the file, so we set cleanup_filename to NULL
15031 here. See unlink_if_set. */
15032 cleanup_filename
= NULL
;
15034 do_cleanups (cleanup
);
15037 /* The mapped index file format is designed to be directly mmap()able
15038 on any architecture. In most cases, a datum is represented using a
15039 little-endian 32-bit integer value, called an offset_type. Big
15040 endian machines must byte-swap the values before using them.
15041 Exceptions to this rule are noted. The data is laid out such that
15042 alignment is always respected.
15044 A mapped index consists of several sections.
15046 1. The file header. This is a sequence of values, of offset_type
15047 unless otherwise noted:
15048 [0] The version number. Currently 1 or 2. The differences are
15049 noted below. Version 1 did not account for .debug_types sections;
15050 the presence of a .debug_types section invalidates any version 1
15051 index that may exist.
15052 [1] The offset, from the start of the file, of the CU list.
15053 [1.5] In version 2, the offset, from the start of the file, of the
15054 types CU list. This offset does not appear in version 1. Note
15055 that this can be empty, in which case this offset will be equal to
15057 [2] The offset, from the start of the file, of the address section.
15058 [3] The offset, from the start of the file, of the symbol table.
15059 [4] The offset, from the start of the file, of the constant pool.
15061 2. The CU list. This is a sequence of pairs of 64-bit
15062 little-endian values, sorted by the CU offset. The first element
15063 in each pair is the offset of a CU in the .debug_info section. The
15064 second element in each pair is the length of that CU. References
15065 to a CU elsewhere in the map are done using a CU index, which is
15066 just the 0-based index into this table. Note that if there are
15067 type CUs, then conceptually CUs and type CUs form a single list for
15068 the purposes of CU indices.
15070 2.5 The types CU list. This does not appear in a version 1 index.
15071 This is a sequence of triplets of 64-bit little-endian values. In
15072 a triplet, the first value is the CU offset, the second value is
15073 the type offset in the CU, and the third value is the type
15074 signature. The types CU list is not sorted.
15076 3. The address section. The address section consists of a sequence
15077 of address entries. Each address entry has three elements.
15078 [0] The low address. This is a 64-bit little-endian value.
15079 [1] The high address. This is a 64-bit little-endian value.
15080 [2] The CU index. This is an offset_type value.
15082 4. The symbol table. This is a hash table. The size of the hash
15083 table is always a power of 2. The initial hash and the step are
15084 currently defined by the `find_slot' function.
15086 Each slot in the hash table consists of a pair of offset_type
15087 values. The first value is the offset of the symbol's name in the
15088 constant pool. The second value is the offset of the CU vector in
15091 If both values are 0, then this slot in the hash table is empty.
15092 This is ok because while 0 is a valid constant pool index, it
15093 cannot be a valid index for both a string and a CU vector.
15095 A string in the constant pool is stored as a \0-terminated string,
15098 A CU vector in the constant pool is a sequence of offset_type
15099 values. The first value is the number of CU indices in the vector.
15100 Each subsequent value is the index of a CU in the CU list. This
15101 element in the hash table is used to indicate which CUs define the
15104 5. The constant pool. This is simply a bunch of bytes. It is
15105 organized so that alignment is correct: CU vectors are stored
15106 first, followed by strings. */
15108 save_gdb_index_command (char *arg
, int from_tty
)
15110 struct objfile
*objfile
;
15113 error (_("usage: save gdb-index DIRECTORY"));
15115 ALL_OBJFILES (objfile
)
15119 /* If the objfile does not correspond to an actual file, skip it. */
15120 if (stat (objfile
->name
, &st
) < 0)
15123 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
15124 if (dwarf2_per_objfile
)
15126 volatile struct gdb_exception except
;
15128 TRY_CATCH (except
, RETURN_MASK_ERROR
)
15130 write_psymtabs_to_index (objfile
, arg
);
15132 if (except
.reason
< 0)
15133 exception_fprintf (gdb_stderr
, except
,
15134 _("Error while writing index for `%s': "),
15142 int dwarf2_always_disassemble
;
15145 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
15146 struct cmd_list_element
*c
, const char *value
)
15148 fprintf_filtered (file
, _("\
15149 Whether to always disassemble DWARF expressions is %s.\n"),
15153 void _initialize_dwarf2_read (void);
15156 _initialize_dwarf2_read (void)
15158 struct cmd_list_element
*c
;
15160 dwarf2_objfile_data_key
15161 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
15163 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
15164 Set DWARF 2 specific variables.\n\
15165 Configure DWARF 2 variables such as the cache size"),
15166 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
15167 0/*allow-unknown*/, &maintenance_set_cmdlist
);
15169 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
15170 Show DWARF 2 specific variables\n\
15171 Show DWARF 2 variables such as the cache size"),
15172 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
15173 0/*allow-unknown*/, &maintenance_show_cmdlist
);
15175 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
15176 &dwarf2_max_cache_age
, _("\
15177 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
15178 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
15179 A higher limit means that cached compilation units will be stored\n\
15180 in memory longer, and more total memory will be used. Zero disables\n\
15181 caching, which can slow down startup."),
15183 show_dwarf2_max_cache_age
,
15184 &set_dwarf2_cmdlist
,
15185 &show_dwarf2_cmdlist
);
15187 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
15188 &dwarf2_always_disassemble
, _("\
15189 Set whether `info address' always disassembles DWARF expressions."), _("\
15190 Show whether `info address' always disassembles DWARF expressions."), _("\
15191 When enabled, DWARF expressions are always printed in an assembly-like\n\
15192 syntax. When disabled, expressions will be printed in a more\n\
15193 conversational style, when possible."),
15195 show_dwarf2_always_disassemble
,
15196 &set_dwarf2_cmdlist
,
15197 &show_dwarf2_cmdlist
);
15199 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
15200 Set debugging of the dwarf2 DIE reader."), _("\
15201 Show debugging of the dwarf2 DIE reader."), _("\
15202 When enabled (non-zero), DIEs are dumped after they are read in.\n\
15203 The value is the maximum depth to print."),
15206 &setdebuglist
, &showdebuglist
);
15208 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
15209 _("Save a .gdb-index file"),
15211 set_cmd_completer (c
, filename_completer
);