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"
60 #include "gdb_string.h"
61 #include "gdb_assert.h"
62 #include <sys/types.h>
69 #define MAP_FAILED ((void *) -1)
73 typedef struct symbol
*symbolp
;
77 /* .debug_info header for a compilation unit
78 Because of alignment constraints, this structure has padding and cannot
79 be mapped directly onto the beginning of the .debug_info section. */
80 typedef struct comp_unit_header
82 unsigned int length
; /* length of the .debug_info
84 unsigned short version
; /* version number -- 2 for DWARF
86 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
87 unsigned char addr_size
; /* byte size of an address -- 4 */
90 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
93 /* .debug_line statement program prologue
94 Because of alignment constraints, this structure has padding and cannot
95 be mapped directly onto the beginning of the .debug_info section. */
96 typedef struct statement_prologue
98 unsigned int total_length
; /* byte length of the statement
100 unsigned short version
; /* version number -- 2 for DWARF
102 unsigned int prologue_length
; /* # bytes between prologue &
104 unsigned char minimum_instruction_length
; /* byte size of
106 unsigned char default_is_stmt
; /* initial value of is_stmt
109 unsigned char line_range
;
110 unsigned char opcode_base
; /* number assigned to first special
112 unsigned char *standard_opcode_lengths
;
116 /* When non-zero, dump DIEs after they are read in. */
117 static int dwarf2_die_debug
= 0;
121 /* When set, the file that we're processing is known to have debugging
122 info for C++ namespaces. GCC 3.3.x did not produce this information,
123 but later versions do. */
125 static int processing_has_namespace_info
;
127 static const struct objfile_data
*dwarf2_objfile_data_key
;
129 struct dwarf2_section_info
135 /* True if we have tried to read this section. */
139 /* All offsets in the index are of this type. It must be
140 architecture-independent. */
141 typedef uint32_t offset_type
;
143 DEF_VEC_I (offset_type
);
145 /* A description of the mapped index. The file format is described in
146 a comment by the code that writes the index. */
149 /* The total length of the buffer. */
151 /* A pointer to the address table data. */
152 const gdb_byte
*address_table
;
153 /* Size of the address table data in bytes. */
154 offset_type address_table_size
;
155 /* The hash table. */
156 const offset_type
*index_table
;
157 /* Size in slots, each slot is 2 offset_types. */
158 offset_type index_table_slots
;
159 /* A pointer to the constant pool. */
160 const char *constant_pool
;
163 struct dwarf2_per_objfile
165 struct dwarf2_section_info info
;
166 struct dwarf2_section_info abbrev
;
167 struct dwarf2_section_info line
;
168 struct dwarf2_section_info loc
;
169 struct dwarf2_section_info macinfo
;
170 struct dwarf2_section_info str
;
171 struct dwarf2_section_info ranges
;
172 struct dwarf2_section_info types
;
173 struct dwarf2_section_info frame
;
174 struct dwarf2_section_info eh_frame
;
175 struct dwarf2_section_info gdb_index
;
178 struct objfile
*objfile
;
180 /* A list of all the compilation units. This is used to locate
181 the target compilation unit of a particular reference. */
182 struct dwarf2_per_cu_data
**all_comp_units
;
184 /* The number of compilation units in ALL_COMP_UNITS. */
187 /* The number of .debug_types-related CUs. */
188 int n_type_comp_units
;
190 /* The .debug_types-related CUs. */
191 struct dwarf2_per_cu_data
**type_comp_units
;
193 /* A chain of compilation units that are currently read in, so that
194 they can be freed later. */
195 struct dwarf2_per_cu_data
*read_in_chain
;
197 /* A table mapping .debug_types signatures to its signatured_type entry.
198 This is NULL if the .debug_types section hasn't been read in yet. */
199 htab_t signatured_types
;
201 /* A flag indicating wether this objfile has a section loaded at a
203 int has_section_at_zero
;
205 /* True if we are using the mapped index. */
206 unsigned char using_index
;
208 /* The mapped index. */
209 struct mapped_index
*index_table
;
212 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
214 /* names of the debugging sections */
216 /* Note that if the debugging section has been compressed, it might
217 have a name like .zdebug_info. */
219 #define INFO_SECTION "debug_info"
220 #define ABBREV_SECTION "debug_abbrev"
221 #define LINE_SECTION "debug_line"
222 #define LOC_SECTION "debug_loc"
223 #define MACINFO_SECTION "debug_macinfo"
224 #define STR_SECTION "debug_str"
225 #define RANGES_SECTION "debug_ranges"
226 #define TYPES_SECTION "debug_types"
227 #define FRAME_SECTION "debug_frame"
228 #define EH_FRAME_SECTION "eh_frame"
229 #define GDB_INDEX_SECTION "gdb_index"
231 /* local data types */
233 /* We hold several abbreviation tables in memory at the same time. */
234 #ifndef ABBREV_HASH_SIZE
235 #define ABBREV_HASH_SIZE 121
238 /* The data in a compilation unit header, after target2host
239 translation, looks like this. */
240 struct comp_unit_head
244 unsigned char addr_size
;
245 unsigned char signed_addr_p
;
246 unsigned int abbrev_offset
;
248 /* Size of file offsets; either 4 or 8. */
249 unsigned int offset_size
;
251 /* Size of the length field; either 4 or 12. */
252 unsigned int initial_length_size
;
254 /* Offset to the first byte of this compilation unit header in the
255 .debug_info section, for resolving relative reference dies. */
258 /* Offset to first die in this cu from the start of the cu.
259 This will be the first byte following the compilation unit header. */
260 unsigned int first_die_offset
;
263 /* Internal state when decoding a particular compilation unit. */
266 /* The objfile containing this compilation unit. */
267 struct objfile
*objfile
;
269 /* The header of the compilation unit. */
270 struct comp_unit_head header
;
272 /* Base address of this compilation unit. */
273 CORE_ADDR base_address
;
275 /* Non-zero if base_address has been set. */
278 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
280 /* The language we are debugging. */
281 enum language language
;
282 const struct language_defn
*language_defn
;
284 const char *producer
;
286 /* The generic symbol table building routines have separate lists for
287 file scope symbols and all all other scopes (local scopes). So
288 we need to select the right one to pass to add_symbol_to_list().
289 We do it by keeping a pointer to the correct list in list_in_scope.
291 FIXME: The original dwarf code just treated the file scope as the
292 first local scope, and all other local scopes as nested local
293 scopes, and worked fine. Check to see if we really need to
294 distinguish these in buildsym.c. */
295 struct pending
**list_in_scope
;
297 /* DWARF abbreviation table associated with this compilation unit. */
298 struct abbrev_info
**dwarf2_abbrevs
;
300 /* Storage for the abbrev table. */
301 struct obstack abbrev_obstack
;
303 /* Hash table holding all the loaded partial DIEs. */
306 /* Storage for things with the same lifetime as this read-in compilation
307 unit, including partial DIEs. */
308 struct obstack comp_unit_obstack
;
310 /* When multiple dwarf2_cu structures are living in memory, this field
311 chains them all together, so that they can be released efficiently.
312 We will probably also want a generation counter so that most-recently-used
313 compilation units are cached... */
314 struct dwarf2_per_cu_data
*read_in_chain
;
316 /* Backchain to our per_cu entry if the tree has been built. */
317 struct dwarf2_per_cu_data
*per_cu
;
319 /* Pointer to the die -> type map. Although it is stored
320 permanently in per_cu, we copy it here to avoid double
324 /* How many compilation units ago was this CU last referenced? */
327 /* A hash table of die offsets for following references. */
330 /* Full DIEs if read in. */
331 struct die_info
*dies
;
333 /* A set of pointers to dwarf2_per_cu_data objects for compilation
334 units referenced by this one. Only set during full symbol processing;
335 partial symbol tables do not have dependencies. */
338 /* Header data from the line table, during full symbol processing. */
339 struct line_header
*line_header
;
341 /* Mark used when releasing cached dies. */
342 unsigned int mark
: 1;
344 /* This flag will be set if this compilation unit might include
345 inter-compilation-unit references. */
346 unsigned int has_form_ref_addr
: 1;
348 /* This flag will be set if this compilation unit includes any
349 DW_TAG_namespace DIEs. If we know that there are explicit
350 DIEs for namespaces, we don't need to try to infer them
351 from mangled names. */
352 unsigned int has_namespace_info
: 1;
355 /* When using the index (and thus not using psymtabs), each CU has an
356 object of this type. This is used to hold information needed by
357 the various "quick" methods. */
358 struct dwarf2_per_cu_quick_data
360 /* The line table. This can be NULL if there was no line table. */
361 struct line_header
*lines
;
363 /* The file names from the line table. */
364 const char **file_names
;
365 /* The file names from the line table after being run through
367 const char **full_names
;
369 /* The corresponding symbol table. This is NULL if symbols for this
370 CU have not yet been read. */
371 struct symtab
*symtab
;
373 /* A temporary mark bit used when iterating over all CUs in
374 expand_symtabs_matching. */
375 unsigned int mark
: 1;
377 /* True if we've tried to read the line table. */
378 unsigned int read_lines
: 1;
381 /* Persistent data held for a compilation unit, even when not
382 processing it. We put a pointer to this structure in the
383 read_symtab_private field of the psymtab. If we encounter
384 inter-compilation-unit references, we also maintain a sorted
385 list of all compilation units. */
387 struct dwarf2_per_cu_data
389 /* The start offset and length of this compilation unit. 2**29-1
390 bytes should suffice to store the length of any compilation unit
391 - if it doesn't, GDB will fall over anyway.
392 NOTE: Unlike comp_unit_head.length, this length includes
393 initial_length_size. */
395 unsigned int length
: 29;
397 /* Flag indicating this compilation unit will be read in before
398 any of the current compilation units are processed. */
399 unsigned int queued
: 1;
401 /* This flag will be set if we need to load absolutely all DIEs
402 for this compilation unit, instead of just the ones we think
403 are interesting. It gets set if we look for a DIE in the
404 hash table and don't find it. */
405 unsigned int load_all_dies
: 1;
407 /* Non-zero if this CU is from .debug_types.
408 Otherwise it's from .debug_info. */
409 unsigned int from_debug_types
: 1;
411 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
412 of the CU cache it gets reset to NULL again. */
413 struct dwarf2_cu
*cu
;
415 /* If full symbols for this CU have been read in, then this field
416 holds a map of DIE offsets to types. It isn't always possible
417 to reconstruct this information later, so we have to preserve
421 /* The corresponding objfile. */
422 struct objfile
*objfile
;
424 /* When using partial symbol tables, the 'psymtab' field is active.
425 Otherwise the 'quick' field is active. */
428 /* The partial symbol table associated with this compilation unit,
429 or NULL for partial units (which do not have an associated
431 struct partial_symtab
*psymtab
;
433 /* Data needed by the "quick" functions. */
434 struct dwarf2_per_cu_quick_data
*quick
;
438 /* Entry in the signatured_types hash table. */
440 struct signatured_type
444 /* Offset in .debug_types of the TU (type_unit) for this type. */
447 /* Offset in .debug_types of the type defined by this TU. */
448 unsigned int type_offset
;
450 /* The CU(/TU) of this type. */
451 struct dwarf2_per_cu_data per_cu
;
454 /* Struct used to pass misc. parameters to read_die_and_children, et. al.
455 which are used for both .debug_info and .debug_types dies.
456 All parameters here are unchanging for the life of the call.
457 This struct exists to abstract away the constant parameters of
460 struct die_reader_specs
462 /* The bfd of this objfile. */
465 /* The CU of the DIE we are parsing. */
466 struct dwarf2_cu
*cu
;
468 /* Pointer to start of section buffer.
469 This is either the start of .debug_info or .debug_types. */
470 const gdb_byte
*buffer
;
473 /* The line number information for a compilation unit (found in the
474 .debug_line section) begins with a "statement program header",
475 which contains the following information. */
478 unsigned int total_length
;
479 unsigned short version
;
480 unsigned int header_length
;
481 unsigned char minimum_instruction_length
;
482 unsigned char maximum_ops_per_instruction
;
483 unsigned char default_is_stmt
;
485 unsigned char line_range
;
486 unsigned char opcode_base
;
488 /* standard_opcode_lengths[i] is the number of operands for the
489 standard opcode whose value is i. This means that
490 standard_opcode_lengths[0] is unused, and the last meaningful
491 element is standard_opcode_lengths[opcode_base - 1]. */
492 unsigned char *standard_opcode_lengths
;
494 /* The include_directories table. NOTE! These strings are not
495 allocated with xmalloc; instead, they are pointers into
496 debug_line_buffer. If you try to free them, `free' will get
498 unsigned int num_include_dirs
, include_dirs_size
;
501 /* The file_names table. NOTE! These strings are not allocated
502 with xmalloc; instead, they are pointers into debug_line_buffer.
503 Don't try to free them directly. */
504 unsigned int num_file_names
, file_names_size
;
508 unsigned int dir_index
;
509 unsigned int mod_time
;
511 int included_p
; /* Non-zero if referenced by the Line Number Program. */
512 struct symtab
*symtab
; /* The associated symbol table, if any. */
515 /* The start and end of the statement program following this
516 header. These point into dwarf2_per_objfile->line_buffer. */
517 gdb_byte
*statement_program_start
, *statement_program_end
;
520 /* When we construct a partial symbol table entry we only
521 need this much information. */
522 struct partial_die_info
524 /* Offset of this DIE. */
527 /* DWARF-2 tag for this DIE. */
528 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
530 /* Assorted flags describing the data found in this DIE. */
531 unsigned int has_children
: 1;
532 unsigned int is_external
: 1;
533 unsigned int is_declaration
: 1;
534 unsigned int has_type
: 1;
535 unsigned int has_specification
: 1;
536 unsigned int has_pc_info
: 1;
538 /* Flag set if the SCOPE field of this structure has been
540 unsigned int scope_set
: 1;
542 /* Flag set if the DIE has a byte_size attribute. */
543 unsigned int has_byte_size
: 1;
545 /* The name of this DIE. Normally the value of DW_AT_name, but
546 sometimes a default name for unnamed DIEs. */
549 /* The scope to prepend to our children. This is generally
550 allocated on the comp_unit_obstack, so will disappear
551 when this compilation unit leaves the cache. */
554 /* The location description associated with this DIE, if any. */
555 struct dwarf_block
*locdesc
;
557 /* If HAS_PC_INFO, the PC range associated with this DIE. */
561 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
562 DW_AT_sibling, if any. */
565 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
566 DW_AT_specification (or DW_AT_abstract_origin or
568 unsigned int spec_offset
;
570 /* Pointers to this DIE's parent, first child, and next sibling,
572 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
575 /* This data structure holds the information of an abbrev. */
578 unsigned int number
; /* number identifying abbrev */
579 enum dwarf_tag tag
; /* dwarf tag */
580 unsigned short has_children
; /* boolean */
581 unsigned short num_attrs
; /* number of attributes */
582 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
583 struct abbrev_info
*next
; /* next in chain */
588 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
589 ENUM_BITFIELD(dwarf_form
) form
: 16;
592 /* Attributes have a name and a value */
595 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
596 ENUM_BITFIELD(dwarf_form
) form
: 15;
598 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
599 field should be in u.str (existing only for DW_STRING) but it is kept
600 here for better struct attribute alignment. */
601 unsigned int string_is_canonical
: 1;
606 struct dwarf_block
*blk
;
610 struct signatured_type
*signatured_type
;
615 /* This data structure holds a complete die structure. */
618 /* DWARF-2 tag for this DIE. */
619 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
621 /* Number of attributes */
622 unsigned short num_attrs
;
627 /* Offset in .debug_info or .debug_types section. */
630 /* The dies in a compilation unit form an n-ary tree. PARENT
631 points to this die's parent; CHILD points to the first child of
632 this node; and all the children of a given node are chained
633 together via their SIBLING fields, terminated by a die whose
635 struct die_info
*child
; /* Its first child, if any. */
636 struct die_info
*sibling
; /* Its next sibling, if any. */
637 struct die_info
*parent
; /* Its parent, if any. */
639 /* An array of attributes, with NUM_ATTRS elements. There may be
640 zero, but it's not common and zero-sized arrays are not
641 sufficiently portable C. */
642 struct attribute attrs
[1];
645 struct function_range
648 CORE_ADDR lowpc
, highpc
;
650 struct function_range
*next
;
653 /* Get at parts of an attribute structure */
655 #define DW_STRING(attr) ((attr)->u.str)
656 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
657 #define DW_UNSND(attr) ((attr)->u.unsnd)
658 #define DW_BLOCK(attr) ((attr)->u.blk)
659 #define DW_SND(attr) ((attr)->u.snd)
660 #define DW_ADDR(attr) ((attr)->u.addr)
661 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
663 /* Blocks are a bunch of untyped bytes. */
670 #ifndef ATTR_ALLOC_CHUNK
671 #define ATTR_ALLOC_CHUNK 4
674 /* Allocate fields for structs, unions and enums in this size. */
675 #ifndef DW_FIELD_ALLOC_CHUNK
676 #define DW_FIELD_ALLOC_CHUNK 4
679 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
680 but this would require a corresponding change in unpack_field_as_long
682 static int bits_per_byte
= 8;
684 /* The routines that read and process dies for a C struct or C++ class
685 pass lists of data member fields and lists of member function fields
686 in an instance of a field_info structure, as defined below. */
689 /* List of data member and baseclasses fields. */
692 struct nextfield
*next
;
697 *fields
, *baseclasses
;
699 /* Number of fields (including baseclasses). */
702 /* Number of baseclasses. */
705 /* Set if the accesibility of one of the fields is not public. */
706 int non_public_fields
;
708 /* Member function fields array, entries are allocated in the order they
709 are encountered in the object file. */
712 struct nextfnfield
*next
;
713 struct fn_field fnfield
;
717 /* Member function fieldlist array, contains name of possibly overloaded
718 member function, number of overloaded member functions and a pointer
719 to the head of the member function field chain. */
724 struct nextfnfield
*head
;
728 /* Number of entries in the fnfieldlists array. */
731 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
732 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
733 struct typedef_field_list
735 struct typedef_field field
;
736 struct typedef_field_list
*next
;
739 unsigned typedef_field_list_count
;
742 /* One item on the queue of compilation units to read in full symbols
744 struct dwarf2_queue_item
746 struct dwarf2_per_cu_data
*per_cu
;
747 struct dwarf2_queue_item
*next
;
750 /* The current queue. */
751 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
753 /* Loaded secondary compilation units are kept in memory until they
754 have not been referenced for the processing of this many
755 compilation units. Set this to zero to disable caching. Cache
756 sizes of up to at least twenty will improve startup time for
757 typical inter-CU-reference binaries, at an obvious memory cost. */
758 static int dwarf2_max_cache_age
= 5;
760 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
761 struct cmd_list_element
*c
, const char *value
)
763 fprintf_filtered (file
, _("\
764 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
769 /* Various complaints about symbol reading that don't abort the process */
772 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
774 complaint (&symfile_complaints
,
775 _("statement list doesn't fit in .debug_line section"));
779 dwarf2_debug_line_missing_file_complaint (void)
781 complaint (&symfile_complaints
,
782 _(".debug_line section has line data without a file"));
786 dwarf2_debug_line_missing_end_sequence_complaint (void)
788 complaint (&symfile_complaints
,
789 _(".debug_line section has line program sequence without an end"));
793 dwarf2_complex_location_expr_complaint (void)
795 complaint (&symfile_complaints
, _("location expression too complex"));
799 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
802 complaint (&symfile_complaints
,
803 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
808 dwarf2_macros_too_long_complaint (void)
810 complaint (&symfile_complaints
,
811 _("macro info runs off end of `.debug_macinfo' section"));
815 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
817 complaint (&symfile_complaints
,
818 _("macro debug info contains a malformed macro definition:\n`%s'"),
823 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
825 complaint (&symfile_complaints
,
826 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
829 /* local function prototypes */
831 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
833 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
836 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
838 struct partial_symtab
*);
840 static void dwarf2_build_psymtabs_hard (struct objfile
*);
842 static void scan_partial_symbols (struct partial_die_info
*,
843 CORE_ADDR
*, CORE_ADDR
*,
844 int, struct dwarf2_cu
*);
846 static void add_partial_symbol (struct partial_die_info
*,
849 static void add_partial_namespace (struct partial_die_info
*pdi
,
850 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
851 int need_pc
, struct dwarf2_cu
*cu
);
853 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
854 CORE_ADDR
*highpc
, int need_pc
,
855 struct dwarf2_cu
*cu
);
857 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
858 struct dwarf2_cu
*cu
);
860 static void add_partial_subprogram (struct partial_die_info
*pdi
,
861 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
862 int need_pc
, struct dwarf2_cu
*cu
);
864 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
865 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
866 bfd
*abfd
, struct dwarf2_cu
*cu
);
868 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
870 static void psymtab_to_symtab_1 (struct partial_symtab
*);
872 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
874 static void dwarf2_free_abbrev_table (void *);
876 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
879 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
882 static struct partial_die_info
*load_partial_dies (bfd
*,
883 gdb_byte
*, gdb_byte
*,
884 int, struct dwarf2_cu
*);
886 static gdb_byte
*read_partial_die (struct partial_die_info
*,
887 struct abbrev_info
*abbrev
,
889 gdb_byte
*, gdb_byte
*,
892 static struct partial_die_info
*find_partial_die (unsigned int,
895 static void fixup_partial_die (struct partial_die_info
*,
898 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
899 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
901 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
902 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
904 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
906 static int read_1_signed_byte (bfd
*, gdb_byte
*);
908 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
910 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
912 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
914 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
917 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
919 static LONGEST read_checked_initial_length_and_offset
920 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
921 unsigned int *, unsigned int *);
923 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
926 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
928 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
930 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
932 static char *read_indirect_string (bfd
*, gdb_byte
*,
933 const struct comp_unit_head
*,
936 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
938 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
940 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
942 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
944 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
947 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
951 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
952 struct dwarf2_cu
*cu
);
954 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
956 static struct die_info
*die_specification (struct die_info
*die
,
957 struct dwarf2_cu
**);
959 static void free_line_header (struct line_header
*lh
);
961 static void add_file_name (struct line_header
*, char *, unsigned int,
962 unsigned int, unsigned int);
964 static struct line_header
*(dwarf_decode_line_header
965 (unsigned int offset
,
966 bfd
*abfd
, struct dwarf2_cu
*cu
));
968 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
969 struct dwarf2_cu
*, struct partial_symtab
*);
971 static void dwarf2_start_subfile (char *, char *, char *);
973 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
976 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
977 struct dwarf2_cu
*, struct symbol
*);
979 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
982 static void dwarf2_const_value_data (struct attribute
*attr
,
986 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
988 static int need_gnat_info (struct dwarf2_cu
*);
990 static struct type
*die_descriptive_type (struct die_info
*, struct dwarf2_cu
*);
992 static void set_descriptive_type (struct type
*, struct die_info
*,
995 static struct type
*die_containing_type (struct die_info
*,
998 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
1000 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1002 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1004 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1005 const char *suffix
, int physname
,
1006 struct dwarf2_cu
*cu
);
1008 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1010 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1012 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1014 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1016 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1017 struct dwarf2_cu
*, struct partial_symtab
*);
1019 static int dwarf2_get_pc_bounds (struct die_info
*,
1020 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1021 struct partial_symtab
*);
1023 static void get_scope_pc_bounds (struct die_info
*,
1024 CORE_ADDR
*, CORE_ADDR
*,
1025 struct dwarf2_cu
*);
1027 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1028 CORE_ADDR
, struct dwarf2_cu
*);
1030 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1031 struct dwarf2_cu
*);
1033 static void dwarf2_attach_fields_to_type (struct field_info
*,
1034 struct type
*, struct dwarf2_cu
*);
1036 static void dwarf2_add_member_fn (struct field_info
*,
1037 struct die_info
*, struct type
*,
1038 struct dwarf2_cu
*);
1040 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1041 struct type
*, struct dwarf2_cu
*);
1043 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1045 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1047 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1049 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1051 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1053 static struct type
*read_module_type (struct die_info
*die
,
1054 struct dwarf2_cu
*cu
);
1056 static const char *namespace_name (struct die_info
*die
,
1057 int *is_anonymous
, struct dwarf2_cu
*);
1059 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1061 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1063 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1064 struct dwarf2_cu
*);
1066 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
1068 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
1070 gdb_byte
**new_info_ptr
,
1071 struct die_info
*parent
);
1073 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
1075 gdb_byte
**new_info_ptr
,
1076 struct die_info
*parent
);
1078 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
1080 gdb_byte
**new_info_ptr
,
1081 struct die_info
*parent
);
1083 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
1084 struct die_info
**, gdb_byte
*,
1087 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1089 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1092 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1094 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1095 struct dwarf2_cu
**);
1097 static char *dwarf_tag_name (unsigned int);
1099 static char *dwarf_attr_name (unsigned int);
1101 static char *dwarf_form_name (unsigned int);
1103 static char *dwarf_bool_name (unsigned int);
1105 static char *dwarf_type_encoding_name (unsigned int);
1108 static char *dwarf_cfi_name (unsigned int);
1111 static struct die_info
*sibling_die (struct die_info
*);
1113 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1115 static void dump_die_for_error (struct die_info
*);
1117 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1120 /*static*/ void dump_die (struct die_info
*, int max_level
);
1122 static void store_in_ref_table (struct die_info
*,
1123 struct dwarf2_cu
*);
1125 static int is_ref_attr (struct attribute
*);
1127 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1129 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1131 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1133 struct dwarf2_cu
**);
1135 static struct die_info
*follow_die_ref (struct die_info
*,
1137 struct dwarf2_cu
**);
1139 static struct die_info
*follow_die_sig (struct die_info
*,
1141 struct dwarf2_cu
**);
1143 static void read_signatured_type_at_offset (struct objfile
*objfile
,
1144 unsigned int offset
);
1146 static void read_signatured_type (struct objfile
*,
1147 struct signatured_type
*type_sig
);
1149 /* memory allocation interface */
1151 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1153 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1155 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1157 static void initialize_cu_func_list (struct dwarf2_cu
*);
1159 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1160 struct dwarf2_cu
*);
1162 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1163 char *, bfd
*, struct dwarf2_cu
*);
1165 static int attr_form_is_block (struct attribute
*);
1167 static int attr_form_is_section_offset (struct attribute
*);
1169 static int attr_form_is_constant (struct attribute
*);
1171 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1173 struct dwarf2_cu
*cu
);
1175 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1176 struct abbrev_info
*abbrev
,
1177 struct dwarf2_cu
*cu
);
1179 static void free_stack_comp_unit (void *);
1181 static hashval_t
partial_die_hash (const void *item
);
1183 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1185 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1186 (unsigned int offset
, struct objfile
*objfile
);
1188 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1189 (unsigned int offset
, struct objfile
*objfile
);
1191 static struct dwarf2_cu
*alloc_one_comp_unit (struct objfile
*objfile
);
1193 static void free_one_comp_unit (void *);
1195 static void free_cached_comp_units (void *);
1197 static void age_cached_comp_units (void);
1199 static void free_one_cached_comp_unit (void *);
1201 static struct type
*set_die_type (struct die_info
*, struct type
*,
1202 struct dwarf2_cu
*);
1204 static void create_all_comp_units (struct objfile
*);
1206 static int create_debug_types_hash_table (struct objfile
*objfile
);
1208 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1211 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1213 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1214 struct dwarf2_per_cu_data
*);
1216 static void dwarf2_mark (struct dwarf2_cu
*);
1218 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1220 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1222 static void dwarf2_release_queue (void *dummy
);
1224 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1225 struct objfile
*objfile
);
1227 static void process_queue (struct objfile
*objfile
);
1229 static void find_file_and_directory (struct die_info
*die
,
1230 struct dwarf2_cu
*cu
,
1231 char **name
, char **comp_dir
);
1233 static char *file_full_name (int file
, struct line_header
*lh
,
1234 const char *comp_dir
);
1236 static gdb_byte
*partial_read_comp_unit_head (struct comp_unit_head
*header
,
1239 unsigned int buffer_size
,
1242 static void init_cu_die_reader (struct die_reader_specs
*reader
,
1243 struct dwarf2_cu
*cu
);
1245 static htab_t
allocate_signatured_type_hash_table (struct objfile
*objfile
);
1249 /* Convert VALUE between big- and little-endian. */
1251 byte_swap (offset_type value
)
1255 result
= (value
& 0xff) << 24;
1256 result
|= (value
& 0xff00) << 8;
1257 result
|= (value
& 0xff0000) >> 8;
1258 result
|= (value
& 0xff000000) >> 24;
1262 #define MAYBE_SWAP(V) byte_swap (V)
1265 #define MAYBE_SWAP(V) (V)
1266 #endif /* WORDS_BIGENDIAN */
1268 /* The suffix for an index file. */
1269 #define INDEX_SUFFIX ".gdb-index"
1271 /* Try to locate the sections we need for DWARF 2 debugging
1272 information and return true if we have enough to do something. */
1275 dwarf2_has_info (struct objfile
*objfile
)
1277 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1278 if (!dwarf2_per_objfile
)
1280 /* Initialize per-objfile state. */
1281 struct dwarf2_per_objfile
*data
1282 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1284 memset (data
, 0, sizeof (*data
));
1285 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1286 dwarf2_per_objfile
= data
;
1288 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1289 dwarf2_per_objfile
->objfile
= objfile
;
1291 return (dwarf2_per_objfile
->info
.asection
!= NULL
1292 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1295 /* When loading sections, we can either look for ".<name>", or for
1296 * ".z<name>", which indicates a compressed section. */
1299 section_is_p (const char *section_name
, const char *name
)
1301 return (section_name
[0] == '.'
1302 && (strcmp (section_name
+ 1, name
) == 0
1303 || (section_name
[1] == 'z'
1304 && strcmp (section_name
+ 2, name
) == 0)));
1307 /* This function is mapped across the sections and remembers the
1308 offset and size of each of the debugging sections we are interested
1312 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1314 if (section_is_p (sectp
->name
, INFO_SECTION
))
1316 dwarf2_per_objfile
->info
.asection
= sectp
;
1317 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1319 else if (section_is_p (sectp
->name
, ABBREV_SECTION
))
1321 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1322 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1324 else if (section_is_p (sectp
->name
, LINE_SECTION
))
1326 dwarf2_per_objfile
->line
.asection
= sectp
;
1327 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1329 else if (section_is_p (sectp
->name
, LOC_SECTION
))
1331 dwarf2_per_objfile
->loc
.asection
= sectp
;
1332 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1334 else if (section_is_p (sectp
->name
, MACINFO_SECTION
))
1336 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1337 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1339 else if (section_is_p (sectp
->name
, STR_SECTION
))
1341 dwarf2_per_objfile
->str
.asection
= sectp
;
1342 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1344 else if (section_is_p (sectp
->name
, FRAME_SECTION
))
1346 dwarf2_per_objfile
->frame
.asection
= sectp
;
1347 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1349 else if (section_is_p (sectp
->name
, EH_FRAME_SECTION
))
1351 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1353 if (aflag
& SEC_HAS_CONTENTS
)
1355 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1356 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1359 else if (section_is_p (sectp
->name
, RANGES_SECTION
))
1361 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1362 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1364 else if (section_is_p (sectp
->name
, TYPES_SECTION
))
1366 dwarf2_per_objfile
->types
.asection
= sectp
;
1367 dwarf2_per_objfile
->types
.size
= bfd_get_section_size (sectp
);
1369 else if (section_is_p (sectp
->name
, GDB_INDEX_SECTION
))
1371 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1372 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1375 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1376 && bfd_section_vma (abfd
, sectp
) == 0)
1377 dwarf2_per_objfile
->has_section_at_zero
= 1;
1380 /* Decompress a section that was compressed using zlib. Store the
1381 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1384 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1385 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1387 bfd
*abfd
= objfile
->obfd
;
1389 error (_("Support for zlib-compressed DWARF data (from '%s') "
1390 "is disabled in this copy of GDB"),
1391 bfd_get_filename (abfd
));
1393 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1394 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1395 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1396 bfd_size_type uncompressed_size
;
1397 gdb_byte
*uncompressed_buffer
;
1400 int header_size
= 12;
1402 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1403 || bfd_bread (compressed_buffer
, compressed_size
, abfd
) != compressed_size
)
1404 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1405 bfd_get_filename (abfd
));
1407 /* Read the zlib header. In this case, it should be "ZLIB" followed
1408 by the uncompressed section size, 8 bytes in big-endian order. */
1409 if (compressed_size
< header_size
1410 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1411 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1412 bfd_get_filename (abfd
));
1413 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1414 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1415 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1416 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1417 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1418 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1419 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1420 uncompressed_size
+= compressed_buffer
[11];
1422 /* It is possible the section consists of several compressed
1423 buffers concatenated together, so we uncompress in a loop. */
1427 strm
.avail_in
= compressed_size
- header_size
;
1428 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1429 strm
.avail_out
= uncompressed_size
;
1430 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1432 rc
= inflateInit (&strm
);
1433 while (strm
.avail_in
> 0)
1436 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1437 bfd_get_filename (abfd
), rc
);
1438 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1439 + (uncompressed_size
- strm
.avail_out
));
1440 rc
= inflate (&strm
, Z_FINISH
);
1441 if (rc
!= Z_STREAM_END
)
1442 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1443 bfd_get_filename (abfd
), rc
);
1444 rc
= inflateReset (&strm
);
1446 rc
= inflateEnd (&strm
);
1448 || strm
.avail_out
!= 0)
1449 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1450 bfd_get_filename (abfd
), rc
);
1452 do_cleanups (cleanup
);
1453 *outbuf
= uncompressed_buffer
;
1454 *outsize
= uncompressed_size
;
1458 /* Read the contents of the section SECTP from object file specified by
1459 OBJFILE, store info about the section into INFO.
1460 If the section is compressed, uncompress it before returning. */
1463 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1465 bfd
*abfd
= objfile
->obfd
;
1466 asection
*sectp
= info
->asection
;
1467 gdb_byte
*buf
, *retbuf
;
1468 unsigned char header
[4];
1472 info
->buffer
= NULL
;
1473 info
->was_mmapped
= 0;
1476 if (info
->asection
== NULL
|| info
->size
== 0)
1479 /* Check if the file has a 4-byte header indicating compression. */
1480 if (info
->size
> sizeof (header
)
1481 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1482 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1484 /* Upon decompression, update the buffer and its size. */
1485 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1487 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1495 pagesize
= getpagesize ();
1497 /* Only try to mmap sections which are large enough: we don't want to
1498 waste space due to fragmentation. Also, only try mmap for sections
1499 without relocations. */
1501 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1503 off_t pg_offset
= sectp
->filepos
& ~(pagesize
- 1);
1504 size_t map_length
= info
->size
+ sectp
->filepos
- pg_offset
;
1505 caddr_t retbuf
= bfd_mmap (abfd
, 0, map_length
, PROT_READ
,
1506 MAP_PRIVATE
, pg_offset
);
1508 if (retbuf
!= MAP_FAILED
)
1510 info
->was_mmapped
= 1;
1511 info
->buffer
= retbuf
+ (sectp
->filepos
& (pagesize
- 1)) ;
1512 #if HAVE_POSIX_MADVISE
1513 posix_madvise (retbuf
, map_length
, POSIX_MADV_WILLNEED
);
1520 /* If we get here, we are a normal, not-compressed section. */
1522 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1524 /* When debugging .o files, we may need to apply relocations; see
1525 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1526 We never compress sections in .o files, so we only need to
1527 try this when the section is not compressed. */
1528 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1531 info
->buffer
= retbuf
;
1535 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1536 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1537 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1538 bfd_get_filename (abfd
));
1541 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1545 dwarf2_get_section_info (struct objfile
*objfile
, const char *section_name
,
1546 asection
**sectp
, gdb_byte
**bufp
,
1547 bfd_size_type
*sizep
)
1549 struct dwarf2_per_objfile
*data
1550 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1551 struct dwarf2_section_info
*info
;
1553 /* We may see an objfile without any DWARF, in which case we just
1562 if (section_is_p (section_name
, EH_FRAME_SECTION
))
1563 info
= &data
->eh_frame
;
1564 else if (section_is_p (section_name
, FRAME_SECTION
))
1565 info
= &data
->frame
;
1569 if (info
->asection
!= NULL
&& info
->size
!= 0 && info
->buffer
== NULL
)
1570 /* We haven't read this section in yet. Do it now. */
1571 dwarf2_read_section (objfile
, info
);
1573 *sectp
= info
->asection
;
1574 *bufp
= info
->buffer
;
1575 *sizep
= info
->size
;
1580 /* Read in the symbols for PER_CU. OBJFILE is the objfile from which
1583 dw2_do_instantiate_symtab (struct objfile
*objfile
,
1584 struct dwarf2_per_cu_data
*per_cu
)
1586 struct cleanup
*back_to
;
1588 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
1590 queue_comp_unit (per_cu
, objfile
);
1592 if (per_cu
->from_debug_types
)
1593 read_signatured_type_at_offset (objfile
, per_cu
->offset
);
1595 load_full_comp_unit (per_cu
, objfile
);
1597 process_queue (objfile
);
1599 /* Age the cache, releasing compilation units that have not
1600 been used recently. */
1601 age_cached_comp_units ();
1603 do_cleanups (back_to
);
1606 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1607 the objfile from which this CU came. Returns the resulting symbol
1609 static struct symtab
*
1610 dw2_instantiate_symtab (struct objfile
*objfile
,
1611 struct dwarf2_per_cu_data
*per_cu
)
1613 if (!per_cu
->v
.quick
->symtab
)
1615 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1616 increment_reading_symtab ();
1617 dw2_do_instantiate_symtab (objfile
, per_cu
);
1618 do_cleanups (back_to
);
1620 return per_cu
->v
.quick
->symtab
;
1623 /* Return the CU given its index. */
1624 static struct dwarf2_per_cu_data
*
1625 dw2_get_cu (int index
)
1627 if (index
>= dwarf2_per_objfile
->n_comp_units
)
1629 index
-= dwarf2_per_objfile
->n_comp_units
;
1630 return dwarf2_per_objfile
->type_comp_units
[index
];
1632 return dwarf2_per_objfile
->all_comp_units
[index
];
1635 /* A helper function that knows how to read a 64-bit value in a way
1636 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1639 extract_cu_value (const char *bytes
, ULONGEST
*result
)
1641 if (sizeof (ULONGEST
) < 8)
1645 /* Ignore the upper 4 bytes if they are all zero. */
1646 for (i
= 0; i
< 4; ++i
)
1647 if (bytes
[i
+ 4] != 0)
1650 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
1653 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
1657 /* Read the CU list from the mapped index, and use it to create all
1658 the CU objects for this objfile. Return 0 if something went wrong,
1659 1 if everything went ok. */
1661 create_cus_from_index (struct objfile
*objfile
, const gdb_byte
*cu_list
,
1662 offset_type cu_list_elements
)
1666 dwarf2_per_objfile
->n_comp_units
= cu_list_elements
/ 2;
1667 dwarf2_per_objfile
->all_comp_units
1668 = obstack_alloc (&objfile
->objfile_obstack
,
1669 dwarf2_per_objfile
->n_comp_units
1670 * sizeof (struct dwarf2_per_cu_data
*));
1672 for (i
= 0; i
< cu_list_elements
; i
+= 2)
1674 struct dwarf2_per_cu_data
*the_cu
;
1675 ULONGEST offset
, length
;
1677 if (!extract_cu_value (cu_list
, &offset
)
1678 || !extract_cu_value (cu_list
+ 8, &length
))
1682 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1683 struct dwarf2_per_cu_data
);
1684 the_cu
->offset
= offset
;
1685 the_cu
->length
= length
;
1686 the_cu
->objfile
= objfile
;
1687 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1688 struct dwarf2_per_cu_quick_data
);
1689 dwarf2_per_objfile
->all_comp_units
[i
/ 2] = the_cu
;
1695 /* Create the signatured type hash table from the index. */
1697 create_signatured_type_hash_from_index (struct objfile
*objfile
,
1698 const gdb_byte
*bytes
,
1699 offset_type elements
)
1704 dwarf2_per_objfile
->n_type_comp_units
= elements
/ 3;
1705 dwarf2_per_objfile
->type_comp_units
1706 = obstack_alloc (&objfile
->objfile_obstack
,
1707 dwarf2_per_objfile
->n_type_comp_units
1708 * sizeof (struct dwarf2_per_cu_data
*));
1710 type_hash
= allocate_signatured_type_hash_table (objfile
);
1712 for (i
= 0; i
< elements
; i
+= 3)
1714 struct signatured_type
*type_sig
;
1715 ULONGEST offset
, type_offset
, signature
;
1718 if (!extract_cu_value (bytes
, &offset
)
1719 || !extract_cu_value (bytes
+ 8, &type_offset
))
1721 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
1724 type_sig
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1725 struct signatured_type
);
1726 type_sig
->signature
= signature
;
1727 type_sig
->offset
= offset
;
1728 type_sig
->type_offset
= type_offset
;
1729 type_sig
->per_cu
.from_debug_types
= 1;
1730 type_sig
->per_cu
.offset
= offset
;
1731 type_sig
->per_cu
.objfile
= objfile
;
1732 type_sig
->per_cu
.v
.quick
1733 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1734 struct dwarf2_per_cu_quick_data
);
1736 slot
= htab_find_slot (type_hash
, type_sig
, INSERT
);
1739 dwarf2_per_objfile
->type_comp_units
[i
/ 3] = &type_sig
->per_cu
;
1742 dwarf2_per_objfile
->signatured_types
= type_hash
;
1747 /* Read the address map data from the mapped index, and use it to
1748 populate the objfile's psymtabs_addrmap. */
1750 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
1752 const gdb_byte
*iter
, *end
;
1753 struct obstack temp_obstack
;
1754 struct addrmap
*mutable_map
;
1755 struct cleanup
*cleanup
;
1758 obstack_init (&temp_obstack
);
1759 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
1760 mutable_map
= addrmap_create_mutable (&temp_obstack
);
1762 iter
= index
->address_table
;
1763 end
= iter
+ index
->address_table_size
;
1765 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1769 ULONGEST hi
, lo
, cu_index
;
1770 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
1772 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
1774 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
1777 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
1778 dw2_get_cu (cu_index
));
1781 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
1782 &objfile
->objfile_obstack
);
1783 do_cleanups (cleanup
);
1786 /* The hash function for strings in the mapped index. This is the
1787 same as the hashtab.c hash function, but we keep a separate copy to
1788 maintain control over the implementation. This is necessary
1789 because the hash function is tied to the format of the mapped index
1792 mapped_index_string_hash (const void *p
)
1794 const unsigned char *str
= (const unsigned char *) p
;
1798 while ((c
= *str
++) != 0)
1799 r
= r
* 67 + c
- 113;
1804 /* Find a slot in the mapped index INDEX for the object named NAME.
1805 If NAME is found, set *VEC_OUT to point to the CU vector in the
1806 constant pool and return 1. If NAME cannot be found, return 0. */
1808 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
1809 offset_type
**vec_out
)
1811 offset_type hash
= mapped_index_string_hash (name
);
1812 offset_type slot
, step
;
1814 slot
= hash
& (index
->index_table_slots
- 1);
1815 step
= ((hash
* 17) & (index
->index_table_slots
- 1)) | 1;
1819 /* Convert a slot number to an offset into the table. */
1820 offset_type i
= 2 * slot
;
1822 if (index
->index_table
[i
] == 0 && index
->index_table
[i
+ 1] == 0)
1825 str
= index
->constant_pool
+ MAYBE_SWAP (index
->index_table
[i
]);
1826 if (!strcmp (name
, str
))
1828 *vec_out
= (offset_type
*) (index
->constant_pool
1829 + MAYBE_SWAP (index
->index_table
[i
+ 1]));
1833 slot
= (slot
+ step
) & (index
->index_table_slots
- 1);
1837 /* Read the index file. If everything went ok, initialize the "quick"
1838 elements of all the CUs and return 1. Otherwise, return 0. */
1840 dwarf2_read_index (struct objfile
*objfile
)
1843 struct mapped_index
*map
;
1844 offset_type
*metadata
;
1845 const gdb_byte
*cu_list
;
1846 const gdb_byte
*types_list
= NULL
;
1847 offset_type version
, cu_list_elements
;
1848 offset_type types_list_elements
= 0;
1851 if (dwarf2_per_objfile
->gdb_index
.asection
== NULL
1852 || dwarf2_per_objfile
->gdb_index
.size
== 0)
1854 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->gdb_index
);
1856 addr
= dwarf2_per_objfile
->gdb_index
.buffer
;
1857 /* Version check. */
1858 version
= MAYBE_SWAP (*(offset_type
*) addr
);
1861 /* Index version 1 neglected to account for .debug_types. So,
1862 if we see .debug_types, we cannot use this index. */
1863 if (dwarf2_per_objfile
->types
.asection
!= NULL
1864 && dwarf2_per_objfile
->types
.size
!= 0)
1867 else if (version
!= 2)
1870 map
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct mapped_index
);
1871 map
->total_size
= dwarf2_per_objfile
->gdb_index
.size
;
1873 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
1876 cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
1877 cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
1883 types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
1884 types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
1885 - MAYBE_SWAP (metadata
[i
]))
1890 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
1891 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
1892 - MAYBE_SWAP (metadata
[i
]));
1895 map
->index_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
1896 map
->index_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
1897 - MAYBE_SWAP (metadata
[i
]))
1898 / (2 * sizeof (offset_type
)));
1901 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
1903 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
))
1907 && types_list_elements
1908 && !create_signatured_type_hash_from_index (objfile
, types_list
,
1909 types_list_elements
))
1912 create_addrmap_from_index (objfile
, map
);
1914 dwarf2_per_objfile
->index_table
= map
;
1915 dwarf2_per_objfile
->using_index
= 1;
1920 /* A helper for the "quick" functions which sets the global
1921 dwarf2_per_objfile according to OBJFILE. */
1923 dw2_setup (struct objfile
*objfile
)
1925 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1926 gdb_assert (dwarf2_per_objfile
);
1929 /* A helper for the "quick" functions which attempts to read the line
1930 table for THIS_CU. */
1932 dw2_require_line_header (struct objfile
*objfile
,
1933 struct dwarf2_per_cu_data
*this_cu
)
1935 bfd
*abfd
= objfile
->obfd
;
1936 struct line_header
*lh
= NULL
;
1937 struct attribute
*attr
;
1938 struct cleanup
*cleanups
;
1939 struct die_info
*comp_unit_die
;
1940 gdb_byte
*beg_of_comp_unit
, *info_ptr
, *buffer
;
1941 int has_children
, i
;
1942 struct dwarf2_cu cu
;
1943 unsigned int bytes_read
, buffer_size
;
1944 struct die_reader_specs reader_specs
;
1945 char *name
, *comp_dir
;
1947 if (this_cu
->v
.quick
->read_lines
)
1949 this_cu
->v
.quick
->read_lines
= 1;
1951 memset (&cu
, 0, sizeof (cu
));
1952 cu
.objfile
= objfile
;
1953 obstack_init (&cu
.comp_unit_obstack
);
1955 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
1957 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
1958 buffer_size
= dwarf2_per_objfile
->info
.size
;
1959 buffer
= dwarf2_per_objfile
->info
.buffer
;
1960 info_ptr
= buffer
+ this_cu
->offset
;
1961 beg_of_comp_unit
= info_ptr
;
1963 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
1964 buffer
, buffer_size
,
1967 /* Complete the cu_header. */
1968 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
1969 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
1972 cu
.per_cu
= this_cu
;
1974 dwarf2_read_abbrevs (abfd
, &cu
);
1975 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1977 if (this_cu
->from_debug_types
)
1978 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
1979 init_cu_die_reader (&reader_specs
, &cu
);
1980 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
1983 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, &cu
);
1986 unsigned int line_offset
= DW_UNSND (attr
);
1987 lh
= dwarf_decode_line_header (line_offset
, abfd
, &cu
);
1991 do_cleanups (cleanups
);
1995 find_file_and_directory (comp_unit_die
, &cu
, &name
, &comp_dir
);
1997 this_cu
->v
.quick
->lines
= lh
;
1999 this_cu
->v
.quick
->file_names
2000 = obstack_alloc (&objfile
->objfile_obstack
,
2001 lh
->num_file_names
* sizeof (char *));
2002 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2003 this_cu
->v
.quick
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2005 do_cleanups (cleanups
);
2008 /* A helper for the "quick" functions which computes and caches the
2009 real path for a given file name from the line table.
2010 dw2_require_line_header must have been called before this is
2013 dw2_require_full_path (struct objfile
*objfile
,
2014 struct dwarf2_per_cu_data
*cu
,
2017 if (!cu
->v
.quick
->full_names
)
2018 cu
->v
.quick
->full_names
2019 = OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2020 cu
->v
.quick
->lines
->num_file_names
,
2023 if (!cu
->v
.quick
->full_names
[index
])
2024 cu
->v
.quick
->full_names
[index
]
2025 = gdb_realpath (cu
->v
.quick
->file_names
[index
]);
2027 return cu
->v
.quick
->full_names
[index
];
2030 static struct symtab
*
2031 dw2_find_last_source_symtab (struct objfile
*objfile
)
2034 dw2_setup (objfile
);
2035 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2036 return dw2_instantiate_symtab (objfile
, dw2_get_cu (index
));
2040 dw2_forget_cached_source_info (struct objfile
*objfile
)
2044 dw2_setup (objfile
);
2045 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2046 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2048 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2050 if (cu
->v
.quick
->full_names
)
2054 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2055 xfree ((void *) cu
->v
.quick
->full_names
[j
]);
2061 dw2_lookup_symtab (struct objfile
*objfile
, const char *name
,
2062 const char *full_path
, const char *real_path
,
2063 struct symtab
**result
)
2066 int check_basename
= lbasename (name
) == name
;
2067 struct dwarf2_per_cu_data
*base_cu
= NULL
;
2069 dw2_setup (objfile
);
2070 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2071 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2074 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2076 if (cu
->v
.quick
->symtab
)
2079 dw2_require_line_header (objfile
, cu
);
2080 if (!cu
->v
.quick
->lines
)
2083 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2085 const char *this_name
= cu
->v
.quick
->file_names
[j
];
2087 if (FILENAME_CMP (name
, this_name
) == 0)
2089 *result
= dw2_instantiate_symtab (objfile
, cu
);
2093 if (check_basename
&& ! base_cu
2094 && FILENAME_CMP (lbasename (this_name
), name
) == 0)
2097 if (full_path
!= NULL
)
2099 const char *this_full_name
= dw2_require_full_path (objfile
,
2103 && FILENAME_CMP (full_path
, this_full_name
) == 0)
2105 *result
= dw2_instantiate_symtab (objfile
, cu
);
2110 if (real_path
!= NULL
)
2112 const char *this_full_name
= dw2_require_full_path (objfile
,
2115 if (this_full_name
!= NULL
)
2117 char *rp
= gdb_realpath (this_full_name
);
2118 if (rp
!= NULL
&& FILENAME_CMP (real_path
, rp
) == 0)
2121 *result
= dw2_instantiate_symtab (objfile
, cu
);
2132 *result
= dw2_instantiate_symtab (objfile
, base_cu
);
2139 static struct symtab
*
2140 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
2141 const char *name
, domain_enum domain
)
2143 /* We do all the work in the pre_expand_symtabs_matching hook
2148 /* A helper function that expands all symtabs that hold an object
2151 dw2_do_expand_symtabs_matching (struct objfile
*objfile
, const char *name
)
2153 dw2_setup (objfile
);
2155 if (dwarf2_per_objfile
->index_table
)
2159 if (find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2162 offset_type i
, len
= MAYBE_SWAP (*vec
);
2163 for (i
= 0; i
< len
; ++i
)
2165 offset_type cu_index
= MAYBE_SWAP (vec
[i
+ 1]);
2166 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (cu_index
);
2168 dw2_instantiate_symtab (objfile
, cu
);
2175 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
2176 int kind
, const char *name
,
2179 dw2_do_expand_symtabs_matching (objfile
, name
);
2183 dw2_print_stats (struct objfile
*objfile
)
2187 dw2_setup (objfile
);
2189 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2190 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2192 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2194 if (!cu
->v
.quick
->symtab
)
2197 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
2201 dw2_dump (struct objfile
*objfile
)
2203 /* Nothing worth printing. */
2207 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
2208 struct section_offsets
*delta
)
2210 /* There's nothing to relocate here. */
2214 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
2215 const char *func_name
)
2217 dw2_do_expand_symtabs_matching (objfile
, func_name
);
2221 dw2_expand_all_symtabs (struct objfile
*objfile
)
2225 dw2_setup (objfile
);
2227 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2228 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2230 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2232 dw2_instantiate_symtab (objfile
, cu
);
2237 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
2238 const char *filename
)
2242 dw2_setup (objfile
);
2243 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2244 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2247 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2249 if (cu
->v
.quick
->symtab
)
2252 dw2_require_line_header (objfile
, cu
);
2253 if (!cu
->v
.quick
->lines
)
2256 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2258 const char *this_name
= cu
->v
.quick
->file_names
[j
];
2259 if (strcmp (this_name
, filename
) == 0)
2261 dw2_instantiate_symtab (objfile
, cu
);
2269 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
2271 struct dwarf2_per_cu_data
*cu
;
2274 dw2_setup (objfile
);
2276 if (!dwarf2_per_objfile
->index_table
)
2279 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2283 /* Note that this just looks at the very first one named NAME -- but
2284 actually we are looking for a function. find_main_filename
2285 should be rewritten so that it doesn't require a custom hook. It
2286 could just use the ordinary symbol tables. */
2287 /* vec[0] is the length, which must always be >0. */
2288 cu
= dw2_get_cu (MAYBE_SWAP (vec
[1]));
2290 dw2_require_line_header (objfile
, cu
);
2291 if (!cu
->v
.quick
->lines
)
2294 return cu
->v
.quick
->file_names
[cu
->v
.quick
->lines
->num_file_names
- 1];
2298 dw2_map_ada_symtabs (struct objfile
*objfile
,
2299 int (*wild_match
) (const char *, int, const char *),
2300 int (*is_name_suffix
) (const char *),
2301 void (*callback
) (struct objfile
*,
2302 struct symtab
*, void *),
2303 const char *name
, int global
,
2304 domain_enum
namespace, int wild
,
2307 /* For now, we don't support Ada, so this function can't be
2309 internal_error (__FILE__
, __LINE__
,
2310 _("map_ada_symtabs called via index method"));
2314 dw2_expand_symtabs_matching (struct objfile
*objfile
,
2315 int (*file_matcher
) (const char *, void *),
2316 int (*name_matcher
) (const char *, void *),
2323 dw2_setup (objfile
);
2324 if (!dwarf2_per_objfile
->index_table
)
2327 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2328 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2331 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2333 cu
->v
.quick
->mark
= 0;
2334 if (cu
->v
.quick
->symtab
)
2337 dw2_require_line_header (objfile
, cu
);
2338 if (!cu
->v
.quick
->lines
)
2341 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2343 if (file_matcher (cu
->v
.quick
->file_names
[j
], data
))
2345 cu
->v
.quick
->mark
= 1;
2352 iter
< dwarf2_per_objfile
->index_table
->index_table_slots
;
2355 offset_type idx
= 2 * iter
;
2357 offset_type
*vec
, vec_len
, vec_idx
;
2359 if (dwarf2_per_objfile
->index_table
->index_table
[idx
] == 0
2360 && dwarf2_per_objfile
->index_table
->index_table
[idx
+ 1] == 0)
2363 name
= (dwarf2_per_objfile
->index_table
->constant_pool
2364 + dwarf2_per_objfile
->index_table
->index_table
[idx
]);
2366 if (! (*name_matcher
) (name
, data
))
2369 /* The name was matched, now expand corresponding CUs that were
2371 vec
= (offset_type
*) (dwarf2_per_objfile
->index_table
->constant_pool
2372 + dwarf2_per_objfile
->index_table
->index_table
[idx
+ 1]);
2373 vec_len
= MAYBE_SWAP (vec
[0]);
2374 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
2376 struct dwarf2_per_cu_data
*cu
;
2378 cu
= dw2_get_cu (MAYBE_SWAP (vec
[vec_idx
+ 1]));
2379 if (cu
->v
.quick
->mark
)
2380 dw2_instantiate_symtab (objfile
, cu
);
2385 static struct symtab
*
2386 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
2387 struct minimal_symbol
*msymbol
,
2389 struct obj_section
*section
,
2392 struct dwarf2_per_cu_data
*data
;
2394 dw2_setup (objfile
);
2396 if (!objfile
->psymtabs_addrmap
)
2399 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
2403 if (warn_if_readin
&& data
->v
.quick
->symtab
)
2404 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2405 paddress (get_objfile_arch (objfile
), pc
));
2407 return dw2_instantiate_symtab (objfile
, data
);
2411 dw2_map_symbol_names (struct objfile
*objfile
,
2412 void (*fun
) (const char *, void *),
2416 dw2_setup (objfile
);
2418 if (!dwarf2_per_objfile
->index_table
)
2422 iter
< dwarf2_per_objfile
->index_table
->index_table_slots
;
2425 offset_type idx
= 2 * iter
;
2427 offset_type
*vec
, vec_len
, vec_idx
;
2429 if (dwarf2_per_objfile
->index_table
->index_table
[idx
] == 0
2430 && dwarf2_per_objfile
->index_table
->index_table
[idx
+ 1] == 0)
2433 name
= (dwarf2_per_objfile
->index_table
->constant_pool
2434 + dwarf2_per_objfile
->index_table
->index_table
[idx
]);
2436 (*fun
) (name
, data
);
2441 dw2_map_symbol_filenames (struct objfile
*objfile
,
2442 void (*fun
) (const char *, const char *, void *),
2447 dw2_setup (objfile
);
2448 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2449 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2452 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2454 if (cu
->v
.quick
->symtab
)
2457 dw2_require_line_header (objfile
, cu
);
2458 if (!cu
->v
.quick
->lines
)
2461 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
2463 const char *this_full_name
= dw2_require_full_path (objfile
, cu
, j
);
2464 (*fun
) (cu
->v
.quick
->file_names
[j
], this_full_name
, data
);
2470 dw2_has_symbols (struct objfile
*objfile
)
2475 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
2478 dw2_find_last_source_symtab
,
2479 dw2_forget_cached_source_info
,
2482 dw2_pre_expand_symtabs_matching
,
2486 dw2_expand_symtabs_for_function
,
2487 dw2_expand_all_symtabs
,
2488 dw2_expand_symtabs_with_filename
,
2489 dw2_find_symbol_file
,
2490 dw2_map_ada_symtabs
,
2491 dw2_expand_symtabs_matching
,
2492 dw2_find_pc_sect_symtab
,
2493 dw2_map_symbol_names
,
2494 dw2_map_symbol_filenames
2497 /* Initialize for reading DWARF for this objfile. Return 0 if this
2498 file will use psymtabs, or 1 if using the GNU index. */
2501 dwarf2_initialize_objfile (struct objfile
*objfile
)
2503 /* If we're about to read full symbols, don't bother with the
2504 indices. In this case we also don't care if some other debug
2505 format is making psymtabs, because they are all about to be
2507 if ((objfile
->flags
& OBJF_READNOW
))
2511 dwarf2_per_objfile
->using_index
= 1;
2512 create_all_comp_units (objfile
);
2513 create_debug_types_hash_table (objfile
);
2515 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2516 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2518 struct dwarf2_per_cu_data
*cu
= dw2_get_cu (i
);
2520 cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2521 struct dwarf2_per_cu_quick_data
);
2524 /* Return 1 so that gdb sees the "quick" functions. However,
2525 these functions will be no-ops because we will have expanded
2530 if (dwarf2_read_index (objfile
))
2533 dwarf2_build_psymtabs (objfile
);
2539 /* Build a partial symbol table. */
2542 dwarf2_build_psymtabs (struct objfile
*objfile
)
2544 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
2546 init_psymbol_list (objfile
, 1024);
2549 dwarf2_build_psymtabs_hard (objfile
);
2552 /* Return TRUE if OFFSET is within CU_HEADER. */
2555 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
2557 unsigned int bottom
= cu_header
->offset
;
2558 unsigned int top
= (cu_header
->offset
2560 + cu_header
->initial_length_size
);
2562 return (offset
>= bottom
&& offset
< top
);
2565 /* Read in the comp unit header information from the debug_info at info_ptr.
2566 NOTE: This leaves members offset, first_die_offset to be filled in
2570 read_comp_unit_head (struct comp_unit_head
*cu_header
,
2571 gdb_byte
*info_ptr
, bfd
*abfd
)
2574 unsigned int bytes_read
;
2576 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
2577 cu_header
->initial_length_size
= bytes_read
;
2578 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
2579 info_ptr
+= bytes_read
;
2580 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
2582 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
2584 info_ptr
+= bytes_read
;
2585 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
2587 signed_addr
= bfd_get_sign_extend_vma (abfd
);
2588 if (signed_addr
< 0)
2589 internal_error (__FILE__
, __LINE__
,
2590 _("read_comp_unit_head: dwarf from non elf file"));
2591 cu_header
->signed_addr_p
= signed_addr
;
2597 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
2598 gdb_byte
*buffer
, unsigned int buffer_size
,
2601 gdb_byte
*beg_of_comp_unit
= info_ptr
;
2603 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
2605 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
2606 error (_("Dwarf Error: wrong version in compilation unit header "
2607 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
2608 bfd_get_filename (abfd
));
2610 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev
.size
)
2611 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
2612 "(offset 0x%lx + 6) [in module %s]"),
2613 (long) header
->abbrev_offset
,
2614 (long) (beg_of_comp_unit
- buffer
),
2615 bfd_get_filename (abfd
));
2617 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
2618 > buffer
+ buffer_size
)
2619 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
2620 "(offset 0x%lx + 0) [in module %s]"),
2621 (long) header
->length
,
2622 (long) (beg_of_comp_unit
- buffer
),
2623 bfd_get_filename (abfd
));
2628 /* Read in the types comp unit header information from .debug_types entry at
2629 types_ptr. The result is a pointer to one past the end of the header. */
2632 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
2633 ULONGEST
*signature
,
2634 gdb_byte
*types_ptr
, bfd
*abfd
)
2636 gdb_byte
*initial_types_ptr
= types_ptr
;
2638 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
2639 &dwarf2_per_objfile
->types
);
2640 cu_header
->offset
= types_ptr
- dwarf2_per_objfile
->types
.buffer
;
2642 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
2644 *signature
= read_8_bytes (abfd
, types_ptr
);
2646 types_ptr
+= cu_header
->offset_size
;
2647 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
2652 /* Allocate a new partial symtab for file named NAME and mark this new
2653 partial symtab as being an include of PST. */
2656 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
2657 struct objfile
*objfile
)
2659 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
2661 subpst
->section_offsets
= pst
->section_offsets
;
2662 subpst
->textlow
= 0;
2663 subpst
->texthigh
= 0;
2665 subpst
->dependencies
= (struct partial_symtab
**)
2666 obstack_alloc (&objfile
->objfile_obstack
,
2667 sizeof (struct partial_symtab
*));
2668 subpst
->dependencies
[0] = pst
;
2669 subpst
->number_of_dependencies
= 1;
2671 subpst
->globals_offset
= 0;
2672 subpst
->n_global_syms
= 0;
2673 subpst
->statics_offset
= 0;
2674 subpst
->n_static_syms
= 0;
2675 subpst
->symtab
= NULL
;
2676 subpst
->read_symtab
= pst
->read_symtab
;
2679 /* No private part is necessary for include psymtabs. This property
2680 can be used to differentiate between such include psymtabs and
2681 the regular ones. */
2682 subpst
->read_symtab_private
= NULL
;
2685 /* Read the Line Number Program data and extract the list of files
2686 included by the source file represented by PST. Build an include
2687 partial symtab for each of these included files. */
2690 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
2691 struct die_info
*die
,
2692 struct partial_symtab
*pst
)
2694 struct objfile
*objfile
= cu
->objfile
;
2695 bfd
*abfd
= objfile
->obfd
;
2696 struct line_header
*lh
= NULL
;
2697 struct attribute
*attr
;
2699 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2702 unsigned int line_offset
= DW_UNSND (attr
);
2704 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2707 return; /* No linetable, so no includes. */
2709 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
2711 free_line_header (lh
);
2715 hash_type_signature (const void *item
)
2717 const struct signatured_type
*type_sig
= item
;
2719 /* This drops the top 32 bits of the signature, but is ok for a hash. */
2720 return type_sig
->signature
;
2724 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
2726 const struct signatured_type
*lhs
= item_lhs
;
2727 const struct signatured_type
*rhs
= item_rhs
;
2729 return lhs
->signature
== rhs
->signature
;
2732 /* Allocate a hash table for signatured types. */
2735 allocate_signatured_type_hash_table (struct objfile
*objfile
)
2737 return htab_create_alloc_ex (41,
2738 hash_type_signature
,
2741 &objfile
->objfile_obstack
,
2742 hashtab_obstack_allocate
,
2743 dummy_obstack_deallocate
);
2746 /* A helper function to add a signatured type CU to a list. */
2749 add_signatured_type_cu_to_list (void **slot
, void *datum
)
2751 struct signatured_type
*sigt
= *slot
;
2752 struct dwarf2_per_cu_data
***datap
= datum
;
2754 **datap
= &sigt
->per_cu
;
2760 /* Create the hash table of all entries in the .debug_types section.
2761 The result is zero if there is an error (e.g. missing .debug_types section),
2762 otherwise non-zero. */
2765 create_debug_types_hash_table (struct objfile
*objfile
)
2769 struct dwarf2_per_cu_data
**iter
;
2771 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
2772 info_ptr
= dwarf2_per_objfile
->types
.buffer
;
2774 if (info_ptr
== NULL
)
2776 dwarf2_per_objfile
->signatured_types
= NULL
;
2780 types_htab
= allocate_signatured_type_hash_table (objfile
);
2782 if (dwarf2_die_debug
)
2783 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
2785 while (info_ptr
< dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
2787 unsigned int offset
;
2788 unsigned int offset_size
;
2789 unsigned int type_offset
;
2790 unsigned int length
, initial_length_size
;
2791 unsigned short version
;
2793 struct signatured_type
*type_sig
;
2795 gdb_byte
*ptr
= info_ptr
;
2797 offset
= ptr
- dwarf2_per_objfile
->types
.buffer
;
2799 /* We need to read the type's signature in order to build the hash
2800 table, but we don't need to read anything else just yet. */
2802 /* Sanity check to ensure entire cu is present. */
2803 length
= read_initial_length (objfile
->obfd
, ptr
, &initial_length_size
);
2804 if (ptr
+ length
+ initial_length_size
2805 > dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
2807 complaint (&symfile_complaints
,
2808 _("debug type entry runs off end of `.debug_types' section, ignored"));
2812 offset_size
= initial_length_size
== 4 ? 4 : 8;
2813 ptr
+= initial_length_size
;
2814 version
= bfd_get_16 (objfile
->obfd
, ptr
);
2816 ptr
+= offset_size
; /* abbrev offset */
2817 ptr
+= 1; /* address size */
2818 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
2820 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
2822 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
2823 memset (type_sig
, 0, sizeof (*type_sig
));
2824 type_sig
->signature
= signature
;
2825 type_sig
->offset
= offset
;
2826 type_sig
->type_offset
= type_offset
;
2827 type_sig
->per_cu
.objfile
= objfile
;
2828 type_sig
->per_cu
.from_debug_types
= 1;
2830 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
2831 gdb_assert (slot
!= NULL
);
2834 if (dwarf2_die_debug
)
2835 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
2836 offset
, phex (signature
, sizeof (signature
)));
2838 info_ptr
= info_ptr
+ initial_length_size
+ length
;
2841 dwarf2_per_objfile
->signatured_types
= types_htab
;
2843 dwarf2_per_objfile
->n_type_comp_units
= htab_elements (types_htab
);
2844 dwarf2_per_objfile
->type_comp_units
2845 = obstack_alloc (&objfile
->objfile_obstack
,
2846 dwarf2_per_objfile
->n_type_comp_units
2847 * sizeof (struct dwarf2_per_cu_data
*));
2848 iter
= &dwarf2_per_objfile
->type_comp_units
[0];
2849 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_list
, &iter
);
2850 gdb_assert (iter
- &dwarf2_per_objfile
->type_comp_units
[0]
2851 == dwarf2_per_objfile
->n_type_comp_units
);
2856 /* Lookup a signature based type.
2857 Returns NULL if SIG is not present in the table. */
2859 static struct signatured_type
*
2860 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
2862 struct signatured_type find_entry
, *entry
;
2864 if (dwarf2_per_objfile
->signatured_types
== NULL
)
2866 complaint (&symfile_complaints
,
2867 _("missing `.debug_types' section for DW_FORM_sig8 die"));
2871 find_entry
.signature
= sig
;
2872 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
2876 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
2879 init_cu_die_reader (struct die_reader_specs
*reader
,
2880 struct dwarf2_cu
*cu
)
2882 reader
->abfd
= cu
->objfile
->obfd
;
2884 if (cu
->per_cu
->from_debug_types
)
2886 gdb_assert (dwarf2_per_objfile
->types
.readin
);
2887 reader
->buffer
= dwarf2_per_objfile
->types
.buffer
;
2891 gdb_assert (dwarf2_per_objfile
->info
.readin
);
2892 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
2896 /* Find the base address of the compilation unit for range lists and
2897 location lists. It will normally be specified by DW_AT_low_pc.
2898 In DWARF-3 draft 4, the base address could be overridden by
2899 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2900 compilation units with discontinuous ranges. */
2903 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
2905 struct attribute
*attr
;
2908 cu
->base_address
= 0;
2910 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
2913 cu
->base_address
= DW_ADDR (attr
);
2918 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
2921 cu
->base_address
= DW_ADDR (attr
);
2927 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
2928 to combine the common parts.
2929 Process a compilation unit for a psymtab.
2930 BUFFER is a pointer to the beginning of the dwarf section buffer,
2931 either .debug_info or debug_types.
2932 INFO_PTR is a pointer to the start of the CU.
2933 Returns a pointer to the next CU. */
2936 process_psymtab_comp_unit (struct objfile
*objfile
,
2937 struct dwarf2_per_cu_data
*this_cu
,
2938 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
2939 unsigned int buffer_size
)
2941 bfd
*abfd
= objfile
->obfd
;
2942 gdb_byte
*beg_of_comp_unit
= info_ptr
;
2943 struct die_info
*comp_unit_die
;
2944 struct partial_symtab
*pst
;
2946 struct cleanup
*back_to_inner
;
2947 struct dwarf2_cu cu
;
2948 int has_children
, has_pc_info
;
2949 struct attribute
*attr
;
2950 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
2951 struct die_reader_specs reader_specs
;
2953 memset (&cu
, 0, sizeof (cu
));
2954 cu
.objfile
= objfile
;
2955 obstack_init (&cu
.comp_unit_obstack
);
2957 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
2959 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
2960 buffer
, buffer_size
,
2963 /* Complete the cu_header. */
2964 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
2965 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
2967 cu
.list_in_scope
= &file_symbols
;
2969 /* If this compilation unit was already read in, free the
2970 cached copy in order to read it in again. This is
2971 necessary because we skipped some symbols when we first
2972 read in the compilation unit (see load_partial_dies).
2973 This problem could be avoided, but the benefit is
2975 if (this_cu
->cu
!= NULL
)
2976 free_one_cached_comp_unit (this_cu
->cu
);
2978 /* Note that this is a pointer to our stack frame, being
2979 added to a global data structure. It will be cleaned up
2980 in free_stack_comp_unit when we finish with this
2981 compilation unit. */
2983 cu
.per_cu
= this_cu
;
2985 /* Read the abbrevs for this compilation unit into a table. */
2986 dwarf2_read_abbrevs (abfd
, &cu
);
2987 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
2989 /* Read the compilation unit die. */
2990 if (this_cu
->from_debug_types
)
2991 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
2992 init_cu_die_reader (&reader_specs
, &cu
);
2993 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2996 if (this_cu
->from_debug_types
)
2998 /* offset,length haven't been set yet for type units. */
2999 this_cu
->offset
= cu
.header
.offset
;
3000 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
3002 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3004 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3005 + cu
.header
.initial_length_size
);
3006 do_cleanups (back_to_inner
);
3010 /* Set the language we're debugging. */
3011 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, &cu
);
3013 set_cu_language (DW_UNSND (attr
), &cu
);
3015 set_cu_language (language_minimal
, &cu
);
3017 /* Allocate a new partial symbol table structure. */
3018 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
3019 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
3020 (attr
!= NULL
) ? DW_STRING (attr
) : "",
3021 /* TEXTLOW and TEXTHIGH are set below. */
3023 objfile
->global_psymbols
.next
,
3024 objfile
->static_psymbols
.next
);
3026 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
3028 pst
->dirname
= DW_STRING (attr
);
3030 pst
->read_symtab_private
= this_cu
;
3032 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3034 /* Store the function that reads in the rest of the symbol table */
3035 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
3037 this_cu
->v
.psymtab
= pst
;
3039 dwarf2_find_base_address (comp_unit_die
, &cu
);
3041 /* Possibly set the default values of LOWPC and HIGHPC from
3043 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
3044 &best_highpc
, &cu
, pst
);
3045 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
3046 /* Store the contiguous range if it is not empty; it can be empty for
3047 CUs with no code. */
3048 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3049 best_lowpc
+ baseaddr
,
3050 best_highpc
+ baseaddr
- 1, pst
);
3052 /* Check if comp unit has_children.
3053 If so, read the rest of the partial symbols from this comp unit.
3054 If not, there's no more debug_info for this comp unit. */
3057 struct partial_die_info
*first_die
;
3058 CORE_ADDR lowpc
, highpc
;
3060 lowpc
= ((CORE_ADDR
) -1);
3061 highpc
= ((CORE_ADDR
) 0);
3063 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
3065 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
3066 ! has_pc_info
, &cu
);
3068 /* If we didn't find a lowpc, set it to highpc to avoid
3069 complaints from `maint check'. */
3070 if (lowpc
== ((CORE_ADDR
) -1))
3073 /* If the compilation unit didn't have an explicit address range,
3074 then use the information extracted from its child dies. */
3078 best_highpc
= highpc
;
3081 pst
->textlow
= best_lowpc
+ baseaddr
;
3082 pst
->texthigh
= best_highpc
+ baseaddr
;
3084 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
3085 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
3086 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
3087 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
3088 sort_pst_symbols (pst
);
3090 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3091 + cu
.header
.initial_length_size
);
3093 if (this_cu
->from_debug_types
)
3095 /* It's not clear we want to do anything with stmt lists here.
3096 Waiting to see what gcc ultimately does. */
3100 /* Get the list of files included in the current compilation unit,
3101 and build a psymtab for each of them. */
3102 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
3105 do_cleanups (back_to_inner
);
3110 /* Traversal function for htab_traverse_noresize.
3111 Process one .debug_types comp-unit. */
3114 process_type_comp_unit (void **slot
, void *info
)
3116 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
3117 struct objfile
*objfile
= (struct objfile
*) info
;
3118 struct dwarf2_per_cu_data
*this_cu
;
3120 this_cu
= &entry
->per_cu
;
3122 gdb_assert (dwarf2_per_objfile
->types
.readin
);
3123 process_psymtab_comp_unit (objfile
, this_cu
,
3124 dwarf2_per_objfile
->types
.buffer
,
3125 dwarf2_per_objfile
->types
.buffer
+ entry
->offset
,
3126 dwarf2_per_objfile
->types
.size
);
3131 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3132 Build partial symbol tables for the .debug_types comp-units. */
3135 build_type_psymtabs (struct objfile
*objfile
)
3137 if (! create_debug_types_hash_table (objfile
))
3140 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
3141 process_type_comp_unit
, objfile
);
3144 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3147 psymtabs_addrmap_cleanup (void *o
)
3149 struct objfile
*objfile
= o
;
3151 objfile
->psymtabs_addrmap
= NULL
;
3154 /* Build the partial symbol table by doing a quick pass through the
3155 .debug_info and .debug_abbrev sections. */
3158 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
3161 struct cleanup
*back_to
, *addrmap_cleanup
;
3162 struct obstack temp_obstack
;
3164 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3165 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3167 /* Any cached compilation units will be linked by the per-objfile
3168 read_in_chain. Make sure to free them when we're done. */
3169 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
3171 build_type_psymtabs (objfile
);
3173 create_all_comp_units (objfile
);
3175 /* Create a temporary address map on a temporary obstack. We later
3176 copy this to the final obstack. */
3177 obstack_init (&temp_obstack
);
3178 make_cleanup_obstack_free (&temp_obstack
);
3179 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
3180 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
3182 /* Since the objects we're extracting from .debug_info vary in
3183 length, only the individual functions to extract them (like
3184 read_comp_unit_head and load_partial_die) can really know whether
3185 the buffer is large enough to hold another complete object.
3187 At the moment, they don't actually check that. If .debug_info
3188 holds just one extra byte after the last compilation unit's dies,
3189 then read_comp_unit_head will happily read off the end of the
3190 buffer. read_partial_die is similarly casual. Those functions
3193 For this loop condition, simply checking whether there's any data
3194 left at all should be sufficient. */
3196 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
3197 + dwarf2_per_objfile
->info
.size
))
3199 struct dwarf2_per_cu_data
*this_cu
;
3201 this_cu
= dwarf2_find_comp_unit (info_ptr
- dwarf2_per_objfile
->info
.buffer
,
3204 info_ptr
= process_psymtab_comp_unit (objfile
, this_cu
,
3205 dwarf2_per_objfile
->info
.buffer
,
3207 dwarf2_per_objfile
->info
.size
);
3210 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
3211 &objfile
->objfile_obstack
);
3212 discard_cleanups (addrmap_cleanup
);
3214 do_cleanups (back_to
);
3217 /* Load the partial DIEs for a secondary CU into memory. */
3220 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
3221 struct objfile
*objfile
)
3223 bfd
*abfd
= objfile
->obfd
;
3224 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
3225 struct die_info
*comp_unit_die
;
3226 struct dwarf2_cu
*cu
;
3227 struct cleanup
*back_to
;
3228 struct attribute
*attr
;
3230 struct die_reader_specs reader_specs
;
3232 gdb_assert (! this_cu
->from_debug_types
);
3234 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3235 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
3236 beg_of_comp_unit
= info_ptr
;
3238 cu
= alloc_one_comp_unit (objfile
);
3240 /* ??? Missing cleanup for CU? */
3242 /* Link this compilation unit into the compilation unit tree. */
3244 cu
->per_cu
= this_cu
;
3245 cu
->type_hash
= this_cu
->type_hash
;
3247 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
3248 dwarf2_per_objfile
->info
.buffer
,
3249 dwarf2_per_objfile
->info
.size
,
3252 /* Complete the cu_header. */
3253 cu
->header
.offset
= this_cu
->offset
;
3254 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3256 /* Read the abbrevs for this compilation unit into a table. */
3257 dwarf2_read_abbrevs (abfd
, cu
);
3258 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3260 /* Read the compilation unit die. */
3261 init_cu_die_reader (&reader_specs
, cu
);
3262 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3265 /* Set the language we're debugging. */
3266 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
3268 set_cu_language (DW_UNSND (attr
), cu
);
3270 set_cu_language (language_minimal
, cu
);
3272 /* Check if comp unit has_children.
3273 If so, read the rest of the partial symbols from this comp unit.
3274 If not, there's no more debug_info for this comp unit. */
3276 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
3278 do_cleanups (back_to
);
3281 /* Create a list of all compilation units in OBJFILE. We do this only
3282 if an inter-comp-unit reference is found; presumably if there is one,
3283 there will be many, and one will occur early in the .debug_info section.
3284 So there's no point in building this list incrementally. */
3287 create_all_comp_units (struct objfile
*objfile
)
3291 struct dwarf2_per_cu_data
**all_comp_units
;
3294 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3295 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3299 all_comp_units
= xmalloc (n_allocated
3300 * sizeof (struct dwarf2_per_cu_data
*));
3302 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
+ dwarf2_per_objfile
->info
.size
)
3304 unsigned int length
, initial_length_size
;
3305 struct dwarf2_per_cu_data
*this_cu
;
3306 unsigned int offset
;
3308 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
3310 /* Read just enough information to find out where the next
3311 compilation unit is. */
3312 length
= read_initial_length (objfile
->obfd
, info_ptr
,
3313 &initial_length_size
);
3315 /* Save the compilation unit for later lookup. */
3316 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
3317 sizeof (struct dwarf2_per_cu_data
));
3318 memset (this_cu
, 0, sizeof (*this_cu
));
3319 this_cu
->offset
= offset
;
3320 this_cu
->length
= length
+ initial_length_size
;
3321 this_cu
->objfile
= objfile
;
3323 if (n_comp_units
== n_allocated
)
3326 all_comp_units
= xrealloc (all_comp_units
,
3328 * sizeof (struct dwarf2_per_cu_data
*));
3330 all_comp_units
[n_comp_units
++] = this_cu
;
3332 info_ptr
= info_ptr
+ this_cu
->length
;
3335 dwarf2_per_objfile
->all_comp_units
3336 = obstack_alloc (&objfile
->objfile_obstack
,
3337 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3338 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
3339 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3340 xfree (all_comp_units
);
3341 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
3344 /* Process all loaded DIEs for compilation unit CU, starting at
3345 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3346 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3347 DW_AT_ranges). If NEED_PC is set, then this function will set
3348 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3349 and record the covered ranges in the addrmap. */
3352 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
3353 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3355 struct partial_die_info
*pdi
;
3357 /* Now, march along the PDI's, descending into ones which have
3358 interesting children but skipping the children of the other ones,
3359 until we reach the end of the compilation unit. */
3365 fixup_partial_die (pdi
, cu
);
3367 /* Anonymous namespaces or modules have no name but have interesting
3368 children, so we need to look at them. Ditto for anonymous
3371 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
3372 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
)
3376 case DW_TAG_subprogram
:
3377 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3379 case DW_TAG_variable
:
3380 case DW_TAG_typedef
:
3381 case DW_TAG_union_type
:
3382 if (!pdi
->is_declaration
)
3384 add_partial_symbol (pdi
, cu
);
3387 case DW_TAG_class_type
:
3388 case DW_TAG_interface_type
:
3389 case DW_TAG_structure_type
:
3390 if (!pdi
->is_declaration
)
3392 add_partial_symbol (pdi
, cu
);
3395 case DW_TAG_enumeration_type
:
3396 if (!pdi
->is_declaration
)
3397 add_partial_enumeration (pdi
, cu
);
3399 case DW_TAG_base_type
:
3400 case DW_TAG_subrange_type
:
3401 /* File scope base type definitions are added to the partial
3403 add_partial_symbol (pdi
, cu
);
3405 case DW_TAG_namespace
:
3406 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
3409 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
3416 /* If the die has a sibling, skip to the sibling. */
3418 pdi
= pdi
->die_sibling
;
3422 /* Functions used to compute the fully scoped name of a partial DIE.
3424 Normally, this is simple. For C++, the parent DIE's fully scoped
3425 name is concatenated with "::" and the partial DIE's name. For
3426 Java, the same thing occurs except that "." is used instead of "::".
3427 Enumerators are an exception; they use the scope of their parent
3428 enumeration type, i.e. the name of the enumeration type is not
3429 prepended to the enumerator.
3431 There are two complexities. One is DW_AT_specification; in this
3432 case "parent" means the parent of the target of the specification,
3433 instead of the direct parent of the DIE. The other is compilers
3434 which do not emit DW_TAG_namespace; in this case we try to guess
3435 the fully qualified name of structure types from their members'
3436 linkage names. This must be done using the DIE's children rather
3437 than the children of any DW_AT_specification target. We only need
3438 to do this for structures at the top level, i.e. if the target of
3439 any DW_AT_specification (if any; otherwise the DIE itself) does not
3442 /* Compute the scope prefix associated with PDI's parent, in
3443 compilation unit CU. The result will be allocated on CU's
3444 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3445 field. NULL is returned if no prefix is necessary. */
3447 partial_die_parent_scope (struct partial_die_info
*pdi
,
3448 struct dwarf2_cu
*cu
)
3450 char *grandparent_scope
;
3451 struct partial_die_info
*parent
, *real_pdi
;
3453 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3454 then this means the parent of the specification DIE. */
3457 while (real_pdi
->has_specification
)
3458 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3460 parent
= real_pdi
->die_parent
;
3464 if (parent
->scope_set
)
3465 return parent
->scope
;
3467 fixup_partial_die (parent
, cu
);
3469 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
3471 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3472 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3473 Work around this problem here. */
3474 if (cu
->language
== language_cplus
3475 && parent
->tag
== DW_TAG_namespace
3476 && strcmp (parent
->name
, "::") == 0
3477 && grandparent_scope
== NULL
)
3479 parent
->scope
= NULL
;
3480 parent
->scope_set
= 1;
3484 if (parent
->tag
== DW_TAG_namespace
3485 || parent
->tag
== DW_TAG_module
3486 || parent
->tag
== DW_TAG_structure_type
3487 || parent
->tag
== DW_TAG_class_type
3488 || parent
->tag
== DW_TAG_interface_type
3489 || parent
->tag
== DW_TAG_union_type
3490 || parent
->tag
== DW_TAG_enumeration_type
)
3492 if (grandparent_scope
== NULL
)
3493 parent
->scope
= parent
->name
;
3495 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
3496 parent
->name
, 0, cu
);
3498 else if (parent
->tag
== DW_TAG_enumerator
)
3499 /* Enumerators should not get the name of the enumeration as a prefix. */
3500 parent
->scope
= grandparent_scope
;
3503 /* FIXME drow/2004-04-01: What should we be doing with
3504 function-local names? For partial symbols, we should probably be
3506 complaint (&symfile_complaints
,
3507 _("unhandled containing DIE tag %d for DIE at %d"),
3508 parent
->tag
, pdi
->offset
);
3509 parent
->scope
= grandparent_scope
;
3512 parent
->scope_set
= 1;
3513 return parent
->scope
;
3516 /* Return the fully scoped name associated with PDI, from compilation unit
3517 CU. The result will be allocated with malloc. */
3519 partial_die_full_name (struct partial_die_info
*pdi
,
3520 struct dwarf2_cu
*cu
)
3524 parent_scope
= partial_die_parent_scope (pdi
, cu
);
3525 if (parent_scope
== NULL
)
3528 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
3532 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
3534 struct objfile
*objfile
= cu
->objfile
;
3536 char *actual_name
= NULL
;
3537 const struct partial_symbol
*psym
= NULL
;
3539 int built_actual_name
= 0;
3541 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3543 actual_name
= partial_die_full_name (pdi
, cu
);
3545 built_actual_name
= 1;
3547 if (actual_name
== NULL
)
3548 actual_name
= pdi
->name
;
3552 case DW_TAG_subprogram
:
3553 if (pdi
->is_external
|| cu
->language
== language_ada
)
3555 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
3556 of the global scope. But in Ada, we want to be able to access
3557 nested procedures globally. So all Ada subprograms are stored
3558 in the global scope. */
3559 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3560 mst_text, objfile); */
3561 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
3563 VAR_DOMAIN
, LOC_BLOCK
,
3564 &objfile
->global_psymbols
,
3565 0, pdi
->lowpc
+ baseaddr
,
3566 cu
->language
, objfile
);
3570 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3571 mst_file_text, objfile); */
3572 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
3574 VAR_DOMAIN
, LOC_BLOCK
,
3575 &objfile
->static_psymbols
,
3576 0, pdi
->lowpc
+ baseaddr
,
3577 cu
->language
, objfile
);
3580 case DW_TAG_variable
:
3582 addr
= decode_locdesc (pdi
->locdesc
, cu
);
3586 && !dwarf2_per_objfile
->has_section_at_zero
)
3588 /* A global or static variable may also have been stripped
3589 out by the linker if unused, in which case its address
3590 will be nullified; do not add such variables into partial
3591 symbol table then. */
3593 else if (pdi
->is_external
)
3596 Don't enter into the minimal symbol tables as there is
3597 a minimal symbol table entry from the ELF symbols already.
3598 Enter into partial symbol table if it has a location
3599 descriptor or a type.
3600 If the location descriptor is missing, new_symbol will create
3601 a LOC_UNRESOLVED symbol, the address of the variable will then
3602 be determined from the minimal symbol table whenever the variable
3604 The address for the partial symbol table entry is not
3605 used by GDB, but it comes in handy for debugging partial symbol
3608 if (pdi
->locdesc
|| pdi
->has_type
)
3609 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
3611 VAR_DOMAIN
, LOC_STATIC
,
3612 &objfile
->global_psymbols
,
3614 cu
->language
, objfile
);
3618 /* Static Variable. Skip symbols without location descriptors. */
3619 if (pdi
->locdesc
== NULL
)
3621 if (built_actual_name
)
3622 xfree (actual_name
);
3625 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
3626 mst_file_data, objfile); */
3627 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
3629 VAR_DOMAIN
, LOC_STATIC
,
3630 &objfile
->static_psymbols
,
3632 cu
->language
, objfile
);
3635 case DW_TAG_typedef
:
3636 case DW_TAG_base_type
:
3637 case DW_TAG_subrange_type
:
3638 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3640 VAR_DOMAIN
, LOC_TYPEDEF
,
3641 &objfile
->static_psymbols
,
3642 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3644 case DW_TAG_namespace
:
3645 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3647 VAR_DOMAIN
, LOC_TYPEDEF
,
3648 &objfile
->global_psymbols
,
3649 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3651 case DW_TAG_class_type
:
3652 case DW_TAG_interface_type
:
3653 case DW_TAG_structure_type
:
3654 case DW_TAG_union_type
:
3655 case DW_TAG_enumeration_type
:
3656 /* Skip external references. The DWARF standard says in the section
3657 about "Structure, Union, and Class Type Entries": "An incomplete
3658 structure, union or class type is represented by a structure,
3659 union or class entry that does not have a byte size attribute
3660 and that has a DW_AT_declaration attribute." */
3661 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
3663 if (built_actual_name
)
3664 xfree (actual_name
);
3668 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
3669 static vs. global. */
3670 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3672 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3673 (cu
->language
== language_cplus
3674 || cu
->language
== language_java
)
3675 ? &objfile
->global_psymbols
3676 : &objfile
->static_psymbols
,
3677 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3680 case DW_TAG_enumerator
:
3681 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3683 VAR_DOMAIN
, LOC_CONST
,
3684 (cu
->language
== language_cplus
3685 || cu
->language
== language_java
)
3686 ? &objfile
->global_psymbols
3687 : &objfile
->static_psymbols
,
3688 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3694 if (built_actual_name
)
3695 xfree (actual_name
);
3698 /* Read a partial die corresponding to a namespace; also, add a symbol
3699 corresponding to that namespace to the symbol table. NAMESPACE is
3700 the name of the enclosing namespace. */
3703 add_partial_namespace (struct partial_die_info
*pdi
,
3704 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3705 int need_pc
, struct dwarf2_cu
*cu
)
3707 /* Add a symbol for the namespace. */
3709 add_partial_symbol (pdi
, cu
);
3711 /* Now scan partial symbols in that namespace. */
3713 if (pdi
->has_children
)
3714 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
3717 /* Read a partial die corresponding to a Fortran module. */
3720 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
3721 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3723 /* Now scan partial symbols in that module. */
3725 if (pdi
->has_children
)
3726 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
3729 /* Read a partial die corresponding to a subprogram and create a partial
3730 symbol for that subprogram. When the CU language allows it, this
3731 routine also defines a partial symbol for each nested subprogram
3732 that this subprogram contains.
3734 DIE my also be a lexical block, in which case we simply search
3735 recursively for suprograms defined inside that lexical block.
3736 Again, this is only performed when the CU language allows this
3737 type of definitions. */
3740 add_partial_subprogram (struct partial_die_info
*pdi
,
3741 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3742 int need_pc
, struct dwarf2_cu
*cu
)
3744 if (pdi
->tag
== DW_TAG_subprogram
)
3746 if (pdi
->has_pc_info
)
3748 if (pdi
->lowpc
< *lowpc
)
3749 *lowpc
= pdi
->lowpc
;
3750 if (pdi
->highpc
> *highpc
)
3751 *highpc
= pdi
->highpc
;
3755 struct objfile
*objfile
= cu
->objfile
;
3757 baseaddr
= ANOFFSET (objfile
->section_offsets
,
3758 SECT_OFF_TEXT (objfile
));
3759 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3760 pdi
->lowpc
+ baseaddr
,
3761 pdi
->highpc
- 1 + baseaddr
,
3762 cu
->per_cu
->v
.psymtab
);
3764 if (!pdi
->is_declaration
)
3765 /* Ignore subprogram DIEs that do not have a name, they are
3766 illegal. Do not emit a complaint at this point, we will
3767 do so when we convert this psymtab into a symtab. */
3769 add_partial_symbol (pdi
, cu
);
3773 if (! pdi
->has_children
)
3776 if (cu
->language
== language_ada
)
3778 pdi
= pdi
->die_child
;
3781 fixup_partial_die (pdi
, cu
);
3782 if (pdi
->tag
== DW_TAG_subprogram
3783 || pdi
->tag
== DW_TAG_lexical_block
)
3784 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3785 pdi
= pdi
->die_sibling
;
3790 /* See if we can figure out if the class lives in a namespace. We do
3791 this by looking for a member function; its demangled name will
3792 contain namespace info, if there is any. */
3795 guess_structure_name (struct partial_die_info
*struct_pdi
,
3796 struct dwarf2_cu
*cu
)
3798 if ((cu
->language
== language_cplus
3799 || cu
->language
== language_java
)
3800 && cu
->has_namespace_info
== 0
3801 && struct_pdi
->has_children
)
3803 /* NOTE: carlton/2003-10-07: Getting the info this way changes
3804 what template types look like, because the demangler
3805 frequently doesn't give the same name as the debug info. We
3806 could fix this by only using the demangled name to get the
3807 prefix (but see comment in read_structure_type). */
3809 struct partial_die_info
*real_pdi
;
3811 /* If this DIE (this DIE's specification, if any) has a parent, then
3812 we should not do this. We'll prepend the parent's fully qualified
3813 name when we create the partial symbol. */
3815 real_pdi
= struct_pdi
;
3816 while (real_pdi
->has_specification
)
3817 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3819 if (real_pdi
->die_parent
!= NULL
)
3824 /* Read a partial die corresponding to an enumeration type. */
3827 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
3828 struct dwarf2_cu
*cu
)
3830 struct partial_die_info
*pdi
;
3832 if (enum_pdi
->name
!= NULL
)
3833 add_partial_symbol (enum_pdi
, cu
);
3835 pdi
= enum_pdi
->die_child
;
3838 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
3839 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
3841 add_partial_symbol (pdi
, cu
);
3842 pdi
= pdi
->die_sibling
;
3846 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
3847 Return the corresponding abbrev, or NULL if the number is zero (indicating
3848 an empty DIE). In either case *BYTES_READ will be set to the length of
3849 the initial number. */
3851 static struct abbrev_info
*
3852 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
3853 struct dwarf2_cu
*cu
)
3855 bfd
*abfd
= cu
->objfile
->obfd
;
3856 unsigned int abbrev_number
;
3857 struct abbrev_info
*abbrev
;
3859 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
3861 if (abbrev_number
== 0)
3864 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
3867 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
3868 bfd_get_filename (abfd
));
3874 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
3875 Returns a pointer to the end of a series of DIEs, terminated by an empty
3876 DIE. Any children of the skipped DIEs will also be skipped. */
3879 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
3881 struct abbrev_info
*abbrev
;
3882 unsigned int bytes_read
;
3886 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
3888 return info_ptr
+ bytes_read
;
3890 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
3894 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
3895 INFO_PTR should point just after the initial uleb128 of a DIE, and the
3896 abbrev corresponding to that skipped uleb128 should be passed in
3897 ABBREV. Returns a pointer to this DIE's sibling, skipping any
3901 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
3902 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
3904 unsigned int bytes_read
;
3905 struct attribute attr
;
3906 bfd
*abfd
= cu
->objfile
->obfd
;
3907 unsigned int form
, i
;
3909 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
3911 /* The only abbrev we care about is DW_AT_sibling. */
3912 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
3914 read_attribute (&attr
, &abbrev
->attrs
[i
],
3915 abfd
, info_ptr
, cu
);
3916 if (attr
.form
== DW_FORM_ref_addr
)
3917 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
3919 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
3922 /* If it isn't DW_AT_sibling, skip this attribute. */
3923 form
= abbrev
->attrs
[i
].form
;
3927 case DW_FORM_ref_addr
:
3928 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
3929 and later it is offset sized. */
3930 if (cu
->header
.version
== 2)
3931 info_ptr
+= cu
->header
.addr_size
;
3933 info_ptr
+= cu
->header
.offset_size
;
3936 info_ptr
+= cu
->header
.addr_size
;
3943 case DW_FORM_flag_present
:
3958 case DW_FORM_string
:
3959 read_direct_string (abfd
, info_ptr
, &bytes_read
);
3960 info_ptr
+= bytes_read
;
3962 case DW_FORM_sec_offset
:
3964 info_ptr
+= cu
->header
.offset_size
;
3966 case DW_FORM_exprloc
:
3968 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3969 info_ptr
+= bytes_read
;
3971 case DW_FORM_block1
:
3972 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
3974 case DW_FORM_block2
:
3975 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
3977 case DW_FORM_block4
:
3978 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
3982 case DW_FORM_ref_udata
:
3983 info_ptr
= skip_leb128 (abfd
, info_ptr
);
3985 case DW_FORM_indirect
:
3986 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3987 info_ptr
+= bytes_read
;
3988 /* We need to continue parsing from here, so just go back to
3990 goto skip_attribute
;
3993 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
3994 dwarf_form_name (form
),
3995 bfd_get_filename (abfd
));
3999 if (abbrev
->has_children
)
4000 return skip_children (buffer
, info_ptr
, cu
);
4005 /* Locate ORIG_PDI's sibling.
4006 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4010 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
4011 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4012 bfd
*abfd
, struct dwarf2_cu
*cu
)
4014 /* Do we know the sibling already? */
4016 if (orig_pdi
->sibling
)
4017 return orig_pdi
->sibling
;
4019 /* Are there any children to deal with? */
4021 if (!orig_pdi
->has_children
)
4024 /* Skip the children the long way. */
4026 return skip_children (buffer
, info_ptr
, cu
);
4029 /* Expand this partial symbol table into a full symbol table. */
4032 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
4038 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
4044 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
4045 gdb_flush (gdb_stdout
);
4048 /* Restore our global data. */
4049 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
4050 dwarf2_objfile_data_key
);
4052 /* If this psymtab is constructed from a debug-only objfile, the
4053 has_section_at_zero flag will not necessarily be correct. We
4054 can get the correct value for this flag by looking at the data
4055 associated with the (presumably stripped) associated objfile. */
4056 if (pst
->objfile
->separate_debug_objfile_backlink
)
4058 struct dwarf2_per_objfile
*dpo_backlink
4059 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
4060 dwarf2_objfile_data_key
);
4062 dwarf2_per_objfile
->has_section_at_zero
4063 = dpo_backlink
->has_section_at_zero
;
4066 psymtab_to_symtab_1 (pst
);
4068 /* Finish up the debug error message. */
4070 printf_filtered (_("done.\n"));
4075 /* Add PER_CU to the queue. */
4078 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
4080 struct dwarf2_queue_item
*item
;
4083 item
= xmalloc (sizeof (*item
));
4084 item
->per_cu
= per_cu
;
4087 if (dwarf2_queue
== NULL
)
4088 dwarf2_queue
= item
;
4090 dwarf2_queue_tail
->next
= item
;
4092 dwarf2_queue_tail
= item
;
4095 /* Process the queue. */
4098 process_queue (struct objfile
*objfile
)
4100 struct dwarf2_queue_item
*item
, *next_item
;
4102 /* The queue starts out with one item, but following a DIE reference
4103 may load a new CU, adding it to the end of the queue. */
4104 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
4106 if (dwarf2_per_objfile
->using_index
4107 ? !item
->per_cu
->v
.quick
->symtab
4108 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
4109 process_full_comp_unit (item
->per_cu
);
4111 item
->per_cu
->queued
= 0;
4112 next_item
= item
->next
;
4116 dwarf2_queue_tail
= NULL
;
4119 /* Free all allocated queue entries. This function only releases anything if
4120 an error was thrown; if the queue was processed then it would have been
4121 freed as we went along. */
4124 dwarf2_release_queue (void *dummy
)
4126 struct dwarf2_queue_item
*item
, *last
;
4128 item
= dwarf2_queue
;
4131 /* Anything still marked queued is likely to be in an
4132 inconsistent state, so discard it. */
4133 if (item
->per_cu
->queued
)
4135 if (item
->per_cu
->cu
!= NULL
)
4136 free_one_cached_comp_unit (item
->per_cu
->cu
);
4137 item
->per_cu
->queued
= 0;
4145 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
4148 /* Read in full symbols for PST, and anything it depends on. */
4151 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
4153 struct dwarf2_per_cu_data
*per_cu
;
4154 struct cleanup
*back_to
;
4157 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
4158 if (!pst
->dependencies
[i
]->readin
)
4160 /* Inform about additional files that need to be read in. */
4163 /* FIXME: i18n: Need to make this a single string. */
4164 fputs_filtered (" ", gdb_stdout
);
4166 fputs_filtered ("and ", gdb_stdout
);
4168 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
4169 wrap_here (""); /* Flush output */
4170 gdb_flush (gdb_stdout
);
4172 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
4175 per_cu
= pst
->read_symtab_private
;
4179 /* It's an include file, no symbols to read for it.
4180 Everything is in the parent symtab. */
4185 dw2_do_instantiate_symtab (pst
->objfile
, per_cu
);
4188 /* Load the DIEs associated with PER_CU into memory. */
4191 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
4193 bfd
*abfd
= objfile
->obfd
;
4194 struct dwarf2_cu
*cu
;
4195 unsigned int offset
;
4196 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
4197 struct cleanup
*back_to
, *free_cu_cleanup
;
4198 struct attribute
*attr
;
4200 gdb_assert (! per_cu
->from_debug_types
);
4202 /* Set local variables from the partial symbol table info. */
4203 offset
= per_cu
->offset
;
4205 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4206 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
4207 beg_of_comp_unit
= info_ptr
;
4209 cu
= alloc_one_comp_unit (objfile
);
4211 /* If an error occurs while loading, release our storage. */
4212 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
4214 /* Read in the comp_unit header. */
4215 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
4217 /* Complete the cu_header. */
4218 cu
->header
.offset
= offset
;
4219 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
4221 /* Read the abbrevs for this compilation unit. */
4222 dwarf2_read_abbrevs (abfd
, cu
);
4223 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
4225 /* Link this compilation unit into the compilation unit tree. */
4227 cu
->per_cu
= per_cu
;
4228 cu
->type_hash
= per_cu
->type_hash
;
4230 cu
->dies
= read_comp_unit (info_ptr
, cu
);
4232 /* We try not to read any attributes in this function, because not
4233 all objfiles needed for references have been loaded yet, and symbol
4234 table processing isn't initialized. But we have to set the CU language,
4235 or we won't be able to build types correctly. */
4236 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
4238 set_cu_language (DW_UNSND (attr
), cu
);
4240 set_cu_language (language_minimal
, cu
);
4242 /* Similarly, if we do not read the producer, we can not apply
4243 producer-specific interpretation. */
4244 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
4246 cu
->producer
= DW_STRING (attr
);
4248 /* Link this CU into read_in_chain. */
4249 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4250 dwarf2_per_objfile
->read_in_chain
= per_cu
;
4252 do_cleanups (back_to
);
4254 /* We've successfully allocated this compilation unit. Let our caller
4255 clean it up when finished with it. */
4256 discard_cleanups (free_cu_cleanup
);
4259 /* Generate full symbol information for PST and CU, whose DIEs have
4260 already been loaded into memory. */
4263 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4265 struct dwarf2_cu
*cu
= per_cu
->cu
;
4266 struct objfile
*objfile
= per_cu
->objfile
;
4267 CORE_ADDR lowpc
, highpc
;
4268 struct symtab
*symtab
;
4269 struct cleanup
*back_to
;
4272 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4275 back_to
= make_cleanup (really_free_pendings
, NULL
);
4277 cu
->list_in_scope
= &file_symbols
;
4279 dwarf2_find_base_address (cu
->dies
, cu
);
4281 /* Do line number decoding in read_file_scope () */
4282 process_die (cu
->dies
, cu
);
4284 /* Some compilers don't define a DW_AT_high_pc attribute for the
4285 compilation unit. If the DW_AT_high_pc is missing, synthesize
4286 it, by scanning the DIE's below the compilation unit. */
4287 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
4289 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
4291 /* Set symtab language to language from DW_AT_language.
4292 If the compilation is from a C file generated by language preprocessors,
4293 do not set the language if it was already deduced by start_subfile. */
4295 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
4297 symtab
->language
= cu
->language
;
4300 if (dwarf2_per_objfile
->using_index
)
4301 per_cu
->v
.quick
->symtab
= symtab
;
4304 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
4305 pst
->symtab
= symtab
;
4309 do_cleanups (back_to
);
4312 /* Process a die and its children. */
4315 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
4319 case DW_TAG_padding
:
4321 case DW_TAG_compile_unit
:
4322 read_file_scope (die
, cu
);
4324 case DW_TAG_type_unit
:
4325 read_type_unit_scope (die
, cu
);
4327 case DW_TAG_subprogram
:
4328 case DW_TAG_inlined_subroutine
:
4329 read_func_scope (die
, cu
);
4331 case DW_TAG_lexical_block
:
4332 case DW_TAG_try_block
:
4333 case DW_TAG_catch_block
:
4334 read_lexical_block_scope (die
, cu
);
4336 case DW_TAG_class_type
:
4337 case DW_TAG_interface_type
:
4338 case DW_TAG_structure_type
:
4339 case DW_TAG_union_type
:
4340 process_structure_scope (die
, cu
);
4342 case DW_TAG_enumeration_type
:
4343 process_enumeration_scope (die
, cu
);
4346 /* These dies have a type, but processing them does not create
4347 a symbol or recurse to process the children. Therefore we can
4348 read them on-demand through read_type_die. */
4349 case DW_TAG_subroutine_type
:
4350 case DW_TAG_set_type
:
4351 case DW_TAG_array_type
:
4352 case DW_TAG_pointer_type
:
4353 case DW_TAG_ptr_to_member_type
:
4354 case DW_TAG_reference_type
:
4355 case DW_TAG_string_type
:
4358 case DW_TAG_base_type
:
4359 case DW_TAG_subrange_type
:
4360 case DW_TAG_typedef
:
4361 /* Add a typedef symbol for the type definition, if it has a
4363 new_symbol (die
, read_type_die (die
, cu
), cu
);
4365 case DW_TAG_common_block
:
4366 read_common_block (die
, cu
);
4368 case DW_TAG_common_inclusion
:
4370 case DW_TAG_namespace
:
4371 processing_has_namespace_info
= 1;
4372 read_namespace (die
, cu
);
4375 processing_has_namespace_info
= 1;
4376 read_module (die
, cu
);
4378 case DW_TAG_imported_declaration
:
4379 case DW_TAG_imported_module
:
4380 processing_has_namespace_info
= 1;
4381 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
4382 || cu
->language
!= language_fortran
))
4383 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
4384 dwarf_tag_name (die
->tag
));
4385 read_import_statement (die
, cu
);
4388 new_symbol (die
, NULL
, cu
);
4393 /* A helper function for dwarf2_compute_name which determines whether DIE
4394 needs to have the name of the scope prepended to the name listed in the
4398 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4400 struct attribute
*attr
;
4404 case DW_TAG_namespace
:
4405 case DW_TAG_typedef
:
4406 case DW_TAG_class_type
:
4407 case DW_TAG_interface_type
:
4408 case DW_TAG_structure_type
:
4409 case DW_TAG_union_type
:
4410 case DW_TAG_enumeration_type
:
4411 case DW_TAG_enumerator
:
4412 case DW_TAG_subprogram
:
4416 case DW_TAG_variable
:
4417 /* We only need to prefix "globally" visible variables. These include
4418 any variable marked with DW_AT_external or any variable that
4419 lives in a namespace. [Variables in anonymous namespaces
4420 require prefixing, but they are not DW_AT_external.] */
4422 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
4424 struct dwarf2_cu
*spec_cu
= cu
;
4426 return die_needs_namespace (die_specification (die
, &spec_cu
),
4430 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
4431 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
4432 && die
->parent
->tag
!= DW_TAG_module
)
4434 /* A variable in a lexical block of some kind does not need a
4435 namespace, even though in C++ such variables may be external
4436 and have a mangled name. */
4437 if (die
->parent
->tag
== DW_TAG_lexical_block
4438 || die
->parent
->tag
== DW_TAG_try_block
4439 || die
->parent
->tag
== DW_TAG_catch_block
4440 || die
->parent
->tag
== DW_TAG_subprogram
)
4449 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
4450 compute the physname for the object, which include a method's
4451 formal parameters (C++/Java) and return type (Java).
4453 For Ada, return the DIE's linkage name rather than the fully qualified
4454 name. PHYSNAME is ignored..
4456 The result is allocated on the objfile_obstack and canonicalized. */
4459 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
4463 name
= dwarf2_name (die
, cu
);
4465 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
4466 compute it by typename_concat inside GDB. */
4467 if (cu
->language
== language_ada
4468 || (cu
->language
== language_fortran
&& physname
))
4470 /* For Ada unit, we prefer the linkage name over the name, as
4471 the former contains the exported name, which the user expects
4472 to be able to reference. Ideally, we want the user to be able
4473 to reference this entity using either natural or linkage name,
4474 but we haven't started looking at this enhancement yet. */
4475 struct attribute
*attr
;
4477 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
4479 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
4480 if (attr
&& DW_STRING (attr
))
4481 return DW_STRING (attr
);
4484 /* These are the only languages we know how to qualify names in. */
4486 && (cu
->language
== language_cplus
|| cu
->language
== language_java
4487 || cu
->language
== language_fortran
))
4489 if (die_needs_namespace (die
, cu
))
4493 struct ui_file
*buf
;
4495 prefix
= determine_prefix (die
, cu
);
4496 buf
= mem_fileopen ();
4497 if (*prefix
!= '\0')
4499 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
4502 fputs_unfiltered (prefixed_name
, buf
);
4503 xfree (prefixed_name
);
4506 fputs_unfiltered (name
? name
: "", buf
);
4508 /* For Java and C++ methods, append formal parameter type
4509 information, if PHYSNAME. */
4511 if (physname
&& die
->tag
== DW_TAG_subprogram
4512 && (cu
->language
== language_cplus
4513 || cu
->language
== language_java
))
4515 struct type
*type
= read_type_die (die
, cu
);
4517 c_type_print_args (type
, buf
, 0, cu
->language
);
4519 if (cu
->language
== language_java
)
4521 /* For java, we must append the return type to method
4523 if (die
->tag
== DW_TAG_subprogram
)
4524 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
4527 else if (cu
->language
== language_cplus
)
4529 if (TYPE_NFIELDS (type
) > 0
4530 && TYPE_FIELD_ARTIFICIAL (type
, 0)
4531 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0))))
4532 fputs_unfiltered (" const", buf
);
4536 name
= ui_file_obsavestring (buf
, &cu
->objfile
->objfile_obstack
,
4538 ui_file_delete (buf
);
4540 if (cu
->language
== language_cplus
)
4543 = dwarf2_canonicalize_name (name
, cu
,
4544 &cu
->objfile
->objfile_obstack
);
4555 /* Return the fully qualified name of DIE, based on its DW_AT_name.
4556 If scope qualifiers are appropriate they will be added. The result
4557 will be allocated on the objfile_obstack, or NULL if the DIE does
4558 not have a name. NAME may either be from a previous call to
4559 dwarf2_name or NULL.
4561 The output string will be canonicalized (if C++/Java). */
4564 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
4566 return dwarf2_compute_name (name
, die
, cu
, 0);
4569 /* Construct a physname for the given DIE in CU. NAME may either be
4570 from a previous call to dwarf2_name or NULL. The result will be
4571 allocated on the objfile_objstack or NULL if the DIE does not have a
4574 The output string will be canonicalized (if C++/Java). */
4577 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
4579 return dwarf2_compute_name (name
, die
, cu
, 1);
4582 /* Read the import statement specified by the given die and record it. */
4585 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
4587 struct attribute
*import_attr
;
4588 struct die_info
*imported_die
;
4589 struct dwarf2_cu
*imported_cu
;
4590 const char *imported_name
;
4591 const char *imported_name_prefix
;
4592 const char *canonical_name
;
4593 const char *import_alias
;
4594 const char *imported_declaration
= NULL
;
4595 const char *import_prefix
;
4599 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
4600 if (import_attr
== NULL
)
4602 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
4603 dwarf_tag_name (die
->tag
));
4608 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
4609 imported_name
= dwarf2_name (imported_die
, imported_cu
);
4610 if (imported_name
== NULL
)
4612 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
4614 The import in the following code:
4628 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
4629 <52> DW_AT_decl_file : 1
4630 <53> DW_AT_decl_line : 6
4631 <54> DW_AT_import : <0x75>
4632 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
4634 <5b> DW_AT_decl_file : 1
4635 <5c> DW_AT_decl_line : 2
4636 <5d> DW_AT_type : <0x6e>
4638 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
4639 <76> DW_AT_byte_size : 4
4640 <77> DW_AT_encoding : 5 (signed)
4642 imports the wrong die ( 0x75 instead of 0x58 ).
4643 This case will be ignored until the gcc bug is fixed. */
4647 /* Figure out the local name after import. */
4648 import_alias
= dwarf2_name (die
, cu
);
4650 /* Figure out where the statement is being imported to. */
4651 import_prefix
= determine_prefix (die
, cu
);
4653 /* Figure out what the scope of the imported die is and prepend it
4654 to the name of the imported die. */
4655 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
4657 if (imported_die
->tag
!= DW_TAG_namespace
4658 && imported_die
->tag
!= DW_TAG_module
)
4660 imported_declaration
= imported_name
;
4661 canonical_name
= imported_name_prefix
;
4663 else if (strlen (imported_name_prefix
) > 0)
4665 temp
= alloca (strlen (imported_name_prefix
)
4666 + 2 + strlen (imported_name
) + 1);
4667 strcpy (temp
, imported_name_prefix
);
4668 strcat (temp
, "::");
4669 strcat (temp
, imported_name
);
4670 canonical_name
= temp
;
4673 canonical_name
= imported_name
;
4675 cp_add_using_directive (import_prefix
,
4678 imported_declaration
,
4679 &cu
->objfile
->objfile_obstack
);
4683 initialize_cu_func_list (struct dwarf2_cu
*cu
)
4685 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
4689 free_cu_line_header (void *arg
)
4691 struct dwarf2_cu
*cu
= arg
;
4693 free_line_header (cu
->line_header
);
4694 cu
->line_header
= NULL
;
4698 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
4699 char **name
, char **comp_dir
)
4701 struct attribute
*attr
;
4706 /* Find the filename. Do not use dwarf2_name here, since the filename
4707 is not a source language identifier. */
4708 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4711 *name
= DW_STRING (attr
);
4714 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
4716 *comp_dir
= DW_STRING (attr
);
4717 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
4719 *comp_dir
= ldirname (*name
);
4720 if (*comp_dir
!= NULL
)
4721 make_cleanup (xfree
, *comp_dir
);
4723 if (*comp_dir
!= NULL
)
4725 /* Irix 6.2 native cc prepends <machine>.: to the compilation
4726 directory, get rid of it. */
4727 char *cp
= strchr (*comp_dir
, ':');
4729 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
4734 *name
= "<unknown>";
4738 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4740 struct objfile
*objfile
= cu
->objfile
;
4741 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4742 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
4743 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
4744 struct attribute
*attr
;
4746 char *comp_dir
= NULL
;
4747 struct die_info
*child_die
;
4748 bfd
*abfd
= objfile
->obfd
;
4749 struct line_header
*line_header
= 0;
4752 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4754 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
4756 /* If we didn't find a lowpc, set it to highpc to avoid complaints
4757 from finish_block. */
4758 if (lowpc
== ((CORE_ADDR
) -1))
4763 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
4765 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
4768 set_cu_language (DW_UNSND (attr
), cu
);
4771 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
4773 cu
->producer
= DW_STRING (attr
);
4775 /* We assume that we're processing GCC output. */
4776 processing_gcc_compilation
= 2;
4778 processing_has_namespace_info
= 0;
4780 start_symtab (name
, comp_dir
, lowpc
);
4781 record_debugformat ("DWARF 2");
4782 record_producer (cu
->producer
);
4784 initialize_cu_func_list (cu
);
4786 /* Decode line number information if present. We do this before
4787 processing child DIEs, so that the line header table is available
4788 for DW_AT_decl_file. */
4789 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
4792 unsigned int line_offset
= DW_UNSND (attr
);
4793 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
4796 cu
->line_header
= line_header
;
4797 make_cleanup (free_cu_line_header
, cu
);
4798 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
4802 /* Process all dies in compilation unit. */
4803 if (die
->child
!= NULL
)
4805 child_die
= die
->child
;
4806 while (child_die
&& child_die
->tag
)
4808 process_die (child_die
, cu
);
4809 child_die
= sibling_die (child_die
);
4813 /* Decode macro information, if present. Dwarf 2 macro information
4814 refers to information in the line number info statement program
4815 header, so we can only read it if we've read the header
4817 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
4818 if (attr
&& line_header
)
4820 unsigned int macro_offset
= DW_UNSND (attr
);
4822 dwarf_decode_macros (line_header
, macro_offset
,
4823 comp_dir
, abfd
, cu
);
4825 do_cleanups (back_to
);
4828 /* For TUs we want to skip the first top level sibling if it's not the
4829 actual type being defined by this TU. In this case the first top
4830 level sibling is there to provide context only. */
4833 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4835 struct objfile
*objfile
= cu
->objfile
;
4836 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4838 struct attribute
*attr
;
4840 char *comp_dir
= NULL
;
4841 struct die_info
*child_die
;
4842 bfd
*abfd
= objfile
->obfd
;
4844 /* start_symtab needs a low pc, but we don't really have one.
4845 Do what read_file_scope would do in the absence of such info. */
4846 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4848 /* Find the filename. Do not use dwarf2_name here, since the filename
4849 is not a source language identifier. */
4850 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4852 name
= DW_STRING (attr
);
4854 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
4856 comp_dir
= DW_STRING (attr
);
4857 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
4859 comp_dir
= ldirname (name
);
4860 if (comp_dir
!= NULL
)
4861 make_cleanup (xfree
, comp_dir
);
4867 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
4869 set_cu_language (DW_UNSND (attr
), cu
);
4871 /* This isn't technically needed today. It is done for symmetry
4872 with read_file_scope. */
4873 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
4875 cu
->producer
= DW_STRING (attr
);
4877 /* We assume that we're processing GCC output. */
4878 processing_gcc_compilation
= 2;
4880 processing_has_namespace_info
= 0;
4882 start_symtab (name
, comp_dir
, lowpc
);
4883 record_debugformat ("DWARF 2");
4884 record_producer (cu
->producer
);
4886 /* Process the dies in the type unit. */
4887 if (die
->child
== NULL
)
4889 dump_die_for_error (die
);
4890 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
4891 bfd_get_filename (abfd
));
4894 child_die
= die
->child
;
4896 while (child_die
&& child_die
->tag
)
4898 process_die (child_die
, cu
);
4900 child_die
= sibling_die (child_die
);
4903 do_cleanups (back_to
);
4907 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
4908 struct dwarf2_cu
*cu
)
4910 struct function_range
*thisfn
;
4912 thisfn
= (struct function_range
*)
4913 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
4914 thisfn
->name
= name
;
4915 thisfn
->lowpc
= lowpc
;
4916 thisfn
->highpc
= highpc
;
4917 thisfn
->seen_line
= 0;
4918 thisfn
->next
= NULL
;
4920 if (cu
->last_fn
== NULL
)
4921 cu
->first_fn
= thisfn
;
4923 cu
->last_fn
->next
= thisfn
;
4925 cu
->last_fn
= thisfn
;
4928 /* qsort helper for inherit_abstract_dies. */
4931 unsigned_int_compar (const void *ap
, const void *bp
)
4933 unsigned int a
= *(unsigned int *) ap
;
4934 unsigned int b
= *(unsigned int *) bp
;
4936 return (a
> b
) - (b
> a
);
4939 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
4940 Inherit only the children of the DW_AT_abstract_origin DIE not being already
4941 referenced by DW_AT_abstract_origin from the children of the current DIE. */
4944 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
4946 struct die_info
*child_die
;
4947 unsigned die_children_count
;
4948 /* CU offsets which were referenced by children of the current DIE. */
4950 unsigned *offsets_end
, *offsetp
;
4951 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
4952 struct die_info
*origin_die
;
4953 /* Iterator of the ORIGIN_DIE children. */
4954 struct die_info
*origin_child_die
;
4955 struct cleanup
*cleanups
;
4956 struct attribute
*attr
;
4958 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
4962 origin_die
= follow_die_ref (die
, attr
, &cu
);
4963 if (die
->tag
!= origin_die
->tag
4964 && !(die
->tag
== DW_TAG_inlined_subroutine
4965 && origin_die
->tag
== DW_TAG_subprogram
))
4966 complaint (&symfile_complaints
,
4967 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
4968 die
->offset
, origin_die
->offset
);
4970 child_die
= die
->child
;
4971 die_children_count
= 0;
4972 while (child_die
&& child_die
->tag
)
4974 child_die
= sibling_die (child_die
);
4975 die_children_count
++;
4977 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
4978 cleanups
= make_cleanup (xfree
, offsets
);
4980 offsets_end
= offsets
;
4981 child_die
= die
->child
;
4982 while (child_die
&& child_die
->tag
)
4984 /* For each CHILD_DIE, find the corresponding child of
4985 ORIGIN_DIE. If there is more than one layer of
4986 DW_AT_abstract_origin, follow them all; there shouldn't be,
4987 but GCC versions at least through 4.4 generate this (GCC PR
4989 struct die_info
*child_origin_die
= child_die
;
4993 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
, cu
);
4996 child_origin_die
= follow_die_ref (child_origin_die
, attr
, &cu
);
4999 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5000 counterpart may exist. */
5001 if (child_origin_die
!= child_die
)
5003 if (child_die
->tag
!= child_origin_die
->tag
5004 && !(child_die
->tag
== DW_TAG_inlined_subroutine
5005 && child_origin_die
->tag
== DW_TAG_subprogram
))
5006 complaint (&symfile_complaints
,
5007 _("Child DIE 0x%x and its abstract origin 0x%x have "
5008 "different tags"), child_die
->offset
,
5009 child_origin_die
->offset
);
5010 if (child_origin_die
->parent
!= origin_die
)
5011 complaint (&symfile_complaints
,
5012 _("Child DIE 0x%x and its abstract origin 0x%x have "
5013 "different parents"), child_die
->offset
,
5014 child_origin_die
->offset
);
5016 *offsets_end
++ = child_origin_die
->offset
;
5018 child_die
= sibling_die (child_die
);
5020 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
5021 unsigned_int_compar
);
5022 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
5023 if (offsetp
[-1] == *offsetp
)
5024 complaint (&symfile_complaints
, _("Multiple children of DIE 0x%x refer "
5025 "to DIE 0x%x as their abstract origin"),
5026 die
->offset
, *offsetp
);
5029 origin_child_die
= origin_die
->child
;
5030 while (origin_child_die
&& origin_child_die
->tag
)
5032 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5033 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
5035 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
5037 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
5038 process_die (origin_child_die
, cu
);
5040 origin_child_die
= sibling_die (origin_child_die
);
5043 do_cleanups (cleanups
);
5047 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5049 struct objfile
*objfile
= cu
->objfile
;
5050 struct context_stack
*new;
5053 struct die_info
*child_die
;
5054 struct attribute
*attr
, *call_line
, *call_file
;
5057 struct block
*block
;
5058 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
5059 VEC (symbolp
) *template_args
= NULL
;
5060 struct template_symbol
*templ_func
= NULL
;
5064 /* If we do not have call site information, we can't show the
5065 caller of this inlined function. That's too confusing, so
5066 only use the scope for local variables. */
5067 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
5068 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
5069 if (call_line
== NULL
|| call_file
== NULL
)
5071 read_lexical_block_scope (die
, cu
);
5076 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5078 name
= dwarf2_name (die
, cu
);
5080 /* Ignore functions with missing or empty names. These are actually
5081 illegal according to the DWARF standard. */
5084 complaint (&symfile_complaints
,
5085 _("missing name for subprogram DIE at %d"), die
->offset
);
5089 /* Ignore functions with missing or invalid low and high pc attributes. */
5090 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5092 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5093 if (!attr
|| !DW_UNSND (attr
))
5094 complaint (&symfile_complaints
,
5095 _("cannot get low and high bounds for subprogram DIE at %d"),
5103 /* Record the function range for dwarf_decode_lines. */
5104 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
5106 /* If we have any template arguments, then we must allocate a
5107 different sort of symbol. */
5108 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
5110 if (child_die
->tag
== DW_TAG_template_type_param
5111 || child_die
->tag
== DW_TAG_template_value_param
)
5113 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5114 struct template_symbol
);
5115 templ_func
->base
.is_cplus_template_function
= 1;
5120 new = push_context (0, lowpc
);
5121 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
5122 (struct symbol
*) templ_func
);
5124 /* If there is a location expression for DW_AT_frame_base, record
5126 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
5128 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
5129 expression is being recorded directly in the function's symbol
5130 and not in a separate frame-base object. I guess this hack is
5131 to avoid adding some sort of frame-base adjunct/annex to the
5132 function's symbol :-(. The problem with doing this is that it
5133 results in a function symbol with a location expression that
5134 has nothing to do with the location of the function, ouch! The
5135 relationship should be: a function's symbol has-a frame base; a
5136 frame-base has-a location expression. */
5137 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
5139 cu
->list_in_scope
= &local_symbols
;
5141 if (die
->child
!= NULL
)
5143 child_die
= die
->child
;
5144 while (child_die
&& child_die
->tag
)
5146 if (child_die
->tag
== DW_TAG_template_type_param
5147 || child_die
->tag
== DW_TAG_template_value_param
)
5149 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
5151 VEC_safe_push (symbolp
, template_args
, arg
);
5154 process_die (child_die
, cu
);
5155 child_die
= sibling_die (child_die
);
5159 inherit_abstract_dies (die
, cu
);
5161 /* If we have a DW_AT_specification, we might need to import using
5162 directives from the context of the specification DIE. See the
5163 comment in determine_prefix. */
5164 if (cu
->language
== language_cplus
5165 && dwarf2_attr (die
, DW_AT_specification
, cu
))
5167 struct dwarf2_cu
*spec_cu
= cu
;
5168 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
5172 child_die
= spec_die
->child
;
5173 while (child_die
&& child_die
->tag
)
5175 if (child_die
->tag
== DW_TAG_imported_module
)
5176 process_die (child_die
, spec_cu
);
5177 child_die
= sibling_die (child_die
);
5180 /* In some cases, GCC generates specification DIEs that
5181 themselves contain DW_AT_specification attributes. */
5182 spec_die
= die_specification (spec_die
, &spec_cu
);
5186 new = pop_context ();
5187 /* Make a block for the local symbols within. */
5188 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
5189 lowpc
, highpc
, objfile
);
5191 /* For C++, set the block's scope. */
5192 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
5193 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
5194 determine_prefix (die
, cu
),
5195 processing_has_namespace_info
);
5197 /* If we have address ranges, record them. */
5198 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
5200 /* Attach template arguments to function. */
5201 if (! VEC_empty (symbolp
, template_args
))
5203 gdb_assert (templ_func
!= NULL
);
5205 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
5206 templ_func
->template_arguments
5207 = obstack_alloc (&objfile
->objfile_obstack
,
5208 (templ_func
->n_template_arguments
5209 * sizeof (struct symbol
*)));
5210 memcpy (templ_func
->template_arguments
,
5211 VEC_address (symbolp
, template_args
),
5212 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
5213 VEC_free (symbolp
, template_args
);
5216 /* In C++, we can have functions nested inside functions (e.g., when
5217 a function declares a class that has methods). This means that
5218 when we finish processing a function scope, we may need to go
5219 back to building a containing block's symbol lists. */
5220 local_symbols
= new->locals
;
5221 param_symbols
= new->params
;
5222 using_directives
= new->using_directives
;
5224 /* If we've finished processing a top-level function, subsequent
5225 symbols go in the file symbol list. */
5226 if (outermost_context_p ())
5227 cu
->list_in_scope
= &file_symbols
;
5230 /* Process all the DIES contained within a lexical block scope. Start
5231 a new scope, process the dies, and then close the scope. */
5234 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5236 struct objfile
*objfile
= cu
->objfile
;
5237 struct context_stack
*new;
5238 CORE_ADDR lowpc
, highpc
;
5239 struct die_info
*child_die
;
5242 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5244 /* Ignore blocks with missing or invalid low and high pc attributes. */
5245 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
5246 as multiple lexical blocks? Handling children in a sane way would
5247 be nasty. Might be easier to properly extend generic blocks to
5249 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5254 push_context (0, lowpc
);
5255 if (die
->child
!= NULL
)
5257 child_die
= die
->child
;
5258 while (child_die
&& child_die
->tag
)
5260 process_die (child_die
, cu
);
5261 child_die
= sibling_die (child_die
);
5264 new = pop_context ();
5266 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
5269 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
5272 /* Note that recording ranges after traversing children, as we
5273 do here, means that recording a parent's ranges entails
5274 walking across all its children's ranges as they appear in
5275 the address map, which is quadratic behavior.
5277 It would be nicer to record the parent's ranges before
5278 traversing its children, simply overriding whatever you find
5279 there. But since we don't even decide whether to create a
5280 block until after we've traversed its children, that's hard
5282 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
5284 local_symbols
= new->locals
;
5285 using_directives
= new->using_directives
;
5288 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
5289 Return 1 if the attributes are present and valid, otherwise, return 0.
5290 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
5293 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
5294 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
5295 struct partial_symtab
*ranges_pst
)
5297 struct objfile
*objfile
= cu
->objfile
;
5298 struct comp_unit_head
*cu_header
= &cu
->header
;
5299 bfd
*obfd
= objfile
->obfd
;
5300 unsigned int addr_size
= cu_header
->addr_size
;
5301 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
5302 /* Base address selection entry. */
5313 found_base
= cu
->base_known
;
5314 base
= cu
->base_address
;
5316 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
5317 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
5319 complaint (&symfile_complaints
,
5320 _("Offset %d out of bounds for DW_AT_ranges attribute"),
5324 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
5326 /* Read in the largest possible address. */
5327 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
5328 if ((marker
& mask
) == mask
)
5330 /* If we found the largest possible address, then
5331 read the base address. */
5332 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
5333 buffer
+= 2 * addr_size
;
5334 offset
+= 2 * addr_size
;
5340 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5344 CORE_ADDR range_beginning
, range_end
;
5346 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
5347 buffer
+= addr_size
;
5348 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
5349 buffer
+= addr_size
;
5350 offset
+= 2 * addr_size
;
5352 /* An end of list marker is a pair of zero addresses. */
5353 if (range_beginning
== 0 && range_end
== 0)
5354 /* Found the end of list entry. */
5357 /* Each base address selection entry is a pair of 2 values.
5358 The first is the largest possible address, the second is
5359 the base address. Check for a base address here. */
5360 if ((range_beginning
& mask
) == mask
)
5362 /* If we found the largest possible address, then
5363 read the base address. */
5364 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
5371 /* We have no valid base address for the ranges
5373 complaint (&symfile_complaints
,
5374 _("Invalid .debug_ranges data (no base address)"));
5378 range_beginning
+= base
;
5381 if (ranges_pst
!= NULL
&& range_beginning
< range_end
)
5382 addrmap_set_empty (objfile
->psymtabs_addrmap
,
5383 range_beginning
+ baseaddr
, range_end
- 1 + baseaddr
,
5386 /* FIXME: This is recording everything as a low-high
5387 segment of consecutive addresses. We should have a
5388 data structure for discontiguous block ranges
5392 low
= range_beginning
;
5398 if (range_beginning
< low
)
5399 low
= range_beginning
;
5400 if (range_end
> high
)
5406 /* If the first entry is an end-of-list marker, the range
5407 describes an empty scope, i.e. no instructions. */
5413 *high_return
= high
;
5417 /* Get low and high pc attributes from a die. Return 1 if the attributes
5418 are present and valid, otherwise, return 0. Return -1 if the range is
5419 discontinuous, i.e. derived from DW_AT_ranges information. */
5421 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
5422 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
5423 struct partial_symtab
*pst
)
5425 struct attribute
*attr
;
5430 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
5433 high
= DW_ADDR (attr
);
5434 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5436 low
= DW_ADDR (attr
);
5438 /* Found high w/o low attribute. */
5441 /* Found consecutive range of addresses. */
5446 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
5449 /* Value of the DW_AT_ranges attribute is the offset in the
5450 .debug_ranges section. */
5451 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
5453 /* Found discontinuous range of addresses. */
5461 /* When using the GNU linker, .gnu.linkonce. sections are used to
5462 eliminate duplicate copies of functions and vtables and such.
5463 The linker will arbitrarily choose one and discard the others.
5464 The AT_*_pc values for such functions refer to local labels in
5465 these sections. If the section from that file was discarded, the
5466 labels are not in the output, so the relocs get a value of 0.
5467 If this is a discarded function, mark the pc bounds as invalid,
5468 so that GDB will ignore it. */
5469 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
5477 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
5478 its low and high PC addresses. Do nothing if these addresses could not
5479 be determined. Otherwise, set LOWPC to the low address if it is smaller,
5480 and HIGHPC to the high address if greater than HIGHPC. */
5483 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
5484 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
5485 struct dwarf2_cu
*cu
)
5487 CORE_ADDR low
, high
;
5488 struct die_info
*child
= die
->child
;
5490 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
5492 *lowpc
= min (*lowpc
, low
);
5493 *highpc
= max (*highpc
, high
);
5496 /* If the language does not allow nested subprograms (either inside
5497 subprograms or lexical blocks), we're done. */
5498 if (cu
->language
!= language_ada
)
5501 /* Check all the children of the given DIE. If it contains nested
5502 subprograms, then check their pc bounds. Likewise, we need to
5503 check lexical blocks as well, as they may also contain subprogram
5505 while (child
&& child
->tag
)
5507 if (child
->tag
== DW_TAG_subprogram
5508 || child
->tag
== DW_TAG_lexical_block
)
5509 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
5510 child
= sibling_die (child
);
5514 /* Get the low and high pc's represented by the scope DIE, and store
5515 them in *LOWPC and *HIGHPC. If the correct values can't be
5516 determined, set *LOWPC to -1 and *HIGHPC to 0. */
5519 get_scope_pc_bounds (struct die_info
*die
,
5520 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
5521 struct dwarf2_cu
*cu
)
5523 CORE_ADDR best_low
= (CORE_ADDR
) -1;
5524 CORE_ADDR best_high
= (CORE_ADDR
) 0;
5525 CORE_ADDR current_low
, current_high
;
5527 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
5529 best_low
= current_low
;
5530 best_high
= current_high
;
5534 struct die_info
*child
= die
->child
;
5536 while (child
&& child
->tag
)
5538 switch (child
->tag
) {
5539 case DW_TAG_subprogram
:
5540 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
5542 case DW_TAG_namespace
:
5544 /* FIXME: carlton/2004-01-16: Should we do this for
5545 DW_TAG_class_type/DW_TAG_structure_type, too? I think
5546 that current GCC's always emit the DIEs corresponding
5547 to definitions of methods of classes as children of a
5548 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
5549 the DIEs giving the declarations, which could be
5550 anywhere). But I don't see any reason why the
5551 standards says that they have to be there. */
5552 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
5554 if (current_low
!= ((CORE_ADDR
) -1))
5556 best_low
= min (best_low
, current_low
);
5557 best_high
= max (best_high
, current_high
);
5565 child
= sibling_die (child
);
5570 *highpc
= best_high
;
5573 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
5576 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
5577 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
5579 struct attribute
*attr
;
5581 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
5584 CORE_ADDR high
= DW_ADDR (attr
);
5586 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5589 CORE_ADDR low
= DW_ADDR (attr
);
5591 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
5595 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
5598 bfd
*obfd
= cu
->objfile
->obfd
;
5600 /* The value of the DW_AT_ranges attribute is the offset of the
5601 address range list in the .debug_ranges section. */
5602 unsigned long offset
= DW_UNSND (attr
);
5603 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
5605 /* For some target architectures, but not others, the
5606 read_address function sign-extends the addresses it returns.
5607 To recognize base address selection entries, we need a
5609 unsigned int addr_size
= cu
->header
.addr_size
;
5610 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
5612 /* The base address, to which the next pair is relative. Note
5613 that this 'base' is a DWARF concept: most entries in a range
5614 list are relative, to reduce the number of relocs against the
5615 debugging information. This is separate from this function's
5616 'baseaddr' argument, which GDB uses to relocate debugging
5617 information from a shared library based on the address at
5618 which the library was loaded. */
5619 CORE_ADDR base
= cu
->base_address
;
5620 int base_known
= cu
->base_known
;
5622 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
5623 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
5625 complaint (&symfile_complaints
,
5626 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
5633 unsigned int bytes_read
;
5634 CORE_ADDR start
, end
;
5636 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
5637 buffer
+= bytes_read
;
5638 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
5639 buffer
+= bytes_read
;
5641 /* Did we find the end of the range list? */
5642 if (start
== 0 && end
== 0)
5645 /* Did we find a base address selection entry? */
5646 else if ((start
& base_select_mask
) == base_select_mask
)
5652 /* We found an ordinary address range. */
5657 complaint (&symfile_complaints
,
5658 _("Invalid .debug_ranges data (no base address)"));
5662 record_block_range (block
,
5663 baseaddr
+ base
+ start
,
5664 baseaddr
+ base
+ end
- 1);
5670 /* Add an aggregate field to the field list. */
5673 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
5674 struct dwarf2_cu
*cu
)
5676 struct objfile
*objfile
= cu
->objfile
;
5677 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5678 struct nextfield
*new_field
;
5679 struct attribute
*attr
;
5681 char *fieldname
= "";
5683 /* Allocate a new field list entry and link it in. */
5684 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
5685 make_cleanup (xfree
, new_field
);
5686 memset (new_field
, 0, sizeof (struct nextfield
));
5688 if (die
->tag
== DW_TAG_inheritance
)
5690 new_field
->next
= fip
->baseclasses
;
5691 fip
->baseclasses
= new_field
;
5695 new_field
->next
= fip
->fields
;
5696 fip
->fields
= new_field
;
5700 /* Handle accessibility and virtuality of field.
5701 The default accessibility for members is public, the default
5702 accessibility for inheritance is private. */
5703 if (die
->tag
!= DW_TAG_inheritance
)
5704 new_field
->accessibility
= DW_ACCESS_public
;
5706 new_field
->accessibility
= DW_ACCESS_private
;
5707 new_field
->virtuality
= DW_VIRTUALITY_none
;
5709 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
5711 new_field
->accessibility
= DW_UNSND (attr
);
5712 if (new_field
->accessibility
!= DW_ACCESS_public
)
5713 fip
->non_public_fields
= 1;
5714 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
5716 new_field
->virtuality
= DW_UNSND (attr
);
5718 fp
= &new_field
->field
;
5720 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
5722 /* Data member other than a C++ static data member. */
5724 /* Get type of field. */
5725 fp
->type
= die_type (die
, cu
);
5727 SET_FIELD_BITPOS (*fp
, 0);
5729 /* Get bit size of field (zero if none). */
5730 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
5733 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
5737 FIELD_BITSIZE (*fp
) = 0;
5740 /* Get bit offset of field. */
5741 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
5744 int byte_offset
= 0;
5746 if (attr_form_is_section_offset (attr
))
5747 dwarf2_complex_location_expr_complaint ();
5748 else if (attr_form_is_constant (attr
))
5749 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
5750 else if (attr_form_is_block (attr
))
5751 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
5753 dwarf2_complex_location_expr_complaint ();
5755 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
5757 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
5760 if (gdbarch_bits_big_endian (gdbarch
))
5762 /* For big endian bits, the DW_AT_bit_offset gives the
5763 additional bit offset from the MSB of the containing
5764 anonymous object to the MSB of the field. We don't
5765 have to do anything special since we don't need to
5766 know the size of the anonymous object. */
5767 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
5771 /* For little endian bits, compute the bit offset to the
5772 MSB of the anonymous object, subtract off the number of
5773 bits from the MSB of the field to the MSB of the
5774 object, and then subtract off the number of bits of
5775 the field itself. The result is the bit offset of
5776 the LSB of the field. */
5778 int bit_offset
= DW_UNSND (attr
);
5780 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5783 /* The size of the anonymous object containing
5784 the bit field is explicit, so use the
5785 indicated size (in bytes). */
5786 anonymous_size
= DW_UNSND (attr
);
5790 /* The size of the anonymous object containing
5791 the bit field must be inferred from the type
5792 attribute of the data member containing the
5794 anonymous_size
= TYPE_LENGTH (fp
->type
);
5796 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
5797 - bit_offset
- FIELD_BITSIZE (*fp
);
5801 /* Get name of field. */
5802 fieldname
= dwarf2_name (die
, cu
);
5803 if (fieldname
== NULL
)
5806 /* The name is already allocated along with this objfile, so we don't
5807 need to duplicate it for the type. */
5808 fp
->name
= fieldname
;
5810 /* Change accessibility for artificial fields (e.g. virtual table
5811 pointer or virtual base class pointer) to private. */
5812 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
5814 FIELD_ARTIFICIAL (*fp
) = 1;
5815 new_field
->accessibility
= DW_ACCESS_private
;
5816 fip
->non_public_fields
= 1;
5819 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
5821 /* C++ static member. */
5823 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
5824 is a declaration, but all versions of G++ as of this writing
5825 (so through at least 3.2.1) incorrectly generate
5826 DW_TAG_variable tags. */
5830 /* Get name of field. */
5831 fieldname
= dwarf2_name (die
, cu
);
5832 if (fieldname
== NULL
)
5835 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
5837 /* Only create a symbol if this is an external value.
5838 new_symbol checks this and puts the value in the global symbol
5839 table, which we want. If it is not external, new_symbol
5840 will try to put the value in cu->list_in_scope which is wrong. */
5841 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
5843 /* A static const member, not much different than an enum as far as
5844 we're concerned, except that we can support more types. */
5845 new_symbol (die
, NULL
, cu
);
5848 /* Get physical name. */
5849 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
5851 /* The name is already allocated along with this objfile, so we don't
5852 need to duplicate it for the type. */
5853 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
5854 FIELD_TYPE (*fp
) = die_type (die
, cu
);
5855 FIELD_NAME (*fp
) = fieldname
;
5857 else if (die
->tag
== DW_TAG_inheritance
)
5859 /* C++ base class field. */
5860 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
5863 int byte_offset
= 0;
5865 if (attr_form_is_section_offset (attr
))
5866 dwarf2_complex_location_expr_complaint ();
5867 else if (attr_form_is_constant (attr
))
5868 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
5869 else if (attr_form_is_block (attr
))
5870 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
5872 dwarf2_complex_location_expr_complaint ();
5874 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
5876 FIELD_BITSIZE (*fp
) = 0;
5877 FIELD_TYPE (*fp
) = die_type (die
, cu
);
5878 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
5879 fip
->nbaseclasses
++;
5883 /* Add a typedef defined in the scope of the FIP's class. */
5886 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
5887 struct dwarf2_cu
*cu
)
5889 struct objfile
*objfile
= cu
->objfile
;
5890 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5891 struct typedef_field_list
*new_field
;
5892 struct attribute
*attr
;
5893 struct typedef_field
*fp
;
5894 char *fieldname
= "";
5896 /* Allocate a new field list entry and link it in. */
5897 new_field
= xzalloc (sizeof (*new_field
));
5898 make_cleanup (xfree
, new_field
);
5900 gdb_assert (die
->tag
== DW_TAG_typedef
);
5902 fp
= &new_field
->field
;
5904 /* Get name of field. */
5905 fp
->name
= dwarf2_name (die
, cu
);
5906 if (fp
->name
== NULL
)
5909 fp
->type
= read_type_die (die
, cu
);
5911 new_field
->next
= fip
->typedef_field_list
;
5912 fip
->typedef_field_list
= new_field
;
5913 fip
->typedef_field_list_count
++;
5916 /* Create the vector of fields, and attach it to the type. */
5919 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
5920 struct dwarf2_cu
*cu
)
5922 int nfields
= fip
->nfields
;
5924 /* Record the field count, allocate space for the array of fields,
5925 and create blank accessibility bitfields if necessary. */
5926 TYPE_NFIELDS (type
) = nfields
;
5927 TYPE_FIELDS (type
) = (struct field
*)
5928 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
5929 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
5931 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
5933 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
5935 TYPE_FIELD_PRIVATE_BITS (type
) =
5936 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
5937 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
5939 TYPE_FIELD_PROTECTED_BITS (type
) =
5940 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
5941 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
5943 TYPE_FIELD_IGNORE_BITS (type
) =
5944 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
5945 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
5948 /* If the type has baseclasses, allocate and clear a bit vector for
5949 TYPE_FIELD_VIRTUAL_BITS. */
5950 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
5952 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
5953 unsigned char *pointer
;
5955 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
5956 pointer
= TYPE_ALLOC (type
, num_bytes
);
5957 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
5958 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
5959 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
5962 /* Copy the saved-up fields into the field vector. Start from the head
5963 of the list, adding to the tail of the field array, so that they end
5964 up in the same order in the array in which they were added to the list. */
5965 while (nfields
-- > 0)
5967 struct nextfield
*fieldp
;
5971 fieldp
= fip
->fields
;
5972 fip
->fields
= fieldp
->next
;
5976 fieldp
= fip
->baseclasses
;
5977 fip
->baseclasses
= fieldp
->next
;
5980 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
5981 switch (fieldp
->accessibility
)
5983 case DW_ACCESS_private
:
5984 if (cu
->language
!= language_ada
)
5985 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
5988 case DW_ACCESS_protected
:
5989 if (cu
->language
!= language_ada
)
5990 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
5993 case DW_ACCESS_public
:
5997 /* Unknown accessibility. Complain and treat it as public. */
5999 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
6000 fieldp
->accessibility
);
6004 if (nfields
< fip
->nbaseclasses
)
6006 switch (fieldp
->virtuality
)
6008 case DW_VIRTUALITY_virtual
:
6009 case DW_VIRTUALITY_pure_virtual
:
6010 if (cu
->language
== language_ada
)
6011 error ("unexpected virtuality in component of Ada type");
6012 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
6019 /* Add a member function to the proper fieldlist. */
6022 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
6023 struct type
*type
, struct dwarf2_cu
*cu
)
6025 struct objfile
*objfile
= cu
->objfile
;
6026 struct attribute
*attr
;
6027 struct fnfieldlist
*flp
;
6029 struct fn_field
*fnp
;
6032 struct nextfnfield
*new_fnfield
;
6033 struct type
*this_type
;
6035 if (cu
->language
== language_ada
)
6036 error ("unexpected member function in Ada type");
6038 /* Get name of member function. */
6039 fieldname
= dwarf2_name (die
, cu
);
6040 if (fieldname
== NULL
)
6043 /* Get the mangled name. */
6044 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
6046 /* Look up member function name in fieldlist. */
6047 for (i
= 0; i
< fip
->nfnfields
; i
++)
6049 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
6053 /* Create new list element if necessary. */
6054 if (i
< fip
->nfnfields
)
6055 flp
= &fip
->fnfieldlists
[i
];
6058 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
6060 fip
->fnfieldlists
= (struct fnfieldlist
*)
6061 xrealloc (fip
->fnfieldlists
,
6062 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
6063 * sizeof (struct fnfieldlist
));
6064 if (fip
->nfnfields
== 0)
6065 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
6067 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
6068 flp
->name
= fieldname
;
6074 /* Create a new member function field and chain it to the field list
6076 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
6077 make_cleanup (xfree
, new_fnfield
);
6078 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
6079 new_fnfield
->next
= flp
->head
;
6080 flp
->head
= new_fnfield
;
6083 /* Fill in the member function field info. */
6084 fnp
= &new_fnfield
->fnfield
;
6085 /* The name is already allocated along with this objfile, so we don't
6086 need to duplicate it for the type. */
6087 fnp
->physname
= physname
? physname
: "";
6088 fnp
->type
= alloc_type (objfile
);
6089 this_type
= read_type_die (die
, cu
);
6090 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
6092 int nparams
= TYPE_NFIELDS (this_type
);
6094 /* TYPE is the domain of this method, and THIS_TYPE is the type
6095 of the method itself (TYPE_CODE_METHOD). */
6096 smash_to_method_type (fnp
->type
, type
,
6097 TYPE_TARGET_TYPE (this_type
),
6098 TYPE_FIELDS (this_type
),
6099 TYPE_NFIELDS (this_type
),
6100 TYPE_VARARGS (this_type
));
6102 /* Handle static member functions.
6103 Dwarf2 has no clean way to discern C++ static and non-static
6104 member functions. G++ helps GDB by marking the first
6105 parameter for non-static member functions (which is the
6106 this pointer) as artificial. We obtain this information
6107 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
6108 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
6109 fnp
->voffset
= VOFFSET_STATIC
;
6112 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
6115 /* Get fcontext from DW_AT_containing_type if present. */
6116 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
6117 fnp
->fcontext
= die_containing_type (die
, cu
);
6119 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
6120 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
6122 /* Get accessibility. */
6123 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
6126 switch (DW_UNSND (attr
))
6128 case DW_ACCESS_private
:
6129 fnp
->is_private
= 1;
6131 case DW_ACCESS_protected
:
6132 fnp
->is_protected
= 1;
6137 /* Check for artificial methods. */
6138 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
6139 if (attr
&& DW_UNSND (attr
) != 0)
6140 fnp
->is_artificial
= 1;
6142 /* Get index in virtual function table if it is a virtual member
6143 function. For older versions of GCC, this is an offset in the
6144 appropriate virtual table, as specified by DW_AT_containing_type.
6145 For everyone else, it is an expression to be evaluated relative
6146 to the object address. */
6148 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
6151 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
6153 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
6155 /* Old-style GCC. */
6156 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
6158 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
6159 || (DW_BLOCK (attr
)->size
> 1
6160 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
6161 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
6163 struct dwarf_block blk
;
6166 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
6168 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
6169 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
6170 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6171 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
6172 dwarf2_complex_location_expr_complaint ();
6174 fnp
->voffset
/= cu
->header
.addr_size
;
6178 dwarf2_complex_location_expr_complaint ();
6181 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
6183 else if (attr_form_is_section_offset (attr
))
6185 dwarf2_complex_location_expr_complaint ();
6189 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
6195 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
6196 if (attr
&& DW_UNSND (attr
))
6198 /* GCC does this, as of 2008-08-25; PR debug/37237. */
6199 complaint (&symfile_complaints
,
6200 _("Member function \"%s\" (offset %d) is virtual but the vtable offset is not specified"),
6201 fieldname
, die
->offset
);
6202 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6203 TYPE_CPLUS_DYNAMIC (type
) = 1;
6208 /* Create the vector of member function fields, and attach it to the type. */
6211 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
6212 struct dwarf2_cu
*cu
)
6214 struct fnfieldlist
*flp
;
6215 int total_length
= 0;
6218 if (cu
->language
== language_ada
)
6219 error ("unexpected member functions in Ada type");
6221 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6222 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
6223 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
6225 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
6227 struct nextfnfield
*nfp
= flp
->head
;
6228 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
6231 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
6232 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
6233 fn_flp
->fn_fields
= (struct fn_field
*)
6234 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
6235 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
6236 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
6238 total_length
+= flp
->length
;
6241 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
6242 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
6245 /* Returns non-zero if NAME is the name of a vtable member in CU's
6246 language, zero otherwise. */
6248 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
6250 static const char vptr
[] = "_vptr";
6251 static const char vtable
[] = "vtable";
6253 /* Look for the C++ and Java forms of the vtable. */
6254 if ((cu
->language
== language_java
6255 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
6256 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
6257 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
6263 /* GCC outputs unnamed structures that are really pointers to member
6264 functions, with the ABI-specified layout. If TYPE describes
6265 such a structure, smash it into a member function type.
6267 GCC shouldn't do this; it should just output pointer to member DIEs.
6268 This is GCC PR debug/28767. */
6271 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
6273 struct type
*pfn_type
, *domain_type
, *new_type
;
6275 /* Check for a structure with no name and two children. */
6276 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
6279 /* Check for __pfn and __delta members. */
6280 if (TYPE_FIELD_NAME (type
, 0) == NULL
6281 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
6282 || TYPE_FIELD_NAME (type
, 1) == NULL
6283 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
6286 /* Find the type of the method. */
6287 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
6288 if (pfn_type
== NULL
6289 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
6290 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
6293 /* Look for the "this" argument. */
6294 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
6295 if (TYPE_NFIELDS (pfn_type
) == 0
6296 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
6297 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
6300 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
6301 new_type
= alloc_type (objfile
);
6302 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
6303 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
6304 TYPE_VARARGS (pfn_type
));
6305 smash_to_methodptr_type (type
, new_type
);
6308 /* Called when we find the DIE that starts a structure or union scope
6309 (definition) to process all dies that define the members of the
6312 NOTE: we need to call struct_type regardless of whether or not the
6313 DIE has an at_name attribute, since it might be an anonymous
6314 structure or union. This gets the type entered into our set of
6317 However, if the structure is incomplete (an opaque struct/union)
6318 then suppress creating a symbol table entry for it since gdb only
6319 wants to find the one with the complete definition. Note that if
6320 it is complete, we just call new_symbol, which does it's own
6321 checking about whether the struct/union is anonymous or not (and
6322 suppresses creating a symbol table entry itself). */
6324 static struct type
*
6325 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6327 struct objfile
*objfile
= cu
->objfile
;
6329 struct attribute
*attr
;
6331 struct cleanup
*back_to
;
6333 /* If the definition of this type lives in .debug_types, read that type.
6334 Don't follow DW_AT_specification though, that will take us back up
6335 the chain and we want to go down. */
6336 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
6339 struct dwarf2_cu
*type_cu
= cu
;
6340 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
6342 /* We could just recurse on read_structure_type, but we need to call
6343 get_die_type to ensure only one type for this DIE is created.
6344 This is important, for example, because for c++ classes we need
6345 TYPE_NAME set which is only done by new_symbol. Blech. */
6346 type
= read_type_die (type_die
, type_cu
);
6347 return set_die_type (die
, type
, cu
);
6350 back_to
= make_cleanup (null_cleanup
, 0);
6352 type
= alloc_type (objfile
);
6353 INIT_CPLUS_SPECIFIC (type
);
6355 name
= dwarf2_name (die
, cu
);
6358 if (cu
->language
== language_cplus
6359 || cu
->language
== language_java
)
6361 TYPE_TAG_NAME (type
) = (char *) dwarf2_full_name (name
, die
, cu
);
6362 if (die
->tag
== DW_TAG_structure_type
6363 || die
->tag
== DW_TAG_class_type
)
6364 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
6368 /* The name is already allocated along with this objfile, so
6369 we don't need to duplicate it for the type. */
6370 TYPE_TAG_NAME (type
) = (char *) name
;
6371 if (die
->tag
== DW_TAG_class_type
)
6372 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
6376 if (die
->tag
== DW_TAG_structure_type
)
6378 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
6380 else if (die
->tag
== DW_TAG_union_type
)
6382 TYPE_CODE (type
) = TYPE_CODE_UNION
;
6386 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
6389 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
6390 TYPE_DECLARED_CLASS (type
) = 1;
6392 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6395 TYPE_LENGTH (type
) = DW_UNSND (attr
);
6399 TYPE_LENGTH (type
) = 0;
6402 TYPE_STUB_SUPPORTED (type
) = 1;
6403 if (die_is_declaration (die
, cu
))
6404 TYPE_STUB (type
) = 1;
6405 else if (attr
== NULL
&& die
->child
== NULL
6406 && producer_is_realview (cu
->producer
))
6407 /* RealView does not output the required DW_AT_declaration
6408 on incomplete types. */
6409 TYPE_STUB (type
) = 1;
6411 /* We need to add the type field to the die immediately so we don't
6412 infinitely recurse when dealing with pointers to the structure
6413 type within the structure itself. */
6414 set_die_type (die
, type
, cu
);
6416 /* set_die_type should be already done. */
6417 set_descriptive_type (type
, die
, cu
);
6419 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
6421 struct field_info fi
;
6422 struct die_info
*child_die
;
6423 VEC (symbolp
) *template_args
= NULL
;
6425 memset (&fi
, 0, sizeof (struct field_info
));
6427 child_die
= die
->child
;
6429 while (child_die
&& child_die
->tag
)
6431 if (child_die
->tag
== DW_TAG_member
6432 || child_die
->tag
== DW_TAG_variable
)
6434 /* NOTE: carlton/2002-11-05: A C++ static data member
6435 should be a DW_TAG_member that is a declaration, but
6436 all versions of G++ as of this writing (so through at
6437 least 3.2.1) incorrectly generate DW_TAG_variable
6438 tags for them instead. */
6439 dwarf2_add_field (&fi
, child_die
, cu
);
6441 else if (child_die
->tag
== DW_TAG_subprogram
)
6443 /* C++ member function. */
6444 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
6446 else if (child_die
->tag
== DW_TAG_inheritance
)
6448 /* C++ base class field. */
6449 dwarf2_add_field (&fi
, child_die
, cu
);
6451 else if (child_die
->tag
== DW_TAG_typedef
)
6452 dwarf2_add_typedef (&fi
, child_die
, cu
);
6453 else if (child_die
->tag
== DW_TAG_template_type_param
6454 || child_die
->tag
== DW_TAG_template_value_param
)
6456 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
6458 VEC_safe_push (symbolp
, template_args
, arg
);
6461 child_die
= sibling_die (child_die
);
6464 /* Attach template arguments to type. */
6465 if (! VEC_empty (symbolp
, template_args
))
6467 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6468 TYPE_N_TEMPLATE_ARGUMENTS (type
)
6469 = VEC_length (symbolp
, template_args
);
6470 TYPE_TEMPLATE_ARGUMENTS (type
)
6471 = obstack_alloc (&objfile
->objfile_obstack
,
6472 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
6473 * sizeof (struct symbol
*)));
6474 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
6475 VEC_address (symbolp
, template_args
),
6476 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
6477 * sizeof (struct symbol
*)));
6478 VEC_free (symbolp
, template_args
);
6481 /* Attach fields and member functions to the type. */
6483 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
6486 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
6488 /* Get the type which refers to the base class (possibly this
6489 class itself) which contains the vtable pointer for the current
6490 class from the DW_AT_containing_type attribute. This use of
6491 DW_AT_containing_type is a GNU extension. */
6493 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
6495 struct type
*t
= die_containing_type (die
, cu
);
6497 TYPE_VPTR_BASETYPE (type
) = t
;
6502 /* Our own class provides vtbl ptr. */
6503 for (i
= TYPE_NFIELDS (t
) - 1;
6504 i
>= TYPE_N_BASECLASSES (t
);
6507 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
6509 if (is_vtable_name (fieldname
, cu
))
6511 TYPE_VPTR_FIELDNO (type
) = i
;
6516 /* Complain if virtual function table field not found. */
6517 if (i
< TYPE_N_BASECLASSES (t
))
6518 complaint (&symfile_complaints
,
6519 _("virtual function table pointer not found when defining class '%s'"),
6520 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
6525 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
6528 else if (cu
->producer
6529 && strncmp (cu
->producer
,
6530 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
6532 /* The IBM XLC compiler does not provide direct indication
6533 of the containing type, but the vtable pointer is
6534 always named __vfp. */
6538 for (i
= TYPE_NFIELDS (type
) - 1;
6539 i
>= TYPE_N_BASECLASSES (type
);
6542 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
6544 TYPE_VPTR_FIELDNO (type
) = i
;
6545 TYPE_VPTR_BASETYPE (type
) = type
;
6552 /* Copy fi.typedef_field_list linked list elements content into the
6553 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
6554 if (fi
.typedef_field_list
)
6556 int i
= fi
.typedef_field_list_count
;
6558 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6559 TYPE_TYPEDEF_FIELD_ARRAY (type
)
6560 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
6561 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
6563 /* Reverse the list order to keep the debug info elements order. */
6566 struct typedef_field
*dest
, *src
;
6568 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
6569 src
= &fi
.typedef_field_list
->field
;
6570 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
6576 quirk_gcc_member_function_pointer (type
, cu
->objfile
);
6578 do_cleanups (back_to
);
6583 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6585 struct die_info
*child_die
= die
->child
;
6586 struct type
*this_type
;
6588 this_type
= get_die_type (die
, cu
);
6589 if (this_type
== NULL
)
6590 this_type
= read_structure_type (die
, cu
);
6592 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
6593 snapshots) has been known to create a die giving a declaration
6594 for a class that has, as a child, a die giving a definition for a
6595 nested class. So we have to process our children even if the
6596 current die is a declaration. Normally, of course, a declaration
6597 won't have any children at all. */
6599 while (child_die
!= NULL
&& child_die
->tag
)
6601 if (child_die
->tag
== DW_TAG_member
6602 || child_die
->tag
== DW_TAG_variable
6603 || child_die
->tag
== DW_TAG_inheritance
6604 || child_die
->tag
== DW_TAG_template_value_param
6605 || child_die
->tag
== DW_TAG_template_type_param
)
6610 process_die (child_die
, cu
);
6612 child_die
= sibling_die (child_die
);
6615 /* Do not consider external references. According to the DWARF standard,
6616 these DIEs are identified by the fact that they have no byte_size
6617 attribute, and a declaration attribute. */
6618 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
6619 || !die_is_declaration (die
, cu
))
6620 new_symbol (die
, this_type
, cu
);
6623 /* Given a DW_AT_enumeration_type die, set its type. We do not
6624 complete the type's fields yet, or create any symbols. */
6626 static struct type
*
6627 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6629 struct objfile
*objfile
= cu
->objfile
;
6631 struct attribute
*attr
;
6634 /* If the definition of this type lives in .debug_types, read that type.
6635 Don't follow DW_AT_specification though, that will take us back up
6636 the chain and we want to go down. */
6637 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
6640 struct dwarf2_cu
*type_cu
= cu
;
6641 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
6643 type
= read_type_die (type_die
, type_cu
);
6644 return set_die_type (die
, type
, cu
);
6647 type
= alloc_type (objfile
);
6649 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
6650 name
= dwarf2_full_name (NULL
, die
, cu
);
6652 TYPE_TAG_NAME (type
) = (char *) name
;
6654 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6657 TYPE_LENGTH (type
) = DW_UNSND (attr
);
6661 TYPE_LENGTH (type
) = 0;
6664 /* The enumeration DIE can be incomplete. In Ada, any type can be
6665 declared as private in the package spec, and then defined only
6666 inside the package body. Such types are known as Taft Amendment
6667 Types. When another package uses such a type, an incomplete DIE
6668 may be generated by the compiler. */
6669 if (die_is_declaration (die
, cu
))
6670 TYPE_STUB (type
) = 1;
6672 return set_die_type (die
, type
, cu
);
6675 /* Given a pointer to a die which begins an enumeration, process all
6676 the dies that define the members of the enumeration, and create the
6677 symbol for the enumeration type.
6679 NOTE: We reverse the order of the element list. */
6682 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6684 struct die_info
*child_die
;
6685 struct field
*fields
;
6688 int unsigned_enum
= 1;
6690 struct type
*this_type
;
6694 this_type
= get_die_type (die
, cu
);
6695 if (this_type
== NULL
)
6696 this_type
= read_enumeration_type (die
, cu
);
6697 if (die
->child
!= NULL
)
6699 child_die
= die
->child
;
6700 while (child_die
&& child_die
->tag
)
6702 if (child_die
->tag
!= DW_TAG_enumerator
)
6704 process_die (child_die
, cu
);
6708 name
= dwarf2_name (child_die
, cu
);
6711 sym
= new_symbol (child_die
, this_type
, cu
);
6712 if (SYMBOL_VALUE (sym
) < 0)
6715 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
6717 fields
= (struct field
*)
6719 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
6720 * sizeof (struct field
));
6723 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
6724 FIELD_TYPE (fields
[num_fields
]) = NULL
;
6725 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
6726 FIELD_BITSIZE (fields
[num_fields
]) = 0;
6732 child_die
= sibling_die (child_die
);
6737 TYPE_NFIELDS (this_type
) = num_fields
;
6738 TYPE_FIELDS (this_type
) = (struct field
*)
6739 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
6740 memcpy (TYPE_FIELDS (this_type
), fields
,
6741 sizeof (struct field
) * num_fields
);
6745 TYPE_UNSIGNED (this_type
) = 1;
6748 new_symbol (die
, this_type
, cu
);
6751 /* Extract all information from a DW_TAG_array_type DIE and put it in
6752 the DIE's type field. For now, this only handles one dimensional
6755 static struct type
*
6756 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6758 struct objfile
*objfile
= cu
->objfile
;
6759 struct die_info
*child_die
;
6761 struct type
*element_type
, *range_type
, *index_type
;
6762 struct type
**range_types
= NULL
;
6763 struct attribute
*attr
;
6765 struct cleanup
*back_to
;
6768 element_type
= die_type (die
, cu
);
6770 /* The die_type call above may have already set the type for this DIE. */
6771 type
= get_die_type (die
, cu
);
6775 /* Irix 6.2 native cc creates array types without children for
6776 arrays with unspecified length. */
6777 if (die
->child
== NULL
)
6779 index_type
= objfile_type (objfile
)->builtin_int
;
6780 range_type
= create_range_type (NULL
, index_type
, 0, -1);
6781 type
= create_array_type (NULL
, element_type
, range_type
);
6782 return set_die_type (die
, type
, cu
);
6785 back_to
= make_cleanup (null_cleanup
, NULL
);
6786 child_die
= die
->child
;
6787 while (child_die
&& child_die
->tag
)
6789 if (child_die
->tag
== DW_TAG_subrange_type
)
6791 struct type
*child_type
= read_type_die (child_die
, cu
);
6793 if (child_type
!= NULL
)
6795 /* The range type was succesfully read. Save it for
6796 the array type creation. */
6797 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
6799 range_types
= (struct type
**)
6800 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
6801 * sizeof (struct type
*));
6803 make_cleanup (free_current_contents
, &range_types
);
6805 range_types
[ndim
++] = child_type
;
6808 child_die
= sibling_die (child_die
);
6811 /* Dwarf2 dimensions are output from left to right, create the
6812 necessary array types in backwards order. */
6814 type
= element_type
;
6816 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
6821 type
= create_array_type (NULL
, type
, range_types
[i
++]);
6826 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
6829 /* Understand Dwarf2 support for vector types (like they occur on
6830 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
6831 array type. This is not part of the Dwarf2/3 standard yet, but a
6832 custom vendor extension. The main difference between a regular
6833 array and the vector variant is that vectors are passed by value
6835 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
6837 make_vector_type (type
);
6839 name
= dwarf2_name (die
, cu
);
6841 TYPE_NAME (type
) = name
;
6843 /* Install the type in the die. */
6844 set_die_type (die
, type
, cu
);
6846 /* set_die_type should be already done. */
6847 set_descriptive_type (type
, die
, cu
);
6849 do_cleanups (back_to
);
6854 static enum dwarf_array_dim_ordering
6855 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
6857 struct attribute
*attr
;
6859 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
6861 if (attr
) return DW_SND (attr
);
6864 GNU F77 is a special case, as at 08/2004 array type info is the
6865 opposite order to the dwarf2 specification, but data is still
6866 laid out as per normal fortran.
6868 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
6872 if (cu
->language
== language_fortran
6873 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
6875 return DW_ORD_row_major
;
6878 switch (cu
->language_defn
->la_array_ordering
)
6880 case array_column_major
:
6881 return DW_ORD_col_major
;
6882 case array_row_major
:
6884 return DW_ORD_row_major
;
6888 /* Extract all information from a DW_TAG_set_type DIE and put it in
6889 the DIE's type field. */
6891 static struct type
*
6892 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6894 struct type
*domain_type
, *set_type
;
6895 struct attribute
*attr
;
6897 domain_type
= die_type (die
, cu
);
6899 /* The die_type call above may have already set the type for this DIE. */
6900 set_type
= get_die_type (die
, cu
);
6904 set_type
= create_set_type (NULL
, domain_type
);
6906 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6908 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
6910 return set_die_type (die
, set_type
, cu
);
6913 /* First cut: install each common block member as a global variable. */
6916 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
6918 struct die_info
*child_die
;
6919 struct attribute
*attr
;
6921 CORE_ADDR base
= (CORE_ADDR
) 0;
6923 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6926 /* Support the .debug_loc offsets */
6927 if (attr_form_is_block (attr
))
6929 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
6931 else if (attr_form_is_section_offset (attr
))
6933 dwarf2_complex_location_expr_complaint ();
6937 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
6938 "common block member");
6941 if (die
->child
!= NULL
)
6943 child_die
= die
->child
;
6944 while (child_die
&& child_die
->tag
)
6946 sym
= new_symbol (child_die
, NULL
, cu
);
6947 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
6950 CORE_ADDR byte_offset
= 0;
6952 if (attr_form_is_section_offset (attr
))
6953 dwarf2_complex_location_expr_complaint ();
6954 else if (attr_form_is_constant (attr
))
6955 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
6956 else if (attr_form_is_block (attr
))
6957 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6959 dwarf2_complex_location_expr_complaint ();
6961 SYMBOL_VALUE_ADDRESS (sym
) = base
+ byte_offset
;
6962 add_symbol_to_list (sym
, &global_symbols
);
6964 child_die
= sibling_die (child_die
);
6969 /* Create a type for a C++ namespace. */
6971 static struct type
*
6972 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6974 struct objfile
*objfile
= cu
->objfile
;
6975 const char *previous_prefix
, *name
;
6979 /* For extensions, reuse the type of the original namespace. */
6980 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
6982 struct die_info
*ext_die
;
6983 struct dwarf2_cu
*ext_cu
= cu
;
6985 ext_die
= dwarf2_extension (die
, &ext_cu
);
6986 type
= read_type_die (ext_die
, ext_cu
);
6987 return set_die_type (die
, type
, cu
);
6990 name
= namespace_name (die
, &is_anonymous
, cu
);
6992 /* Now build the name of the current namespace. */
6994 previous_prefix
= determine_prefix (die
, cu
);
6995 if (previous_prefix
[0] != '\0')
6996 name
= typename_concat (&objfile
->objfile_obstack
,
6997 previous_prefix
, name
, 0, cu
);
6999 /* Create the type. */
7000 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
7002 TYPE_NAME (type
) = (char *) name
;
7003 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7005 return set_die_type (die
, type
, cu
);
7008 /* Read a C++ namespace. */
7011 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
7013 struct objfile
*objfile
= cu
->objfile
;
7017 /* Add a symbol associated to this if we haven't seen the namespace
7018 before. Also, add a using directive if it's an anonymous
7021 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
7025 type
= read_type_die (die
, cu
);
7026 new_symbol (die
, type
, cu
);
7028 name
= namespace_name (die
, &is_anonymous
, cu
);
7031 const char *previous_prefix
= determine_prefix (die
, cu
);
7033 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
7034 NULL
, &objfile
->objfile_obstack
);
7038 if (die
->child
!= NULL
)
7040 struct die_info
*child_die
= die
->child
;
7042 while (child_die
&& child_die
->tag
)
7044 process_die (child_die
, cu
);
7045 child_die
= sibling_die (child_die
);
7050 /* Read a Fortran module as type. This DIE can be only a declaration used for
7051 imported module. Still we need that type as local Fortran "use ... only"
7052 declaration imports depend on the created type in determine_prefix. */
7054 static struct type
*
7055 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7057 struct objfile
*objfile
= cu
->objfile
;
7061 module_name
= dwarf2_name (die
, cu
);
7063 complaint (&symfile_complaints
, _("DW_TAG_module has no name, offset 0x%x"),
7065 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
7067 /* determine_prefix uses TYPE_TAG_NAME. */
7068 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7070 return set_die_type (die
, type
, cu
);
7073 /* Read a Fortran module. */
7076 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
7078 struct die_info
*child_die
= die
->child
;
7080 while (child_die
&& child_die
->tag
)
7082 process_die (child_die
, cu
);
7083 child_die
= sibling_die (child_die
);
7087 /* Return the name of the namespace represented by DIE. Set
7088 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
7092 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
7094 struct die_info
*current_die
;
7095 const char *name
= NULL
;
7097 /* Loop through the extensions until we find a name. */
7099 for (current_die
= die
;
7100 current_die
!= NULL
;
7101 current_die
= dwarf2_extension (die
, &cu
))
7103 name
= dwarf2_name (current_die
, cu
);
7108 /* Is it an anonymous namespace? */
7110 *is_anonymous
= (name
== NULL
);
7112 name
= "(anonymous namespace)";
7117 /* Extract all information from a DW_TAG_pointer_type DIE and add to
7118 the user defined type vector. */
7120 static struct type
*
7121 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7123 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
7124 struct comp_unit_head
*cu_header
= &cu
->header
;
7126 struct attribute
*attr_byte_size
;
7127 struct attribute
*attr_address_class
;
7128 int byte_size
, addr_class
;
7129 struct type
*target_type
;
7131 target_type
= die_type (die
, cu
);
7133 /* The die_type call above may have already set the type for this DIE. */
7134 type
= get_die_type (die
, cu
);
7138 type
= lookup_pointer_type (target_type
);
7140 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7142 byte_size
= DW_UNSND (attr_byte_size
);
7144 byte_size
= cu_header
->addr_size
;
7146 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
7147 if (attr_address_class
)
7148 addr_class
= DW_UNSND (attr_address_class
);
7150 addr_class
= DW_ADDR_none
;
7152 /* If the pointer size or address class is different than the
7153 default, create a type variant marked as such and set the
7154 length accordingly. */
7155 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
7157 if (gdbarch_address_class_type_flags_p (gdbarch
))
7161 type_flags
= gdbarch_address_class_type_flags
7162 (gdbarch
, byte_size
, addr_class
);
7163 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
7165 type
= make_type_with_address_space (type
, type_flags
);
7167 else if (TYPE_LENGTH (type
) != byte_size
)
7169 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
7173 /* Should we also complain about unhandled address classes? */
7177 TYPE_LENGTH (type
) = byte_size
;
7178 return set_die_type (die
, type
, cu
);
7181 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
7182 the user defined type vector. */
7184 static struct type
*
7185 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7188 struct type
*to_type
;
7189 struct type
*domain
;
7191 to_type
= die_type (die
, cu
);
7192 domain
= die_containing_type (die
, cu
);
7194 /* The calls above may have already set the type for this DIE. */
7195 type
= get_die_type (die
, cu
);
7199 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
7200 type
= lookup_methodptr_type (to_type
);
7202 type
= lookup_memberptr_type (to_type
, domain
);
7204 return set_die_type (die
, type
, cu
);
7207 /* Extract all information from a DW_TAG_reference_type DIE and add to
7208 the user defined type vector. */
7210 static struct type
*
7211 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7213 struct comp_unit_head
*cu_header
= &cu
->header
;
7214 struct type
*type
, *target_type
;
7215 struct attribute
*attr
;
7217 target_type
= die_type (die
, cu
);
7219 /* The die_type call above may have already set the type for this DIE. */
7220 type
= get_die_type (die
, cu
);
7224 type
= lookup_reference_type (target_type
);
7225 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7228 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7232 TYPE_LENGTH (type
) = cu_header
->addr_size
;
7234 return set_die_type (die
, type
, cu
);
7237 static struct type
*
7238 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7240 struct type
*base_type
, *cv_type
;
7242 base_type
= die_type (die
, cu
);
7244 /* The die_type call above may have already set the type for this DIE. */
7245 cv_type
= get_die_type (die
, cu
);
7249 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
7250 return set_die_type (die
, cv_type
, cu
);
7253 static struct type
*
7254 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7256 struct type
*base_type
, *cv_type
;
7258 base_type
= die_type (die
, cu
);
7260 /* The die_type call above may have already set the type for this DIE. */
7261 cv_type
= get_die_type (die
, cu
);
7265 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
7266 return set_die_type (die
, cv_type
, cu
);
7269 /* Extract all information from a DW_TAG_string_type DIE and add to
7270 the user defined type vector. It isn't really a user defined type,
7271 but it behaves like one, with other DIE's using an AT_user_def_type
7272 attribute to reference it. */
7274 static struct type
*
7275 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7277 struct objfile
*objfile
= cu
->objfile
;
7278 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7279 struct type
*type
, *range_type
, *index_type
, *char_type
;
7280 struct attribute
*attr
;
7281 unsigned int length
;
7283 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
7286 length
= DW_UNSND (attr
);
7290 /* check for the DW_AT_byte_size attribute */
7291 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7294 length
= DW_UNSND (attr
);
7302 index_type
= objfile_type (objfile
)->builtin_int
;
7303 range_type
= create_range_type (NULL
, index_type
, 1, length
);
7304 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
7305 type
= create_string_type (NULL
, char_type
, range_type
);
7307 return set_die_type (die
, type
, cu
);
7310 /* Handle DIES due to C code like:
7314 int (*funcp)(int a, long l);
7318 ('funcp' generates a DW_TAG_subroutine_type DIE)
7321 static struct type
*
7322 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7324 struct type
*type
; /* Type that this function returns */
7325 struct type
*ftype
; /* Function that returns above type */
7326 struct attribute
*attr
;
7328 type
= die_type (die
, cu
);
7330 /* The die_type call above may have already set the type for this DIE. */
7331 ftype
= get_die_type (die
, cu
);
7335 ftype
= lookup_function_type (type
);
7337 /* All functions in C++, Pascal and Java have prototypes. */
7338 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
7339 if ((attr
&& (DW_UNSND (attr
) != 0))
7340 || cu
->language
== language_cplus
7341 || cu
->language
== language_java
7342 || cu
->language
== language_pascal
)
7343 TYPE_PROTOTYPED (ftype
) = 1;
7344 else if (producer_is_realview (cu
->producer
))
7345 /* RealView does not emit DW_AT_prototyped. We can not
7346 distinguish prototyped and unprototyped functions; default to
7347 prototyped, since that is more common in modern code (and
7348 RealView warns about unprototyped functions). */
7349 TYPE_PROTOTYPED (ftype
) = 1;
7351 /* Store the calling convention in the type if it's available in
7352 the subroutine die. Otherwise set the calling convention to
7353 the default value DW_CC_normal. */
7354 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
7355 TYPE_CALLING_CONVENTION (ftype
) = attr
? DW_UNSND (attr
) : DW_CC_normal
;
7357 /* We need to add the subroutine type to the die immediately so
7358 we don't infinitely recurse when dealing with parameters
7359 declared as the same subroutine type. */
7360 set_die_type (die
, ftype
, cu
);
7362 if (die
->child
!= NULL
)
7364 struct type
*void_type
= objfile_type (cu
->objfile
)->builtin_void
;
7365 struct die_info
*child_die
;
7366 int nparams
, iparams
;
7368 /* Count the number of parameters.
7369 FIXME: GDB currently ignores vararg functions, but knows about
7370 vararg member functions. */
7372 child_die
= die
->child
;
7373 while (child_die
&& child_die
->tag
)
7375 if (child_die
->tag
== DW_TAG_formal_parameter
)
7377 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
7378 TYPE_VARARGS (ftype
) = 1;
7379 child_die
= sibling_die (child_die
);
7382 /* Allocate storage for parameters and fill them in. */
7383 TYPE_NFIELDS (ftype
) = nparams
;
7384 TYPE_FIELDS (ftype
) = (struct field
*)
7385 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
7387 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
7388 even if we error out during the parameters reading below. */
7389 for (iparams
= 0; iparams
< nparams
; iparams
++)
7390 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
7393 child_die
= die
->child
;
7394 while (child_die
&& child_die
->tag
)
7396 if (child_die
->tag
== DW_TAG_formal_parameter
)
7398 /* Dwarf2 has no clean way to discern C++ static and non-static
7399 member functions. G++ helps GDB by marking the first
7400 parameter for non-static member functions (which is the
7401 this pointer) as artificial. We pass this information
7402 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
7403 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
7405 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
7408 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
7410 /* GCC/43521: In java, the formal parameter
7411 "this" is sometimes not marked with DW_AT_artificial. */
7412 if (cu
->language
== language_java
)
7414 const char *name
= dwarf2_name (child_die
, cu
);
7416 if (name
&& !strcmp (name
, "this"))
7417 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
7420 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
7423 child_die
= sibling_die (child_die
);
7430 static struct type
*
7431 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
7433 struct objfile
*objfile
= cu
->objfile
;
7434 const char *name
= NULL
;
7435 struct type
*this_type
;
7437 name
= dwarf2_full_name (NULL
, die
, cu
);
7438 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
7439 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
7440 TYPE_NAME (this_type
) = (char *) name
;
7441 set_die_type (die
, this_type
, cu
);
7442 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
7446 /* Find a representation of a given base type and install
7447 it in the TYPE field of the die. */
7449 static struct type
*
7450 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7452 struct objfile
*objfile
= cu
->objfile
;
7454 struct attribute
*attr
;
7455 int encoding
= 0, size
= 0;
7457 enum type_code code
= TYPE_CODE_INT
;
7459 struct type
*target_type
= NULL
;
7461 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
7464 encoding
= DW_UNSND (attr
);
7466 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7469 size
= DW_UNSND (attr
);
7471 name
= dwarf2_name (die
, cu
);
7474 complaint (&symfile_complaints
,
7475 _("DW_AT_name missing from DW_TAG_base_type"));
7480 case DW_ATE_address
:
7481 /* Turn DW_ATE_address into a void * pointer. */
7482 code
= TYPE_CODE_PTR
;
7483 type_flags
|= TYPE_FLAG_UNSIGNED
;
7484 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
7486 case DW_ATE_boolean
:
7487 code
= TYPE_CODE_BOOL
;
7488 type_flags
|= TYPE_FLAG_UNSIGNED
;
7490 case DW_ATE_complex_float
:
7491 code
= TYPE_CODE_COMPLEX
;
7492 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
7494 case DW_ATE_decimal_float
:
7495 code
= TYPE_CODE_DECFLOAT
;
7498 code
= TYPE_CODE_FLT
;
7502 case DW_ATE_unsigned
:
7503 type_flags
|= TYPE_FLAG_UNSIGNED
;
7505 case DW_ATE_signed_char
:
7506 if (cu
->language
== language_ada
|| cu
->language
== language_m2
7507 || cu
->language
== language_pascal
)
7508 code
= TYPE_CODE_CHAR
;
7510 case DW_ATE_unsigned_char
:
7511 if (cu
->language
== language_ada
|| cu
->language
== language_m2
7512 || cu
->language
== language_pascal
)
7513 code
= TYPE_CODE_CHAR
;
7514 type_flags
|= TYPE_FLAG_UNSIGNED
;
7517 /* We just treat this as an integer and then recognize the
7518 type by name elsewhere. */
7522 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
7523 dwarf_type_encoding_name (encoding
));
7527 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
7528 TYPE_NAME (type
) = name
;
7529 TYPE_TARGET_TYPE (type
) = target_type
;
7531 if (name
&& strcmp (name
, "char") == 0)
7532 TYPE_NOSIGN (type
) = 1;
7534 return set_die_type (die
, type
, cu
);
7537 /* Read the given DW_AT_subrange DIE. */
7539 static struct type
*
7540 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7542 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
7543 struct type
*base_type
;
7544 struct type
*range_type
;
7545 struct attribute
*attr
;
7549 LONGEST negative_mask
;
7551 base_type
= die_type (die
, cu
);
7552 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
7553 check_typedef (base_type
);
7555 /* The die_type call above may have already set the type for this DIE. */
7556 range_type
= get_die_type (die
, cu
);
7560 if (cu
->language
== language_fortran
)
7562 /* FORTRAN implies a lower bound of 1, if not given. */
7566 /* FIXME: For variable sized arrays either of these could be
7567 a variable rather than a constant value. We'll allow it,
7568 but we don't know how to handle it. */
7569 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
7571 low
= dwarf2_get_attr_constant_value (attr
, 0);
7573 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
7576 if (attr
->form
== DW_FORM_block1
|| is_ref_attr (attr
))
7578 /* GCC encodes arrays with unspecified or dynamic length
7579 with a DW_FORM_block1 attribute or a reference attribute.
7580 FIXME: GDB does not yet know how to handle dynamic
7581 arrays properly, treat them as arrays with unspecified
7584 FIXME: jimb/2003-09-22: GDB does not really know
7585 how to handle arrays of unspecified length
7586 either; we just represent them as zero-length
7587 arrays. Choose an appropriate upper bound given
7588 the lower bound we've computed above. */
7592 high
= dwarf2_get_attr_constant_value (attr
, 1);
7596 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
7599 int count
= dwarf2_get_attr_constant_value (attr
, 1);
7600 high
= low
+ count
- 1;
7604 /* Dwarf-2 specifications explicitly allows to create subrange types
7605 without specifying a base type.
7606 In that case, the base type must be set to the type of
7607 the lower bound, upper bound or count, in that order, if any of these
7608 three attributes references an object that has a type.
7609 If no base type is found, the Dwarf-2 specifications say that
7610 a signed integer type of size equal to the size of an address should
7612 For the following C code: `extern char gdb_int [];'
7613 GCC produces an empty range DIE.
7614 FIXME: muller/2010-05-28: Possible references to object for low bound,
7615 high bound or count are not yet handled by this code.
7617 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
7619 struct objfile
*objfile
= cu
->objfile
;
7620 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7621 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
7622 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
7624 /* Test "int", "long int", and "long long int" objfile types,
7625 and select the first one having a size above or equal to the
7626 architecture address size. */
7627 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
7628 base_type
= int_type
;
7631 int_type
= objfile_type (objfile
)->builtin_long
;
7632 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
7633 base_type
= int_type
;
7636 int_type
= objfile_type (objfile
)->builtin_long_long
;
7637 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
7638 base_type
= int_type
;
7644 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
7645 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
7646 low
|= negative_mask
;
7647 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
7648 high
|= negative_mask
;
7650 range_type
= create_range_type (NULL
, base_type
, low
, high
);
7652 /* Mark arrays with dynamic length at least as an array of unspecified
7653 length. GDB could check the boundary but before it gets implemented at
7654 least allow accessing the array elements. */
7655 if (attr
&& attr
->form
== DW_FORM_block1
)
7656 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
7658 name
= dwarf2_name (die
, cu
);
7660 TYPE_NAME (range_type
) = name
;
7662 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7664 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
7666 set_die_type (die
, range_type
, cu
);
7668 /* set_die_type should be already done. */
7669 set_descriptive_type (range_type
, die
, cu
);
7674 static struct type
*
7675 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7679 /* For now, we only support the C meaning of an unspecified type: void. */
7681 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
7682 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
7684 return set_die_type (die
, type
, cu
);
7687 /* Trivial hash function for die_info: the hash value of a DIE
7688 is its offset in .debug_info for this objfile. */
7691 die_hash (const void *item
)
7693 const struct die_info
*die
= item
;
7698 /* Trivial comparison function for die_info structures: two DIEs
7699 are equal if they have the same offset. */
7702 die_eq (const void *item_lhs
, const void *item_rhs
)
7704 const struct die_info
*die_lhs
= item_lhs
;
7705 const struct die_info
*die_rhs
= item_rhs
;
7707 return die_lhs
->offset
== die_rhs
->offset
;
7710 /* Read a whole compilation unit into a linked list of dies. */
7712 static struct die_info
*
7713 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
7715 struct die_reader_specs reader_specs
;
7717 gdb_assert (cu
->die_hash
== NULL
);
7719 = htab_create_alloc_ex (cu
->header
.length
/ 12,
7723 &cu
->comp_unit_obstack
,
7724 hashtab_obstack_allocate
,
7725 dummy_obstack_deallocate
);
7727 init_cu_die_reader (&reader_specs
, cu
);
7729 return read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
7732 /* Main entry point for reading a DIE and all children.
7733 Read the DIE and dump it if requested. */
7735 static struct die_info
*
7736 read_die_and_children (const struct die_reader_specs
*reader
,
7738 gdb_byte
**new_info_ptr
,
7739 struct die_info
*parent
)
7741 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
7742 new_info_ptr
, parent
);
7744 if (dwarf2_die_debug
)
7746 fprintf_unfiltered (gdb_stdlog
,
7747 "\nRead die from %s of %s:\n",
7748 reader
->buffer
== dwarf2_per_objfile
->info
.buffer
7750 : reader
->buffer
== dwarf2_per_objfile
->types
.buffer
7752 : "unknown section",
7753 reader
->abfd
->filename
);
7754 dump_die (result
, dwarf2_die_debug
);
7760 /* Read a single die and all its descendents. Set the die's sibling
7761 field to NULL; set other fields in the die correctly, and set all
7762 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
7763 location of the info_ptr after reading all of those dies. PARENT
7764 is the parent of the die in question. */
7766 static struct die_info
*
7767 read_die_and_children_1 (const struct die_reader_specs
*reader
,
7769 gdb_byte
**new_info_ptr
,
7770 struct die_info
*parent
)
7772 struct die_info
*die
;
7776 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
7779 *new_info_ptr
= cur_ptr
;
7782 store_in_ref_table (die
, reader
->cu
);
7785 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
7789 *new_info_ptr
= cur_ptr
;
7792 die
->sibling
= NULL
;
7793 die
->parent
= parent
;
7797 /* Read a die, all of its descendents, and all of its siblings; set
7798 all of the fields of all of the dies correctly. Arguments are as
7799 in read_die_and_children. */
7801 static struct die_info
*
7802 read_die_and_siblings (const struct die_reader_specs
*reader
,
7804 gdb_byte
**new_info_ptr
,
7805 struct die_info
*parent
)
7807 struct die_info
*first_die
, *last_sibling
;
7811 first_die
= last_sibling
= NULL
;
7815 struct die_info
*die
7816 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
7820 *new_info_ptr
= cur_ptr
;
7827 last_sibling
->sibling
= die
;
7833 /* Read the die from the .debug_info section buffer. Set DIEP to
7834 point to a newly allocated die with its information, except for its
7835 child, sibling, and parent fields. Set HAS_CHILDREN to tell
7836 whether the die has children or not. */
7839 read_full_die (const struct die_reader_specs
*reader
,
7840 struct die_info
**diep
, gdb_byte
*info_ptr
,
7843 unsigned int abbrev_number
, bytes_read
, i
, offset
;
7844 struct abbrev_info
*abbrev
;
7845 struct die_info
*die
;
7846 struct dwarf2_cu
*cu
= reader
->cu
;
7847 bfd
*abfd
= reader
->abfd
;
7849 offset
= info_ptr
- reader
->buffer
;
7850 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7851 info_ptr
+= bytes_read
;
7859 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
7861 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
7863 bfd_get_filename (abfd
));
7865 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
7866 die
->offset
= offset
;
7867 die
->tag
= abbrev
->tag
;
7868 die
->abbrev
= abbrev_number
;
7870 die
->num_attrs
= abbrev
->num_attrs
;
7872 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
7873 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
7874 abfd
, info_ptr
, cu
);
7877 *has_children
= abbrev
->has_children
;
7881 /* In DWARF version 2, the description of the debugging information is
7882 stored in a separate .debug_abbrev section. Before we read any
7883 dies from a section we read in all abbreviations and install them
7884 in a hash table. This function also sets flags in CU describing
7885 the data found in the abbrev table. */
7888 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
7890 struct comp_unit_head
*cu_header
= &cu
->header
;
7891 gdb_byte
*abbrev_ptr
;
7892 struct abbrev_info
*cur_abbrev
;
7893 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
7894 unsigned int abbrev_form
, hash_number
;
7895 struct attr_abbrev
*cur_attrs
;
7896 unsigned int allocated_attrs
;
7898 /* Initialize dwarf2 abbrevs */
7899 obstack_init (&cu
->abbrev_obstack
);
7900 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
7902 * sizeof (struct abbrev_info
*)));
7903 memset (cu
->dwarf2_abbrevs
, 0,
7904 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
7906 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
7907 &dwarf2_per_objfile
->abbrev
);
7908 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
7909 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7910 abbrev_ptr
+= bytes_read
;
7912 allocated_attrs
= ATTR_ALLOC_CHUNK
;
7913 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
7915 /* loop until we reach an abbrev number of 0 */
7916 while (abbrev_number
)
7918 cur_abbrev
= dwarf_alloc_abbrev (cu
);
7920 /* read in abbrev header */
7921 cur_abbrev
->number
= abbrev_number
;
7922 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7923 abbrev_ptr
+= bytes_read
;
7924 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
7927 if (cur_abbrev
->tag
== DW_TAG_namespace
)
7928 cu
->has_namespace_info
= 1;
7930 /* now read in declarations */
7931 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7932 abbrev_ptr
+= bytes_read
;
7933 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7934 abbrev_ptr
+= bytes_read
;
7937 if (cur_abbrev
->num_attrs
== allocated_attrs
)
7939 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
7941 = xrealloc (cur_attrs
, (allocated_attrs
7942 * sizeof (struct attr_abbrev
)));
7945 /* Record whether this compilation unit might have
7946 inter-compilation-unit references. If we don't know what form
7947 this attribute will have, then it might potentially be a
7948 DW_FORM_ref_addr, so we conservatively expect inter-CU
7951 if (abbrev_form
== DW_FORM_ref_addr
7952 || abbrev_form
== DW_FORM_indirect
)
7953 cu
->has_form_ref_addr
= 1;
7955 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
7956 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
7957 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7958 abbrev_ptr
+= bytes_read
;
7959 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7960 abbrev_ptr
+= bytes_read
;
7963 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
7964 (cur_abbrev
->num_attrs
7965 * sizeof (struct attr_abbrev
)));
7966 memcpy (cur_abbrev
->attrs
, cur_attrs
,
7967 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
7969 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
7970 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
7971 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
7973 /* Get next abbreviation.
7974 Under Irix6 the abbreviations for a compilation unit are not
7975 always properly terminated with an abbrev number of 0.
7976 Exit loop if we encounter an abbreviation which we have
7977 already read (which means we are about to read the abbreviations
7978 for the next compile unit) or if the end of the abbreviation
7979 table is reached. */
7980 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
7981 >= dwarf2_per_objfile
->abbrev
.size
)
7983 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7984 abbrev_ptr
+= bytes_read
;
7985 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
7992 /* Release the memory used by the abbrev table for a compilation unit. */
7995 dwarf2_free_abbrev_table (void *ptr_to_cu
)
7997 struct dwarf2_cu
*cu
= ptr_to_cu
;
7999 obstack_free (&cu
->abbrev_obstack
, NULL
);
8000 cu
->dwarf2_abbrevs
= NULL
;
8003 /* Lookup an abbrev_info structure in the abbrev hash table. */
8005 static struct abbrev_info
*
8006 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
8008 unsigned int hash_number
;
8009 struct abbrev_info
*abbrev
;
8011 hash_number
= number
% ABBREV_HASH_SIZE
;
8012 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
8016 if (abbrev
->number
== number
)
8019 abbrev
= abbrev
->next
;
8024 /* Returns nonzero if TAG represents a type that we might generate a partial
8028 is_type_tag_for_partial (int tag
)
8033 /* Some types that would be reasonable to generate partial symbols for,
8034 that we don't at present. */
8035 case DW_TAG_array_type
:
8036 case DW_TAG_file_type
:
8037 case DW_TAG_ptr_to_member_type
:
8038 case DW_TAG_set_type
:
8039 case DW_TAG_string_type
:
8040 case DW_TAG_subroutine_type
:
8042 case DW_TAG_base_type
:
8043 case DW_TAG_class_type
:
8044 case DW_TAG_interface_type
:
8045 case DW_TAG_enumeration_type
:
8046 case DW_TAG_structure_type
:
8047 case DW_TAG_subrange_type
:
8048 case DW_TAG_typedef
:
8049 case DW_TAG_union_type
:
8056 /* Load all DIEs that are interesting for partial symbols into memory. */
8058 static struct partial_die_info
*
8059 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
8060 int building_psymtab
, struct dwarf2_cu
*cu
)
8062 struct partial_die_info
*part_die
;
8063 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
8064 struct abbrev_info
*abbrev
;
8065 unsigned int bytes_read
;
8066 unsigned int load_all
= 0;
8068 int nesting_level
= 1;
8073 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
8077 = htab_create_alloc_ex (cu
->header
.length
/ 12,
8081 &cu
->comp_unit_obstack
,
8082 hashtab_obstack_allocate
,
8083 dummy_obstack_deallocate
);
8085 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
8086 sizeof (struct partial_die_info
));
8090 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
8092 /* A NULL abbrev means the end of a series of children. */
8095 if (--nesting_level
== 0)
8097 /* PART_DIE was probably the last thing allocated on the
8098 comp_unit_obstack, so we could call obstack_free
8099 here. We don't do that because the waste is small,
8100 and will be cleaned up when we're done with this
8101 compilation unit. This way, we're also more robust
8102 against other users of the comp_unit_obstack. */
8105 info_ptr
+= bytes_read
;
8106 last_die
= parent_die
;
8107 parent_die
= parent_die
->die_parent
;
8111 /* Check whether this DIE is interesting enough to save. Normally
8112 we would not be interested in members here, but there may be
8113 later variables referencing them via DW_AT_specification (for
8116 && !is_type_tag_for_partial (abbrev
->tag
)
8117 && abbrev
->tag
!= DW_TAG_enumerator
8118 && abbrev
->tag
!= DW_TAG_subprogram
8119 && abbrev
->tag
!= DW_TAG_lexical_block
8120 && abbrev
->tag
!= DW_TAG_variable
8121 && abbrev
->tag
!= DW_TAG_namespace
8122 && abbrev
->tag
!= DW_TAG_module
8123 && abbrev
->tag
!= DW_TAG_member
)
8125 /* Otherwise we skip to the next sibling, if any. */
8126 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
8130 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
8131 buffer
, info_ptr
, cu
);
8133 /* This two-pass algorithm for processing partial symbols has a
8134 high cost in cache pressure. Thus, handle some simple cases
8135 here which cover the majority of C partial symbols. DIEs
8136 which neither have specification tags in them, nor could have
8137 specification tags elsewhere pointing at them, can simply be
8138 processed and discarded.
8140 This segment is also optional; scan_partial_symbols and
8141 add_partial_symbol will handle these DIEs if we chain
8142 them in normally. When compilers which do not emit large
8143 quantities of duplicate debug information are more common,
8144 this code can probably be removed. */
8146 /* Any complete simple types at the top level (pretty much all
8147 of them, for a language without namespaces), can be processed
8149 if (parent_die
== NULL
8150 && part_die
->has_specification
== 0
8151 && part_die
->is_declaration
== 0
8152 && (part_die
->tag
== DW_TAG_typedef
8153 || part_die
->tag
== DW_TAG_base_type
8154 || part_die
->tag
== DW_TAG_subrange_type
))
8156 if (building_psymtab
&& part_die
->name
!= NULL
)
8157 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
8158 VAR_DOMAIN
, LOC_TYPEDEF
,
8159 &cu
->objfile
->static_psymbols
,
8160 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
8161 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
8165 /* If we're at the second level, and we're an enumerator, and
8166 our parent has no specification (meaning possibly lives in a
8167 namespace elsewhere), then we can add the partial symbol now
8168 instead of queueing it. */
8169 if (part_die
->tag
== DW_TAG_enumerator
8170 && parent_die
!= NULL
8171 && parent_die
->die_parent
== NULL
8172 && parent_die
->tag
== DW_TAG_enumeration_type
8173 && parent_die
->has_specification
== 0)
8175 if (part_die
->name
== NULL
)
8176 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
8177 else if (building_psymtab
)
8178 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
8179 VAR_DOMAIN
, LOC_CONST
,
8180 (cu
->language
== language_cplus
8181 || cu
->language
== language_java
)
8182 ? &cu
->objfile
->global_psymbols
8183 : &cu
->objfile
->static_psymbols
,
8184 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
8186 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
8190 /* We'll save this DIE so link it in. */
8191 part_die
->die_parent
= parent_die
;
8192 part_die
->die_sibling
= NULL
;
8193 part_die
->die_child
= NULL
;
8195 if (last_die
&& last_die
== parent_die
)
8196 last_die
->die_child
= part_die
;
8198 last_die
->die_sibling
= part_die
;
8200 last_die
= part_die
;
8202 if (first_die
== NULL
)
8203 first_die
= part_die
;
8205 /* Maybe add the DIE to the hash table. Not all DIEs that we
8206 find interesting need to be in the hash table, because we
8207 also have the parent/sibling/child chains; only those that we
8208 might refer to by offset later during partial symbol reading.
8210 For now this means things that might have be the target of a
8211 DW_AT_specification, DW_AT_abstract_origin, or
8212 DW_AT_extension. DW_AT_extension will refer only to
8213 namespaces; DW_AT_abstract_origin refers to functions (and
8214 many things under the function DIE, but we do not recurse
8215 into function DIEs during partial symbol reading) and
8216 possibly variables as well; DW_AT_specification refers to
8217 declarations. Declarations ought to have the DW_AT_declaration
8218 flag. It happens that GCC forgets to put it in sometimes, but
8219 only for functions, not for types.
8221 Adding more things than necessary to the hash table is harmless
8222 except for the performance cost. Adding too few will result in
8223 wasted time in find_partial_die, when we reread the compilation
8224 unit with load_all_dies set. */
8227 || abbrev
->tag
== DW_TAG_subprogram
8228 || abbrev
->tag
== DW_TAG_variable
8229 || abbrev
->tag
== DW_TAG_namespace
8230 || part_die
->is_declaration
)
8234 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
8235 part_die
->offset
, INSERT
);
8239 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
8240 sizeof (struct partial_die_info
));
8242 /* For some DIEs we want to follow their children (if any). For C
8243 we have no reason to follow the children of structures; for other
8244 languages we have to, both so that we can get at method physnames
8245 to infer fully qualified class names, and for DW_AT_specification.
8247 For Ada, we need to scan the children of subprograms and lexical
8248 blocks as well because Ada allows the definition of nested
8249 entities that could be interesting for the debugger, such as
8250 nested subprograms for instance. */
8251 if (last_die
->has_children
8253 || last_die
->tag
== DW_TAG_namespace
8254 || last_die
->tag
== DW_TAG_module
8255 || last_die
->tag
== DW_TAG_enumeration_type
8256 || (cu
->language
!= language_c
8257 && (last_die
->tag
== DW_TAG_class_type
8258 || last_die
->tag
== DW_TAG_interface_type
8259 || last_die
->tag
== DW_TAG_structure_type
8260 || last_die
->tag
== DW_TAG_union_type
))
8261 || (cu
->language
== language_ada
8262 && (last_die
->tag
== DW_TAG_subprogram
8263 || last_die
->tag
== DW_TAG_lexical_block
))))
8266 parent_die
= last_die
;
8270 /* Otherwise we skip to the next sibling, if any. */
8271 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
8273 /* Back to the top, do it again. */
8277 /* Read a minimal amount of information into the minimal die structure. */
8280 read_partial_die (struct partial_die_info
*part_die
,
8281 struct abbrev_info
*abbrev
,
8282 unsigned int abbrev_len
, bfd
*abfd
,
8283 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
8284 struct dwarf2_cu
*cu
)
8287 struct attribute attr
;
8288 int has_low_pc_attr
= 0;
8289 int has_high_pc_attr
= 0;
8291 memset (part_die
, 0, sizeof (struct partial_die_info
));
8293 part_die
->offset
= info_ptr
- buffer
;
8295 info_ptr
+= abbrev_len
;
8300 part_die
->tag
= abbrev
->tag
;
8301 part_die
->has_children
= abbrev
->has_children
;
8303 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
8305 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
8307 /* Store the data if it is of an attribute we want to keep in a
8308 partial symbol table. */
8312 switch (part_die
->tag
)
8314 case DW_TAG_compile_unit
:
8315 case DW_TAG_type_unit
:
8316 /* Compilation units have a DW_AT_name that is a filename, not
8317 a source language identifier. */
8318 case DW_TAG_enumeration_type
:
8319 case DW_TAG_enumerator
:
8320 /* These tags always have simple identifiers already; no need
8321 to canonicalize them. */
8322 part_die
->name
= DW_STRING (&attr
);
8326 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
8327 &cu
->objfile
->objfile_obstack
);
8331 case DW_AT_linkage_name
:
8332 case DW_AT_MIPS_linkage_name
:
8333 /* Note that both forms of linkage name might appear. We
8334 assume they will be the same, and we only store the last
8336 if (cu
->language
== language_ada
)
8337 part_die
->name
= DW_STRING (&attr
);
8340 has_low_pc_attr
= 1;
8341 part_die
->lowpc
= DW_ADDR (&attr
);
8344 has_high_pc_attr
= 1;
8345 part_die
->highpc
= DW_ADDR (&attr
);
8347 case DW_AT_location
:
8348 /* Support the .debug_loc offsets */
8349 if (attr_form_is_block (&attr
))
8351 part_die
->locdesc
= DW_BLOCK (&attr
);
8353 else if (attr_form_is_section_offset (&attr
))
8355 dwarf2_complex_location_expr_complaint ();
8359 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
8360 "partial symbol information");
8363 case DW_AT_external
:
8364 part_die
->is_external
= DW_UNSND (&attr
);
8366 case DW_AT_declaration
:
8367 part_die
->is_declaration
= DW_UNSND (&attr
);
8370 part_die
->has_type
= 1;
8372 case DW_AT_abstract_origin
:
8373 case DW_AT_specification
:
8374 case DW_AT_extension
:
8375 part_die
->has_specification
= 1;
8376 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
8379 /* Ignore absolute siblings, they might point outside of
8380 the current compile unit. */
8381 if (attr
.form
== DW_FORM_ref_addr
)
8382 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
8384 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
8386 case DW_AT_byte_size
:
8387 part_die
->has_byte_size
= 1;
8389 case DW_AT_calling_convention
:
8390 /* DWARF doesn't provide a way to identify a program's source-level
8391 entry point. DW_AT_calling_convention attributes are only meant
8392 to describe functions' calling conventions.
8394 However, because it's a necessary piece of information in
8395 Fortran, and because DW_CC_program is the only piece of debugging
8396 information whose definition refers to a 'main program' at all,
8397 several compilers have begun marking Fortran main programs with
8398 DW_CC_program --- even when those functions use the standard
8399 calling conventions.
8401 So until DWARF specifies a way to provide this information and
8402 compilers pick up the new representation, we'll support this
8404 if (DW_UNSND (&attr
) == DW_CC_program
8405 && cu
->language
== language_fortran
)
8406 set_main_name (part_die
->name
);
8413 /* When using the GNU linker, .gnu.linkonce. sections are used to
8414 eliminate duplicate copies of functions and vtables and such.
8415 The linker will arbitrarily choose one and discard the others.
8416 The AT_*_pc values for such functions refer to local labels in
8417 these sections. If the section from that file was discarded, the
8418 labels are not in the output, so the relocs get a value of 0.
8419 If this is a discarded function, mark the pc bounds as invalid,
8420 so that GDB will ignore it. */
8421 if (has_low_pc_attr
&& has_high_pc_attr
8422 && part_die
->lowpc
< part_die
->highpc
8423 && (part_die
->lowpc
!= 0
8424 || dwarf2_per_objfile
->has_section_at_zero
))
8425 part_die
->has_pc_info
= 1;
8430 /* Find a cached partial DIE at OFFSET in CU. */
8432 static struct partial_die_info
*
8433 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
8435 struct partial_die_info
*lookup_die
= NULL
;
8436 struct partial_die_info part_die
;
8438 part_die
.offset
= offset
;
8439 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
8444 /* Find a partial DIE at OFFSET, which may or may not be in CU,
8445 except in the case of .debug_types DIEs which do not reference
8446 outside their CU (they do however referencing other types via
8449 static struct partial_die_info
*
8450 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
8452 struct dwarf2_per_cu_data
*per_cu
= NULL
;
8453 struct partial_die_info
*pd
= NULL
;
8455 if (cu
->per_cu
->from_debug_types
)
8457 pd
= find_partial_die_in_comp_unit (offset
, cu
);
8463 if (offset_in_cu_p (&cu
->header
, offset
))
8465 pd
= find_partial_die_in_comp_unit (offset
, cu
);
8470 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
8472 if (per_cu
->cu
== NULL
)
8474 load_partial_comp_unit (per_cu
, cu
->objfile
);
8475 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
8476 dwarf2_per_objfile
->read_in_chain
= per_cu
;
8479 per_cu
->cu
->last_used
= 0;
8480 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
8482 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
8484 struct cleanup
*back_to
;
8485 struct partial_die_info comp_unit_die
;
8486 struct abbrev_info
*abbrev
;
8487 unsigned int bytes_read
;
8490 per_cu
->load_all_dies
= 1;
8492 /* Re-read the DIEs. */
8493 back_to
= make_cleanup (null_cleanup
, 0);
8494 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
8496 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
8497 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
8499 info_ptr
= (dwarf2_per_objfile
->info
.buffer
8500 + per_cu
->cu
->header
.offset
8501 + per_cu
->cu
->header
.first_die_offset
);
8502 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
8503 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
8504 per_cu
->cu
->objfile
->obfd
,
8505 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
8507 if (comp_unit_die
.has_children
)
8508 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
8509 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
8511 do_cleanups (back_to
);
8513 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
8519 internal_error (__FILE__
, __LINE__
,
8520 _("could not find partial DIE 0x%x in cache [from module %s]\n"),
8521 offset
, bfd_get_filename (cu
->objfile
->obfd
));
8525 /* Adjust PART_DIE before generating a symbol for it. This function
8526 may set the is_external flag or change the DIE's name. */
8529 fixup_partial_die (struct partial_die_info
*part_die
,
8530 struct dwarf2_cu
*cu
)
8532 /* If we found a reference attribute and the DIE has no name, try
8533 to find a name in the referred to DIE. */
8535 if (part_die
->name
== NULL
&& part_die
->has_specification
)
8537 struct partial_die_info
*spec_die
;
8539 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
8541 fixup_partial_die (spec_die
, cu
);
8545 part_die
->name
= spec_die
->name
;
8547 /* Copy DW_AT_external attribute if it is set. */
8548 if (spec_die
->is_external
)
8549 part_die
->is_external
= spec_die
->is_external
;
8553 /* Set default names for some unnamed DIEs. */
8554 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
8555 || part_die
->tag
== DW_TAG_class_type
))
8556 part_die
->name
= "(anonymous class)";
8558 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
8559 part_die
->name
= "(anonymous namespace)";
8561 if (part_die
->tag
== DW_TAG_structure_type
8562 || part_die
->tag
== DW_TAG_class_type
8563 || part_die
->tag
== DW_TAG_union_type
)
8564 guess_structure_name (part_die
, cu
);
8567 /* Read an attribute value described by an attribute form. */
8570 read_attribute_value (struct attribute
*attr
, unsigned form
,
8571 bfd
*abfd
, gdb_byte
*info_ptr
,
8572 struct dwarf2_cu
*cu
)
8574 struct comp_unit_head
*cu_header
= &cu
->header
;
8575 unsigned int bytes_read
;
8576 struct dwarf_block
*blk
;
8581 case DW_FORM_ref_addr
:
8582 if (cu
->header
.version
== 2)
8583 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
8585 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
8586 info_ptr
+= bytes_read
;
8589 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
8590 info_ptr
+= bytes_read
;
8592 case DW_FORM_block2
:
8593 blk
= dwarf_alloc_block (cu
);
8594 blk
->size
= read_2_bytes (abfd
, info_ptr
);
8596 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
8597 info_ptr
+= blk
->size
;
8598 DW_BLOCK (attr
) = blk
;
8600 case DW_FORM_block4
:
8601 blk
= dwarf_alloc_block (cu
);
8602 blk
->size
= read_4_bytes (abfd
, info_ptr
);
8604 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
8605 info_ptr
+= blk
->size
;
8606 DW_BLOCK (attr
) = blk
;
8609 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
8613 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
8617 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
8620 case DW_FORM_sec_offset
:
8621 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
8622 info_ptr
+= bytes_read
;
8624 case DW_FORM_string
:
8625 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
8626 DW_STRING_IS_CANONICAL (attr
) = 0;
8627 info_ptr
+= bytes_read
;
8630 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
8632 DW_STRING_IS_CANONICAL (attr
) = 0;
8633 info_ptr
+= bytes_read
;
8635 case DW_FORM_exprloc
:
8637 blk
= dwarf_alloc_block (cu
);
8638 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8639 info_ptr
+= bytes_read
;
8640 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
8641 info_ptr
+= blk
->size
;
8642 DW_BLOCK (attr
) = blk
;
8644 case DW_FORM_block1
:
8645 blk
= dwarf_alloc_block (cu
);
8646 blk
->size
= read_1_byte (abfd
, info_ptr
);
8648 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
8649 info_ptr
+= blk
->size
;
8650 DW_BLOCK (attr
) = blk
;
8653 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
8657 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
8660 case DW_FORM_flag_present
:
8661 DW_UNSND (attr
) = 1;
8664 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
8665 info_ptr
+= bytes_read
;
8668 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8669 info_ptr
+= bytes_read
;
8672 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
8676 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
8680 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
8684 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
8688 /* Convert the signature to something we can record in DW_UNSND
8690 NOTE: This is NULL if the type wasn't found. */
8691 DW_SIGNATURED_TYPE (attr
) =
8692 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
8695 case DW_FORM_ref_udata
:
8696 DW_ADDR (attr
) = (cu
->header
.offset
8697 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
8698 info_ptr
+= bytes_read
;
8700 case DW_FORM_indirect
:
8701 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8702 info_ptr
+= bytes_read
;
8703 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
8706 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
8707 dwarf_form_name (form
),
8708 bfd_get_filename (abfd
));
8711 /* We have seen instances where the compiler tried to emit a byte
8712 size attribute of -1 which ended up being encoded as an unsigned
8713 0xffffffff. Although 0xffffffff is technically a valid size value,
8714 an object of this size seems pretty unlikely so we can relatively
8715 safely treat these cases as if the size attribute was invalid and
8716 treat them as zero by default. */
8717 if (attr
->name
== DW_AT_byte_size
8718 && form
== DW_FORM_data4
8719 && DW_UNSND (attr
) >= 0xffffffff)
8722 (&symfile_complaints
,
8723 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
8724 hex_string (DW_UNSND (attr
)));
8725 DW_UNSND (attr
) = 0;
8731 /* Read an attribute described by an abbreviated attribute. */
8734 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
8735 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
8737 attr
->name
= abbrev
->name
;
8738 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
8741 /* read dwarf information from a buffer */
8744 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
8746 return bfd_get_8 (abfd
, buf
);
8750 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
8752 return bfd_get_signed_8 (abfd
, buf
);
8756 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
8758 return bfd_get_16 (abfd
, buf
);
8762 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
8764 return bfd_get_signed_16 (abfd
, buf
);
8768 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
8770 return bfd_get_32 (abfd
, buf
);
8774 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
8776 return bfd_get_signed_32 (abfd
, buf
);
8780 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
8782 return bfd_get_64 (abfd
, buf
);
8786 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
8787 unsigned int *bytes_read
)
8789 struct comp_unit_head
*cu_header
= &cu
->header
;
8790 CORE_ADDR retval
= 0;
8792 if (cu_header
->signed_addr_p
)
8794 switch (cu_header
->addr_size
)
8797 retval
= bfd_get_signed_16 (abfd
, buf
);
8800 retval
= bfd_get_signed_32 (abfd
, buf
);
8803 retval
= bfd_get_signed_64 (abfd
, buf
);
8806 internal_error (__FILE__
, __LINE__
,
8807 _("read_address: bad switch, signed [in module %s]"),
8808 bfd_get_filename (abfd
));
8813 switch (cu_header
->addr_size
)
8816 retval
= bfd_get_16 (abfd
, buf
);
8819 retval
= bfd_get_32 (abfd
, buf
);
8822 retval
= bfd_get_64 (abfd
, buf
);
8825 internal_error (__FILE__
, __LINE__
,
8826 _("read_address: bad switch, unsigned [in module %s]"),
8827 bfd_get_filename (abfd
));
8831 *bytes_read
= cu_header
->addr_size
;
8835 /* Read the initial length from a section. The (draft) DWARF 3
8836 specification allows the initial length to take up either 4 bytes
8837 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
8838 bytes describe the length and all offsets will be 8 bytes in length
8841 An older, non-standard 64-bit format is also handled by this
8842 function. The older format in question stores the initial length
8843 as an 8-byte quantity without an escape value. Lengths greater
8844 than 2^32 aren't very common which means that the initial 4 bytes
8845 is almost always zero. Since a length value of zero doesn't make
8846 sense for the 32-bit format, this initial zero can be considered to
8847 be an escape value which indicates the presence of the older 64-bit
8848 format. As written, the code can't detect (old format) lengths
8849 greater than 4GB. If it becomes necessary to handle lengths
8850 somewhat larger than 4GB, we could allow other small values (such
8851 as the non-sensical values of 1, 2, and 3) to also be used as
8852 escape values indicating the presence of the old format.
8854 The value returned via bytes_read should be used to increment the
8855 relevant pointer after calling read_initial_length().
8857 [ Note: read_initial_length() and read_offset() are based on the
8858 document entitled "DWARF Debugging Information Format", revision
8859 3, draft 8, dated November 19, 2001. This document was obtained
8862 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
8864 This document is only a draft and is subject to change. (So beware.)
8866 Details regarding the older, non-standard 64-bit format were
8867 determined empirically by examining 64-bit ELF files produced by
8868 the SGI toolchain on an IRIX 6.5 machine.
8870 - Kevin, July 16, 2002
8874 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
8876 LONGEST length
= bfd_get_32 (abfd
, buf
);
8878 if (length
== 0xffffffff)
8880 length
= bfd_get_64 (abfd
, buf
+ 4);
8883 else if (length
== 0)
8885 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
8886 length
= bfd_get_64 (abfd
, buf
);
8897 /* Cover function for read_initial_length.
8898 Returns the length of the object at BUF, and stores the size of the
8899 initial length in *BYTES_READ and stores the size that offsets will be in
8901 If the initial length size is not equivalent to that specified in
8902 CU_HEADER then issue a complaint.
8903 This is useful when reading non-comp-unit headers. */
8906 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
8907 const struct comp_unit_head
*cu_header
,
8908 unsigned int *bytes_read
,
8909 unsigned int *offset_size
)
8911 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
8913 gdb_assert (cu_header
->initial_length_size
== 4
8914 || cu_header
->initial_length_size
== 8
8915 || cu_header
->initial_length_size
== 12);
8917 if (cu_header
->initial_length_size
!= *bytes_read
)
8918 complaint (&symfile_complaints
,
8919 _("intermixed 32-bit and 64-bit DWARF sections"));
8921 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
8925 /* Read an offset from the data stream. The size of the offset is
8926 given by cu_header->offset_size. */
8929 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
8930 unsigned int *bytes_read
)
8932 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
8934 *bytes_read
= cu_header
->offset_size
;
8938 /* Read an offset from the data stream. */
8941 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
8945 switch (offset_size
)
8948 retval
= bfd_get_32 (abfd
, buf
);
8951 retval
= bfd_get_64 (abfd
, buf
);
8954 internal_error (__FILE__
, __LINE__
,
8955 _("read_offset_1: bad switch [in module %s]"),
8956 bfd_get_filename (abfd
));
8963 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
8965 /* If the size of a host char is 8 bits, we can return a pointer
8966 to the buffer, otherwise we have to copy the data to a buffer
8967 allocated on the temporary obstack. */
8968 gdb_assert (HOST_CHAR_BIT
== 8);
8973 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
8975 /* If the size of a host char is 8 bits, we can return a pointer
8976 to the string, otherwise we have to copy the string to a buffer
8977 allocated on the temporary obstack. */
8978 gdb_assert (HOST_CHAR_BIT
== 8);
8981 *bytes_read_ptr
= 1;
8984 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
8985 return (char *) buf
;
8989 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
8990 const struct comp_unit_head
*cu_header
,
8991 unsigned int *bytes_read_ptr
)
8993 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
8995 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
8996 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
8998 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
8999 bfd_get_filename (abfd
));
9002 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
9004 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
9005 bfd_get_filename (abfd
));
9008 gdb_assert (HOST_CHAR_BIT
== 8);
9009 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
9011 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
9014 static unsigned long
9015 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9017 unsigned long result
;
9018 unsigned int num_read
;
9028 byte
= bfd_get_8 (abfd
, buf
);
9031 result
|= ((unsigned long)(byte
& 127) << shift
);
9032 if ((byte
& 128) == 0)
9038 *bytes_read_ptr
= num_read
;
9043 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9046 int i
, shift
, num_read
;
9055 byte
= bfd_get_8 (abfd
, buf
);
9058 result
|= ((long)(byte
& 127) << shift
);
9060 if ((byte
& 128) == 0)
9065 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
9066 result
|= -(((long)1) << shift
);
9067 *bytes_read_ptr
= num_read
;
9071 /* Return a pointer to just past the end of an LEB128 number in BUF. */
9074 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
9080 byte
= bfd_get_8 (abfd
, buf
);
9082 if ((byte
& 128) == 0)
9088 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
9095 cu
->language
= language_c
;
9097 case DW_LANG_C_plus_plus
:
9098 cu
->language
= language_cplus
;
9101 cu
->language
= language_d
;
9103 case DW_LANG_Fortran77
:
9104 case DW_LANG_Fortran90
:
9105 case DW_LANG_Fortran95
:
9106 cu
->language
= language_fortran
;
9108 case DW_LANG_Mips_Assembler
:
9109 cu
->language
= language_asm
;
9112 cu
->language
= language_java
;
9116 cu
->language
= language_ada
;
9118 case DW_LANG_Modula2
:
9119 cu
->language
= language_m2
;
9121 case DW_LANG_Pascal83
:
9122 cu
->language
= language_pascal
;
9125 cu
->language
= language_objc
;
9127 case DW_LANG_Cobol74
:
9128 case DW_LANG_Cobol85
:
9130 cu
->language
= language_minimal
;
9133 cu
->language_defn
= language_def (cu
->language
);
9136 /* Return the named attribute or NULL if not there. */
9138 static struct attribute
*
9139 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
9142 struct attribute
*spec
= NULL
;
9144 for (i
= 0; i
< die
->num_attrs
; ++i
)
9146 if (die
->attrs
[i
].name
== name
)
9147 return &die
->attrs
[i
];
9148 if (die
->attrs
[i
].name
== DW_AT_specification
9149 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
9150 spec
= &die
->attrs
[i
];
9155 die
= follow_die_ref (die
, spec
, &cu
);
9156 return dwarf2_attr (die
, name
, cu
);
9162 /* Return the named attribute or NULL if not there,
9163 but do not follow DW_AT_specification, etc.
9164 This is for use in contexts where we're reading .debug_types dies.
9165 Following DW_AT_specification, DW_AT_abstract_origin will take us
9166 back up the chain, and we want to go down. */
9168 static struct attribute
*
9169 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
9170 struct dwarf2_cu
*cu
)
9174 for (i
= 0; i
< die
->num_attrs
; ++i
)
9175 if (die
->attrs
[i
].name
== name
)
9176 return &die
->attrs
[i
];
9181 /* Return non-zero iff the attribute NAME is defined for the given DIE,
9182 and holds a non-zero value. This function should only be used for
9183 DW_FORM_flag or DW_FORM_flag_present attributes. */
9186 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
9188 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
9190 return (attr
&& DW_UNSND (attr
));
9194 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
9196 /* A DIE is a declaration if it has a DW_AT_declaration attribute
9197 which value is non-zero. However, we have to be careful with
9198 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
9199 (via dwarf2_flag_true_p) follows this attribute. So we may
9200 end up accidently finding a declaration attribute that belongs
9201 to a different DIE referenced by the specification attribute,
9202 even though the given DIE does not have a declaration attribute. */
9203 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
9204 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
9207 /* Return the die giving the specification for DIE, if there is
9208 one. *SPEC_CU is the CU containing DIE on input, and the CU
9209 containing the return value on output. If there is no
9210 specification, but there is an abstract origin, that is
9213 static struct die_info
*
9214 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
9216 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
9219 if (spec_attr
== NULL
)
9220 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
9222 if (spec_attr
== NULL
)
9225 return follow_die_ref (die
, spec_attr
, spec_cu
);
9228 /* Free the line_header structure *LH, and any arrays and strings it
9231 free_line_header (struct line_header
*lh
)
9233 if (lh
->standard_opcode_lengths
)
9234 xfree (lh
->standard_opcode_lengths
);
9236 /* Remember that all the lh->file_names[i].name pointers are
9237 pointers into debug_line_buffer, and don't need to be freed. */
9239 xfree (lh
->file_names
);
9241 /* Similarly for the include directory names. */
9242 if (lh
->include_dirs
)
9243 xfree (lh
->include_dirs
);
9249 /* Add an entry to LH's include directory table. */
9251 add_include_dir (struct line_header
*lh
, char *include_dir
)
9253 /* Grow the array if necessary. */
9254 if (lh
->include_dirs_size
== 0)
9256 lh
->include_dirs_size
= 1; /* for testing */
9257 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
9258 * sizeof (*lh
->include_dirs
));
9260 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
9262 lh
->include_dirs_size
*= 2;
9263 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
9264 (lh
->include_dirs_size
9265 * sizeof (*lh
->include_dirs
)));
9268 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
9272 /* Add an entry to LH's file name table. */
9274 add_file_name (struct line_header
*lh
,
9276 unsigned int dir_index
,
9277 unsigned int mod_time
,
9278 unsigned int length
)
9280 struct file_entry
*fe
;
9282 /* Grow the array if necessary. */
9283 if (lh
->file_names_size
== 0)
9285 lh
->file_names_size
= 1; /* for testing */
9286 lh
->file_names
= xmalloc (lh
->file_names_size
9287 * sizeof (*lh
->file_names
));
9289 else if (lh
->num_file_names
>= lh
->file_names_size
)
9291 lh
->file_names_size
*= 2;
9292 lh
->file_names
= xrealloc (lh
->file_names
,
9293 (lh
->file_names_size
9294 * sizeof (*lh
->file_names
)));
9297 fe
= &lh
->file_names
[lh
->num_file_names
++];
9299 fe
->dir_index
= dir_index
;
9300 fe
->mod_time
= mod_time
;
9301 fe
->length
= length
;
9307 /* Read the statement program header starting at OFFSET in
9308 .debug_line, according to the endianness of ABFD. Return a pointer
9309 to a struct line_header, allocated using xmalloc.
9311 NOTE: the strings in the include directory and file name tables of
9312 the returned object point into debug_line_buffer, and must not be
9314 static struct line_header
*
9315 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
9316 struct dwarf2_cu
*cu
)
9318 struct cleanup
*back_to
;
9319 struct line_header
*lh
;
9321 unsigned int bytes_read
, offset_size
;
9323 char *cur_dir
, *cur_file
;
9325 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
9326 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
9328 complaint (&symfile_complaints
, _("missing .debug_line section"));
9332 /* Make sure that at least there's room for the total_length field.
9333 That could be 12 bytes long, but we're just going to fudge that. */
9334 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
9336 dwarf2_statement_list_fits_in_line_number_section_complaint ();
9340 lh
= xmalloc (sizeof (*lh
));
9341 memset (lh
, 0, sizeof (*lh
));
9342 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
9345 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
9347 /* Read in the header. */
9349 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
9350 &bytes_read
, &offset_size
);
9351 line_ptr
+= bytes_read
;
9352 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
9353 + dwarf2_per_objfile
->line
.size
))
9355 dwarf2_statement_list_fits_in_line_number_section_complaint ();
9358 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
9359 lh
->version
= read_2_bytes (abfd
, line_ptr
);
9361 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
9362 line_ptr
+= offset_size
;
9363 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
9365 if (lh
->version
>= 4)
9367 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
9371 lh
->maximum_ops_per_instruction
= 1;
9373 if (lh
->maximum_ops_per_instruction
== 0)
9375 lh
->maximum_ops_per_instruction
= 1;
9376 complaint (&symfile_complaints
,
9377 _("invalid maximum_ops_per_instruction in `.debug_line' section"));
9380 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
9382 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
9384 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
9386 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
9388 lh
->standard_opcode_lengths
9389 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
9391 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
9392 for (i
= 1; i
< lh
->opcode_base
; ++i
)
9394 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
9398 /* Read directory table. */
9399 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
9401 line_ptr
+= bytes_read
;
9402 add_include_dir (lh
, cur_dir
);
9404 line_ptr
+= bytes_read
;
9406 /* Read file name table. */
9407 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
9409 unsigned int dir_index
, mod_time
, length
;
9411 line_ptr
+= bytes_read
;
9412 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9413 line_ptr
+= bytes_read
;
9414 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9415 line_ptr
+= bytes_read
;
9416 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9417 line_ptr
+= bytes_read
;
9419 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
9421 line_ptr
+= bytes_read
;
9422 lh
->statement_program_start
= line_ptr
;
9424 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
9425 + dwarf2_per_objfile
->line
.size
))
9426 complaint (&symfile_complaints
,
9427 _("line number info header doesn't fit in `.debug_line' section"));
9429 discard_cleanups (back_to
);
9433 /* This function exists to work around a bug in certain compilers
9434 (particularly GCC 2.95), in which the first line number marker of a
9435 function does not show up until after the prologue, right before
9436 the second line number marker. This function shifts ADDRESS down
9437 to the beginning of the function if necessary, and is called on
9438 addresses passed to record_line. */
9441 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
9443 struct function_range
*fn
;
9445 /* Find the function_range containing address. */
9450 cu
->cached_fn
= cu
->first_fn
;
9454 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
9460 while (fn
&& fn
!= cu
->cached_fn
)
9461 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
9471 if (address
!= fn
->lowpc
)
9472 complaint (&symfile_complaints
,
9473 _("misplaced first line number at 0x%lx for '%s'"),
9474 (unsigned long) address
, fn
->name
);
9479 /* Decode the Line Number Program (LNP) for the given line_header
9480 structure and CU. The actual information extracted and the type
9481 of structures created from the LNP depends on the value of PST.
9483 1. If PST is NULL, then this procedure uses the data from the program
9484 to create all necessary symbol tables, and their linetables.
9485 The compilation directory of the file is passed in COMP_DIR,
9486 and must not be NULL.
9488 2. If PST is not NULL, this procedure reads the program to determine
9489 the list of files included by the unit represented by PST, and
9490 builds all the associated partial symbol tables. In this case,
9491 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
9492 is not used to compute the full name of the symtab, and therefore
9493 omitting it when building the partial symtab does not introduce
9494 the potential for inconsistency - a partial symtab and its associated
9495 symbtab having a different fullname -). */
9498 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
9499 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
9501 gdb_byte
*line_ptr
, *extended_end
;
9503 unsigned int bytes_read
, extended_len
;
9504 unsigned char op_code
, extended_op
, adj_opcode
;
9506 struct objfile
*objfile
= cu
->objfile
;
9507 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9508 const int decode_for_pst_p
= (pst
!= NULL
);
9509 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
9511 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9513 line_ptr
= lh
->statement_program_start
;
9514 line_end
= lh
->statement_program_end
;
9516 /* Read the statement sequences until there's nothing left. */
9517 while (line_ptr
< line_end
)
9519 /* state machine registers */
9520 CORE_ADDR address
= 0;
9521 unsigned int file
= 1;
9522 unsigned int line
= 1;
9523 unsigned int column
= 0;
9524 int is_stmt
= lh
->default_is_stmt
;
9525 int basic_block
= 0;
9526 int end_sequence
= 0;
9528 unsigned char op_index
= 0;
9530 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
9532 /* Start a subfile for the current file of the state machine. */
9533 /* lh->include_dirs and lh->file_names are 0-based, but the
9534 directory and file name numbers in the statement program
9536 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9540 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9542 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
9545 /* Decode the table. */
9546 while (!end_sequence
)
9548 op_code
= read_1_byte (abfd
, line_ptr
);
9550 if (line_ptr
> line_end
)
9552 dwarf2_debug_line_missing_end_sequence_complaint ();
9556 if (op_code
>= lh
->opcode_base
)
9558 /* Special operand. */
9559 adj_opcode
= op_code
- lh
->opcode_base
;
9560 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
9561 / lh
->maximum_ops_per_instruction
)
9562 * lh
->minimum_instruction_length
);
9563 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
9564 % lh
->maximum_ops_per_instruction
);
9565 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
9566 if (lh
->num_file_names
< file
|| file
== 0)
9567 dwarf2_debug_line_missing_file_complaint ();
9568 /* For now we ignore lines not starting on an
9569 instruction boundary. */
9570 else if (op_index
== 0)
9572 lh
->file_names
[file
- 1].included_p
= 1;
9573 if (!decode_for_pst_p
&& is_stmt
)
9575 if (last_subfile
!= current_subfile
)
9577 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
9579 record_line (last_subfile
, 0, addr
);
9580 last_subfile
= current_subfile
;
9582 /* Append row to matrix using current values. */
9583 addr
= check_cu_functions (address
, cu
);
9584 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
9585 record_line (current_subfile
, line
, addr
);
9590 else switch (op_code
)
9592 case DW_LNS_extended_op
:
9593 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9594 line_ptr
+= bytes_read
;
9595 extended_end
= line_ptr
+ extended_len
;
9596 extended_op
= read_1_byte (abfd
, line_ptr
);
9598 switch (extended_op
)
9600 case DW_LNE_end_sequence
:
9603 case DW_LNE_set_address
:
9604 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
9606 line_ptr
+= bytes_read
;
9607 address
+= baseaddr
;
9609 case DW_LNE_define_file
:
9612 unsigned int dir_index
, mod_time
, length
;
9614 cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
);
9615 line_ptr
+= bytes_read
;
9617 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9618 line_ptr
+= bytes_read
;
9620 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9621 line_ptr
+= bytes_read
;
9623 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9624 line_ptr
+= bytes_read
;
9625 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
9628 case DW_LNE_set_discriminator
:
9629 /* The discriminator is not interesting to the debugger;
9631 line_ptr
= extended_end
;
9634 complaint (&symfile_complaints
,
9635 _("mangled .debug_line section"));
9638 /* Make sure that we parsed the extended op correctly. If e.g.
9639 we expected a different address size than the producer used,
9640 we may have read the wrong number of bytes. */
9641 if (line_ptr
!= extended_end
)
9643 complaint (&symfile_complaints
,
9644 _("mangled .debug_line section"));
9649 if (lh
->num_file_names
< file
|| file
== 0)
9650 dwarf2_debug_line_missing_file_complaint ();
9653 lh
->file_names
[file
- 1].included_p
= 1;
9654 if (!decode_for_pst_p
&& is_stmt
)
9656 if (last_subfile
!= current_subfile
)
9658 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
9660 record_line (last_subfile
, 0, addr
);
9661 last_subfile
= current_subfile
;
9663 addr
= check_cu_functions (address
, cu
);
9664 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
9665 record_line (current_subfile
, line
, addr
);
9670 case DW_LNS_advance_pc
:
9673 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9675 address
+= (((op_index
+ adjust
)
9676 / lh
->maximum_ops_per_instruction
)
9677 * lh
->minimum_instruction_length
);
9678 op_index
= ((op_index
+ adjust
)
9679 % lh
->maximum_ops_per_instruction
);
9680 line_ptr
+= bytes_read
;
9683 case DW_LNS_advance_line
:
9684 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
9685 line_ptr
+= bytes_read
;
9687 case DW_LNS_set_file
:
9689 /* The arrays lh->include_dirs and lh->file_names are
9690 0-based, but the directory and file name numbers in
9691 the statement program are 1-based. */
9692 struct file_entry
*fe
;
9695 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9696 line_ptr
+= bytes_read
;
9697 if (lh
->num_file_names
< file
|| file
== 0)
9698 dwarf2_debug_line_missing_file_complaint ();
9701 fe
= &lh
->file_names
[file
- 1];
9703 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9704 if (!decode_for_pst_p
)
9706 last_subfile
= current_subfile
;
9707 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
9712 case DW_LNS_set_column
:
9713 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9714 line_ptr
+= bytes_read
;
9716 case DW_LNS_negate_stmt
:
9717 is_stmt
= (!is_stmt
);
9719 case DW_LNS_set_basic_block
:
9722 /* Add to the address register of the state machine the
9723 address increment value corresponding to special opcode
9724 255. I.e., this value is scaled by the minimum
9725 instruction length since special opcode 255 would have
9726 scaled the the increment. */
9727 case DW_LNS_const_add_pc
:
9729 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
9731 address
+= (((op_index
+ adjust
)
9732 / lh
->maximum_ops_per_instruction
)
9733 * lh
->minimum_instruction_length
);
9734 op_index
= ((op_index
+ adjust
)
9735 % lh
->maximum_ops_per_instruction
);
9738 case DW_LNS_fixed_advance_pc
:
9739 address
+= read_2_bytes (abfd
, line_ptr
);
9745 /* Unknown standard opcode, ignore it. */
9748 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
9750 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9751 line_ptr
+= bytes_read
;
9756 if (lh
->num_file_names
< file
|| file
== 0)
9757 dwarf2_debug_line_missing_file_complaint ();
9760 lh
->file_names
[file
- 1].included_p
= 1;
9761 if (!decode_for_pst_p
)
9763 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
9764 record_line (current_subfile
, 0, addr
);
9769 if (decode_for_pst_p
)
9773 /* Now that we're done scanning the Line Header Program, we can
9774 create the psymtab of each included file. */
9775 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
9776 if (lh
->file_names
[file_index
].included_p
== 1)
9778 const struct file_entry fe
= lh
->file_names
[file_index
];
9779 char *include_name
= fe
.name
;
9780 char *dir_name
= NULL
;
9781 char *pst_filename
= pst
->filename
;
9784 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
9786 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
9788 include_name
= concat (dir_name
, SLASH_STRING
,
9789 include_name
, (char *)NULL
);
9790 make_cleanup (xfree
, include_name
);
9793 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
9795 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
9796 pst_filename
, (char *)NULL
);
9797 make_cleanup (xfree
, pst_filename
);
9800 if (strcmp (include_name
, pst_filename
) != 0)
9801 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
9806 /* Make sure a symtab is created for every file, even files
9807 which contain only variables (i.e. no code with associated
9811 struct file_entry
*fe
;
9813 for (i
= 0; i
< lh
->num_file_names
; i
++)
9817 fe
= &lh
->file_names
[i
];
9819 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9820 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
9822 /* Skip the main file; we don't need it, and it must be
9823 allocated last, so that it will show up before the
9824 non-primary symtabs in the objfile's symtab list. */
9825 if (current_subfile
== first_subfile
)
9828 if (current_subfile
->symtab
== NULL
)
9829 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
9831 fe
->symtab
= current_subfile
->symtab
;
9836 /* Start a subfile for DWARF. FILENAME is the name of the file and
9837 DIRNAME the name of the source directory which contains FILENAME
9838 or NULL if not known. COMP_DIR is the compilation directory for the
9839 linetable's compilation unit or NULL if not known.
9840 This routine tries to keep line numbers from identical absolute and
9841 relative file names in a common subfile.
9843 Using the `list' example from the GDB testsuite, which resides in
9844 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
9845 of /srcdir/list0.c yields the following debugging information for list0.c:
9847 DW_AT_name: /srcdir/list0.c
9848 DW_AT_comp_dir: /compdir
9849 files.files[0].name: list0.h
9850 files.files[0].dir: /srcdir
9851 files.files[1].name: list0.c
9852 files.files[1].dir: /srcdir
9854 The line number information for list0.c has to end up in a single
9855 subfile, so that `break /srcdir/list0.c:1' works as expected.
9856 start_subfile will ensure that this happens provided that we pass the
9857 concatenation of files.files[1].dir and files.files[1].name as the
9861 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
9865 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
9866 `start_symtab' will always pass the contents of DW_AT_comp_dir as
9867 second argument to start_subfile. To be consistent, we do the
9868 same here. In order not to lose the line information directory,
9869 we concatenate it to the filename when it makes sense.
9870 Note that the Dwarf3 standard says (speaking of filenames in line
9871 information): ``The directory index is ignored for file names
9872 that represent full path names''. Thus ignoring dirname in the
9873 `else' branch below isn't an issue. */
9875 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
9876 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
9878 fullname
= filename
;
9880 start_subfile (fullname
, comp_dir
);
9882 if (fullname
!= filename
)
9887 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
9888 struct dwarf2_cu
*cu
)
9890 struct objfile
*objfile
= cu
->objfile
;
9891 struct comp_unit_head
*cu_header
= &cu
->header
;
9893 /* NOTE drow/2003-01-30: There used to be a comment and some special
9894 code here to turn a symbol with DW_AT_external and a
9895 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
9896 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
9897 with some versions of binutils) where shared libraries could have
9898 relocations against symbols in their debug information - the
9899 minimal symbol would have the right address, but the debug info
9900 would not. It's no longer necessary, because we will explicitly
9901 apply relocations when we read in the debug information now. */
9903 /* A DW_AT_location attribute with no contents indicates that a
9904 variable has been optimized away. */
9905 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
9907 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
9911 /* Handle one degenerate form of location expression specially, to
9912 preserve GDB's previous behavior when section offsets are
9913 specified. If this is just a DW_OP_addr then mark this symbol
9916 if (attr_form_is_block (attr
)
9917 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
9918 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
9922 SYMBOL_VALUE_ADDRESS (sym
) =
9923 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
9924 SYMBOL_CLASS (sym
) = LOC_STATIC
;
9925 fixup_symbol_section (sym
, objfile
);
9926 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
9927 SYMBOL_SECTION (sym
));
9931 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
9932 expression evaluator, and use LOC_COMPUTED only when necessary
9933 (i.e. when the value of a register or memory location is
9934 referenced, or a thread-local block, etc.). Then again, it might
9935 not be worthwhile. I'm assuming that it isn't unless performance
9936 or memory numbers show me otherwise. */
9938 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
9939 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
9942 /* Given a pointer to a DWARF information entry, figure out if we need
9943 to make a symbol table entry for it, and if so, create a new entry
9944 and return a pointer to it.
9945 If TYPE is NULL, determine symbol type from the die, otherwise
9946 used the passed type.
9947 If SPACE is not NULL, use it to hold the new symbol. If it is
9948 NULL, allocate a new symbol on the objfile's obstack. */
9950 static struct symbol
*
9951 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
9952 struct symbol
*space
)
9954 struct objfile
*objfile
= cu
->objfile
;
9955 struct symbol
*sym
= NULL
;
9957 struct attribute
*attr
= NULL
;
9958 struct attribute
*attr2
= NULL
;
9960 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
9962 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9964 name
= dwarf2_name (die
, cu
);
9967 const char *linkagename
;
9968 int suppress_add
= 0;
9973 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
9974 OBJSTAT (objfile
, n_syms
++);
9976 /* Cache this symbol's name and the name's demangled form (if any). */
9977 SYMBOL_LANGUAGE (sym
) = cu
->language
;
9978 linkagename
= dwarf2_physname (name
, die
, cu
);
9979 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
9981 /* Fortran does not have mangling standard and the mangling does differ
9982 between gfortran, iFort etc. */
9983 if (cu
->language
== language_fortran
9984 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
9985 symbol_set_demangled_name (&(sym
->ginfo
),
9986 (char *) dwarf2_full_name (name
, die
, cu
),
9989 /* Default assumptions.
9990 Use the passed type or decode it from the die. */
9991 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
9992 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
9994 SYMBOL_TYPE (sym
) = type
;
9996 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
9997 attr
= dwarf2_attr (die
,
9998 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
10002 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
10005 attr
= dwarf2_attr (die
,
10006 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
10010 int file_index
= DW_UNSND (attr
);
10012 if (cu
->line_header
== NULL
10013 || file_index
> cu
->line_header
->num_file_names
)
10014 complaint (&symfile_complaints
,
10015 _("file index out of range"));
10016 else if (file_index
> 0)
10018 struct file_entry
*fe
;
10020 fe
= &cu
->line_header
->file_names
[file_index
- 1];
10021 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
10028 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
10031 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
10033 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
10034 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
10035 SYMBOL_CLASS (sym
) = LOC_LABEL
;
10036 add_symbol_to_list (sym
, cu
->list_in_scope
);
10038 case DW_TAG_subprogram
:
10039 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
10041 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
10042 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10043 if ((attr2
&& (DW_UNSND (attr2
) != 0))
10044 || cu
->language
== language_ada
)
10046 /* Subprograms marked external are stored as a global symbol.
10047 Ada subprograms, whether marked external or not, are always
10048 stored as a global symbol, because we want to be able to
10049 access them globally. For instance, we want to be able
10050 to break on a nested subprogram without having to
10051 specify the context. */
10052 add_symbol_to_list (sym
, &global_symbols
);
10056 add_symbol_to_list (sym
, cu
->list_in_scope
);
10059 case DW_TAG_inlined_subroutine
:
10060 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
10062 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
10063 SYMBOL_INLINED (sym
) = 1;
10064 /* Do not add the symbol to any lists. It will be found via
10065 BLOCK_FUNCTION from the blockvector. */
10067 case DW_TAG_template_value_param
:
10069 /* Fall through. */
10070 case DW_TAG_variable
:
10071 case DW_TAG_member
:
10072 /* Compilation with minimal debug info may result in variables
10073 with missing type entries. Change the misleading `void' type
10074 to something sensible. */
10075 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
10077 = objfile_type (objfile
)->nodebug_data_symbol
;
10079 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10080 /* In the case of DW_TAG_member, we should only be called for
10081 static const members. */
10082 if (die
->tag
== DW_TAG_member
)
10084 /* dwarf2_add_field uses die_is_declaration,
10085 so we do the same. */
10086 gdb_assert (die_is_declaration (die
, cu
));
10091 dwarf2_const_value (attr
, sym
, cu
);
10092 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10095 sym
->hash_next
= objfile
->template_symbols
;
10096 objfile
->template_symbols
= sym
;
10100 if (attr2
&& (DW_UNSND (attr2
) != 0))
10101 add_symbol_to_list (sym
, &global_symbols
);
10103 add_symbol_to_list (sym
, cu
->list_in_scope
);
10107 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
10110 var_decode_location (attr
, sym
, cu
);
10111 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10112 if (SYMBOL_CLASS (sym
) == LOC_STATIC
10113 && SYMBOL_VALUE_ADDRESS (sym
) == 0
10114 && !dwarf2_per_objfile
->has_section_at_zero
)
10116 /* When a static variable is eliminated by the linker,
10117 the corresponding debug information is not stripped
10118 out, but the variable address is set to null;
10119 do not add such variables into symbol table. */
10121 else if (attr2
&& (DW_UNSND (attr2
) != 0))
10123 struct pending
**list_to_add
;
10125 /* Workaround gfortran PR debug/40040 - it uses
10126 DW_AT_location for variables in -fPIC libraries which may
10127 get overriden by other libraries/executable and get
10128 a different address. Resolve it by the minimal symbol
10129 which may come from inferior's executable using copy
10130 relocation. Make this workaround only for gfortran as for
10131 other compilers GDB cannot guess the minimal symbol
10132 Fortran mangling kind. */
10133 if (cu
->language
== language_fortran
&& die
->parent
10134 && die
->parent
->tag
== DW_TAG_module
10136 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
10137 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
10139 /* A variable with DW_AT_external is never static,
10140 but it may be block-scoped. */
10141 list_to_add
= (cu
->list_in_scope
== &file_symbols
10142 ? &global_symbols
: cu
->list_in_scope
);
10143 add_symbol_to_list (sym
, list_to_add
);
10146 add_symbol_to_list (sym
, cu
->list_in_scope
);
10150 /* We do not know the address of this symbol.
10151 If it is an external symbol and we have type information
10152 for it, enter the symbol as a LOC_UNRESOLVED symbol.
10153 The address of the variable will then be determined from
10154 the minimal symbol table whenever the variable is
10156 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10157 if (attr2
&& (DW_UNSND (attr2
) != 0)
10158 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
10160 struct pending
**list_to_add
;
10162 /* A variable with DW_AT_external is never static, but it
10163 may be block-scoped. */
10164 list_to_add
= (cu
->list_in_scope
== &file_symbols
10165 ? &global_symbols
: cu
->list_in_scope
);
10167 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
10170 sym
->hash_next
= objfile
->template_symbols
;
10171 objfile
->template_symbols
= sym
;
10174 add_symbol_to_list (sym
, list_to_add
);
10176 else if (!die_is_declaration (die
, cu
))
10178 /* Use the default LOC_OPTIMIZED_OUT class. */
10179 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
10182 sym
->hash_next
= objfile
->template_symbols
;
10183 objfile
->template_symbols
= sym
;
10186 add_symbol_to_list (sym
, cu
->list_in_scope
);
10190 case DW_TAG_formal_parameter
:
10191 /* If we are inside a function, mark this as an argument. If
10192 not, we might be looking at an argument to an inlined function
10193 when we do not have enough information to show inlined frames;
10194 pretend it's a local variable in that case so that the user can
10196 if (context_stack_depth
> 0
10197 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
10198 SYMBOL_IS_ARGUMENT (sym
) = 1;
10199 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
10202 var_decode_location (attr
, sym
, cu
);
10204 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10207 dwarf2_const_value (attr
, sym
, cu
);
10209 attr
= dwarf2_attr (die
, DW_AT_variable_parameter
, cu
);
10210 if (attr
&& DW_UNSND (attr
))
10212 struct type
*ref_type
;
10214 ref_type
= lookup_reference_type (SYMBOL_TYPE (sym
));
10215 SYMBOL_TYPE (sym
) = ref_type
;
10218 add_symbol_to_list (sym
, cu
->list_in_scope
);
10220 case DW_TAG_unspecified_parameters
:
10221 /* From varargs functions; gdb doesn't seem to have any
10222 interest in this information, so just ignore it for now.
10225 case DW_TAG_template_type_param
:
10227 /* Fall through. */
10228 case DW_TAG_class_type
:
10229 case DW_TAG_interface_type
:
10230 case DW_TAG_structure_type
:
10231 case DW_TAG_union_type
:
10232 case DW_TAG_set_type
:
10233 case DW_TAG_enumeration_type
:
10234 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10235 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
10238 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
10239 really ever be static objects: otherwise, if you try
10240 to, say, break of a class's method and you're in a file
10241 which doesn't mention that class, it won't work unless
10242 the check for all static symbols in lookup_symbol_aux
10243 saves you. See the OtherFileClass tests in
10244 gdb.c++/namespace.exp. */
10248 sym
->hash_next
= objfile
->template_symbols
;
10249 objfile
->template_symbols
= sym
;
10253 struct pending
**list_to_add
;
10255 list_to_add
= (cu
->list_in_scope
== &file_symbols
10256 && (cu
->language
== language_cplus
10257 || cu
->language
== language_java
)
10258 ? &global_symbols
: cu
->list_in_scope
);
10260 add_symbol_to_list (sym
, list_to_add
);
10263 /* The semantics of C++ state that "struct foo { ... }" also
10264 defines a typedef for "foo". A Java class declaration also
10265 defines a typedef for the class. */
10266 if (cu
->language
== language_cplus
10267 || cu
->language
== language_java
10268 || cu
->language
== language_ada
)
10270 /* The symbol's name is already allocated along with
10271 this objfile, so we don't need to duplicate it for
10273 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
10274 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
10278 case DW_TAG_typedef
:
10279 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10280 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
10281 add_symbol_to_list (sym
, cu
->list_in_scope
);
10283 case DW_TAG_base_type
:
10284 case DW_TAG_subrange_type
:
10285 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10286 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
10287 add_symbol_to_list (sym
, cu
->list_in_scope
);
10289 case DW_TAG_enumerator
:
10290 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10293 dwarf2_const_value (attr
, sym
, cu
);
10296 /* NOTE: carlton/2003-11-10: See comment above in the
10297 DW_TAG_class_type, etc. block. */
10299 struct pending
**list_to_add
;
10301 list_to_add
= (cu
->list_in_scope
== &file_symbols
10302 && (cu
->language
== language_cplus
10303 || cu
->language
== language_java
)
10304 ? &global_symbols
: cu
->list_in_scope
);
10306 add_symbol_to_list (sym
, list_to_add
);
10309 case DW_TAG_namespace
:
10310 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10311 add_symbol_to_list (sym
, &global_symbols
);
10314 /* Not a tag we recognize. Hopefully we aren't processing
10315 trash data, but since we must specifically ignore things
10316 we don't recognize, there is nothing else we should do at
10318 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
10319 dwarf_tag_name (die
->tag
));
10323 /* For the benefit of old versions of GCC, check for anonymous
10324 namespaces based on the demangled name. */
10325 if (!processing_has_namespace_info
10326 && cu
->language
== language_cplus
)
10327 cp_scan_for_anonymous_namespaces (sym
);
10332 /* A wrapper for new_symbol_full that always allocates a new symbol. */
10334 static struct symbol
*
10335 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
10337 return new_symbol_full (die
, type
, cu
, NULL
);
10340 /* Copy constant value from an attribute to a symbol. */
10343 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
10344 struct dwarf2_cu
*cu
)
10346 struct objfile
*objfile
= cu
->objfile
;
10347 struct comp_unit_head
*cu_header
= &cu
->header
;
10348 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
10349 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
10350 struct dwarf_block
*blk
;
10352 switch (attr
->form
)
10356 struct dwarf2_locexpr_baton
*baton
;
10359 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
10360 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
10361 cu_header
->addr_size
,
10362 TYPE_LENGTH (SYMBOL_TYPE
10364 /* Symbols of this form are reasonably rare, so we just
10365 piggyback on the existing location code rather than writing
10366 a new implementation of symbol_computed_ops. */
10367 baton
= obstack_alloc (&objfile
->objfile_obstack
,
10368 sizeof (struct dwarf2_locexpr_baton
));
10369 baton
->per_cu
= cu
->per_cu
;
10370 gdb_assert (baton
->per_cu
);
10372 baton
->size
= 2 + cu_header
->addr_size
;
10373 data
= obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
10374 baton
->data
= data
;
10376 data
[0] = DW_OP_addr
;
10377 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
10378 byte_order
, DW_ADDR (attr
));
10379 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
10381 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
10382 SYMBOL_LOCATION_BATON (sym
) = baton
;
10383 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
10386 case DW_FORM_string
:
10388 /* DW_STRING is already allocated on the obstack, point directly
10390 SYMBOL_VALUE_BYTES (sym
) = (gdb_byte
*) DW_STRING (attr
);
10391 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
10393 case DW_FORM_block1
:
10394 case DW_FORM_block2
:
10395 case DW_FORM_block4
:
10396 case DW_FORM_block
:
10397 case DW_FORM_exprloc
:
10398 blk
= DW_BLOCK (attr
);
10399 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
10400 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
10402 TYPE_LENGTH (SYMBOL_TYPE
10404 SYMBOL_VALUE_BYTES (sym
) =
10405 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
10406 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
10407 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
10410 /* The DW_AT_const_value attributes are supposed to carry the
10411 symbol's value "represented as it would be on the target
10412 architecture." By the time we get here, it's already been
10413 converted to host endianness, so we just need to sign- or
10414 zero-extend it as appropriate. */
10415 case DW_FORM_data1
:
10416 dwarf2_const_value_data (attr
, sym
, 8);
10418 case DW_FORM_data2
:
10419 dwarf2_const_value_data (attr
, sym
, 16);
10421 case DW_FORM_data4
:
10422 dwarf2_const_value_data (attr
, sym
, 32);
10424 case DW_FORM_data8
:
10425 dwarf2_const_value_data (attr
, sym
, 64);
10428 case DW_FORM_sdata
:
10429 SYMBOL_VALUE (sym
) = DW_SND (attr
);
10430 SYMBOL_CLASS (sym
) = LOC_CONST
;
10433 case DW_FORM_udata
:
10434 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
10435 SYMBOL_CLASS (sym
) = LOC_CONST
;
10439 complaint (&symfile_complaints
,
10440 _("unsupported const value attribute form: '%s'"),
10441 dwarf_form_name (attr
->form
));
10442 SYMBOL_VALUE (sym
) = 0;
10443 SYMBOL_CLASS (sym
) = LOC_CONST
;
10449 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
10450 or zero-extend it as appropriate for the symbol's type. */
10452 dwarf2_const_value_data (struct attribute
*attr
,
10453 struct symbol
*sym
,
10456 LONGEST l
= DW_UNSND (attr
);
10458 if (bits
< sizeof (l
) * 8)
10460 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
10461 l
&= ((LONGEST
) 1 << bits
) - 1;
10463 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
10466 SYMBOL_VALUE (sym
) = l
;
10467 SYMBOL_CLASS (sym
) = LOC_CONST
;
10471 /* Return the type of the die in question using its DW_AT_type attribute. */
10473 static struct type
*
10474 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10476 struct attribute
*type_attr
;
10477 struct die_info
*type_die
;
10479 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
10482 /* A missing DW_AT_type represents a void type. */
10483 return objfile_type (cu
->objfile
)->builtin_void
;
10486 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
10488 return tag_type_to_type (type_die
, cu
);
10491 /* True iff CU's producer generates GNAT Ada auxiliary information
10492 that allows to find parallel types through that information instead
10493 of having to do expensive parallel lookups by type name. */
10496 need_gnat_info (struct dwarf2_cu
*cu
)
10498 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
10499 of GNAT produces this auxiliary information, without any indication
10500 that it is produced. Part of enhancing the FSF version of GNAT
10501 to produce that information will be to put in place an indicator
10502 that we can use in order to determine whether the descriptive type
10503 info is available or not. One suggestion that has been made is
10504 to use a new attribute, attached to the CU die. For now, assume
10505 that the descriptive type info is not available. */
10510 /* Return the auxiliary type of the die in question using its
10511 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
10512 attribute is not present. */
10514 static struct type
*
10515 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10517 struct attribute
*type_attr
;
10518 struct die_info
*type_die
;
10520 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
10524 type_die
= follow_die_ref (die
, type_attr
, &cu
);
10525 return tag_type_to_type (type_die
, cu
);
10528 /* If DIE has a descriptive_type attribute, then set the TYPE's
10529 descriptive type accordingly. */
10532 set_descriptive_type (struct type
*type
, struct die_info
*die
,
10533 struct dwarf2_cu
*cu
)
10535 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
10537 if (descriptive_type
)
10539 ALLOCATE_GNAT_AUX_TYPE (type
);
10540 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
10544 /* Return the containing type of the die in question using its
10545 DW_AT_containing_type attribute. */
10547 static struct type
*
10548 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10550 struct attribute
*type_attr
;
10551 struct die_info
*type_die
;
10553 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
10555 error (_("Dwarf Error: Problem turning containing type into gdb type "
10556 "[in module %s]"), cu
->objfile
->name
);
10558 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
10559 return tag_type_to_type (type_die
, cu
);
10562 static struct type
*
10563 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10565 struct type
*this_type
;
10567 this_type
= read_type_die (die
, cu
);
10570 char *message
, *saved
;
10572 /* read_type_die already issued a complaint. */
10573 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
10577 saved
= obstack_copy0 (&cu
->objfile
->objfile_obstack
,
10578 message
, strlen (message
));
10581 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, cu
->objfile
);
10586 static struct type
*
10587 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10589 struct type
*this_type
;
10591 this_type
= get_die_type (die
, cu
);
10597 case DW_TAG_class_type
:
10598 case DW_TAG_interface_type
:
10599 case DW_TAG_structure_type
:
10600 case DW_TAG_union_type
:
10601 this_type
= read_structure_type (die
, cu
);
10603 case DW_TAG_enumeration_type
:
10604 this_type
= read_enumeration_type (die
, cu
);
10606 case DW_TAG_subprogram
:
10607 case DW_TAG_subroutine_type
:
10608 case DW_TAG_inlined_subroutine
:
10609 this_type
= read_subroutine_type (die
, cu
);
10611 case DW_TAG_array_type
:
10612 this_type
= read_array_type (die
, cu
);
10614 case DW_TAG_set_type
:
10615 this_type
= read_set_type (die
, cu
);
10617 case DW_TAG_pointer_type
:
10618 this_type
= read_tag_pointer_type (die
, cu
);
10620 case DW_TAG_ptr_to_member_type
:
10621 this_type
= read_tag_ptr_to_member_type (die
, cu
);
10623 case DW_TAG_reference_type
:
10624 this_type
= read_tag_reference_type (die
, cu
);
10626 case DW_TAG_const_type
:
10627 this_type
= read_tag_const_type (die
, cu
);
10629 case DW_TAG_volatile_type
:
10630 this_type
= read_tag_volatile_type (die
, cu
);
10632 case DW_TAG_string_type
:
10633 this_type
= read_tag_string_type (die
, cu
);
10635 case DW_TAG_typedef
:
10636 this_type
= read_typedef (die
, cu
);
10638 case DW_TAG_subrange_type
:
10639 this_type
= read_subrange_type (die
, cu
);
10641 case DW_TAG_base_type
:
10642 this_type
= read_base_type (die
, cu
);
10644 case DW_TAG_unspecified_type
:
10645 this_type
= read_unspecified_type (die
, cu
);
10647 case DW_TAG_namespace
:
10648 this_type
= read_namespace_type (die
, cu
);
10650 case DW_TAG_module
:
10651 this_type
= read_module_type (die
, cu
);
10654 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
10655 dwarf_tag_name (die
->tag
));
10662 /* Return the name of the namespace/class that DIE is defined within,
10663 or "" if we can't tell. The caller should not xfree the result.
10665 For example, if we're within the method foo() in the following
10675 then determine_prefix on foo's die will return "N::C". */
10678 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
10680 struct die_info
*parent
, *spec_die
;
10681 struct dwarf2_cu
*spec_cu
;
10682 struct type
*parent_type
;
10684 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
10685 && cu
->language
!= language_fortran
)
10688 /* We have to be careful in the presence of DW_AT_specification.
10689 For example, with GCC 3.4, given the code
10693 // Definition of N::foo.
10697 then we'll have a tree of DIEs like this:
10699 1: DW_TAG_compile_unit
10700 2: DW_TAG_namespace // N
10701 3: DW_TAG_subprogram // declaration of N::foo
10702 4: DW_TAG_subprogram // definition of N::foo
10703 DW_AT_specification // refers to die #3
10705 Thus, when processing die #4, we have to pretend that we're in
10706 the context of its DW_AT_specification, namely the contex of die
10709 spec_die
= die_specification (die
, &spec_cu
);
10710 if (spec_die
== NULL
)
10711 parent
= die
->parent
;
10714 parent
= spec_die
->parent
;
10718 if (parent
== NULL
)
10721 switch (parent
->tag
)
10723 case DW_TAG_namespace
:
10724 parent_type
= read_type_die (parent
, cu
);
10725 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
10726 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
10727 Work around this problem here. */
10728 if (cu
->language
== language_cplus
10729 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
10731 /* We give a name to even anonymous namespaces. */
10732 return TYPE_TAG_NAME (parent_type
);
10733 case DW_TAG_class_type
:
10734 case DW_TAG_interface_type
:
10735 case DW_TAG_structure_type
:
10736 case DW_TAG_union_type
:
10737 case DW_TAG_module
:
10738 parent_type
= read_type_die (parent
, cu
);
10739 if (TYPE_TAG_NAME (parent_type
) != NULL
)
10740 return TYPE_TAG_NAME (parent_type
);
10742 /* An anonymous structure is only allowed non-static data
10743 members; no typedefs, no member functions, et cetera.
10744 So it does not need a prefix. */
10747 return determine_prefix (parent
, cu
);
10751 /* Return a newly-allocated string formed by concatenating PREFIX and
10752 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
10753 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
10754 perform an obconcat, otherwise allocate storage for the result. The CU argument
10755 is used to determine the language and hence, the appropriate separator. */
10757 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
10760 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
10761 int physname
, struct dwarf2_cu
*cu
)
10763 const char *lead
= "";
10766 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
10768 else if (cu
->language
== language_java
)
10770 else if (cu
->language
== language_fortran
&& physname
)
10772 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
10773 DW_AT_MIPS_linkage_name is preferred and used instead. */
10781 if (prefix
== NULL
)
10783 if (suffix
== NULL
)
10788 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
10790 strcpy (retval
, lead
);
10791 strcat (retval
, prefix
);
10792 strcat (retval
, sep
);
10793 strcat (retval
, suffix
);
10798 /* We have an obstack. */
10799 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
10803 /* Return sibling of die, NULL if no sibling. */
10805 static struct die_info
*
10806 sibling_die (struct die_info
*die
)
10808 return die
->sibling
;
10811 /* Get name of a die, return NULL if not found. */
10814 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
10815 struct obstack
*obstack
)
10817 if (name
&& cu
->language
== language_cplus
)
10819 char *canon_name
= cp_canonicalize_string (name
);
10821 if (canon_name
!= NULL
)
10823 if (strcmp (canon_name
, name
) != 0)
10824 name
= obsavestring (canon_name
, strlen (canon_name
),
10826 xfree (canon_name
);
10833 /* Get name of a die, return NULL if not found. */
10836 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10838 struct attribute
*attr
;
10840 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10841 if (!attr
|| !DW_STRING (attr
))
10846 case DW_TAG_compile_unit
:
10847 /* Compilation units have a DW_AT_name that is a filename, not
10848 a source language identifier. */
10849 case DW_TAG_enumeration_type
:
10850 case DW_TAG_enumerator
:
10851 /* These tags always have simple identifiers already; no need
10852 to canonicalize them. */
10853 return DW_STRING (attr
);
10855 case DW_TAG_subprogram
:
10856 /* Java constructors will all be named "<init>", so return
10857 the class name when we see this special case. */
10858 if (cu
->language
== language_java
10859 && DW_STRING (attr
) != NULL
10860 && strcmp (DW_STRING (attr
), "<init>") == 0)
10862 struct dwarf2_cu
*spec_cu
= cu
;
10863 struct die_info
*spec_die
;
10865 /* GCJ will output '<init>' for Java constructor names.
10866 For this special case, return the name of the parent class. */
10868 /* GCJ may output suprogram DIEs with AT_specification set.
10869 If so, use the name of the specified DIE. */
10870 spec_die
= die_specification (die
, &spec_cu
);
10871 if (spec_die
!= NULL
)
10872 return dwarf2_name (spec_die
, spec_cu
);
10877 if (die
->tag
== DW_TAG_class_type
)
10878 return dwarf2_name (die
, cu
);
10880 while (die
->tag
!= DW_TAG_compile_unit
);
10884 case DW_TAG_class_type
:
10885 case DW_TAG_interface_type
:
10886 case DW_TAG_structure_type
:
10887 case DW_TAG_union_type
:
10888 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
10889 structures or unions. These were of the form "._%d" in GCC 4.1,
10890 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
10891 and GCC 4.4. We work around this problem by ignoring these. */
10892 if (strncmp (DW_STRING (attr
), "._", 2) == 0
10893 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0)
10901 if (!DW_STRING_IS_CANONICAL (attr
))
10904 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
10905 &cu
->objfile
->objfile_obstack
);
10906 DW_STRING_IS_CANONICAL (attr
) = 1;
10908 return DW_STRING (attr
);
10911 /* Return the die that this die in an extension of, or NULL if there
10912 is none. *EXT_CU is the CU containing DIE on input, and the CU
10913 containing the return value on output. */
10915 static struct die_info
*
10916 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
10918 struct attribute
*attr
;
10920 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
10924 return follow_die_ref (die
, attr
, ext_cu
);
10927 /* Convert a DIE tag into its string name. */
10930 dwarf_tag_name (unsigned tag
)
10934 case DW_TAG_padding
:
10935 return "DW_TAG_padding";
10936 case DW_TAG_array_type
:
10937 return "DW_TAG_array_type";
10938 case DW_TAG_class_type
:
10939 return "DW_TAG_class_type";
10940 case DW_TAG_entry_point
:
10941 return "DW_TAG_entry_point";
10942 case DW_TAG_enumeration_type
:
10943 return "DW_TAG_enumeration_type";
10944 case DW_TAG_formal_parameter
:
10945 return "DW_TAG_formal_parameter";
10946 case DW_TAG_imported_declaration
:
10947 return "DW_TAG_imported_declaration";
10949 return "DW_TAG_label";
10950 case DW_TAG_lexical_block
:
10951 return "DW_TAG_lexical_block";
10952 case DW_TAG_member
:
10953 return "DW_TAG_member";
10954 case DW_TAG_pointer_type
:
10955 return "DW_TAG_pointer_type";
10956 case DW_TAG_reference_type
:
10957 return "DW_TAG_reference_type";
10958 case DW_TAG_compile_unit
:
10959 return "DW_TAG_compile_unit";
10960 case DW_TAG_string_type
:
10961 return "DW_TAG_string_type";
10962 case DW_TAG_structure_type
:
10963 return "DW_TAG_structure_type";
10964 case DW_TAG_subroutine_type
:
10965 return "DW_TAG_subroutine_type";
10966 case DW_TAG_typedef
:
10967 return "DW_TAG_typedef";
10968 case DW_TAG_union_type
:
10969 return "DW_TAG_union_type";
10970 case DW_TAG_unspecified_parameters
:
10971 return "DW_TAG_unspecified_parameters";
10972 case DW_TAG_variant
:
10973 return "DW_TAG_variant";
10974 case DW_TAG_common_block
:
10975 return "DW_TAG_common_block";
10976 case DW_TAG_common_inclusion
:
10977 return "DW_TAG_common_inclusion";
10978 case DW_TAG_inheritance
:
10979 return "DW_TAG_inheritance";
10980 case DW_TAG_inlined_subroutine
:
10981 return "DW_TAG_inlined_subroutine";
10982 case DW_TAG_module
:
10983 return "DW_TAG_module";
10984 case DW_TAG_ptr_to_member_type
:
10985 return "DW_TAG_ptr_to_member_type";
10986 case DW_TAG_set_type
:
10987 return "DW_TAG_set_type";
10988 case DW_TAG_subrange_type
:
10989 return "DW_TAG_subrange_type";
10990 case DW_TAG_with_stmt
:
10991 return "DW_TAG_with_stmt";
10992 case DW_TAG_access_declaration
:
10993 return "DW_TAG_access_declaration";
10994 case DW_TAG_base_type
:
10995 return "DW_TAG_base_type";
10996 case DW_TAG_catch_block
:
10997 return "DW_TAG_catch_block";
10998 case DW_TAG_const_type
:
10999 return "DW_TAG_const_type";
11000 case DW_TAG_constant
:
11001 return "DW_TAG_constant";
11002 case DW_TAG_enumerator
:
11003 return "DW_TAG_enumerator";
11004 case DW_TAG_file_type
:
11005 return "DW_TAG_file_type";
11006 case DW_TAG_friend
:
11007 return "DW_TAG_friend";
11008 case DW_TAG_namelist
:
11009 return "DW_TAG_namelist";
11010 case DW_TAG_namelist_item
:
11011 return "DW_TAG_namelist_item";
11012 case DW_TAG_packed_type
:
11013 return "DW_TAG_packed_type";
11014 case DW_TAG_subprogram
:
11015 return "DW_TAG_subprogram";
11016 case DW_TAG_template_type_param
:
11017 return "DW_TAG_template_type_param";
11018 case DW_TAG_template_value_param
:
11019 return "DW_TAG_template_value_param";
11020 case DW_TAG_thrown_type
:
11021 return "DW_TAG_thrown_type";
11022 case DW_TAG_try_block
:
11023 return "DW_TAG_try_block";
11024 case DW_TAG_variant_part
:
11025 return "DW_TAG_variant_part";
11026 case DW_TAG_variable
:
11027 return "DW_TAG_variable";
11028 case DW_TAG_volatile_type
:
11029 return "DW_TAG_volatile_type";
11030 case DW_TAG_dwarf_procedure
:
11031 return "DW_TAG_dwarf_procedure";
11032 case DW_TAG_restrict_type
:
11033 return "DW_TAG_restrict_type";
11034 case DW_TAG_interface_type
:
11035 return "DW_TAG_interface_type";
11036 case DW_TAG_namespace
:
11037 return "DW_TAG_namespace";
11038 case DW_TAG_imported_module
:
11039 return "DW_TAG_imported_module";
11040 case DW_TAG_unspecified_type
:
11041 return "DW_TAG_unspecified_type";
11042 case DW_TAG_partial_unit
:
11043 return "DW_TAG_partial_unit";
11044 case DW_TAG_imported_unit
:
11045 return "DW_TAG_imported_unit";
11046 case DW_TAG_condition
:
11047 return "DW_TAG_condition";
11048 case DW_TAG_shared_type
:
11049 return "DW_TAG_shared_type";
11050 case DW_TAG_type_unit
:
11051 return "DW_TAG_type_unit";
11052 case DW_TAG_MIPS_loop
:
11053 return "DW_TAG_MIPS_loop";
11054 case DW_TAG_HP_array_descriptor
:
11055 return "DW_TAG_HP_array_descriptor";
11056 case DW_TAG_format_label
:
11057 return "DW_TAG_format_label";
11058 case DW_TAG_function_template
:
11059 return "DW_TAG_function_template";
11060 case DW_TAG_class_template
:
11061 return "DW_TAG_class_template";
11062 case DW_TAG_GNU_BINCL
:
11063 return "DW_TAG_GNU_BINCL";
11064 case DW_TAG_GNU_EINCL
:
11065 return "DW_TAG_GNU_EINCL";
11066 case DW_TAG_upc_shared_type
:
11067 return "DW_TAG_upc_shared_type";
11068 case DW_TAG_upc_strict_type
:
11069 return "DW_TAG_upc_strict_type";
11070 case DW_TAG_upc_relaxed_type
:
11071 return "DW_TAG_upc_relaxed_type";
11072 case DW_TAG_PGI_kanji_type
:
11073 return "DW_TAG_PGI_kanji_type";
11074 case DW_TAG_PGI_interface_block
:
11075 return "DW_TAG_PGI_interface_block";
11077 return "DW_TAG_<unknown>";
11081 /* Convert a DWARF attribute code into its string name. */
11084 dwarf_attr_name (unsigned attr
)
11088 case DW_AT_sibling
:
11089 return "DW_AT_sibling";
11090 case DW_AT_location
:
11091 return "DW_AT_location";
11093 return "DW_AT_name";
11094 case DW_AT_ordering
:
11095 return "DW_AT_ordering";
11096 case DW_AT_subscr_data
:
11097 return "DW_AT_subscr_data";
11098 case DW_AT_byte_size
:
11099 return "DW_AT_byte_size";
11100 case DW_AT_bit_offset
:
11101 return "DW_AT_bit_offset";
11102 case DW_AT_bit_size
:
11103 return "DW_AT_bit_size";
11104 case DW_AT_element_list
:
11105 return "DW_AT_element_list";
11106 case DW_AT_stmt_list
:
11107 return "DW_AT_stmt_list";
11109 return "DW_AT_low_pc";
11110 case DW_AT_high_pc
:
11111 return "DW_AT_high_pc";
11112 case DW_AT_language
:
11113 return "DW_AT_language";
11115 return "DW_AT_member";
11117 return "DW_AT_discr";
11118 case DW_AT_discr_value
:
11119 return "DW_AT_discr_value";
11120 case DW_AT_visibility
:
11121 return "DW_AT_visibility";
11123 return "DW_AT_import";
11124 case DW_AT_string_length
:
11125 return "DW_AT_string_length";
11126 case DW_AT_common_reference
:
11127 return "DW_AT_common_reference";
11128 case DW_AT_comp_dir
:
11129 return "DW_AT_comp_dir";
11130 case DW_AT_const_value
:
11131 return "DW_AT_const_value";
11132 case DW_AT_containing_type
:
11133 return "DW_AT_containing_type";
11134 case DW_AT_default_value
:
11135 return "DW_AT_default_value";
11137 return "DW_AT_inline";
11138 case DW_AT_is_optional
:
11139 return "DW_AT_is_optional";
11140 case DW_AT_lower_bound
:
11141 return "DW_AT_lower_bound";
11142 case DW_AT_producer
:
11143 return "DW_AT_producer";
11144 case DW_AT_prototyped
:
11145 return "DW_AT_prototyped";
11146 case DW_AT_return_addr
:
11147 return "DW_AT_return_addr";
11148 case DW_AT_start_scope
:
11149 return "DW_AT_start_scope";
11150 case DW_AT_bit_stride
:
11151 return "DW_AT_bit_stride";
11152 case DW_AT_upper_bound
:
11153 return "DW_AT_upper_bound";
11154 case DW_AT_abstract_origin
:
11155 return "DW_AT_abstract_origin";
11156 case DW_AT_accessibility
:
11157 return "DW_AT_accessibility";
11158 case DW_AT_address_class
:
11159 return "DW_AT_address_class";
11160 case DW_AT_artificial
:
11161 return "DW_AT_artificial";
11162 case DW_AT_base_types
:
11163 return "DW_AT_base_types";
11164 case DW_AT_calling_convention
:
11165 return "DW_AT_calling_convention";
11167 return "DW_AT_count";
11168 case DW_AT_data_member_location
:
11169 return "DW_AT_data_member_location";
11170 case DW_AT_decl_column
:
11171 return "DW_AT_decl_column";
11172 case DW_AT_decl_file
:
11173 return "DW_AT_decl_file";
11174 case DW_AT_decl_line
:
11175 return "DW_AT_decl_line";
11176 case DW_AT_declaration
:
11177 return "DW_AT_declaration";
11178 case DW_AT_discr_list
:
11179 return "DW_AT_discr_list";
11180 case DW_AT_encoding
:
11181 return "DW_AT_encoding";
11182 case DW_AT_external
:
11183 return "DW_AT_external";
11184 case DW_AT_frame_base
:
11185 return "DW_AT_frame_base";
11187 return "DW_AT_friend";
11188 case DW_AT_identifier_case
:
11189 return "DW_AT_identifier_case";
11190 case DW_AT_macro_info
:
11191 return "DW_AT_macro_info";
11192 case DW_AT_namelist_items
:
11193 return "DW_AT_namelist_items";
11194 case DW_AT_priority
:
11195 return "DW_AT_priority";
11196 case DW_AT_segment
:
11197 return "DW_AT_segment";
11198 case DW_AT_specification
:
11199 return "DW_AT_specification";
11200 case DW_AT_static_link
:
11201 return "DW_AT_static_link";
11203 return "DW_AT_type";
11204 case DW_AT_use_location
:
11205 return "DW_AT_use_location";
11206 case DW_AT_variable_parameter
:
11207 return "DW_AT_variable_parameter";
11208 case DW_AT_virtuality
:
11209 return "DW_AT_virtuality";
11210 case DW_AT_vtable_elem_location
:
11211 return "DW_AT_vtable_elem_location";
11212 /* DWARF 3 values. */
11213 case DW_AT_allocated
:
11214 return "DW_AT_allocated";
11215 case DW_AT_associated
:
11216 return "DW_AT_associated";
11217 case DW_AT_data_location
:
11218 return "DW_AT_data_location";
11219 case DW_AT_byte_stride
:
11220 return "DW_AT_byte_stride";
11221 case DW_AT_entry_pc
:
11222 return "DW_AT_entry_pc";
11223 case DW_AT_use_UTF8
:
11224 return "DW_AT_use_UTF8";
11225 case DW_AT_extension
:
11226 return "DW_AT_extension";
11228 return "DW_AT_ranges";
11229 case DW_AT_trampoline
:
11230 return "DW_AT_trampoline";
11231 case DW_AT_call_column
:
11232 return "DW_AT_call_column";
11233 case DW_AT_call_file
:
11234 return "DW_AT_call_file";
11235 case DW_AT_call_line
:
11236 return "DW_AT_call_line";
11237 case DW_AT_description
:
11238 return "DW_AT_description";
11239 case DW_AT_binary_scale
:
11240 return "DW_AT_binary_scale";
11241 case DW_AT_decimal_scale
:
11242 return "DW_AT_decimal_scale";
11244 return "DW_AT_small";
11245 case DW_AT_decimal_sign
:
11246 return "DW_AT_decimal_sign";
11247 case DW_AT_digit_count
:
11248 return "DW_AT_digit_count";
11249 case DW_AT_picture_string
:
11250 return "DW_AT_picture_string";
11251 case DW_AT_mutable
:
11252 return "DW_AT_mutable";
11253 case DW_AT_threads_scaled
:
11254 return "DW_AT_threads_scaled";
11255 case DW_AT_explicit
:
11256 return "DW_AT_explicit";
11257 case DW_AT_object_pointer
:
11258 return "DW_AT_object_pointer";
11259 case DW_AT_endianity
:
11260 return "DW_AT_endianity";
11261 case DW_AT_elemental
:
11262 return "DW_AT_elemental";
11264 return "DW_AT_pure";
11265 case DW_AT_recursive
:
11266 return "DW_AT_recursive";
11267 /* DWARF 4 values. */
11268 case DW_AT_signature
:
11269 return "DW_AT_signature";
11270 case DW_AT_linkage_name
:
11271 return "DW_AT_linkage_name";
11272 /* SGI/MIPS extensions. */
11273 #ifdef MIPS /* collides with DW_AT_HP_block_index */
11274 case DW_AT_MIPS_fde
:
11275 return "DW_AT_MIPS_fde";
11277 case DW_AT_MIPS_loop_begin
:
11278 return "DW_AT_MIPS_loop_begin";
11279 case DW_AT_MIPS_tail_loop_begin
:
11280 return "DW_AT_MIPS_tail_loop_begin";
11281 case DW_AT_MIPS_epilog_begin
:
11282 return "DW_AT_MIPS_epilog_begin";
11283 case DW_AT_MIPS_loop_unroll_factor
:
11284 return "DW_AT_MIPS_loop_unroll_factor";
11285 case DW_AT_MIPS_software_pipeline_depth
:
11286 return "DW_AT_MIPS_software_pipeline_depth";
11287 case DW_AT_MIPS_linkage_name
:
11288 return "DW_AT_MIPS_linkage_name";
11289 case DW_AT_MIPS_stride
:
11290 return "DW_AT_MIPS_stride";
11291 case DW_AT_MIPS_abstract_name
:
11292 return "DW_AT_MIPS_abstract_name";
11293 case DW_AT_MIPS_clone_origin
:
11294 return "DW_AT_MIPS_clone_origin";
11295 case DW_AT_MIPS_has_inlines
:
11296 return "DW_AT_MIPS_has_inlines";
11297 /* HP extensions. */
11298 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
11299 case DW_AT_HP_block_index
:
11300 return "DW_AT_HP_block_index";
11302 case DW_AT_HP_unmodifiable
:
11303 return "DW_AT_HP_unmodifiable";
11304 case DW_AT_HP_actuals_stmt_list
:
11305 return "DW_AT_HP_actuals_stmt_list";
11306 case DW_AT_HP_proc_per_section
:
11307 return "DW_AT_HP_proc_per_section";
11308 case DW_AT_HP_raw_data_ptr
:
11309 return "DW_AT_HP_raw_data_ptr";
11310 case DW_AT_HP_pass_by_reference
:
11311 return "DW_AT_HP_pass_by_reference";
11312 case DW_AT_HP_opt_level
:
11313 return "DW_AT_HP_opt_level";
11314 case DW_AT_HP_prof_version_id
:
11315 return "DW_AT_HP_prof_version_id";
11316 case DW_AT_HP_opt_flags
:
11317 return "DW_AT_HP_opt_flags";
11318 case DW_AT_HP_cold_region_low_pc
:
11319 return "DW_AT_HP_cold_region_low_pc";
11320 case DW_AT_HP_cold_region_high_pc
:
11321 return "DW_AT_HP_cold_region_high_pc";
11322 case DW_AT_HP_all_variables_modifiable
:
11323 return "DW_AT_HP_all_variables_modifiable";
11324 case DW_AT_HP_linkage_name
:
11325 return "DW_AT_HP_linkage_name";
11326 case DW_AT_HP_prof_flags
:
11327 return "DW_AT_HP_prof_flags";
11328 /* GNU extensions. */
11329 case DW_AT_sf_names
:
11330 return "DW_AT_sf_names";
11331 case DW_AT_src_info
:
11332 return "DW_AT_src_info";
11333 case DW_AT_mac_info
:
11334 return "DW_AT_mac_info";
11335 case DW_AT_src_coords
:
11336 return "DW_AT_src_coords";
11337 case DW_AT_body_begin
:
11338 return "DW_AT_body_begin";
11339 case DW_AT_body_end
:
11340 return "DW_AT_body_end";
11341 case DW_AT_GNU_vector
:
11342 return "DW_AT_GNU_vector";
11343 /* VMS extensions. */
11344 case DW_AT_VMS_rtnbeg_pd_address
:
11345 return "DW_AT_VMS_rtnbeg_pd_address";
11346 /* UPC extension. */
11347 case DW_AT_upc_threads_scaled
:
11348 return "DW_AT_upc_threads_scaled";
11349 /* PGI (STMicroelectronics) extensions. */
11350 case DW_AT_PGI_lbase
:
11351 return "DW_AT_PGI_lbase";
11352 case DW_AT_PGI_soffset
:
11353 return "DW_AT_PGI_soffset";
11354 case DW_AT_PGI_lstride
:
11355 return "DW_AT_PGI_lstride";
11357 return "DW_AT_<unknown>";
11361 /* Convert a DWARF value form code into its string name. */
11364 dwarf_form_name (unsigned form
)
11369 return "DW_FORM_addr";
11370 case DW_FORM_block2
:
11371 return "DW_FORM_block2";
11372 case DW_FORM_block4
:
11373 return "DW_FORM_block4";
11374 case DW_FORM_data2
:
11375 return "DW_FORM_data2";
11376 case DW_FORM_data4
:
11377 return "DW_FORM_data4";
11378 case DW_FORM_data8
:
11379 return "DW_FORM_data8";
11380 case DW_FORM_string
:
11381 return "DW_FORM_string";
11382 case DW_FORM_block
:
11383 return "DW_FORM_block";
11384 case DW_FORM_block1
:
11385 return "DW_FORM_block1";
11386 case DW_FORM_data1
:
11387 return "DW_FORM_data1";
11389 return "DW_FORM_flag";
11390 case DW_FORM_sdata
:
11391 return "DW_FORM_sdata";
11393 return "DW_FORM_strp";
11394 case DW_FORM_udata
:
11395 return "DW_FORM_udata";
11396 case DW_FORM_ref_addr
:
11397 return "DW_FORM_ref_addr";
11399 return "DW_FORM_ref1";
11401 return "DW_FORM_ref2";
11403 return "DW_FORM_ref4";
11405 return "DW_FORM_ref8";
11406 case DW_FORM_ref_udata
:
11407 return "DW_FORM_ref_udata";
11408 case DW_FORM_indirect
:
11409 return "DW_FORM_indirect";
11410 case DW_FORM_sec_offset
:
11411 return "DW_FORM_sec_offset";
11412 case DW_FORM_exprloc
:
11413 return "DW_FORM_exprloc";
11414 case DW_FORM_flag_present
:
11415 return "DW_FORM_flag_present";
11417 return "DW_FORM_sig8";
11419 return "DW_FORM_<unknown>";
11423 /* Convert a DWARF stack opcode into its string name. */
11426 dwarf_stack_op_name (unsigned op
, int def
)
11431 return "DW_OP_addr";
11433 return "DW_OP_deref";
11434 case DW_OP_const1u
:
11435 return "DW_OP_const1u";
11436 case DW_OP_const1s
:
11437 return "DW_OP_const1s";
11438 case DW_OP_const2u
:
11439 return "DW_OP_const2u";
11440 case DW_OP_const2s
:
11441 return "DW_OP_const2s";
11442 case DW_OP_const4u
:
11443 return "DW_OP_const4u";
11444 case DW_OP_const4s
:
11445 return "DW_OP_const4s";
11446 case DW_OP_const8u
:
11447 return "DW_OP_const8u";
11448 case DW_OP_const8s
:
11449 return "DW_OP_const8s";
11451 return "DW_OP_constu";
11453 return "DW_OP_consts";
11455 return "DW_OP_dup";
11457 return "DW_OP_drop";
11459 return "DW_OP_over";
11461 return "DW_OP_pick";
11463 return "DW_OP_swap";
11465 return "DW_OP_rot";
11467 return "DW_OP_xderef";
11469 return "DW_OP_abs";
11471 return "DW_OP_and";
11473 return "DW_OP_div";
11475 return "DW_OP_minus";
11477 return "DW_OP_mod";
11479 return "DW_OP_mul";
11481 return "DW_OP_neg";
11483 return "DW_OP_not";
11487 return "DW_OP_plus";
11488 case DW_OP_plus_uconst
:
11489 return "DW_OP_plus_uconst";
11491 return "DW_OP_shl";
11493 return "DW_OP_shr";
11495 return "DW_OP_shra";
11497 return "DW_OP_xor";
11499 return "DW_OP_bra";
11513 return "DW_OP_skip";
11515 return "DW_OP_lit0";
11517 return "DW_OP_lit1";
11519 return "DW_OP_lit2";
11521 return "DW_OP_lit3";
11523 return "DW_OP_lit4";
11525 return "DW_OP_lit5";
11527 return "DW_OP_lit6";
11529 return "DW_OP_lit7";
11531 return "DW_OP_lit8";
11533 return "DW_OP_lit9";
11535 return "DW_OP_lit10";
11537 return "DW_OP_lit11";
11539 return "DW_OP_lit12";
11541 return "DW_OP_lit13";
11543 return "DW_OP_lit14";
11545 return "DW_OP_lit15";
11547 return "DW_OP_lit16";
11549 return "DW_OP_lit17";
11551 return "DW_OP_lit18";
11553 return "DW_OP_lit19";
11555 return "DW_OP_lit20";
11557 return "DW_OP_lit21";
11559 return "DW_OP_lit22";
11561 return "DW_OP_lit23";
11563 return "DW_OP_lit24";
11565 return "DW_OP_lit25";
11567 return "DW_OP_lit26";
11569 return "DW_OP_lit27";
11571 return "DW_OP_lit28";
11573 return "DW_OP_lit29";
11575 return "DW_OP_lit30";
11577 return "DW_OP_lit31";
11579 return "DW_OP_reg0";
11581 return "DW_OP_reg1";
11583 return "DW_OP_reg2";
11585 return "DW_OP_reg3";
11587 return "DW_OP_reg4";
11589 return "DW_OP_reg5";
11591 return "DW_OP_reg6";
11593 return "DW_OP_reg7";
11595 return "DW_OP_reg8";
11597 return "DW_OP_reg9";
11599 return "DW_OP_reg10";
11601 return "DW_OP_reg11";
11603 return "DW_OP_reg12";
11605 return "DW_OP_reg13";
11607 return "DW_OP_reg14";
11609 return "DW_OP_reg15";
11611 return "DW_OP_reg16";
11613 return "DW_OP_reg17";
11615 return "DW_OP_reg18";
11617 return "DW_OP_reg19";
11619 return "DW_OP_reg20";
11621 return "DW_OP_reg21";
11623 return "DW_OP_reg22";
11625 return "DW_OP_reg23";
11627 return "DW_OP_reg24";
11629 return "DW_OP_reg25";
11631 return "DW_OP_reg26";
11633 return "DW_OP_reg27";
11635 return "DW_OP_reg28";
11637 return "DW_OP_reg29";
11639 return "DW_OP_reg30";
11641 return "DW_OP_reg31";
11643 return "DW_OP_breg0";
11645 return "DW_OP_breg1";
11647 return "DW_OP_breg2";
11649 return "DW_OP_breg3";
11651 return "DW_OP_breg4";
11653 return "DW_OP_breg5";
11655 return "DW_OP_breg6";
11657 return "DW_OP_breg7";
11659 return "DW_OP_breg8";
11661 return "DW_OP_breg9";
11663 return "DW_OP_breg10";
11665 return "DW_OP_breg11";
11667 return "DW_OP_breg12";
11669 return "DW_OP_breg13";
11671 return "DW_OP_breg14";
11673 return "DW_OP_breg15";
11675 return "DW_OP_breg16";
11677 return "DW_OP_breg17";
11679 return "DW_OP_breg18";
11681 return "DW_OP_breg19";
11683 return "DW_OP_breg20";
11685 return "DW_OP_breg21";
11687 return "DW_OP_breg22";
11689 return "DW_OP_breg23";
11691 return "DW_OP_breg24";
11693 return "DW_OP_breg25";
11695 return "DW_OP_breg26";
11697 return "DW_OP_breg27";
11699 return "DW_OP_breg28";
11701 return "DW_OP_breg29";
11703 return "DW_OP_breg30";
11705 return "DW_OP_breg31";
11707 return "DW_OP_regx";
11709 return "DW_OP_fbreg";
11711 return "DW_OP_bregx";
11713 return "DW_OP_piece";
11714 case DW_OP_deref_size
:
11715 return "DW_OP_deref_size";
11716 case DW_OP_xderef_size
:
11717 return "DW_OP_xderef_size";
11719 return "DW_OP_nop";
11720 /* DWARF 3 extensions. */
11721 case DW_OP_push_object_address
:
11722 return "DW_OP_push_object_address";
11724 return "DW_OP_call2";
11726 return "DW_OP_call4";
11727 case DW_OP_call_ref
:
11728 return "DW_OP_call_ref";
11729 case DW_OP_form_tls_address
:
11730 return "DW_OP_form_tls_address";
11731 case DW_OP_call_frame_cfa
:
11732 return "DW_OP_call_frame_cfa";
11733 case DW_OP_bit_piece
:
11734 return "DW_OP_bit_piece";
11735 /* DWARF 4 extensions. */
11736 case DW_OP_implicit_value
:
11737 return "DW_OP_implicit_value";
11738 case DW_OP_stack_value
:
11739 return "DW_OP_stack_value";
11740 /* GNU extensions. */
11741 case DW_OP_GNU_push_tls_address
:
11742 return "DW_OP_GNU_push_tls_address";
11743 case DW_OP_GNU_uninit
:
11744 return "DW_OP_GNU_uninit";
11746 return def
? "OP_<unknown>" : NULL
;
11751 dwarf_bool_name (unsigned mybool
)
11759 /* Convert a DWARF type code into its string name. */
11762 dwarf_type_encoding_name (unsigned enc
)
11767 return "DW_ATE_void";
11768 case DW_ATE_address
:
11769 return "DW_ATE_address";
11770 case DW_ATE_boolean
:
11771 return "DW_ATE_boolean";
11772 case DW_ATE_complex_float
:
11773 return "DW_ATE_complex_float";
11775 return "DW_ATE_float";
11776 case DW_ATE_signed
:
11777 return "DW_ATE_signed";
11778 case DW_ATE_signed_char
:
11779 return "DW_ATE_signed_char";
11780 case DW_ATE_unsigned
:
11781 return "DW_ATE_unsigned";
11782 case DW_ATE_unsigned_char
:
11783 return "DW_ATE_unsigned_char";
11785 case DW_ATE_imaginary_float
:
11786 return "DW_ATE_imaginary_float";
11787 case DW_ATE_packed_decimal
:
11788 return "DW_ATE_packed_decimal";
11789 case DW_ATE_numeric_string
:
11790 return "DW_ATE_numeric_string";
11791 case DW_ATE_edited
:
11792 return "DW_ATE_edited";
11793 case DW_ATE_signed_fixed
:
11794 return "DW_ATE_signed_fixed";
11795 case DW_ATE_unsigned_fixed
:
11796 return "DW_ATE_unsigned_fixed";
11797 case DW_ATE_decimal_float
:
11798 return "DW_ATE_decimal_float";
11801 return "DW_ATE_UTF";
11802 /* HP extensions. */
11803 case DW_ATE_HP_float80
:
11804 return "DW_ATE_HP_float80";
11805 case DW_ATE_HP_complex_float80
:
11806 return "DW_ATE_HP_complex_float80";
11807 case DW_ATE_HP_float128
:
11808 return "DW_ATE_HP_float128";
11809 case DW_ATE_HP_complex_float128
:
11810 return "DW_ATE_HP_complex_float128";
11811 case DW_ATE_HP_floathpintel
:
11812 return "DW_ATE_HP_floathpintel";
11813 case DW_ATE_HP_imaginary_float80
:
11814 return "DW_ATE_HP_imaginary_float80";
11815 case DW_ATE_HP_imaginary_float128
:
11816 return "DW_ATE_HP_imaginary_float128";
11818 return "DW_ATE_<unknown>";
11822 /* Convert a DWARF call frame info operation to its string name. */
11826 dwarf_cfi_name (unsigned cfi_opc
)
11830 case DW_CFA_advance_loc
:
11831 return "DW_CFA_advance_loc";
11832 case DW_CFA_offset
:
11833 return "DW_CFA_offset";
11834 case DW_CFA_restore
:
11835 return "DW_CFA_restore";
11837 return "DW_CFA_nop";
11838 case DW_CFA_set_loc
:
11839 return "DW_CFA_set_loc";
11840 case DW_CFA_advance_loc1
:
11841 return "DW_CFA_advance_loc1";
11842 case DW_CFA_advance_loc2
:
11843 return "DW_CFA_advance_loc2";
11844 case DW_CFA_advance_loc4
:
11845 return "DW_CFA_advance_loc4";
11846 case DW_CFA_offset_extended
:
11847 return "DW_CFA_offset_extended";
11848 case DW_CFA_restore_extended
:
11849 return "DW_CFA_restore_extended";
11850 case DW_CFA_undefined
:
11851 return "DW_CFA_undefined";
11852 case DW_CFA_same_value
:
11853 return "DW_CFA_same_value";
11854 case DW_CFA_register
:
11855 return "DW_CFA_register";
11856 case DW_CFA_remember_state
:
11857 return "DW_CFA_remember_state";
11858 case DW_CFA_restore_state
:
11859 return "DW_CFA_restore_state";
11860 case DW_CFA_def_cfa
:
11861 return "DW_CFA_def_cfa";
11862 case DW_CFA_def_cfa_register
:
11863 return "DW_CFA_def_cfa_register";
11864 case DW_CFA_def_cfa_offset
:
11865 return "DW_CFA_def_cfa_offset";
11867 case DW_CFA_def_cfa_expression
:
11868 return "DW_CFA_def_cfa_expression";
11869 case DW_CFA_expression
:
11870 return "DW_CFA_expression";
11871 case DW_CFA_offset_extended_sf
:
11872 return "DW_CFA_offset_extended_sf";
11873 case DW_CFA_def_cfa_sf
:
11874 return "DW_CFA_def_cfa_sf";
11875 case DW_CFA_def_cfa_offset_sf
:
11876 return "DW_CFA_def_cfa_offset_sf";
11877 case DW_CFA_val_offset
:
11878 return "DW_CFA_val_offset";
11879 case DW_CFA_val_offset_sf
:
11880 return "DW_CFA_val_offset_sf";
11881 case DW_CFA_val_expression
:
11882 return "DW_CFA_val_expression";
11883 /* SGI/MIPS specific. */
11884 case DW_CFA_MIPS_advance_loc8
:
11885 return "DW_CFA_MIPS_advance_loc8";
11886 /* GNU extensions. */
11887 case DW_CFA_GNU_window_save
:
11888 return "DW_CFA_GNU_window_save";
11889 case DW_CFA_GNU_args_size
:
11890 return "DW_CFA_GNU_args_size";
11891 case DW_CFA_GNU_negative_offset_extended
:
11892 return "DW_CFA_GNU_negative_offset_extended";
11894 return "DW_CFA_<unknown>";
11900 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
11904 print_spaces (indent
, f
);
11905 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
11906 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
11908 if (die
->parent
!= NULL
)
11910 print_spaces (indent
, f
);
11911 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
11912 die
->parent
->offset
);
11915 print_spaces (indent
, f
);
11916 fprintf_unfiltered (f
, " has children: %s\n",
11917 dwarf_bool_name (die
->child
!= NULL
));
11919 print_spaces (indent
, f
);
11920 fprintf_unfiltered (f
, " attributes:\n");
11922 for (i
= 0; i
< die
->num_attrs
; ++i
)
11924 print_spaces (indent
, f
);
11925 fprintf_unfiltered (f
, " %s (%s) ",
11926 dwarf_attr_name (die
->attrs
[i
].name
),
11927 dwarf_form_name (die
->attrs
[i
].form
));
11929 switch (die
->attrs
[i
].form
)
11931 case DW_FORM_ref_addr
:
11933 fprintf_unfiltered (f
, "address: ");
11934 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
11936 case DW_FORM_block2
:
11937 case DW_FORM_block4
:
11938 case DW_FORM_block
:
11939 case DW_FORM_block1
:
11940 fprintf_unfiltered (f
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
11942 case DW_FORM_exprloc
:
11943 fprintf_unfiltered (f
, "expression: size %u",
11944 DW_BLOCK (&die
->attrs
[i
])->size
);
11949 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
11950 (long) (DW_ADDR (&die
->attrs
[i
])));
11952 case DW_FORM_data1
:
11953 case DW_FORM_data2
:
11954 case DW_FORM_data4
:
11955 case DW_FORM_data8
:
11956 case DW_FORM_udata
:
11957 case DW_FORM_sdata
:
11958 fprintf_unfiltered (f
, "constant: %s",
11959 pulongest (DW_UNSND (&die
->attrs
[i
])));
11961 case DW_FORM_sec_offset
:
11962 fprintf_unfiltered (f
, "section offset: %s",
11963 pulongest (DW_UNSND (&die
->attrs
[i
])));
11966 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
11967 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
11968 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->offset
);
11970 fprintf_unfiltered (f
, "signatured type, offset: unknown");
11972 case DW_FORM_string
:
11974 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
11975 DW_STRING (&die
->attrs
[i
])
11976 ? DW_STRING (&die
->attrs
[i
]) : "",
11977 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
11980 if (DW_UNSND (&die
->attrs
[i
]))
11981 fprintf_unfiltered (f
, "flag: TRUE");
11983 fprintf_unfiltered (f
, "flag: FALSE");
11985 case DW_FORM_flag_present
:
11986 fprintf_unfiltered (f
, "flag: TRUE");
11988 case DW_FORM_indirect
:
11989 /* the reader will have reduced the indirect form to
11990 the "base form" so this form should not occur */
11991 fprintf_unfiltered (f
, "unexpected attribute form: DW_FORM_indirect");
11994 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
11995 die
->attrs
[i
].form
);
11998 fprintf_unfiltered (f
, "\n");
12003 dump_die_for_error (struct die_info
*die
)
12005 dump_die_shallow (gdb_stderr
, 0, die
);
12009 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
12011 int indent
= level
* 4;
12013 gdb_assert (die
!= NULL
);
12015 if (level
>= max_level
)
12018 dump_die_shallow (f
, indent
, die
);
12020 if (die
->child
!= NULL
)
12022 print_spaces (indent
, f
);
12023 fprintf_unfiltered (f
, " Children:");
12024 if (level
+ 1 < max_level
)
12026 fprintf_unfiltered (f
, "\n");
12027 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
12031 fprintf_unfiltered (f
, " [not printed, max nesting level reached]\n");
12035 if (die
->sibling
!= NULL
&& level
> 0)
12037 dump_die_1 (f
, level
, max_level
, die
->sibling
);
12041 /* This is called from the pdie macro in gdbinit.in.
12042 It's not static so gcc will keep a copy callable from gdb. */
12045 dump_die (struct die_info
*die
, int max_level
)
12047 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
12051 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
12055 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
12061 is_ref_attr (struct attribute
*attr
)
12063 switch (attr
->form
)
12065 case DW_FORM_ref_addr
:
12070 case DW_FORM_ref_udata
:
12077 static unsigned int
12078 dwarf2_get_ref_die_offset (struct attribute
*attr
)
12080 if (is_ref_attr (attr
))
12081 return DW_ADDR (attr
);
12083 complaint (&symfile_complaints
,
12084 _("unsupported die ref attribute form: '%s'"),
12085 dwarf_form_name (attr
->form
));
12089 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
12090 * the value held by the attribute is not constant. */
12093 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
12095 if (attr
->form
== DW_FORM_sdata
)
12096 return DW_SND (attr
);
12097 else if (attr
->form
== DW_FORM_udata
12098 || attr
->form
== DW_FORM_data1
12099 || attr
->form
== DW_FORM_data2
12100 || attr
->form
== DW_FORM_data4
12101 || attr
->form
== DW_FORM_data8
)
12102 return DW_UNSND (attr
);
12105 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
12106 dwarf_form_name (attr
->form
));
12107 return default_value
;
12111 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
12112 unit and add it to our queue.
12113 The result is non-zero if PER_CU was queued, otherwise the result is zero
12114 meaning either PER_CU is already queued or it is already loaded. */
12117 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
12118 struct dwarf2_per_cu_data
*per_cu
)
12120 /* Mark the dependence relation so that we don't flush PER_CU
12122 dwarf2_add_dependence (this_cu
, per_cu
);
12124 /* If it's already on the queue, we have nothing to do. */
12125 if (per_cu
->queued
)
12128 /* If the compilation unit is already loaded, just mark it as
12130 if (per_cu
->cu
!= NULL
)
12132 per_cu
->cu
->last_used
= 0;
12136 /* Add it to the queue. */
12137 queue_comp_unit (per_cu
, this_cu
->objfile
);
12142 /* Follow reference or signature attribute ATTR of SRC_DIE.
12143 On entry *REF_CU is the CU of SRC_DIE.
12144 On exit *REF_CU is the CU of the result. */
12146 static struct die_info
*
12147 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
12148 struct dwarf2_cu
**ref_cu
)
12150 struct die_info
*die
;
12152 if (is_ref_attr (attr
))
12153 die
= follow_die_ref (src_die
, attr
, ref_cu
);
12154 else if (attr
->form
== DW_FORM_sig8
)
12155 die
= follow_die_sig (src_die
, attr
, ref_cu
);
12158 dump_die_for_error (src_die
);
12159 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
12160 (*ref_cu
)->objfile
->name
);
12166 /* Follow reference OFFSET.
12167 On entry *REF_CU is the CU of source DIE referencing OFFSET.
12168 On exit *REF_CU is the CU of the result. */
12170 static struct die_info
*
12171 follow_die_offset (unsigned int offset
, struct dwarf2_cu
**ref_cu
)
12173 struct die_info temp_die
;
12174 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
12176 gdb_assert (cu
->per_cu
!= NULL
);
12178 if (cu
->per_cu
->from_debug_types
)
12180 /* .debug_types CUs cannot reference anything outside their CU.
12181 If they need to, they have to reference a signatured type via
12183 if (! offset_in_cu_p (&cu
->header
, offset
))
12187 else if (! offset_in_cu_p (&cu
->header
, offset
))
12189 struct dwarf2_per_cu_data
*per_cu
;
12191 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
12193 /* If necessary, add it to the queue and load its DIEs. */
12194 if (maybe_queue_comp_unit (cu
, per_cu
))
12195 load_full_comp_unit (per_cu
, cu
->objfile
);
12197 target_cu
= per_cu
->cu
;
12202 *ref_cu
= target_cu
;
12203 temp_die
.offset
= offset
;
12204 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
12207 /* Follow reference attribute ATTR of SRC_DIE.
12208 On entry *REF_CU is the CU of SRC_DIE.
12209 On exit *REF_CU is the CU of the result. */
12211 static struct die_info
*
12212 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
12213 struct dwarf2_cu
**ref_cu
)
12215 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
12216 struct dwarf2_cu
*cu
= *ref_cu
;
12217 struct die_info
*die
;
12219 die
= follow_die_offset (offset
, ref_cu
);
12221 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
12222 "at 0x%x [in module %s]"),
12223 offset
, src_die
->offset
, cu
->objfile
->name
);
12228 /* Return DWARF block and its CU referenced by OFFSET at PER_CU. Returned
12229 value is intended for DW_OP_call*. */
12231 struct dwarf2_locexpr_baton
12232 dwarf2_fetch_die_location_block (unsigned int offset
,
12233 struct dwarf2_per_cu_data
*per_cu
)
12235 struct dwarf2_cu
*cu
= per_cu
->cu
;
12236 struct die_info
*die
;
12237 struct attribute
*attr
;
12238 struct dwarf2_locexpr_baton retval
;
12240 die
= follow_die_offset (offset
, &cu
);
12242 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
12243 offset
, per_cu
->cu
->objfile
->name
);
12245 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
12248 /* DWARF: "If there is no such attribute, then there is no effect.". */
12250 retval
.data
= NULL
;
12255 if (!attr_form_is_block (attr
))
12256 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
12257 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
12258 offset
, per_cu
->cu
->objfile
->name
);
12260 retval
.data
= DW_BLOCK (attr
)->data
;
12261 retval
.size
= DW_BLOCK (attr
)->size
;
12263 retval
.per_cu
= cu
->per_cu
;
12267 /* Follow the signature attribute ATTR in SRC_DIE.
12268 On entry *REF_CU is the CU of SRC_DIE.
12269 On exit *REF_CU is the CU of the result. */
12271 static struct die_info
*
12272 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
12273 struct dwarf2_cu
**ref_cu
)
12275 struct objfile
*objfile
= (*ref_cu
)->objfile
;
12276 struct die_info temp_die
;
12277 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
12278 struct dwarf2_cu
*sig_cu
;
12279 struct die_info
*die
;
12281 /* sig_type will be NULL if the signatured type is missing from
12283 if (sig_type
== NULL
)
12284 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
12285 "at 0x%x [in module %s]"),
12286 src_die
->offset
, objfile
->name
);
12288 /* If necessary, add it to the queue and load its DIEs. */
12290 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
12291 read_signatured_type (objfile
, sig_type
);
12293 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
12295 sig_cu
= sig_type
->per_cu
.cu
;
12296 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
12297 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
12304 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced from DIE "
12305 "at 0x%x [in module %s]"),
12306 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
12309 /* Given an offset of a signatured type, return its signatured_type. */
12311 static struct signatured_type
*
12312 lookup_signatured_type_at_offset (struct objfile
*objfile
, unsigned int offset
)
12314 gdb_byte
*info_ptr
= dwarf2_per_objfile
->types
.buffer
+ offset
;
12315 unsigned int length
, initial_length_size
;
12316 unsigned int sig_offset
;
12317 struct signatured_type find_entry
, *type_sig
;
12319 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
12320 sig_offset
= (initial_length_size
12322 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
12323 + 1 /*address_size*/);
12324 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
12325 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
12327 /* This is only used to lookup previously recorded types.
12328 If we didn't find it, it's our bug. */
12329 gdb_assert (type_sig
!= NULL
);
12330 gdb_assert (offset
== type_sig
->offset
);
12335 /* Read in signatured type at OFFSET and build its CU and die(s). */
12338 read_signatured_type_at_offset (struct objfile
*objfile
,
12339 unsigned int offset
)
12341 struct signatured_type
*type_sig
;
12343 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
12345 /* We have the section offset, but we need the signature to do the
12346 hash table lookup. */
12347 type_sig
= lookup_signatured_type_at_offset (objfile
, offset
);
12349 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
12351 read_signatured_type (objfile
, type_sig
);
12353 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
12356 /* Read in a signatured type and build its CU and DIEs. */
12359 read_signatured_type (struct objfile
*objfile
,
12360 struct signatured_type
*type_sig
)
12362 gdb_byte
*types_ptr
;
12363 struct die_reader_specs reader_specs
;
12364 struct dwarf2_cu
*cu
;
12365 ULONGEST signature
;
12366 struct cleanup
*back_to
, *free_cu_cleanup
;
12367 struct attribute
*attr
;
12369 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
12370 types_ptr
= dwarf2_per_objfile
->types
.buffer
+ type_sig
->offset
;
12372 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
12374 cu
= xmalloc (sizeof (struct dwarf2_cu
));
12375 memset (cu
, 0, sizeof (struct dwarf2_cu
));
12376 obstack_init (&cu
->comp_unit_obstack
);
12377 cu
->objfile
= objfile
;
12378 type_sig
->per_cu
.cu
= cu
;
12379 cu
->per_cu
= &type_sig
->per_cu
;
12381 /* If an error occurs while loading, release our storage. */
12382 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
12384 types_ptr
= read_type_comp_unit_head (&cu
->header
, &signature
,
12385 types_ptr
, objfile
->obfd
);
12386 gdb_assert (signature
== type_sig
->signature
);
12389 = htab_create_alloc_ex (cu
->header
.length
/ 12,
12393 &cu
->comp_unit_obstack
,
12394 hashtab_obstack_allocate
,
12395 dummy_obstack_deallocate
);
12397 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
12398 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
12400 init_cu_die_reader (&reader_specs
, cu
);
12402 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
12405 /* We try not to read any attributes in this function, because not
12406 all objfiles needed for references have been loaded yet, and symbol
12407 table processing isn't initialized. But we have to set the CU language,
12408 or we won't be able to build types correctly. */
12409 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
12411 set_cu_language (DW_UNSND (attr
), cu
);
12413 set_cu_language (language_minimal
, cu
);
12415 do_cleanups (back_to
);
12417 /* We've successfully allocated this compilation unit. Let our caller
12418 clean it up when finished with it. */
12419 discard_cleanups (free_cu_cleanup
);
12421 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
12422 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
12425 /* Decode simple location descriptions.
12426 Given a pointer to a dwarf block that defines a location, compute
12427 the location and return the value.
12429 NOTE drow/2003-11-18: This function is called in two situations
12430 now: for the address of static or global variables (partial symbols
12431 only) and for offsets into structures which are expected to be
12432 (more or less) constant. The partial symbol case should go away,
12433 and only the constant case should remain. That will let this
12434 function complain more accurately. A few special modes are allowed
12435 without complaint for global variables (for instance, global
12436 register values and thread-local values).
12438 A location description containing no operations indicates that the
12439 object is optimized out. The return value is 0 for that case.
12440 FIXME drow/2003-11-16: No callers check for this case any more; soon all
12441 callers will only want a very basic result and this can become a
12444 Note that stack[0] is unused except as a default error return.
12445 Note that stack overflow is not yet handled. */
12448 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
12450 struct objfile
*objfile
= cu
->objfile
;
12452 int size
= blk
->size
;
12453 gdb_byte
*data
= blk
->data
;
12454 CORE_ADDR stack
[64];
12456 unsigned int bytes_read
, unsnd
;
12500 stack
[++stacki
] = op
- DW_OP_lit0
;
12535 stack
[++stacki
] = op
- DW_OP_reg0
;
12537 dwarf2_complex_location_expr_complaint ();
12541 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
12543 stack
[++stacki
] = unsnd
;
12545 dwarf2_complex_location_expr_complaint ();
12549 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
12554 case DW_OP_const1u
:
12555 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
12559 case DW_OP_const1s
:
12560 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
12564 case DW_OP_const2u
:
12565 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
12569 case DW_OP_const2s
:
12570 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
12574 case DW_OP_const4u
:
12575 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
12579 case DW_OP_const4s
:
12580 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
12585 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
12591 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
12596 stack
[stacki
+ 1] = stack
[stacki
];
12601 stack
[stacki
- 1] += stack
[stacki
];
12605 case DW_OP_plus_uconst
:
12606 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
12611 stack
[stacki
- 1] -= stack
[stacki
];
12616 /* If we're not the last op, then we definitely can't encode
12617 this using GDB's address_class enum. This is valid for partial
12618 global symbols, although the variable's address will be bogus
12621 dwarf2_complex_location_expr_complaint ();
12624 case DW_OP_GNU_push_tls_address
:
12625 /* The top of the stack has the offset from the beginning
12626 of the thread control block at which the variable is located. */
12627 /* Nothing should follow this operator, so the top of stack would
12629 /* This is valid for partial global symbols, but the variable's
12630 address will be bogus in the psymtab. */
12632 dwarf2_complex_location_expr_complaint ();
12635 case DW_OP_GNU_uninit
:
12639 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
12640 dwarf_stack_op_name (op
, 1));
12641 return (stack
[stacki
]);
12644 return (stack
[stacki
]);
12647 /* memory allocation interface */
12649 static struct dwarf_block
*
12650 dwarf_alloc_block (struct dwarf2_cu
*cu
)
12652 struct dwarf_block
*blk
;
12654 blk
= (struct dwarf_block
*)
12655 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
12659 static struct abbrev_info
*
12660 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
12662 struct abbrev_info
*abbrev
;
12664 abbrev
= (struct abbrev_info
*)
12665 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
12666 memset (abbrev
, 0, sizeof (struct abbrev_info
));
12670 static struct die_info
*
12671 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
12673 struct die_info
*die
;
12674 size_t size
= sizeof (struct die_info
);
12677 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
12679 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
12680 memset (die
, 0, sizeof (struct die_info
));
12685 /* Macro support. */
12688 /* Return the full name of file number I in *LH's file name table.
12689 Use COMP_DIR as the name of the current directory of the
12690 compilation. The result is allocated using xmalloc; the caller is
12691 responsible for freeing it. */
12693 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
12695 /* Is the file number a valid index into the line header's file name
12696 table? Remember that file numbers start with one, not zero. */
12697 if (1 <= file
&& file
<= lh
->num_file_names
)
12699 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
12701 if (IS_ABSOLUTE_PATH (fe
->name
))
12702 return xstrdup (fe
->name
);
12710 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
12716 dir_len
= strlen (dir
);
12717 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
12718 strcpy (full_name
, dir
);
12719 full_name
[dir_len
] = '/';
12720 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
12724 return xstrdup (fe
->name
);
12729 /* The compiler produced a bogus file number. We can at least
12730 record the macro definitions made in the file, even if we
12731 won't be able to find the file by name. */
12732 char fake_name
[80];
12734 sprintf (fake_name
, "<bad macro file number %d>", file
);
12736 complaint (&symfile_complaints
,
12737 _("bad file number in macro information (%d)"),
12740 return xstrdup (fake_name
);
12745 static struct macro_source_file
*
12746 macro_start_file (int file
, int line
,
12747 struct macro_source_file
*current_file
,
12748 const char *comp_dir
,
12749 struct line_header
*lh
, struct objfile
*objfile
)
12751 /* The full name of this source file. */
12752 char *full_name
= file_full_name (file
, lh
, comp_dir
);
12754 /* We don't create a macro table for this compilation unit
12755 at all until we actually get a filename. */
12756 if (! pending_macros
)
12757 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
12758 objfile
->macro_cache
);
12760 if (! current_file
)
12761 /* If we have no current file, then this must be the start_file
12762 directive for the compilation unit's main source file. */
12763 current_file
= macro_set_main (pending_macros
, full_name
);
12765 current_file
= macro_include (current_file
, line
, full_name
);
12769 return current_file
;
12773 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
12774 followed by a null byte. */
12776 copy_string (const char *buf
, int len
)
12778 char *s
= xmalloc (len
+ 1);
12780 memcpy (s
, buf
, len
);
12786 static const char *
12787 consume_improper_spaces (const char *p
, const char *body
)
12791 complaint (&symfile_complaints
,
12792 _("macro definition contains spaces in formal argument list:\n`%s'"),
12804 parse_macro_definition (struct macro_source_file
*file
, int line
,
12809 /* The body string takes one of two forms. For object-like macro
12810 definitions, it should be:
12812 <macro name> " " <definition>
12814 For function-like macro definitions, it should be:
12816 <macro name> "() " <definition>
12818 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
12820 Spaces may appear only where explicitly indicated, and in the
12823 The Dwarf 2 spec says that an object-like macro's name is always
12824 followed by a space, but versions of GCC around March 2002 omit
12825 the space when the macro's definition is the empty string.
12827 The Dwarf 2 spec says that there should be no spaces between the
12828 formal arguments in a function-like macro's formal argument list,
12829 but versions of GCC around March 2002 include spaces after the
12833 /* Find the extent of the macro name. The macro name is terminated
12834 by either a space or null character (for an object-like macro) or
12835 an opening paren (for a function-like macro). */
12836 for (p
= body
; *p
; p
++)
12837 if (*p
== ' ' || *p
== '(')
12840 if (*p
== ' ' || *p
== '\0')
12842 /* It's an object-like macro. */
12843 int name_len
= p
- body
;
12844 char *name
= copy_string (body
, name_len
);
12845 const char *replacement
;
12848 replacement
= body
+ name_len
+ 1;
12851 dwarf2_macro_malformed_definition_complaint (body
);
12852 replacement
= body
+ name_len
;
12855 macro_define_object (file
, line
, name
, replacement
);
12859 else if (*p
== '(')
12861 /* It's a function-like macro. */
12862 char *name
= copy_string (body
, p
- body
);
12865 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
12869 p
= consume_improper_spaces (p
, body
);
12871 /* Parse the formal argument list. */
12872 while (*p
&& *p
!= ')')
12874 /* Find the extent of the current argument name. */
12875 const char *arg_start
= p
;
12877 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
12880 if (! *p
|| p
== arg_start
)
12881 dwarf2_macro_malformed_definition_complaint (body
);
12884 /* Make sure argv has room for the new argument. */
12885 if (argc
>= argv_size
)
12888 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
12891 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
12894 p
= consume_improper_spaces (p
, body
);
12896 /* Consume the comma, if present. */
12901 p
= consume_improper_spaces (p
, body
);
12910 /* Perfectly formed definition, no complaints. */
12911 macro_define_function (file
, line
, name
,
12912 argc
, (const char **) argv
,
12914 else if (*p
== '\0')
12916 /* Complain, but do define it. */
12917 dwarf2_macro_malformed_definition_complaint (body
);
12918 macro_define_function (file
, line
, name
,
12919 argc
, (const char **) argv
,
12923 /* Just complain. */
12924 dwarf2_macro_malformed_definition_complaint (body
);
12927 /* Just complain. */
12928 dwarf2_macro_malformed_definition_complaint (body
);
12934 for (i
= 0; i
< argc
; i
++)
12940 dwarf2_macro_malformed_definition_complaint (body
);
12945 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
12946 char *comp_dir
, bfd
*abfd
,
12947 struct dwarf2_cu
*cu
)
12949 gdb_byte
*mac_ptr
, *mac_end
;
12950 struct macro_source_file
*current_file
= 0;
12951 enum dwarf_macinfo_record_type macinfo_type
;
12952 int at_commandline
;
12954 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
12955 &dwarf2_per_objfile
->macinfo
);
12956 if (dwarf2_per_objfile
->macinfo
.buffer
== NULL
)
12958 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
12962 /* First pass: Find the name of the base filename.
12963 This filename is needed in order to process all macros whose definition
12964 (or undefinition) comes from the command line. These macros are defined
12965 before the first DW_MACINFO_start_file entry, and yet still need to be
12966 associated to the base file.
12968 To determine the base file name, we scan the macro definitions until we
12969 reach the first DW_MACINFO_start_file entry. We then initialize
12970 CURRENT_FILE accordingly so that any macro definition found before the
12971 first DW_MACINFO_start_file can still be associated to the base file. */
12973 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
12974 mac_end
= dwarf2_per_objfile
->macinfo
.buffer
12975 + dwarf2_per_objfile
->macinfo
.size
;
12979 /* Do we at least have room for a macinfo type byte? */
12980 if (mac_ptr
>= mac_end
)
12982 /* Complaint is printed during the second pass as GDB will probably
12983 stop the first pass earlier upon finding DW_MACINFO_start_file. */
12987 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
12990 switch (macinfo_type
)
12992 /* A zero macinfo type indicates the end of the macro
12997 case DW_MACINFO_define
:
12998 case DW_MACINFO_undef
:
12999 /* Only skip the data by MAC_PTR. */
13001 unsigned int bytes_read
;
13003 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13004 mac_ptr
+= bytes_read
;
13005 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13006 mac_ptr
+= bytes_read
;
13010 case DW_MACINFO_start_file
:
13012 unsigned int bytes_read
;
13015 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13016 mac_ptr
+= bytes_read
;
13017 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13018 mac_ptr
+= bytes_read
;
13020 current_file
= macro_start_file (file
, line
, current_file
, comp_dir
,
13025 case DW_MACINFO_end_file
:
13026 /* No data to skip by MAC_PTR. */
13029 case DW_MACINFO_vendor_ext
:
13030 /* Only skip the data by MAC_PTR. */
13032 unsigned int bytes_read
;
13034 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13035 mac_ptr
+= bytes_read
;
13036 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13037 mac_ptr
+= bytes_read
;
13044 } while (macinfo_type
!= 0 && current_file
== NULL
);
13046 /* Second pass: Process all entries.
13048 Use the AT_COMMAND_LINE flag to determine whether we are still processing
13049 command-line macro definitions/undefinitions. This flag is unset when we
13050 reach the first DW_MACINFO_start_file entry. */
13052 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
13054 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
13055 GDB is still reading the definitions from command line. First
13056 DW_MACINFO_start_file will need to be ignored as it was already executed
13057 to create CURRENT_FILE for the main source holding also the command line
13058 definitions. On first met DW_MACINFO_start_file this flag is reset to
13059 normally execute all the remaining DW_MACINFO_start_file macinfos. */
13061 at_commandline
= 1;
13065 /* Do we at least have room for a macinfo type byte? */
13066 if (mac_ptr
>= mac_end
)
13068 dwarf2_macros_too_long_complaint ();
13072 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
13075 switch (macinfo_type
)
13077 /* A zero macinfo type indicates the end of the macro
13082 case DW_MACINFO_define
:
13083 case DW_MACINFO_undef
:
13085 unsigned int bytes_read
;
13089 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13090 mac_ptr
+= bytes_read
;
13091 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13092 mac_ptr
+= bytes_read
;
13094 if (! current_file
)
13096 /* DWARF violation as no main source is present. */
13097 complaint (&symfile_complaints
,
13098 _("debug info with no main source gives macro %s "
13100 macinfo_type
== DW_MACINFO_define
?
13102 macinfo_type
== DW_MACINFO_undef
?
13103 _("undefinition") :
13104 _("something-or-other"), line
, body
);
13107 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
13108 complaint (&symfile_complaints
,
13109 _("debug info gives %s macro %s with %s line %d: %s"),
13110 at_commandline
? _("command-line") : _("in-file"),
13111 macinfo_type
== DW_MACINFO_define
?
13113 macinfo_type
== DW_MACINFO_undef
?
13114 _("undefinition") :
13115 _("something-or-other"),
13116 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
13118 if (macinfo_type
== DW_MACINFO_define
)
13119 parse_macro_definition (current_file
, line
, body
);
13120 else if (macinfo_type
== DW_MACINFO_undef
)
13121 macro_undef (current_file
, line
, body
);
13125 case DW_MACINFO_start_file
:
13127 unsigned int bytes_read
;
13130 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13131 mac_ptr
+= bytes_read
;
13132 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13133 mac_ptr
+= bytes_read
;
13135 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
13136 complaint (&symfile_complaints
,
13137 _("debug info gives source %d included "
13138 "from %s at %s line %d"),
13139 file
, at_commandline
? _("command-line") : _("file"),
13140 line
== 0 ? _("zero") : _("non-zero"), line
);
13142 if (at_commandline
)
13144 /* This DW_MACINFO_start_file was executed in the pass one. */
13145 at_commandline
= 0;
13148 current_file
= macro_start_file (file
, line
,
13149 current_file
, comp_dir
,
13154 case DW_MACINFO_end_file
:
13155 if (! current_file
)
13156 complaint (&symfile_complaints
,
13157 _("macro debug info has an unmatched `close_file' directive"));
13160 current_file
= current_file
->included_by
;
13161 if (! current_file
)
13163 enum dwarf_macinfo_record_type next_type
;
13165 /* GCC circa March 2002 doesn't produce the zero
13166 type byte marking the end of the compilation
13167 unit. Complain if it's not there, but exit no
13170 /* Do we at least have room for a macinfo type byte? */
13171 if (mac_ptr
>= mac_end
)
13173 dwarf2_macros_too_long_complaint ();
13177 /* We don't increment mac_ptr here, so this is just
13179 next_type
= read_1_byte (abfd
, mac_ptr
);
13180 if (next_type
!= 0)
13181 complaint (&symfile_complaints
,
13182 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
13189 case DW_MACINFO_vendor_ext
:
13191 unsigned int bytes_read
;
13195 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13196 mac_ptr
+= bytes_read
;
13197 string
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13198 mac_ptr
+= bytes_read
;
13200 /* We don't recognize any vendor extensions. */
13204 } while (macinfo_type
!= 0);
13207 /* Check if the attribute's form is a DW_FORM_block*
13208 if so return true else false. */
13210 attr_form_is_block (struct attribute
*attr
)
13212 return (attr
== NULL
? 0 :
13213 attr
->form
== DW_FORM_block1
13214 || attr
->form
== DW_FORM_block2
13215 || attr
->form
== DW_FORM_block4
13216 || attr
->form
== DW_FORM_block
13217 || attr
->form
== DW_FORM_exprloc
);
13220 /* Return non-zero if ATTR's value is a section offset --- classes
13221 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
13222 You may use DW_UNSND (attr) to retrieve such offsets.
13224 Section 7.5.4, "Attribute Encodings", explains that no attribute
13225 may have a value that belongs to more than one of these classes; it
13226 would be ambiguous if we did, because we use the same forms for all
13229 attr_form_is_section_offset (struct attribute
*attr
)
13231 return (attr
->form
== DW_FORM_data4
13232 || attr
->form
== DW_FORM_data8
13233 || attr
->form
== DW_FORM_sec_offset
);
13237 /* Return non-zero if ATTR's value falls in the 'constant' class, or
13238 zero otherwise. When this function returns true, you can apply
13239 dwarf2_get_attr_constant_value to it.
13241 However, note that for some attributes you must check
13242 attr_form_is_section_offset before using this test. DW_FORM_data4
13243 and DW_FORM_data8 are members of both the constant class, and of
13244 the classes that contain offsets into other debug sections
13245 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
13246 that, if an attribute's can be either a constant or one of the
13247 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
13248 taken as section offsets, not constants. */
13250 attr_form_is_constant (struct attribute
*attr
)
13252 switch (attr
->form
)
13254 case DW_FORM_sdata
:
13255 case DW_FORM_udata
:
13256 case DW_FORM_data1
:
13257 case DW_FORM_data2
:
13258 case DW_FORM_data4
:
13259 case DW_FORM_data8
:
13267 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
13268 struct dwarf2_cu
*cu
)
13270 if (attr_form_is_section_offset (attr
)
13271 /* ".debug_loc" may not exist at all, or the offset may be outside
13272 the section. If so, fall through to the complaint in the
13274 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc
.size
)
13276 struct dwarf2_loclist_baton
*baton
;
13278 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
13279 sizeof (struct dwarf2_loclist_baton
));
13280 baton
->per_cu
= cu
->per_cu
;
13281 gdb_assert (baton
->per_cu
);
13283 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
13284 &dwarf2_per_objfile
->loc
);
13286 /* We don't know how long the location list is, but make sure we
13287 don't run off the edge of the section. */
13288 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
13289 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
13290 baton
->base_address
= cu
->base_address
;
13291 if (cu
->base_known
== 0)
13292 complaint (&symfile_complaints
,
13293 _("Location list used without specifying the CU base address."));
13295 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
13296 SYMBOL_LOCATION_BATON (sym
) = baton
;
13300 struct dwarf2_locexpr_baton
*baton
;
13302 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
13303 sizeof (struct dwarf2_locexpr_baton
));
13304 baton
->per_cu
= cu
->per_cu
;
13305 gdb_assert (baton
->per_cu
);
13307 if (attr_form_is_block (attr
))
13309 /* Note that we're just copying the block's data pointer
13310 here, not the actual data. We're still pointing into the
13311 info_buffer for SYM's objfile; right now we never release
13312 that buffer, but when we do clean up properly this may
13314 baton
->size
= DW_BLOCK (attr
)->size
;
13315 baton
->data
= DW_BLOCK (attr
)->data
;
13319 dwarf2_invalid_attrib_class_complaint ("location description",
13320 SYMBOL_NATURAL_NAME (sym
));
13322 baton
->data
= NULL
;
13325 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
13326 SYMBOL_LOCATION_BATON (sym
) = baton
;
13330 /* Return the OBJFILE associated with the compilation unit CU. If CU
13331 came from a separate debuginfo file, then the master objfile is
13335 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
13337 struct objfile
*objfile
= per_cu
->objfile
;
13339 /* Return the master objfile, so that we can report and look up the
13340 correct file containing this variable. */
13341 if (objfile
->separate_debug_objfile_backlink
)
13342 objfile
= objfile
->separate_debug_objfile_backlink
;
13347 /* Return the address size given in the compilation unit header for CU. */
13350 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
13353 return per_cu
->cu
->header
.addr_size
;
13356 /* If the CU is not currently read in, we re-read its header. */
13357 struct objfile
*objfile
= per_cu
->objfile
;
13358 struct dwarf2_per_objfile
*per_objfile
13359 = objfile_data (objfile
, dwarf2_objfile_data_key
);
13360 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
13361 struct comp_unit_head cu_header
;
13363 memset (&cu_header
, 0, sizeof cu_header
);
13364 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
13365 return cu_header
.addr_size
;
13369 /* Return the offset size given in the compilation unit header for CU. */
13372 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
13375 return per_cu
->cu
->header
.offset_size
;
13378 /* If the CU is not currently read in, we re-read its header. */
13379 struct objfile
*objfile
= per_cu
->objfile
;
13380 struct dwarf2_per_objfile
*per_objfile
13381 = objfile_data (objfile
, dwarf2_objfile_data_key
);
13382 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
13383 struct comp_unit_head cu_header
;
13385 memset (&cu_header
, 0, sizeof cu_header
);
13386 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
13387 return cu_header
.offset_size
;
13391 /* Return the text offset of the CU. The returned offset comes from
13392 this CU's objfile. If this objfile came from a separate debuginfo
13393 file, then the offset may be different from the corresponding
13394 offset in the parent objfile. */
13397 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
13399 struct objfile
*objfile
= per_cu
->objfile
;
13401 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13404 /* Locate the .debug_info compilation unit from CU's objfile which contains
13405 the DIE at OFFSET. Raises an error on failure. */
13407 static struct dwarf2_per_cu_data
*
13408 dwarf2_find_containing_comp_unit (unsigned int offset
,
13409 struct objfile
*objfile
)
13411 struct dwarf2_per_cu_data
*this_cu
;
13415 high
= dwarf2_per_objfile
->n_comp_units
- 1;
13418 int mid
= low
+ (high
- low
) / 2;
13420 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
13425 gdb_assert (low
== high
);
13426 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
13429 error (_("Dwarf Error: could not find partial DIE containing "
13430 "offset 0x%lx [in module %s]"),
13431 (long) offset
, bfd_get_filename (objfile
->obfd
));
13433 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
13434 return dwarf2_per_objfile
->all_comp_units
[low
-1];
13438 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
13439 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
13440 && offset
>= this_cu
->offset
+ this_cu
->length
)
13441 error (_("invalid dwarf2 offset %u"), offset
);
13442 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
13447 /* Locate the compilation unit from OBJFILE which is located at exactly
13448 OFFSET. Raises an error on failure. */
13450 static struct dwarf2_per_cu_data
*
13451 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
13453 struct dwarf2_per_cu_data
*this_cu
;
13455 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
13456 if (this_cu
->offset
!= offset
)
13457 error (_("no compilation unit with offset %u."), offset
);
13461 /* Malloc space for a dwarf2_cu for OBJFILE and initialize it. */
13463 static struct dwarf2_cu
*
13464 alloc_one_comp_unit (struct objfile
*objfile
)
13466 struct dwarf2_cu
*cu
= xcalloc (1, sizeof (struct dwarf2_cu
));
13467 cu
->objfile
= objfile
;
13468 obstack_init (&cu
->comp_unit_obstack
);
13472 /* Release one cached compilation unit, CU. We unlink it from the tree
13473 of compilation units, but we don't remove it from the read_in_chain;
13474 the caller is responsible for that.
13475 NOTE: DATA is a void * because this function is also used as a
13476 cleanup routine. */
13479 free_one_comp_unit (void *data
)
13481 struct dwarf2_cu
*cu
= data
;
13483 if (cu
->per_cu
!= NULL
)
13484 cu
->per_cu
->cu
= NULL
;
13487 obstack_free (&cu
->comp_unit_obstack
, NULL
);
13492 /* This cleanup function is passed the address of a dwarf2_cu on the stack
13493 when we're finished with it. We can't free the pointer itself, but be
13494 sure to unlink it from the cache. Also release any associated storage
13495 and perform cache maintenance.
13497 Only used during partial symbol parsing. */
13500 free_stack_comp_unit (void *data
)
13502 struct dwarf2_cu
*cu
= data
;
13504 obstack_free (&cu
->comp_unit_obstack
, NULL
);
13505 cu
->partial_dies
= NULL
;
13507 if (cu
->per_cu
!= NULL
)
13509 /* This compilation unit is on the stack in our caller, so we
13510 should not xfree it. Just unlink it. */
13511 cu
->per_cu
->cu
= NULL
;
13514 /* If we had a per-cu pointer, then we may have other compilation
13515 units loaded, so age them now. */
13516 age_cached_comp_units ();
13520 /* Free all cached compilation units. */
13523 free_cached_comp_units (void *data
)
13525 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
13527 per_cu
= dwarf2_per_objfile
->read_in_chain
;
13528 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
13529 while (per_cu
!= NULL
)
13531 struct dwarf2_per_cu_data
*next_cu
;
13533 next_cu
= per_cu
->cu
->read_in_chain
;
13535 free_one_comp_unit (per_cu
->cu
);
13536 *last_chain
= next_cu
;
13542 /* Increase the age counter on each cached compilation unit, and free
13543 any that are too old. */
13546 age_cached_comp_units (void)
13548 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
13550 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
13551 per_cu
= dwarf2_per_objfile
->read_in_chain
;
13552 while (per_cu
!= NULL
)
13554 per_cu
->cu
->last_used
++;
13555 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
13556 dwarf2_mark (per_cu
->cu
);
13557 per_cu
= per_cu
->cu
->read_in_chain
;
13560 per_cu
= dwarf2_per_objfile
->read_in_chain
;
13561 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
13562 while (per_cu
!= NULL
)
13564 struct dwarf2_per_cu_data
*next_cu
;
13566 next_cu
= per_cu
->cu
->read_in_chain
;
13568 if (!per_cu
->cu
->mark
)
13570 free_one_comp_unit (per_cu
->cu
);
13571 *last_chain
= next_cu
;
13574 last_chain
= &per_cu
->cu
->read_in_chain
;
13580 /* Remove a single compilation unit from the cache. */
13583 free_one_cached_comp_unit (void *target_cu
)
13585 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
13587 per_cu
= dwarf2_per_objfile
->read_in_chain
;
13588 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
13589 while (per_cu
!= NULL
)
13591 struct dwarf2_per_cu_data
*next_cu
;
13593 next_cu
= per_cu
->cu
->read_in_chain
;
13595 if (per_cu
->cu
== target_cu
)
13597 free_one_comp_unit (per_cu
->cu
);
13598 *last_chain
= next_cu
;
13602 last_chain
= &per_cu
->cu
->read_in_chain
;
13608 /* Release all extra memory associated with OBJFILE. */
13611 dwarf2_free_objfile (struct objfile
*objfile
)
13613 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
13615 if (dwarf2_per_objfile
== NULL
)
13618 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
13619 free_cached_comp_units (NULL
);
13621 if (dwarf2_per_objfile
->using_index
)
13625 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
13628 struct dwarf2_per_cu_data
*cu
= dwarf2_per_objfile
->all_comp_units
[i
];
13630 if (!cu
->v
.quick
->lines
)
13633 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
13635 if (cu
->v
.quick
->file_names
)
13636 xfree ((void *) cu
->v
.quick
->file_names
[j
]);
13637 if (cu
->v
.quick
->full_names
)
13638 xfree ((void *) cu
->v
.quick
->full_names
[j
]);
13641 free_line_header (cu
->v
.quick
->lines
);
13645 /* Everything else should be on the objfile obstack. */
13648 /* A pair of DIE offset and GDB type pointer. We store these
13649 in a hash table separate from the DIEs, and preserve them
13650 when the DIEs are flushed out of cache. */
13652 struct dwarf2_offset_and_type
13654 unsigned int offset
;
13658 /* Hash function for a dwarf2_offset_and_type. */
13661 offset_and_type_hash (const void *item
)
13663 const struct dwarf2_offset_and_type
*ofs
= item
;
13665 return ofs
->offset
;
13668 /* Equality function for a dwarf2_offset_and_type. */
13671 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
13673 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
13674 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
13676 return ofs_lhs
->offset
== ofs_rhs
->offset
;
13679 /* Set the type associated with DIE to TYPE. Save it in CU's hash
13680 table if necessary. For convenience, return TYPE.
13682 The DIEs reading must have careful ordering to:
13683 * Not cause infite loops trying to read in DIEs as a prerequisite for
13684 reading current DIE.
13685 * Not trying to dereference contents of still incompletely read in types
13686 while reading in other DIEs.
13687 * Enable referencing still incompletely read in types just by a pointer to
13688 the type without accessing its fields.
13690 Therefore caller should follow these rules:
13691 * Try to fetch any prerequisite types we may need to build this DIE type
13692 before building the type and calling set_die_type.
13693 * After building typer call set_die_type for current DIE as soon as
13694 possible before fetching more types to complete the current type.
13695 * Make the type as complete as possible before fetching more types. */
13697 static struct type
*
13698 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
13700 struct dwarf2_offset_and_type
**slot
, ofs
;
13702 /* For Ada types, make sure that the gnat-specific data is always
13703 initialized (if not already set). There are a few types where
13704 we should not be doing so, because the type-specific area is
13705 already used to hold some other piece of info (eg: TYPE_CODE_FLT
13706 where the type-specific area is used to store the floatformat).
13707 But this is not a problem, because the gnat-specific information
13708 is actually not needed for these types. */
13709 if (need_gnat_info (cu
)
13710 && TYPE_CODE (type
) != TYPE_CODE_FUNC
13711 && TYPE_CODE (type
) != TYPE_CODE_FLT
13712 && !HAVE_GNAT_AUX_INFO (type
))
13713 INIT_GNAT_SPECIFIC (type
);
13715 if (cu
->type_hash
== NULL
)
13717 gdb_assert (cu
->per_cu
!= NULL
);
13718 cu
->per_cu
->type_hash
13719 = htab_create_alloc_ex (cu
->header
.length
/ 24,
13720 offset_and_type_hash
,
13721 offset_and_type_eq
,
13723 &cu
->objfile
->objfile_obstack
,
13724 hashtab_obstack_allocate
,
13725 dummy_obstack_deallocate
);
13726 cu
->type_hash
= cu
->per_cu
->type_hash
;
13729 ofs
.offset
= die
->offset
;
13731 slot
= (struct dwarf2_offset_and_type
**)
13732 htab_find_slot_with_hash (cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
13734 complaint (&symfile_complaints
,
13735 _("A problem internal to GDB: DIE 0x%x has type already set"),
13737 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
13742 /* Find the type for DIE in CU's type_hash, or return NULL if DIE does
13743 not have a saved type. */
13745 static struct type
*
13746 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13748 struct dwarf2_offset_and_type
*slot
, ofs
;
13749 htab_t type_hash
= cu
->type_hash
;
13751 if (type_hash
== NULL
)
13754 ofs
.offset
= die
->offset
;
13755 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
13762 /* Add a dependence relationship from CU to REF_PER_CU. */
13765 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
13766 struct dwarf2_per_cu_data
*ref_per_cu
)
13770 if (cu
->dependencies
== NULL
)
13772 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
13773 NULL
, &cu
->comp_unit_obstack
,
13774 hashtab_obstack_allocate
,
13775 dummy_obstack_deallocate
);
13777 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
13779 *slot
= ref_per_cu
;
13782 /* Subroutine of dwarf2_mark to pass to htab_traverse.
13783 Set the mark field in every compilation unit in the
13784 cache that we must keep because we are keeping CU. */
13787 dwarf2_mark_helper (void **slot
, void *data
)
13789 struct dwarf2_per_cu_data
*per_cu
;
13791 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
13792 if (per_cu
->cu
->mark
)
13794 per_cu
->cu
->mark
= 1;
13796 if (per_cu
->cu
->dependencies
!= NULL
)
13797 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
13802 /* Set the mark field in CU and in every other compilation unit in the
13803 cache that we must keep because we are keeping CU. */
13806 dwarf2_mark (struct dwarf2_cu
*cu
)
13811 if (cu
->dependencies
!= NULL
)
13812 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
13816 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
13820 per_cu
->cu
->mark
= 0;
13821 per_cu
= per_cu
->cu
->read_in_chain
;
13825 /* Trivial hash function for partial_die_info: the hash value of a DIE
13826 is its offset in .debug_info for this objfile. */
13829 partial_die_hash (const void *item
)
13831 const struct partial_die_info
*part_die
= item
;
13833 return part_die
->offset
;
13836 /* Trivial comparison function for partial_die_info structures: two DIEs
13837 are equal if they have the same offset. */
13840 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
13842 const struct partial_die_info
*part_die_lhs
= item_lhs
;
13843 const struct partial_die_info
*part_die_rhs
= item_rhs
;
13845 return part_die_lhs
->offset
== part_die_rhs
->offset
;
13848 static struct cmd_list_element
*set_dwarf2_cmdlist
;
13849 static struct cmd_list_element
*show_dwarf2_cmdlist
;
13852 set_dwarf2_cmd (char *args
, int from_tty
)
13854 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
13858 show_dwarf2_cmd (char *args
, int from_tty
)
13860 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
13863 /* If section described by INFO was mmapped, munmap it now. */
13866 munmap_section_buffer (struct dwarf2_section_info
*info
)
13868 if (info
->was_mmapped
)
13871 intptr_t begin
= (intptr_t) info
->buffer
;
13872 intptr_t map_begin
= begin
& ~(pagesize
- 1);
13873 size_t map_length
= info
->size
+ begin
- map_begin
;
13875 gdb_assert (munmap ((void *) map_begin
, map_length
) == 0);
13877 /* Without HAVE_MMAP, we should never be here to begin with. */
13883 /* munmap debug sections for OBJFILE, if necessary. */
13886 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
13888 struct dwarf2_per_objfile
*data
= d
;
13890 munmap_section_buffer (&data
->info
);
13891 munmap_section_buffer (&data
->abbrev
);
13892 munmap_section_buffer (&data
->line
);
13893 munmap_section_buffer (&data
->str
);
13894 munmap_section_buffer (&data
->macinfo
);
13895 munmap_section_buffer (&data
->ranges
);
13896 munmap_section_buffer (&data
->loc
);
13897 munmap_section_buffer (&data
->frame
);
13898 munmap_section_buffer (&data
->eh_frame
);
13899 munmap_section_buffer (&data
->gdb_index
);
13904 /* The contents of the hash table we create when building the string
13906 struct strtab_entry
13908 offset_type offset
;
13912 /* Hash function for a strtab_entry. */
13914 hash_strtab_entry (const void *e
)
13916 const struct strtab_entry
*entry
= e
;
13917 return mapped_index_string_hash (entry
->str
);
13920 /* Equality function for a strtab_entry. */
13922 eq_strtab_entry (const void *a
, const void *b
)
13924 const struct strtab_entry
*ea
= a
;
13925 const struct strtab_entry
*eb
= b
;
13926 return !strcmp (ea
->str
, eb
->str
);
13929 /* Create a strtab_entry hash table. */
13931 create_strtab (void)
13933 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
13934 xfree
, xcalloc
, xfree
);
13937 /* Add a string to the constant pool. Return the string's offset in
13940 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
13943 struct strtab_entry entry
;
13944 struct strtab_entry
*result
;
13947 slot
= htab_find_slot (table
, &entry
, INSERT
);
13952 result
= XNEW (struct strtab_entry
);
13953 result
->offset
= obstack_object_size (cpool
);
13955 obstack_grow_str0 (cpool
, str
);
13958 return result
->offset
;
13961 /* An entry in the symbol table. */
13962 struct symtab_index_entry
13964 /* The name of the symbol. */
13966 /* The offset of the name in the constant pool. */
13967 offset_type index_offset
;
13968 /* A sorted vector of the indices of all the CUs that hold an object
13970 VEC (offset_type
) *cu_indices
;
13973 /* The symbol table. This is a power-of-2-sized hash table. */
13974 struct mapped_symtab
13976 offset_type n_elements
;
13978 struct symtab_index_entry
**data
;
13981 /* Hash function for a symtab_index_entry. */
13983 hash_symtab_entry (const void *e
)
13985 const struct symtab_index_entry
*entry
= e
;
13986 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
13987 sizeof (offset_type
) * VEC_length (offset_type
,
13988 entry
->cu_indices
),
13992 /* Equality function for a symtab_index_entry. */
13994 eq_symtab_entry (const void *a
, const void *b
)
13996 const struct symtab_index_entry
*ea
= a
;
13997 const struct symtab_index_entry
*eb
= b
;
13998 int len
= VEC_length (offset_type
, ea
->cu_indices
);
13999 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
14001 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
14002 VEC_address (offset_type
, eb
->cu_indices
),
14003 sizeof (offset_type
) * len
);
14006 /* Destroy a symtab_index_entry. */
14008 delete_symtab_entry (void *p
)
14010 struct symtab_index_entry
*entry
= p
;
14011 VEC_free (offset_type
, entry
->cu_indices
);
14015 /* Create a hash table holding symtab_index_entry objects. */
14017 create_index_table (void)
14019 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
14020 delete_symtab_entry
, xcalloc
, xfree
);
14023 /* Create a new mapped symtab object. */
14024 static struct mapped_symtab
*
14025 create_mapped_symtab (void)
14027 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
14028 symtab
->n_elements
= 0;
14029 symtab
->size
= 1024;
14030 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
14034 /* Destroy a mapped_symtab. */
14036 cleanup_mapped_symtab (void *p
)
14038 struct mapped_symtab
*symtab
= p
;
14039 /* The contents of the array are freed when the other hash table is
14041 xfree (symtab
->data
);
14045 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
14047 static struct symtab_index_entry
**
14048 find_slot (struct mapped_symtab
*symtab
, const char *name
)
14050 offset_type index
, step
, hash
= mapped_index_string_hash (name
);
14052 index
= hash
& (symtab
->size
- 1);
14053 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
14057 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
14058 return &symtab
->data
[index
];
14059 index
= (index
+ step
) & (symtab
->size
- 1);
14063 /* Expand SYMTAB's hash table. */
14065 hash_expand (struct mapped_symtab
*symtab
)
14067 offset_type old_size
= symtab
->size
;
14069 struct symtab_index_entry
**old_entries
= symtab
->data
;
14072 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
14074 for (i
= 0; i
< old_size
; ++i
)
14076 if (old_entries
[i
])
14078 struct symtab_index_entry
**slot
= find_slot (symtab
,
14079 old_entries
[i
]->name
);
14080 *slot
= old_entries
[i
];
14084 xfree (old_entries
);
14087 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
14088 is the index of the CU in which the symbol appears. */
14090 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
14091 offset_type cu_index
)
14093 struct symtab_index_entry
**slot
;
14095 ++symtab
->n_elements
;
14096 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
14097 hash_expand (symtab
);
14099 slot
= find_slot (symtab
, name
);
14102 *slot
= XNEW (struct symtab_index_entry
);
14103 (*slot
)->name
= name
;
14104 (*slot
)->cu_indices
= NULL
;
14106 /* Don't push an index twice. Due to how we add entries we only
14107 have to check the last one. */
14108 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
14109 || VEC_length (offset_type
, (*slot
)->cu_indices
) != cu_index
)
14110 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
14113 /* Add a vector of indices to the constant pool. */
14115 add_indices_to_cpool (htab_t index_table
, struct obstack
*cpool
,
14116 struct symtab_index_entry
*entry
)
14120 slot
= htab_find_slot (index_table
, entry
, INSERT
);
14123 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
14124 offset_type val
= MAYBE_SWAP (len
);
14129 entry
->index_offset
= obstack_object_size (cpool
);
14131 obstack_grow (cpool
, &val
, sizeof (val
));
14133 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
14136 val
= MAYBE_SWAP (iter
);
14137 obstack_grow (cpool
, &val
, sizeof (val
));
14142 struct symtab_index_entry
*old_entry
= *slot
;
14143 entry
->index_offset
= old_entry
->index_offset
;
14146 return entry
->index_offset
;
14149 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
14150 constant pool entries going into the obstack CPOOL. */
14152 write_hash_table (struct mapped_symtab
*symtab
,
14153 struct obstack
*output
, struct obstack
*cpool
)
14156 htab_t index_table
;
14159 index_table
= create_index_table ();
14160 str_table
= create_strtab ();
14161 /* We add all the index vectors to the constant pool first, to
14162 ensure alignment is ok. */
14163 for (i
= 0; i
< symtab
->size
; ++i
)
14165 if (symtab
->data
[i
])
14166 add_indices_to_cpool (index_table
, cpool
, symtab
->data
[i
]);
14169 /* Now write out the hash table. */
14170 for (i
= 0; i
< symtab
->size
; ++i
)
14172 offset_type str_off
, vec_off
;
14174 if (symtab
->data
[i
])
14176 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
14177 vec_off
= symtab
->data
[i
]->index_offset
;
14181 /* While 0 is a valid constant pool index, it is not valid
14182 to have 0 for both offsets. */
14187 str_off
= MAYBE_SWAP (str_off
);
14188 vec_off
= MAYBE_SWAP (vec_off
);
14190 obstack_grow (output
, &str_off
, sizeof (str_off
));
14191 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
14194 htab_delete (str_table
);
14195 htab_delete (index_table
);
14198 /* Write an address entry to ADDR_OBSTACK. The addresses are taken
14199 from PST; CU_INDEX is the index of the CU in the vector of all
14202 add_address_entry (struct objfile
*objfile
,
14203 struct obstack
*addr_obstack
, struct partial_symtab
*pst
,
14204 unsigned int cu_index
)
14206 offset_type offset
;
14208 CORE_ADDR baseaddr
;
14210 /* Don't bother recording empty ranges. */
14211 if (pst
->textlow
== pst
->texthigh
)
14214 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14216 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, pst
->textlow
- baseaddr
);
14217 obstack_grow (addr_obstack
, addr
, 8);
14218 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, pst
->texthigh
- baseaddr
);
14219 obstack_grow (addr_obstack
, addr
, 8);
14220 offset
= MAYBE_SWAP (cu_index
);
14221 obstack_grow (addr_obstack
, &offset
, sizeof (offset_type
));
14224 /* Add a list of partial symbols to SYMTAB. */
14226 write_psymbols (struct mapped_symtab
*symtab
,
14227 struct partial_symbol
**psymp
,
14229 offset_type cu_index
)
14231 for (; count
-- > 0; ++psymp
)
14233 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
14234 error (_("Ada is not currently supported by the index"));
14235 add_index_entry (symtab
, SYMBOL_NATURAL_NAME (*psymp
), cu_index
);
14239 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
14240 exception if there is an error. */
14242 write_obstack (FILE *file
, struct obstack
*obstack
)
14244 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
14246 != obstack_object_size (obstack
))
14247 error (_("couldn't data write to file"));
14250 /* Unlink a file if the argument is not NULL. */
14252 unlink_if_set (void *p
)
14254 char **filename
= p
;
14256 unlink (*filename
);
14259 /* A helper struct used when iterating over debug_types. */
14260 struct signatured_type_index_data
14262 struct objfile
*objfile
;
14263 struct mapped_symtab
*symtab
;
14264 struct obstack
*types_list
;
14268 /* A helper function that writes a single signatured_type to an
14271 write_one_signatured_type (void **slot
, void *d
)
14273 struct signatured_type_index_data
*info
= d
;
14274 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
14275 struct dwarf2_per_cu_data
*cu
= &entry
->per_cu
;
14276 struct partial_symtab
*psymtab
= cu
->v
.psymtab
;
14279 write_psymbols (info
->symtab
,
14280 info
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
14281 psymtab
->n_global_syms
, info
->cu_index
);
14282 write_psymbols (info
->symtab
,
14283 info
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
14284 psymtab
->n_static_syms
, info
->cu_index
);
14286 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->offset
);
14287 obstack_grow (info
->types_list
, val
, 8);
14288 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->type_offset
);
14289 obstack_grow (info
->types_list
, val
, 8);
14290 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
14291 obstack_grow (info
->types_list
, val
, 8);
14298 /* Create an index file for OBJFILE in the directory DIR. */
14300 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
14302 struct cleanup
*cleanup
;
14303 char *filename
, *cleanup_filename
;
14304 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
14305 struct obstack cu_list
, types_cu_list
;
14308 struct mapped_symtab
*symtab
;
14309 offset_type val
, size_of_contents
, total_len
;
14313 if (!objfile
->psymtabs
)
14315 if (dwarf2_per_objfile
->using_index
)
14316 error (_("Cannot use an index to create the index"));
14318 if (stat (objfile
->name
, &st
) < 0)
14319 perror_with_name (_("Could not stat"));
14321 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
14322 INDEX_SUFFIX
, (char *) NULL
);
14323 cleanup
= make_cleanup (xfree
, filename
);
14325 out_file
= fopen (filename
, "wb");
14327 error (_("Can't open `%s' for writing"), filename
);
14329 cleanup_filename
= filename
;
14330 make_cleanup (unlink_if_set
, &cleanup_filename
);
14332 symtab
= create_mapped_symtab ();
14333 make_cleanup (cleanup_mapped_symtab
, symtab
);
14335 obstack_init (&addr_obstack
);
14336 make_cleanup_obstack_free (&addr_obstack
);
14338 obstack_init (&cu_list
);
14339 make_cleanup_obstack_free (&cu_list
);
14341 obstack_init (&types_cu_list
);
14342 make_cleanup_obstack_free (&types_cu_list
);
14344 /* The list is already sorted, so we don't need to do additional
14345 work here. Also, the debug_types entries do not appear in
14346 all_comp_units, but only in their own hash table. */
14347 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
14349 struct dwarf2_per_cu_data
*cu
= dwarf2_per_objfile
->all_comp_units
[i
];
14350 struct partial_symtab
*psymtab
= cu
->v
.psymtab
;
14353 write_psymbols (symtab
,
14354 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
14355 psymtab
->n_global_syms
, i
);
14356 write_psymbols (symtab
,
14357 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
14358 psymtab
->n_static_syms
, i
);
14360 add_address_entry (objfile
, &addr_obstack
, psymtab
, i
);
14362 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, cu
->offset
);
14363 obstack_grow (&cu_list
, val
, 8);
14364 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, cu
->length
);
14365 obstack_grow (&cu_list
, val
, 8);
14368 /* Write out the .debug_type entries, if any. */
14369 if (dwarf2_per_objfile
->signatured_types
)
14371 struct signatured_type_index_data sig_data
;
14373 sig_data
.objfile
= objfile
;
14374 sig_data
.symtab
= symtab
;
14375 sig_data
.types_list
= &types_cu_list
;
14376 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
14377 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
14378 write_one_signatured_type
, &sig_data
);
14381 obstack_init (&constant_pool
);
14382 make_cleanup_obstack_free (&constant_pool
);
14383 obstack_init (&symtab_obstack
);
14384 make_cleanup_obstack_free (&symtab_obstack
);
14385 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
14387 obstack_init (&contents
);
14388 make_cleanup_obstack_free (&contents
);
14389 size_of_contents
= 6 * sizeof (offset_type
);
14390 total_len
= size_of_contents
;
14392 /* The version number. */
14393 val
= MAYBE_SWAP (2);
14394 obstack_grow (&contents
, &val
, sizeof (val
));
14396 /* The offset of the CU list from the start of the file. */
14397 val
= MAYBE_SWAP (total_len
);
14398 obstack_grow (&contents
, &val
, sizeof (val
));
14399 total_len
+= obstack_object_size (&cu_list
);
14401 /* The offset of the types CU list from the start of the file. */
14402 val
= MAYBE_SWAP (total_len
);
14403 obstack_grow (&contents
, &val
, sizeof (val
));
14404 total_len
+= obstack_object_size (&types_cu_list
);
14406 /* The offset of the address table from the start of the file. */
14407 val
= MAYBE_SWAP (total_len
);
14408 obstack_grow (&contents
, &val
, sizeof (val
));
14409 total_len
+= obstack_object_size (&addr_obstack
);
14411 /* The offset of the symbol table from the start of the file. */
14412 val
= MAYBE_SWAP (total_len
);
14413 obstack_grow (&contents
, &val
, sizeof (val
));
14414 total_len
+= obstack_object_size (&symtab_obstack
);
14416 /* The offset of the constant pool from the start of the file. */
14417 val
= MAYBE_SWAP (total_len
);
14418 obstack_grow (&contents
, &val
, sizeof (val
));
14419 total_len
+= obstack_object_size (&constant_pool
);
14421 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
14423 write_obstack (out_file
, &contents
);
14424 write_obstack (out_file
, &cu_list
);
14425 write_obstack (out_file
, &types_cu_list
);
14426 write_obstack (out_file
, &addr_obstack
);
14427 write_obstack (out_file
, &symtab_obstack
);
14428 write_obstack (out_file
, &constant_pool
);
14432 /* We want to keep the file, so we set cleanup_filename to NULL
14433 here. See unlink_if_set. */
14434 cleanup_filename
= NULL
;
14436 do_cleanups (cleanup
);
14439 /* The mapped index file format is designed to be directly mmap()able
14440 on any architecture. In most cases, a datum is represented using a
14441 little-endian 32-bit integer value, called an offset_type. Big
14442 endian machines must byte-swap the values before using them.
14443 Exceptions to this rule are noted. The data is laid out such that
14444 alignment is always respected.
14446 A mapped index consists of several sections.
14448 1. The file header. This is a sequence of values, of offset_type
14449 unless otherwise noted:
14450 [0] The version number. Currently 1 or 2. The differences are
14451 noted below. Version 1 did not account for .debug_types sections;
14452 the presence of a .debug_types section invalidates any version 1
14453 index that may exist.
14454 [1] The offset, from the start of the file, of the CU list.
14455 [1.5] In version 2, the offset, from the start of the file, of the
14456 types CU list. This offset does not appear in version 1. Note
14457 that this can be empty, in which case this offset will be equal to
14459 [2] The offset, from the start of the file, of the address section.
14460 [3] The offset, from the start of the file, of the symbol table.
14461 [4] The offset, from the start of the file, of the constant pool.
14463 2. The CU list. This is a sequence of pairs of 64-bit
14464 little-endian values, sorted by the CU offset. The first element
14465 in each pair is the offset of a CU in the .debug_info section. The
14466 second element in each pair is the length of that CU. References
14467 to a CU elsewhere in the map are done using a CU index, which is
14468 just the 0-based index into this table. Note that if there are
14469 type CUs, then conceptually CUs and type CUs form a single list for
14470 the purposes of CU indices.
14472 2.5 The types CU list. This does not appear in a version 1 index.
14473 This is a sequence of triplets of 64-bit little-endian values. In
14474 a triplet, the first value is the CU offset, the second value is
14475 the type offset in the CU, and the third value is the type
14476 signature. The types CU list is not sorted.
14478 3. The address section. The address section consists of a sequence
14479 of address entries. Each address entry has three elements.
14480 [0] The low address. This is a 64-bit little-endian value.
14481 [1] The high address. This is a 64-bit little-endian value.
14482 [2] The CU index. This is an offset_type value.
14484 4. The symbol table. This is a hash table. The size of the hash
14485 table is always a power of 2. The initial hash and the step are
14486 currently defined by the `find_slot' function.
14488 Each slot in the hash table consists of a pair of offset_type
14489 values. The first value is the offset of the symbol's name in the
14490 constant pool. The second value is the offset of the CU vector in
14493 If both values are 0, then this slot in the hash table is empty.
14494 This is ok because while 0 is a valid constant pool index, it
14495 cannot be a valid index for both a string and a CU vector.
14497 A string in the constant pool is stored as a \0-terminated string,
14500 A CU vector in the constant pool is a sequence of offset_type
14501 values. The first value is the number of CU indices in the vector.
14502 Each subsequent value is the index of a CU in the CU list. This
14503 element in the hash table is used to indicate which CUs define the
14506 5. The constant pool. This is simply a bunch of bytes. It is
14507 organized so that alignment is correct: CU vectors are stored
14508 first, followed by strings. */
14510 save_gdb_index_command (char *arg
, int from_tty
)
14512 struct objfile
*objfile
;
14515 error (_("usage: save gdb-index DIRECTORY"));
14517 ALL_OBJFILES (objfile
)
14521 /* If the objfile does not correspond to an actual file, skip it. */
14522 if (stat (objfile
->name
, &st
) < 0)
14525 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
14526 if (dwarf2_per_objfile
)
14528 volatile struct gdb_exception except
;
14530 TRY_CATCH (except
, RETURN_MASK_ERROR
)
14532 write_psymtabs_to_index (objfile
, arg
);
14534 if (except
.reason
< 0)
14535 exception_fprintf (gdb_stderr
, except
,
14536 _("Error while writing index for `%s': "),
14544 int dwarf2_always_disassemble
;
14547 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
14548 struct cmd_list_element
*c
, const char *value
)
14550 fprintf_filtered (file
, _("\
14551 Whether to always disassemble DWARF expressions is %s.\n"),
14555 void _initialize_dwarf2_read (void);
14558 _initialize_dwarf2_read (void)
14560 struct cmd_list_element
*c
;
14562 dwarf2_objfile_data_key
14563 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
14565 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
14566 Set DWARF 2 specific variables.\n\
14567 Configure DWARF 2 variables such as the cache size"),
14568 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
14569 0/*allow-unknown*/, &maintenance_set_cmdlist
);
14571 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
14572 Show DWARF 2 specific variables\n\
14573 Show DWARF 2 variables such as the cache size"),
14574 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
14575 0/*allow-unknown*/, &maintenance_show_cmdlist
);
14577 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
14578 &dwarf2_max_cache_age
, _("\
14579 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
14580 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
14581 A higher limit means that cached compilation units will be stored\n\
14582 in memory longer, and more total memory will be used. Zero disables\n\
14583 caching, which can slow down startup."),
14585 show_dwarf2_max_cache_age
,
14586 &set_dwarf2_cmdlist
,
14587 &show_dwarf2_cmdlist
);
14589 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
14590 &dwarf2_always_disassemble
, _("\
14591 Set whether `info address' always disassembles DWARF expressions."), _("\
14592 Show whether `info address' always disassembles DWARF expressions."), _("\
14593 When enabled, DWARF expressions are always printed in an assembly-like\n\
14594 syntax. When disabled, expressions will be printed in a more\n\
14595 conversational style, when possible."),
14597 show_dwarf2_always_disassemble
,
14598 &set_dwarf2_cmdlist
,
14599 &show_dwarf2_cmdlist
);
14601 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
14602 Set debugging of the dwarf2 DIE reader."), _("\
14603 Show debugging of the dwarf2 DIE reader."), _("\
14604 When enabled (non-zero), DIEs are dumped after they are read in.\n\
14605 The value is the maximum depth to print."),
14608 &setdebuglist
, &showdebuglist
);
14610 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
14611 _("Save a .gdb-index file"),
14613 set_cmd_completer (c
, filename_completer
);