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 struct type
*arg_type
;
7400 /* DWARF version 2 has no clean way to discern C++
7401 static and non-static member functions. G++ helps
7402 GDB by marking the first parameter for non-static
7403 member functions (which is the this pointer) as
7404 artificial. We pass this information to
7405 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
7407 DWARF version 3 added DW_AT_object_pointer, which GCC
7408 4.5 does not yet generate. */
7409 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
7411 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
7414 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
7416 /* GCC/43521: In java, the formal parameter
7417 "this" is sometimes not marked with DW_AT_artificial. */
7418 if (cu
->language
== language_java
)
7420 const char *name
= dwarf2_name (child_die
, cu
);
7422 if (name
&& !strcmp (name
, "this"))
7423 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
7426 arg_type
= die_type (child_die
, cu
);
7428 /* RealView does not mark THIS as const, which the testsuite
7429 expects. GCC marks THIS as const in method definitions,
7430 but not in the class specifications (GCC PR 43053). */
7431 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
7432 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
7435 struct dwarf2_cu
*arg_cu
= cu
;
7436 const char *name
= dwarf2_name (child_die
, cu
);
7438 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
7441 /* If the compiler emits this, use it. */
7442 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
7445 else if (name
&& strcmp (name
, "this") == 0)
7446 /* Function definitions will have the argument names. */
7448 else if (name
== NULL
&& iparams
== 0)
7449 /* Declarations may not have the names, so like
7450 elsewhere in GDB, assume an artificial first
7451 argument is "this". */
7455 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
7459 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
7462 child_die
= sibling_die (child_die
);
7469 static struct type
*
7470 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
7472 struct objfile
*objfile
= cu
->objfile
;
7473 const char *name
= NULL
;
7474 struct type
*this_type
;
7476 name
= dwarf2_full_name (NULL
, die
, cu
);
7477 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
7478 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
7479 TYPE_NAME (this_type
) = (char *) name
;
7480 set_die_type (die
, this_type
, cu
);
7481 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
7485 /* Find a representation of a given base type and install
7486 it in the TYPE field of the die. */
7488 static struct type
*
7489 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7491 struct objfile
*objfile
= cu
->objfile
;
7493 struct attribute
*attr
;
7494 int encoding
= 0, size
= 0;
7496 enum type_code code
= TYPE_CODE_INT
;
7498 struct type
*target_type
= NULL
;
7500 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
7503 encoding
= DW_UNSND (attr
);
7505 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7508 size
= DW_UNSND (attr
);
7510 name
= dwarf2_name (die
, cu
);
7513 complaint (&symfile_complaints
,
7514 _("DW_AT_name missing from DW_TAG_base_type"));
7519 case DW_ATE_address
:
7520 /* Turn DW_ATE_address into a void * pointer. */
7521 code
= TYPE_CODE_PTR
;
7522 type_flags
|= TYPE_FLAG_UNSIGNED
;
7523 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
7525 case DW_ATE_boolean
:
7526 code
= TYPE_CODE_BOOL
;
7527 type_flags
|= TYPE_FLAG_UNSIGNED
;
7529 case DW_ATE_complex_float
:
7530 code
= TYPE_CODE_COMPLEX
;
7531 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
7533 case DW_ATE_decimal_float
:
7534 code
= TYPE_CODE_DECFLOAT
;
7537 code
= TYPE_CODE_FLT
;
7541 case DW_ATE_unsigned
:
7542 type_flags
|= TYPE_FLAG_UNSIGNED
;
7544 case DW_ATE_signed_char
:
7545 if (cu
->language
== language_ada
|| cu
->language
== language_m2
7546 || cu
->language
== language_pascal
)
7547 code
= TYPE_CODE_CHAR
;
7549 case DW_ATE_unsigned_char
:
7550 if (cu
->language
== language_ada
|| cu
->language
== language_m2
7551 || cu
->language
== language_pascal
)
7552 code
= TYPE_CODE_CHAR
;
7553 type_flags
|= TYPE_FLAG_UNSIGNED
;
7556 /* We just treat this as an integer and then recognize the
7557 type by name elsewhere. */
7561 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
7562 dwarf_type_encoding_name (encoding
));
7566 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
7567 TYPE_NAME (type
) = name
;
7568 TYPE_TARGET_TYPE (type
) = target_type
;
7570 if (name
&& strcmp (name
, "char") == 0)
7571 TYPE_NOSIGN (type
) = 1;
7573 return set_die_type (die
, type
, cu
);
7576 /* Read the given DW_AT_subrange DIE. */
7578 static struct type
*
7579 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7581 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
7582 struct type
*base_type
;
7583 struct type
*range_type
;
7584 struct attribute
*attr
;
7588 LONGEST negative_mask
;
7590 base_type
= die_type (die
, cu
);
7591 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
7592 check_typedef (base_type
);
7594 /* The die_type call above may have already set the type for this DIE. */
7595 range_type
= get_die_type (die
, cu
);
7599 if (cu
->language
== language_fortran
)
7601 /* FORTRAN implies a lower bound of 1, if not given. */
7605 /* FIXME: For variable sized arrays either of these could be
7606 a variable rather than a constant value. We'll allow it,
7607 but we don't know how to handle it. */
7608 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
7610 low
= dwarf2_get_attr_constant_value (attr
, 0);
7612 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
7615 if (attr
->form
== DW_FORM_block1
|| is_ref_attr (attr
))
7617 /* GCC encodes arrays with unspecified or dynamic length
7618 with a DW_FORM_block1 attribute or a reference attribute.
7619 FIXME: GDB does not yet know how to handle dynamic
7620 arrays properly, treat them as arrays with unspecified
7623 FIXME: jimb/2003-09-22: GDB does not really know
7624 how to handle arrays of unspecified length
7625 either; we just represent them as zero-length
7626 arrays. Choose an appropriate upper bound given
7627 the lower bound we've computed above. */
7631 high
= dwarf2_get_attr_constant_value (attr
, 1);
7635 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
7638 int count
= dwarf2_get_attr_constant_value (attr
, 1);
7639 high
= low
+ count
- 1;
7643 /* Dwarf-2 specifications explicitly allows to create subrange types
7644 without specifying a base type.
7645 In that case, the base type must be set to the type of
7646 the lower bound, upper bound or count, in that order, if any of these
7647 three attributes references an object that has a type.
7648 If no base type is found, the Dwarf-2 specifications say that
7649 a signed integer type of size equal to the size of an address should
7651 For the following C code: `extern char gdb_int [];'
7652 GCC produces an empty range DIE.
7653 FIXME: muller/2010-05-28: Possible references to object for low bound,
7654 high bound or count are not yet handled by this code.
7656 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
7658 struct objfile
*objfile
= cu
->objfile
;
7659 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7660 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
7661 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
7663 /* Test "int", "long int", and "long long int" objfile types,
7664 and select the first one having a size above or equal to the
7665 architecture address size. */
7666 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
7667 base_type
= int_type
;
7670 int_type
= objfile_type (objfile
)->builtin_long
;
7671 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
7672 base_type
= int_type
;
7675 int_type
= objfile_type (objfile
)->builtin_long_long
;
7676 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
7677 base_type
= int_type
;
7683 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
7684 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
7685 low
|= negative_mask
;
7686 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
7687 high
|= negative_mask
;
7689 range_type
= create_range_type (NULL
, base_type
, low
, high
);
7691 /* Mark arrays with dynamic length at least as an array of unspecified
7692 length. GDB could check the boundary but before it gets implemented at
7693 least allow accessing the array elements. */
7694 if (attr
&& attr
->form
== DW_FORM_block1
)
7695 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
7697 name
= dwarf2_name (die
, cu
);
7699 TYPE_NAME (range_type
) = name
;
7701 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7703 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
7705 set_die_type (die
, range_type
, cu
);
7707 /* set_die_type should be already done. */
7708 set_descriptive_type (range_type
, die
, cu
);
7713 static struct type
*
7714 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7718 /* For now, we only support the C meaning of an unspecified type: void. */
7720 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
7721 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
7723 return set_die_type (die
, type
, cu
);
7726 /* Trivial hash function for die_info: the hash value of a DIE
7727 is its offset in .debug_info for this objfile. */
7730 die_hash (const void *item
)
7732 const struct die_info
*die
= item
;
7737 /* Trivial comparison function for die_info structures: two DIEs
7738 are equal if they have the same offset. */
7741 die_eq (const void *item_lhs
, const void *item_rhs
)
7743 const struct die_info
*die_lhs
= item_lhs
;
7744 const struct die_info
*die_rhs
= item_rhs
;
7746 return die_lhs
->offset
== die_rhs
->offset
;
7749 /* Read a whole compilation unit into a linked list of dies. */
7751 static struct die_info
*
7752 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
7754 struct die_reader_specs reader_specs
;
7756 gdb_assert (cu
->die_hash
== NULL
);
7758 = htab_create_alloc_ex (cu
->header
.length
/ 12,
7762 &cu
->comp_unit_obstack
,
7763 hashtab_obstack_allocate
,
7764 dummy_obstack_deallocate
);
7766 init_cu_die_reader (&reader_specs
, cu
);
7768 return read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
7771 /* Main entry point for reading a DIE and all children.
7772 Read the DIE and dump it if requested. */
7774 static struct die_info
*
7775 read_die_and_children (const struct die_reader_specs
*reader
,
7777 gdb_byte
**new_info_ptr
,
7778 struct die_info
*parent
)
7780 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
7781 new_info_ptr
, parent
);
7783 if (dwarf2_die_debug
)
7785 fprintf_unfiltered (gdb_stdlog
,
7786 "\nRead die from %s of %s:\n",
7787 reader
->buffer
== dwarf2_per_objfile
->info
.buffer
7789 : reader
->buffer
== dwarf2_per_objfile
->types
.buffer
7791 : "unknown section",
7792 reader
->abfd
->filename
);
7793 dump_die (result
, dwarf2_die_debug
);
7799 /* Read a single die and all its descendents. Set the die's sibling
7800 field to NULL; set other fields in the die correctly, and set all
7801 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
7802 location of the info_ptr after reading all of those dies. PARENT
7803 is the parent of the die in question. */
7805 static struct die_info
*
7806 read_die_and_children_1 (const struct die_reader_specs
*reader
,
7808 gdb_byte
**new_info_ptr
,
7809 struct die_info
*parent
)
7811 struct die_info
*die
;
7815 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
7818 *new_info_ptr
= cur_ptr
;
7821 store_in_ref_table (die
, reader
->cu
);
7824 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
7828 *new_info_ptr
= cur_ptr
;
7831 die
->sibling
= NULL
;
7832 die
->parent
= parent
;
7836 /* Read a die, all of its descendents, and all of its siblings; set
7837 all of the fields of all of the dies correctly. Arguments are as
7838 in read_die_and_children. */
7840 static struct die_info
*
7841 read_die_and_siblings (const struct die_reader_specs
*reader
,
7843 gdb_byte
**new_info_ptr
,
7844 struct die_info
*parent
)
7846 struct die_info
*first_die
, *last_sibling
;
7850 first_die
= last_sibling
= NULL
;
7854 struct die_info
*die
7855 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
7859 *new_info_ptr
= cur_ptr
;
7866 last_sibling
->sibling
= die
;
7872 /* Read the die from the .debug_info section buffer. Set DIEP to
7873 point to a newly allocated die with its information, except for its
7874 child, sibling, and parent fields. Set HAS_CHILDREN to tell
7875 whether the die has children or not. */
7878 read_full_die (const struct die_reader_specs
*reader
,
7879 struct die_info
**diep
, gdb_byte
*info_ptr
,
7882 unsigned int abbrev_number
, bytes_read
, i
, offset
;
7883 struct abbrev_info
*abbrev
;
7884 struct die_info
*die
;
7885 struct dwarf2_cu
*cu
= reader
->cu
;
7886 bfd
*abfd
= reader
->abfd
;
7888 offset
= info_ptr
- reader
->buffer
;
7889 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7890 info_ptr
+= bytes_read
;
7898 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
7900 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
7902 bfd_get_filename (abfd
));
7904 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
7905 die
->offset
= offset
;
7906 die
->tag
= abbrev
->tag
;
7907 die
->abbrev
= abbrev_number
;
7909 die
->num_attrs
= abbrev
->num_attrs
;
7911 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
7912 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
7913 abfd
, info_ptr
, cu
);
7916 *has_children
= abbrev
->has_children
;
7920 /* In DWARF version 2, the description of the debugging information is
7921 stored in a separate .debug_abbrev section. Before we read any
7922 dies from a section we read in all abbreviations and install them
7923 in a hash table. This function also sets flags in CU describing
7924 the data found in the abbrev table. */
7927 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
7929 struct comp_unit_head
*cu_header
= &cu
->header
;
7930 gdb_byte
*abbrev_ptr
;
7931 struct abbrev_info
*cur_abbrev
;
7932 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
7933 unsigned int abbrev_form
, hash_number
;
7934 struct attr_abbrev
*cur_attrs
;
7935 unsigned int allocated_attrs
;
7937 /* Initialize dwarf2 abbrevs */
7938 obstack_init (&cu
->abbrev_obstack
);
7939 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
7941 * sizeof (struct abbrev_info
*)));
7942 memset (cu
->dwarf2_abbrevs
, 0,
7943 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
7945 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
7946 &dwarf2_per_objfile
->abbrev
);
7947 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
7948 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7949 abbrev_ptr
+= bytes_read
;
7951 allocated_attrs
= ATTR_ALLOC_CHUNK
;
7952 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
7954 /* loop until we reach an abbrev number of 0 */
7955 while (abbrev_number
)
7957 cur_abbrev
= dwarf_alloc_abbrev (cu
);
7959 /* read in abbrev header */
7960 cur_abbrev
->number
= abbrev_number
;
7961 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7962 abbrev_ptr
+= bytes_read
;
7963 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
7966 if (cur_abbrev
->tag
== DW_TAG_namespace
)
7967 cu
->has_namespace_info
= 1;
7969 /* now read in declarations */
7970 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7971 abbrev_ptr
+= bytes_read
;
7972 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7973 abbrev_ptr
+= bytes_read
;
7976 if (cur_abbrev
->num_attrs
== allocated_attrs
)
7978 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
7980 = xrealloc (cur_attrs
, (allocated_attrs
7981 * sizeof (struct attr_abbrev
)));
7984 /* Record whether this compilation unit might have
7985 inter-compilation-unit references. If we don't know what form
7986 this attribute will have, then it might potentially be a
7987 DW_FORM_ref_addr, so we conservatively expect inter-CU
7990 if (abbrev_form
== DW_FORM_ref_addr
7991 || abbrev_form
== DW_FORM_indirect
)
7992 cu
->has_form_ref_addr
= 1;
7994 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
7995 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
7996 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7997 abbrev_ptr
+= bytes_read
;
7998 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
7999 abbrev_ptr
+= bytes_read
;
8002 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
8003 (cur_abbrev
->num_attrs
8004 * sizeof (struct attr_abbrev
)));
8005 memcpy (cur_abbrev
->attrs
, cur_attrs
,
8006 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
8008 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
8009 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
8010 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
8012 /* Get next abbreviation.
8013 Under Irix6 the abbreviations for a compilation unit are not
8014 always properly terminated with an abbrev number of 0.
8015 Exit loop if we encounter an abbreviation which we have
8016 already read (which means we are about to read the abbreviations
8017 for the next compile unit) or if the end of the abbreviation
8018 table is reached. */
8019 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
8020 >= dwarf2_per_objfile
->abbrev
.size
)
8022 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8023 abbrev_ptr
+= bytes_read
;
8024 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
8031 /* Release the memory used by the abbrev table for a compilation unit. */
8034 dwarf2_free_abbrev_table (void *ptr_to_cu
)
8036 struct dwarf2_cu
*cu
= ptr_to_cu
;
8038 obstack_free (&cu
->abbrev_obstack
, NULL
);
8039 cu
->dwarf2_abbrevs
= NULL
;
8042 /* Lookup an abbrev_info structure in the abbrev hash table. */
8044 static struct abbrev_info
*
8045 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
8047 unsigned int hash_number
;
8048 struct abbrev_info
*abbrev
;
8050 hash_number
= number
% ABBREV_HASH_SIZE
;
8051 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
8055 if (abbrev
->number
== number
)
8058 abbrev
= abbrev
->next
;
8063 /* Returns nonzero if TAG represents a type that we might generate a partial
8067 is_type_tag_for_partial (int tag
)
8072 /* Some types that would be reasonable to generate partial symbols for,
8073 that we don't at present. */
8074 case DW_TAG_array_type
:
8075 case DW_TAG_file_type
:
8076 case DW_TAG_ptr_to_member_type
:
8077 case DW_TAG_set_type
:
8078 case DW_TAG_string_type
:
8079 case DW_TAG_subroutine_type
:
8081 case DW_TAG_base_type
:
8082 case DW_TAG_class_type
:
8083 case DW_TAG_interface_type
:
8084 case DW_TAG_enumeration_type
:
8085 case DW_TAG_structure_type
:
8086 case DW_TAG_subrange_type
:
8087 case DW_TAG_typedef
:
8088 case DW_TAG_union_type
:
8095 /* Load all DIEs that are interesting for partial symbols into memory. */
8097 static struct partial_die_info
*
8098 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
8099 int building_psymtab
, struct dwarf2_cu
*cu
)
8101 struct partial_die_info
*part_die
;
8102 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
8103 struct abbrev_info
*abbrev
;
8104 unsigned int bytes_read
;
8105 unsigned int load_all
= 0;
8107 int nesting_level
= 1;
8112 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
8116 = htab_create_alloc_ex (cu
->header
.length
/ 12,
8120 &cu
->comp_unit_obstack
,
8121 hashtab_obstack_allocate
,
8122 dummy_obstack_deallocate
);
8124 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
8125 sizeof (struct partial_die_info
));
8129 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
8131 /* A NULL abbrev means the end of a series of children. */
8134 if (--nesting_level
== 0)
8136 /* PART_DIE was probably the last thing allocated on the
8137 comp_unit_obstack, so we could call obstack_free
8138 here. We don't do that because the waste is small,
8139 and will be cleaned up when we're done with this
8140 compilation unit. This way, we're also more robust
8141 against other users of the comp_unit_obstack. */
8144 info_ptr
+= bytes_read
;
8145 last_die
= parent_die
;
8146 parent_die
= parent_die
->die_parent
;
8150 /* Check whether this DIE is interesting enough to save. Normally
8151 we would not be interested in members here, but there may be
8152 later variables referencing them via DW_AT_specification (for
8155 && !is_type_tag_for_partial (abbrev
->tag
)
8156 && abbrev
->tag
!= DW_TAG_enumerator
8157 && abbrev
->tag
!= DW_TAG_subprogram
8158 && abbrev
->tag
!= DW_TAG_lexical_block
8159 && abbrev
->tag
!= DW_TAG_variable
8160 && abbrev
->tag
!= DW_TAG_namespace
8161 && abbrev
->tag
!= DW_TAG_module
8162 && abbrev
->tag
!= DW_TAG_member
)
8164 /* Otherwise we skip to the next sibling, if any. */
8165 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
8169 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
8170 buffer
, info_ptr
, cu
);
8172 /* This two-pass algorithm for processing partial symbols has a
8173 high cost in cache pressure. Thus, handle some simple cases
8174 here which cover the majority of C partial symbols. DIEs
8175 which neither have specification tags in them, nor could have
8176 specification tags elsewhere pointing at them, can simply be
8177 processed and discarded.
8179 This segment is also optional; scan_partial_symbols and
8180 add_partial_symbol will handle these DIEs if we chain
8181 them in normally. When compilers which do not emit large
8182 quantities of duplicate debug information are more common,
8183 this code can probably be removed. */
8185 /* Any complete simple types at the top level (pretty much all
8186 of them, for a language without namespaces), can be processed
8188 if (parent_die
== NULL
8189 && part_die
->has_specification
== 0
8190 && part_die
->is_declaration
== 0
8191 && (part_die
->tag
== DW_TAG_typedef
8192 || part_die
->tag
== DW_TAG_base_type
8193 || part_die
->tag
== DW_TAG_subrange_type
))
8195 if (building_psymtab
&& part_die
->name
!= NULL
)
8196 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
8197 VAR_DOMAIN
, LOC_TYPEDEF
,
8198 &cu
->objfile
->static_psymbols
,
8199 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
8200 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
8204 /* If we're at the second level, and we're an enumerator, and
8205 our parent has no specification (meaning possibly lives in a
8206 namespace elsewhere), then we can add the partial symbol now
8207 instead of queueing it. */
8208 if (part_die
->tag
== DW_TAG_enumerator
8209 && parent_die
!= NULL
8210 && parent_die
->die_parent
== NULL
8211 && parent_die
->tag
== DW_TAG_enumeration_type
8212 && parent_die
->has_specification
== 0)
8214 if (part_die
->name
== NULL
)
8215 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
8216 else if (building_psymtab
)
8217 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
8218 VAR_DOMAIN
, LOC_CONST
,
8219 (cu
->language
== language_cplus
8220 || cu
->language
== language_java
)
8221 ? &cu
->objfile
->global_psymbols
8222 : &cu
->objfile
->static_psymbols
,
8223 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
8225 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
8229 /* We'll save this DIE so link it in. */
8230 part_die
->die_parent
= parent_die
;
8231 part_die
->die_sibling
= NULL
;
8232 part_die
->die_child
= NULL
;
8234 if (last_die
&& last_die
== parent_die
)
8235 last_die
->die_child
= part_die
;
8237 last_die
->die_sibling
= part_die
;
8239 last_die
= part_die
;
8241 if (first_die
== NULL
)
8242 first_die
= part_die
;
8244 /* Maybe add the DIE to the hash table. Not all DIEs that we
8245 find interesting need to be in the hash table, because we
8246 also have the parent/sibling/child chains; only those that we
8247 might refer to by offset later during partial symbol reading.
8249 For now this means things that might have be the target of a
8250 DW_AT_specification, DW_AT_abstract_origin, or
8251 DW_AT_extension. DW_AT_extension will refer only to
8252 namespaces; DW_AT_abstract_origin refers to functions (and
8253 many things under the function DIE, but we do not recurse
8254 into function DIEs during partial symbol reading) and
8255 possibly variables as well; DW_AT_specification refers to
8256 declarations. Declarations ought to have the DW_AT_declaration
8257 flag. It happens that GCC forgets to put it in sometimes, but
8258 only for functions, not for types.
8260 Adding more things than necessary to the hash table is harmless
8261 except for the performance cost. Adding too few will result in
8262 wasted time in find_partial_die, when we reread the compilation
8263 unit with load_all_dies set. */
8266 || abbrev
->tag
== DW_TAG_subprogram
8267 || abbrev
->tag
== DW_TAG_variable
8268 || abbrev
->tag
== DW_TAG_namespace
8269 || part_die
->is_declaration
)
8273 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
8274 part_die
->offset
, INSERT
);
8278 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
8279 sizeof (struct partial_die_info
));
8281 /* For some DIEs we want to follow their children (if any). For C
8282 we have no reason to follow the children of structures; for other
8283 languages we have to, both so that we can get at method physnames
8284 to infer fully qualified class names, and for DW_AT_specification.
8286 For Ada, we need to scan the children of subprograms and lexical
8287 blocks as well because Ada allows the definition of nested
8288 entities that could be interesting for the debugger, such as
8289 nested subprograms for instance. */
8290 if (last_die
->has_children
8292 || last_die
->tag
== DW_TAG_namespace
8293 || last_die
->tag
== DW_TAG_module
8294 || last_die
->tag
== DW_TAG_enumeration_type
8295 || (cu
->language
!= language_c
8296 && (last_die
->tag
== DW_TAG_class_type
8297 || last_die
->tag
== DW_TAG_interface_type
8298 || last_die
->tag
== DW_TAG_structure_type
8299 || last_die
->tag
== DW_TAG_union_type
))
8300 || (cu
->language
== language_ada
8301 && (last_die
->tag
== DW_TAG_subprogram
8302 || last_die
->tag
== DW_TAG_lexical_block
))))
8305 parent_die
= last_die
;
8309 /* Otherwise we skip to the next sibling, if any. */
8310 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
8312 /* Back to the top, do it again. */
8316 /* Read a minimal amount of information into the minimal die structure. */
8319 read_partial_die (struct partial_die_info
*part_die
,
8320 struct abbrev_info
*abbrev
,
8321 unsigned int abbrev_len
, bfd
*abfd
,
8322 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
8323 struct dwarf2_cu
*cu
)
8326 struct attribute attr
;
8327 int has_low_pc_attr
= 0;
8328 int has_high_pc_attr
= 0;
8330 memset (part_die
, 0, sizeof (struct partial_die_info
));
8332 part_die
->offset
= info_ptr
- buffer
;
8334 info_ptr
+= abbrev_len
;
8339 part_die
->tag
= abbrev
->tag
;
8340 part_die
->has_children
= abbrev
->has_children
;
8342 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
8344 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
8346 /* Store the data if it is of an attribute we want to keep in a
8347 partial symbol table. */
8351 switch (part_die
->tag
)
8353 case DW_TAG_compile_unit
:
8354 case DW_TAG_type_unit
:
8355 /* Compilation units have a DW_AT_name that is a filename, not
8356 a source language identifier. */
8357 case DW_TAG_enumeration_type
:
8358 case DW_TAG_enumerator
:
8359 /* These tags always have simple identifiers already; no need
8360 to canonicalize them. */
8361 part_die
->name
= DW_STRING (&attr
);
8365 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
8366 &cu
->objfile
->objfile_obstack
);
8370 case DW_AT_linkage_name
:
8371 case DW_AT_MIPS_linkage_name
:
8372 /* Note that both forms of linkage name might appear. We
8373 assume they will be the same, and we only store the last
8375 if (cu
->language
== language_ada
)
8376 part_die
->name
= DW_STRING (&attr
);
8379 has_low_pc_attr
= 1;
8380 part_die
->lowpc
= DW_ADDR (&attr
);
8383 has_high_pc_attr
= 1;
8384 part_die
->highpc
= DW_ADDR (&attr
);
8386 case DW_AT_location
:
8387 /* Support the .debug_loc offsets */
8388 if (attr_form_is_block (&attr
))
8390 part_die
->locdesc
= DW_BLOCK (&attr
);
8392 else if (attr_form_is_section_offset (&attr
))
8394 dwarf2_complex_location_expr_complaint ();
8398 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
8399 "partial symbol information");
8402 case DW_AT_external
:
8403 part_die
->is_external
= DW_UNSND (&attr
);
8405 case DW_AT_declaration
:
8406 part_die
->is_declaration
= DW_UNSND (&attr
);
8409 part_die
->has_type
= 1;
8411 case DW_AT_abstract_origin
:
8412 case DW_AT_specification
:
8413 case DW_AT_extension
:
8414 part_die
->has_specification
= 1;
8415 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
8418 /* Ignore absolute siblings, they might point outside of
8419 the current compile unit. */
8420 if (attr
.form
== DW_FORM_ref_addr
)
8421 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
8423 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
8425 case DW_AT_byte_size
:
8426 part_die
->has_byte_size
= 1;
8428 case DW_AT_calling_convention
:
8429 /* DWARF doesn't provide a way to identify a program's source-level
8430 entry point. DW_AT_calling_convention attributes are only meant
8431 to describe functions' calling conventions.
8433 However, because it's a necessary piece of information in
8434 Fortran, and because DW_CC_program is the only piece of debugging
8435 information whose definition refers to a 'main program' at all,
8436 several compilers have begun marking Fortran main programs with
8437 DW_CC_program --- even when those functions use the standard
8438 calling conventions.
8440 So until DWARF specifies a way to provide this information and
8441 compilers pick up the new representation, we'll support this
8443 if (DW_UNSND (&attr
) == DW_CC_program
8444 && cu
->language
== language_fortran
)
8445 set_main_name (part_die
->name
);
8452 /* When using the GNU linker, .gnu.linkonce. sections are used to
8453 eliminate duplicate copies of functions and vtables and such.
8454 The linker will arbitrarily choose one and discard the others.
8455 The AT_*_pc values for such functions refer to local labels in
8456 these sections. If the section from that file was discarded, the
8457 labels are not in the output, so the relocs get a value of 0.
8458 If this is a discarded function, mark the pc bounds as invalid,
8459 so that GDB will ignore it. */
8460 if (has_low_pc_attr
&& has_high_pc_attr
8461 && part_die
->lowpc
< part_die
->highpc
8462 && (part_die
->lowpc
!= 0
8463 || dwarf2_per_objfile
->has_section_at_zero
))
8464 part_die
->has_pc_info
= 1;
8469 /* Find a cached partial DIE at OFFSET in CU. */
8471 static struct partial_die_info
*
8472 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
8474 struct partial_die_info
*lookup_die
= NULL
;
8475 struct partial_die_info part_die
;
8477 part_die
.offset
= offset
;
8478 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
8483 /* Find a partial DIE at OFFSET, which may or may not be in CU,
8484 except in the case of .debug_types DIEs which do not reference
8485 outside their CU (they do however referencing other types via
8488 static struct partial_die_info
*
8489 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
8491 struct dwarf2_per_cu_data
*per_cu
= NULL
;
8492 struct partial_die_info
*pd
= NULL
;
8494 if (cu
->per_cu
->from_debug_types
)
8496 pd
= find_partial_die_in_comp_unit (offset
, cu
);
8502 if (offset_in_cu_p (&cu
->header
, offset
))
8504 pd
= find_partial_die_in_comp_unit (offset
, cu
);
8509 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
8511 if (per_cu
->cu
== NULL
)
8513 load_partial_comp_unit (per_cu
, cu
->objfile
);
8514 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
8515 dwarf2_per_objfile
->read_in_chain
= per_cu
;
8518 per_cu
->cu
->last_used
= 0;
8519 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
8521 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
8523 struct cleanup
*back_to
;
8524 struct partial_die_info comp_unit_die
;
8525 struct abbrev_info
*abbrev
;
8526 unsigned int bytes_read
;
8529 per_cu
->load_all_dies
= 1;
8531 /* Re-read the DIEs. */
8532 back_to
= make_cleanup (null_cleanup
, 0);
8533 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
8535 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
8536 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
8538 info_ptr
= (dwarf2_per_objfile
->info
.buffer
8539 + per_cu
->cu
->header
.offset
8540 + per_cu
->cu
->header
.first_die_offset
);
8541 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
8542 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
8543 per_cu
->cu
->objfile
->obfd
,
8544 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
8546 if (comp_unit_die
.has_children
)
8547 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
8548 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
8550 do_cleanups (back_to
);
8552 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
8558 internal_error (__FILE__
, __LINE__
,
8559 _("could not find partial DIE 0x%x in cache [from module %s]\n"),
8560 offset
, bfd_get_filename (cu
->objfile
->obfd
));
8564 /* Adjust PART_DIE before generating a symbol for it. This function
8565 may set the is_external flag or change the DIE's name. */
8568 fixup_partial_die (struct partial_die_info
*part_die
,
8569 struct dwarf2_cu
*cu
)
8571 /* If we found a reference attribute and the DIE has no name, try
8572 to find a name in the referred to DIE. */
8574 if (part_die
->name
== NULL
&& part_die
->has_specification
)
8576 struct partial_die_info
*spec_die
;
8578 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
8580 fixup_partial_die (spec_die
, cu
);
8584 part_die
->name
= spec_die
->name
;
8586 /* Copy DW_AT_external attribute if it is set. */
8587 if (spec_die
->is_external
)
8588 part_die
->is_external
= spec_die
->is_external
;
8592 /* Set default names for some unnamed DIEs. */
8593 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
8594 || part_die
->tag
== DW_TAG_class_type
))
8595 part_die
->name
= "(anonymous class)";
8597 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
8598 part_die
->name
= "(anonymous namespace)";
8600 if (part_die
->tag
== DW_TAG_structure_type
8601 || part_die
->tag
== DW_TAG_class_type
8602 || part_die
->tag
== DW_TAG_union_type
)
8603 guess_structure_name (part_die
, cu
);
8606 /* Read an attribute value described by an attribute form. */
8609 read_attribute_value (struct attribute
*attr
, unsigned form
,
8610 bfd
*abfd
, gdb_byte
*info_ptr
,
8611 struct dwarf2_cu
*cu
)
8613 struct comp_unit_head
*cu_header
= &cu
->header
;
8614 unsigned int bytes_read
;
8615 struct dwarf_block
*blk
;
8620 case DW_FORM_ref_addr
:
8621 if (cu
->header
.version
== 2)
8622 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
8624 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
8625 info_ptr
+= bytes_read
;
8628 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
8629 info_ptr
+= bytes_read
;
8631 case DW_FORM_block2
:
8632 blk
= dwarf_alloc_block (cu
);
8633 blk
->size
= read_2_bytes (abfd
, info_ptr
);
8635 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
8636 info_ptr
+= blk
->size
;
8637 DW_BLOCK (attr
) = blk
;
8639 case DW_FORM_block4
:
8640 blk
= dwarf_alloc_block (cu
);
8641 blk
->size
= read_4_bytes (abfd
, info_ptr
);
8643 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
8644 info_ptr
+= blk
->size
;
8645 DW_BLOCK (attr
) = blk
;
8648 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
8652 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
8656 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
8659 case DW_FORM_sec_offset
:
8660 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
8661 info_ptr
+= bytes_read
;
8663 case DW_FORM_string
:
8664 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
8665 DW_STRING_IS_CANONICAL (attr
) = 0;
8666 info_ptr
+= bytes_read
;
8669 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
8671 DW_STRING_IS_CANONICAL (attr
) = 0;
8672 info_ptr
+= bytes_read
;
8674 case DW_FORM_exprloc
:
8676 blk
= dwarf_alloc_block (cu
);
8677 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8678 info_ptr
+= bytes_read
;
8679 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
8680 info_ptr
+= blk
->size
;
8681 DW_BLOCK (attr
) = blk
;
8683 case DW_FORM_block1
:
8684 blk
= dwarf_alloc_block (cu
);
8685 blk
->size
= read_1_byte (abfd
, info_ptr
);
8687 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
8688 info_ptr
+= blk
->size
;
8689 DW_BLOCK (attr
) = blk
;
8692 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
8696 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
8699 case DW_FORM_flag_present
:
8700 DW_UNSND (attr
) = 1;
8703 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
8704 info_ptr
+= bytes_read
;
8707 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8708 info_ptr
+= bytes_read
;
8711 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
8715 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
8719 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
8723 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
8727 /* Convert the signature to something we can record in DW_UNSND
8729 NOTE: This is NULL if the type wasn't found. */
8730 DW_SIGNATURED_TYPE (attr
) =
8731 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
8734 case DW_FORM_ref_udata
:
8735 DW_ADDR (attr
) = (cu
->header
.offset
8736 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
8737 info_ptr
+= bytes_read
;
8739 case DW_FORM_indirect
:
8740 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8741 info_ptr
+= bytes_read
;
8742 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
8745 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
8746 dwarf_form_name (form
),
8747 bfd_get_filename (abfd
));
8750 /* We have seen instances where the compiler tried to emit a byte
8751 size attribute of -1 which ended up being encoded as an unsigned
8752 0xffffffff. Although 0xffffffff is technically a valid size value,
8753 an object of this size seems pretty unlikely so we can relatively
8754 safely treat these cases as if the size attribute was invalid and
8755 treat them as zero by default. */
8756 if (attr
->name
== DW_AT_byte_size
8757 && form
== DW_FORM_data4
8758 && DW_UNSND (attr
) >= 0xffffffff)
8761 (&symfile_complaints
,
8762 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
8763 hex_string (DW_UNSND (attr
)));
8764 DW_UNSND (attr
) = 0;
8770 /* Read an attribute described by an abbreviated attribute. */
8773 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
8774 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
8776 attr
->name
= abbrev
->name
;
8777 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
8780 /* read dwarf information from a buffer */
8783 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
8785 return bfd_get_8 (abfd
, buf
);
8789 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
8791 return bfd_get_signed_8 (abfd
, buf
);
8795 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
8797 return bfd_get_16 (abfd
, buf
);
8801 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
8803 return bfd_get_signed_16 (abfd
, buf
);
8807 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
8809 return bfd_get_32 (abfd
, buf
);
8813 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
8815 return bfd_get_signed_32 (abfd
, buf
);
8819 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
8821 return bfd_get_64 (abfd
, buf
);
8825 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
8826 unsigned int *bytes_read
)
8828 struct comp_unit_head
*cu_header
= &cu
->header
;
8829 CORE_ADDR retval
= 0;
8831 if (cu_header
->signed_addr_p
)
8833 switch (cu_header
->addr_size
)
8836 retval
= bfd_get_signed_16 (abfd
, buf
);
8839 retval
= bfd_get_signed_32 (abfd
, buf
);
8842 retval
= bfd_get_signed_64 (abfd
, buf
);
8845 internal_error (__FILE__
, __LINE__
,
8846 _("read_address: bad switch, signed [in module %s]"),
8847 bfd_get_filename (abfd
));
8852 switch (cu_header
->addr_size
)
8855 retval
= bfd_get_16 (abfd
, buf
);
8858 retval
= bfd_get_32 (abfd
, buf
);
8861 retval
= bfd_get_64 (abfd
, buf
);
8864 internal_error (__FILE__
, __LINE__
,
8865 _("read_address: bad switch, unsigned [in module %s]"),
8866 bfd_get_filename (abfd
));
8870 *bytes_read
= cu_header
->addr_size
;
8874 /* Read the initial length from a section. The (draft) DWARF 3
8875 specification allows the initial length to take up either 4 bytes
8876 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
8877 bytes describe the length and all offsets will be 8 bytes in length
8880 An older, non-standard 64-bit format is also handled by this
8881 function. The older format in question stores the initial length
8882 as an 8-byte quantity without an escape value. Lengths greater
8883 than 2^32 aren't very common which means that the initial 4 bytes
8884 is almost always zero. Since a length value of zero doesn't make
8885 sense for the 32-bit format, this initial zero can be considered to
8886 be an escape value which indicates the presence of the older 64-bit
8887 format. As written, the code can't detect (old format) lengths
8888 greater than 4GB. If it becomes necessary to handle lengths
8889 somewhat larger than 4GB, we could allow other small values (such
8890 as the non-sensical values of 1, 2, and 3) to also be used as
8891 escape values indicating the presence of the old format.
8893 The value returned via bytes_read should be used to increment the
8894 relevant pointer after calling read_initial_length().
8896 [ Note: read_initial_length() and read_offset() are based on the
8897 document entitled "DWARF Debugging Information Format", revision
8898 3, draft 8, dated November 19, 2001. This document was obtained
8901 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
8903 This document is only a draft and is subject to change. (So beware.)
8905 Details regarding the older, non-standard 64-bit format were
8906 determined empirically by examining 64-bit ELF files produced by
8907 the SGI toolchain on an IRIX 6.5 machine.
8909 - Kevin, July 16, 2002
8913 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
8915 LONGEST length
= bfd_get_32 (abfd
, buf
);
8917 if (length
== 0xffffffff)
8919 length
= bfd_get_64 (abfd
, buf
+ 4);
8922 else if (length
== 0)
8924 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
8925 length
= bfd_get_64 (abfd
, buf
);
8936 /* Cover function for read_initial_length.
8937 Returns the length of the object at BUF, and stores the size of the
8938 initial length in *BYTES_READ and stores the size that offsets will be in
8940 If the initial length size is not equivalent to that specified in
8941 CU_HEADER then issue a complaint.
8942 This is useful when reading non-comp-unit headers. */
8945 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
8946 const struct comp_unit_head
*cu_header
,
8947 unsigned int *bytes_read
,
8948 unsigned int *offset_size
)
8950 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
8952 gdb_assert (cu_header
->initial_length_size
== 4
8953 || cu_header
->initial_length_size
== 8
8954 || cu_header
->initial_length_size
== 12);
8956 if (cu_header
->initial_length_size
!= *bytes_read
)
8957 complaint (&symfile_complaints
,
8958 _("intermixed 32-bit and 64-bit DWARF sections"));
8960 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
8964 /* Read an offset from the data stream. The size of the offset is
8965 given by cu_header->offset_size. */
8968 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
8969 unsigned int *bytes_read
)
8971 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
8973 *bytes_read
= cu_header
->offset_size
;
8977 /* Read an offset from the data stream. */
8980 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
8984 switch (offset_size
)
8987 retval
= bfd_get_32 (abfd
, buf
);
8990 retval
= bfd_get_64 (abfd
, buf
);
8993 internal_error (__FILE__
, __LINE__
,
8994 _("read_offset_1: bad switch [in module %s]"),
8995 bfd_get_filename (abfd
));
9002 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
9004 /* If the size of a host char is 8 bits, we can return a pointer
9005 to the buffer, otherwise we have to copy the data to a buffer
9006 allocated on the temporary obstack. */
9007 gdb_assert (HOST_CHAR_BIT
== 8);
9012 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9014 /* If the size of a host char is 8 bits, we can return a pointer
9015 to the string, otherwise we have to copy the string to a buffer
9016 allocated on the temporary obstack. */
9017 gdb_assert (HOST_CHAR_BIT
== 8);
9020 *bytes_read_ptr
= 1;
9023 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
9024 return (char *) buf
;
9028 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
9029 const struct comp_unit_head
*cu_header
,
9030 unsigned int *bytes_read_ptr
)
9032 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
9034 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
9035 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
9037 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
9038 bfd_get_filename (abfd
));
9041 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
9043 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
9044 bfd_get_filename (abfd
));
9047 gdb_assert (HOST_CHAR_BIT
== 8);
9048 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
9050 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
9053 static unsigned long
9054 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9056 unsigned long result
;
9057 unsigned int num_read
;
9067 byte
= bfd_get_8 (abfd
, buf
);
9070 result
|= ((unsigned long)(byte
& 127) << shift
);
9071 if ((byte
& 128) == 0)
9077 *bytes_read_ptr
= num_read
;
9082 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9085 int i
, shift
, num_read
;
9094 byte
= bfd_get_8 (abfd
, buf
);
9097 result
|= ((long)(byte
& 127) << shift
);
9099 if ((byte
& 128) == 0)
9104 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
9105 result
|= -(((long)1) << shift
);
9106 *bytes_read_ptr
= num_read
;
9110 /* Return a pointer to just past the end of an LEB128 number in BUF. */
9113 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
9119 byte
= bfd_get_8 (abfd
, buf
);
9121 if ((byte
& 128) == 0)
9127 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
9134 cu
->language
= language_c
;
9136 case DW_LANG_C_plus_plus
:
9137 cu
->language
= language_cplus
;
9140 cu
->language
= language_d
;
9142 case DW_LANG_Fortran77
:
9143 case DW_LANG_Fortran90
:
9144 case DW_LANG_Fortran95
:
9145 cu
->language
= language_fortran
;
9147 case DW_LANG_Mips_Assembler
:
9148 cu
->language
= language_asm
;
9151 cu
->language
= language_java
;
9155 cu
->language
= language_ada
;
9157 case DW_LANG_Modula2
:
9158 cu
->language
= language_m2
;
9160 case DW_LANG_Pascal83
:
9161 cu
->language
= language_pascal
;
9164 cu
->language
= language_objc
;
9166 case DW_LANG_Cobol74
:
9167 case DW_LANG_Cobol85
:
9169 cu
->language
= language_minimal
;
9172 cu
->language_defn
= language_def (cu
->language
);
9175 /* Return the named attribute or NULL if not there. */
9177 static struct attribute
*
9178 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
9181 struct attribute
*spec
= NULL
;
9183 for (i
= 0; i
< die
->num_attrs
; ++i
)
9185 if (die
->attrs
[i
].name
== name
)
9186 return &die
->attrs
[i
];
9187 if (die
->attrs
[i
].name
== DW_AT_specification
9188 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
9189 spec
= &die
->attrs
[i
];
9194 die
= follow_die_ref (die
, spec
, &cu
);
9195 return dwarf2_attr (die
, name
, cu
);
9201 /* Return the named attribute or NULL if not there,
9202 but do not follow DW_AT_specification, etc.
9203 This is for use in contexts where we're reading .debug_types dies.
9204 Following DW_AT_specification, DW_AT_abstract_origin will take us
9205 back up the chain, and we want to go down. */
9207 static struct attribute
*
9208 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
9209 struct dwarf2_cu
*cu
)
9213 for (i
= 0; i
< die
->num_attrs
; ++i
)
9214 if (die
->attrs
[i
].name
== name
)
9215 return &die
->attrs
[i
];
9220 /* Return non-zero iff the attribute NAME is defined for the given DIE,
9221 and holds a non-zero value. This function should only be used for
9222 DW_FORM_flag or DW_FORM_flag_present attributes. */
9225 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
9227 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
9229 return (attr
&& DW_UNSND (attr
));
9233 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
9235 /* A DIE is a declaration if it has a DW_AT_declaration attribute
9236 which value is non-zero. However, we have to be careful with
9237 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
9238 (via dwarf2_flag_true_p) follows this attribute. So we may
9239 end up accidently finding a declaration attribute that belongs
9240 to a different DIE referenced by the specification attribute,
9241 even though the given DIE does not have a declaration attribute. */
9242 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
9243 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
9246 /* Return the die giving the specification for DIE, if there is
9247 one. *SPEC_CU is the CU containing DIE on input, and the CU
9248 containing the return value on output. If there is no
9249 specification, but there is an abstract origin, that is
9252 static struct die_info
*
9253 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
9255 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
9258 if (spec_attr
== NULL
)
9259 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
9261 if (spec_attr
== NULL
)
9264 return follow_die_ref (die
, spec_attr
, spec_cu
);
9267 /* Free the line_header structure *LH, and any arrays and strings it
9270 free_line_header (struct line_header
*lh
)
9272 if (lh
->standard_opcode_lengths
)
9273 xfree (lh
->standard_opcode_lengths
);
9275 /* Remember that all the lh->file_names[i].name pointers are
9276 pointers into debug_line_buffer, and don't need to be freed. */
9278 xfree (lh
->file_names
);
9280 /* Similarly for the include directory names. */
9281 if (lh
->include_dirs
)
9282 xfree (lh
->include_dirs
);
9288 /* Add an entry to LH's include directory table. */
9290 add_include_dir (struct line_header
*lh
, char *include_dir
)
9292 /* Grow the array if necessary. */
9293 if (lh
->include_dirs_size
== 0)
9295 lh
->include_dirs_size
= 1; /* for testing */
9296 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
9297 * sizeof (*lh
->include_dirs
));
9299 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
9301 lh
->include_dirs_size
*= 2;
9302 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
9303 (lh
->include_dirs_size
9304 * sizeof (*lh
->include_dirs
)));
9307 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
9311 /* Add an entry to LH's file name table. */
9313 add_file_name (struct line_header
*lh
,
9315 unsigned int dir_index
,
9316 unsigned int mod_time
,
9317 unsigned int length
)
9319 struct file_entry
*fe
;
9321 /* Grow the array if necessary. */
9322 if (lh
->file_names_size
== 0)
9324 lh
->file_names_size
= 1; /* for testing */
9325 lh
->file_names
= xmalloc (lh
->file_names_size
9326 * sizeof (*lh
->file_names
));
9328 else if (lh
->num_file_names
>= lh
->file_names_size
)
9330 lh
->file_names_size
*= 2;
9331 lh
->file_names
= xrealloc (lh
->file_names
,
9332 (lh
->file_names_size
9333 * sizeof (*lh
->file_names
)));
9336 fe
= &lh
->file_names
[lh
->num_file_names
++];
9338 fe
->dir_index
= dir_index
;
9339 fe
->mod_time
= mod_time
;
9340 fe
->length
= length
;
9346 /* Read the statement program header starting at OFFSET in
9347 .debug_line, according to the endianness of ABFD. Return a pointer
9348 to a struct line_header, allocated using xmalloc.
9350 NOTE: the strings in the include directory and file name tables of
9351 the returned object point into debug_line_buffer, and must not be
9353 static struct line_header
*
9354 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
9355 struct dwarf2_cu
*cu
)
9357 struct cleanup
*back_to
;
9358 struct line_header
*lh
;
9360 unsigned int bytes_read
, offset_size
;
9362 char *cur_dir
, *cur_file
;
9364 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
9365 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
9367 complaint (&symfile_complaints
, _("missing .debug_line section"));
9371 /* Make sure that at least there's room for the total_length field.
9372 That could be 12 bytes long, but we're just going to fudge that. */
9373 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
9375 dwarf2_statement_list_fits_in_line_number_section_complaint ();
9379 lh
= xmalloc (sizeof (*lh
));
9380 memset (lh
, 0, sizeof (*lh
));
9381 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
9384 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
9386 /* Read in the header. */
9388 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
9389 &bytes_read
, &offset_size
);
9390 line_ptr
+= bytes_read
;
9391 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
9392 + dwarf2_per_objfile
->line
.size
))
9394 dwarf2_statement_list_fits_in_line_number_section_complaint ();
9397 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
9398 lh
->version
= read_2_bytes (abfd
, line_ptr
);
9400 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
9401 line_ptr
+= offset_size
;
9402 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
9404 if (lh
->version
>= 4)
9406 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
9410 lh
->maximum_ops_per_instruction
= 1;
9412 if (lh
->maximum_ops_per_instruction
== 0)
9414 lh
->maximum_ops_per_instruction
= 1;
9415 complaint (&symfile_complaints
,
9416 _("invalid maximum_ops_per_instruction in `.debug_line' section"));
9419 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
9421 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
9423 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
9425 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
9427 lh
->standard_opcode_lengths
9428 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
9430 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
9431 for (i
= 1; i
< lh
->opcode_base
; ++i
)
9433 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
9437 /* Read directory table. */
9438 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
9440 line_ptr
+= bytes_read
;
9441 add_include_dir (lh
, cur_dir
);
9443 line_ptr
+= bytes_read
;
9445 /* Read file name table. */
9446 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
9448 unsigned int dir_index
, mod_time
, length
;
9450 line_ptr
+= bytes_read
;
9451 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9452 line_ptr
+= bytes_read
;
9453 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9454 line_ptr
+= bytes_read
;
9455 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9456 line_ptr
+= bytes_read
;
9458 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
9460 line_ptr
+= bytes_read
;
9461 lh
->statement_program_start
= line_ptr
;
9463 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
9464 + dwarf2_per_objfile
->line
.size
))
9465 complaint (&symfile_complaints
,
9466 _("line number info header doesn't fit in `.debug_line' section"));
9468 discard_cleanups (back_to
);
9472 /* This function exists to work around a bug in certain compilers
9473 (particularly GCC 2.95), in which the first line number marker of a
9474 function does not show up until after the prologue, right before
9475 the second line number marker. This function shifts ADDRESS down
9476 to the beginning of the function if necessary, and is called on
9477 addresses passed to record_line. */
9480 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
9482 struct function_range
*fn
;
9484 /* Find the function_range containing address. */
9489 cu
->cached_fn
= cu
->first_fn
;
9493 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
9499 while (fn
&& fn
!= cu
->cached_fn
)
9500 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
9510 if (address
!= fn
->lowpc
)
9511 complaint (&symfile_complaints
,
9512 _("misplaced first line number at 0x%lx for '%s'"),
9513 (unsigned long) address
, fn
->name
);
9518 /* Decode the Line Number Program (LNP) for the given line_header
9519 structure and CU. The actual information extracted and the type
9520 of structures created from the LNP depends on the value of PST.
9522 1. If PST is NULL, then this procedure uses the data from the program
9523 to create all necessary symbol tables, and their linetables.
9524 The compilation directory of the file is passed in COMP_DIR,
9525 and must not be NULL.
9527 2. If PST is not NULL, this procedure reads the program to determine
9528 the list of files included by the unit represented by PST, and
9529 builds all the associated partial symbol tables. In this case,
9530 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
9531 is not used to compute the full name of the symtab, and therefore
9532 omitting it when building the partial symtab does not introduce
9533 the potential for inconsistency - a partial symtab and its associated
9534 symbtab having a different fullname -). */
9537 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
9538 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
9540 gdb_byte
*line_ptr
, *extended_end
;
9542 unsigned int bytes_read
, extended_len
;
9543 unsigned char op_code
, extended_op
, adj_opcode
;
9545 struct objfile
*objfile
= cu
->objfile
;
9546 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9547 const int decode_for_pst_p
= (pst
!= NULL
);
9548 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
9550 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9552 line_ptr
= lh
->statement_program_start
;
9553 line_end
= lh
->statement_program_end
;
9555 /* Read the statement sequences until there's nothing left. */
9556 while (line_ptr
< line_end
)
9558 /* state machine registers */
9559 CORE_ADDR address
= 0;
9560 unsigned int file
= 1;
9561 unsigned int line
= 1;
9562 unsigned int column
= 0;
9563 int is_stmt
= lh
->default_is_stmt
;
9564 int basic_block
= 0;
9565 int end_sequence
= 0;
9567 unsigned char op_index
= 0;
9569 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
9571 /* Start a subfile for the current file of the state machine. */
9572 /* lh->include_dirs and lh->file_names are 0-based, but the
9573 directory and file name numbers in the statement program
9575 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9579 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9581 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
9584 /* Decode the table. */
9585 while (!end_sequence
)
9587 op_code
= read_1_byte (abfd
, line_ptr
);
9589 if (line_ptr
> line_end
)
9591 dwarf2_debug_line_missing_end_sequence_complaint ();
9595 if (op_code
>= lh
->opcode_base
)
9597 /* Special operand. */
9598 adj_opcode
= op_code
- lh
->opcode_base
;
9599 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
9600 / lh
->maximum_ops_per_instruction
)
9601 * lh
->minimum_instruction_length
);
9602 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
9603 % lh
->maximum_ops_per_instruction
);
9604 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
9605 if (lh
->num_file_names
< file
|| file
== 0)
9606 dwarf2_debug_line_missing_file_complaint ();
9607 /* For now we ignore lines not starting on an
9608 instruction boundary. */
9609 else if (op_index
== 0)
9611 lh
->file_names
[file
- 1].included_p
= 1;
9612 if (!decode_for_pst_p
&& is_stmt
)
9614 if (last_subfile
!= current_subfile
)
9616 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
9618 record_line (last_subfile
, 0, addr
);
9619 last_subfile
= current_subfile
;
9621 /* Append row to matrix using current values. */
9622 addr
= check_cu_functions (address
, cu
);
9623 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
9624 record_line (current_subfile
, line
, addr
);
9629 else switch (op_code
)
9631 case DW_LNS_extended_op
:
9632 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9633 line_ptr
+= bytes_read
;
9634 extended_end
= line_ptr
+ extended_len
;
9635 extended_op
= read_1_byte (abfd
, line_ptr
);
9637 switch (extended_op
)
9639 case DW_LNE_end_sequence
:
9642 case DW_LNE_set_address
:
9643 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
9645 line_ptr
+= bytes_read
;
9646 address
+= baseaddr
;
9648 case DW_LNE_define_file
:
9651 unsigned int dir_index
, mod_time
, length
;
9653 cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
);
9654 line_ptr
+= bytes_read
;
9656 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9657 line_ptr
+= bytes_read
;
9659 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9660 line_ptr
+= bytes_read
;
9662 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9663 line_ptr
+= bytes_read
;
9664 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
9667 case DW_LNE_set_discriminator
:
9668 /* The discriminator is not interesting to the debugger;
9670 line_ptr
= extended_end
;
9673 complaint (&symfile_complaints
,
9674 _("mangled .debug_line section"));
9677 /* Make sure that we parsed the extended op correctly. If e.g.
9678 we expected a different address size than the producer used,
9679 we may have read the wrong number of bytes. */
9680 if (line_ptr
!= extended_end
)
9682 complaint (&symfile_complaints
,
9683 _("mangled .debug_line section"));
9688 if (lh
->num_file_names
< file
|| file
== 0)
9689 dwarf2_debug_line_missing_file_complaint ();
9692 lh
->file_names
[file
- 1].included_p
= 1;
9693 if (!decode_for_pst_p
&& is_stmt
)
9695 if (last_subfile
!= current_subfile
)
9697 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
9699 record_line (last_subfile
, 0, addr
);
9700 last_subfile
= current_subfile
;
9702 addr
= check_cu_functions (address
, cu
);
9703 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
9704 record_line (current_subfile
, line
, addr
);
9709 case DW_LNS_advance_pc
:
9712 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9714 address
+= (((op_index
+ adjust
)
9715 / lh
->maximum_ops_per_instruction
)
9716 * lh
->minimum_instruction_length
);
9717 op_index
= ((op_index
+ adjust
)
9718 % lh
->maximum_ops_per_instruction
);
9719 line_ptr
+= bytes_read
;
9722 case DW_LNS_advance_line
:
9723 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
9724 line_ptr
+= bytes_read
;
9726 case DW_LNS_set_file
:
9728 /* The arrays lh->include_dirs and lh->file_names are
9729 0-based, but the directory and file name numbers in
9730 the statement program are 1-based. */
9731 struct file_entry
*fe
;
9734 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9735 line_ptr
+= bytes_read
;
9736 if (lh
->num_file_names
< file
|| file
== 0)
9737 dwarf2_debug_line_missing_file_complaint ();
9740 fe
= &lh
->file_names
[file
- 1];
9742 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9743 if (!decode_for_pst_p
)
9745 last_subfile
= current_subfile
;
9746 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
9751 case DW_LNS_set_column
:
9752 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9753 line_ptr
+= bytes_read
;
9755 case DW_LNS_negate_stmt
:
9756 is_stmt
= (!is_stmt
);
9758 case DW_LNS_set_basic_block
:
9761 /* Add to the address register of the state machine the
9762 address increment value corresponding to special opcode
9763 255. I.e., this value is scaled by the minimum
9764 instruction length since special opcode 255 would have
9765 scaled the the increment. */
9766 case DW_LNS_const_add_pc
:
9768 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
9770 address
+= (((op_index
+ adjust
)
9771 / lh
->maximum_ops_per_instruction
)
9772 * lh
->minimum_instruction_length
);
9773 op_index
= ((op_index
+ adjust
)
9774 % lh
->maximum_ops_per_instruction
);
9777 case DW_LNS_fixed_advance_pc
:
9778 address
+= read_2_bytes (abfd
, line_ptr
);
9784 /* Unknown standard opcode, ignore it. */
9787 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
9789 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
9790 line_ptr
+= bytes_read
;
9795 if (lh
->num_file_names
< file
|| file
== 0)
9796 dwarf2_debug_line_missing_file_complaint ();
9799 lh
->file_names
[file
- 1].included_p
= 1;
9800 if (!decode_for_pst_p
)
9802 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
9803 record_line (current_subfile
, 0, addr
);
9808 if (decode_for_pst_p
)
9812 /* Now that we're done scanning the Line Header Program, we can
9813 create the psymtab of each included file. */
9814 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
9815 if (lh
->file_names
[file_index
].included_p
== 1)
9817 const struct file_entry fe
= lh
->file_names
[file_index
];
9818 char *include_name
= fe
.name
;
9819 char *dir_name
= NULL
;
9820 char *pst_filename
= pst
->filename
;
9823 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
9825 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
9827 include_name
= concat (dir_name
, SLASH_STRING
,
9828 include_name
, (char *)NULL
);
9829 make_cleanup (xfree
, include_name
);
9832 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
9834 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
9835 pst_filename
, (char *)NULL
);
9836 make_cleanup (xfree
, pst_filename
);
9839 if (strcmp (include_name
, pst_filename
) != 0)
9840 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
9845 /* Make sure a symtab is created for every file, even files
9846 which contain only variables (i.e. no code with associated
9850 struct file_entry
*fe
;
9852 for (i
= 0; i
< lh
->num_file_names
; i
++)
9856 fe
= &lh
->file_names
[i
];
9858 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9859 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
9861 /* Skip the main file; we don't need it, and it must be
9862 allocated last, so that it will show up before the
9863 non-primary symtabs in the objfile's symtab list. */
9864 if (current_subfile
== first_subfile
)
9867 if (current_subfile
->symtab
== NULL
)
9868 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
9870 fe
->symtab
= current_subfile
->symtab
;
9875 /* Start a subfile for DWARF. FILENAME is the name of the file and
9876 DIRNAME the name of the source directory which contains FILENAME
9877 or NULL if not known. COMP_DIR is the compilation directory for the
9878 linetable's compilation unit or NULL if not known.
9879 This routine tries to keep line numbers from identical absolute and
9880 relative file names in a common subfile.
9882 Using the `list' example from the GDB testsuite, which resides in
9883 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
9884 of /srcdir/list0.c yields the following debugging information for list0.c:
9886 DW_AT_name: /srcdir/list0.c
9887 DW_AT_comp_dir: /compdir
9888 files.files[0].name: list0.h
9889 files.files[0].dir: /srcdir
9890 files.files[1].name: list0.c
9891 files.files[1].dir: /srcdir
9893 The line number information for list0.c has to end up in a single
9894 subfile, so that `break /srcdir/list0.c:1' works as expected.
9895 start_subfile will ensure that this happens provided that we pass the
9896 concatenation of files.files[1].dir and files.files[1].name as the
9900 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
9904 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
9905 `start_symtab' will always pass the contents of DW_AT_comp_dir as
9906 second argument to start_subfile. To be consistent, we do the
9907 same here. In order not to lose the line information directory,
9908 we concatenate it to the filename when it makes sense.
9909 Note that the Dwarf3 standard says (speaking of filenames in line
9910 information): ``The directory index is ignored for file names
9911 that represent full path names''. Thus ignoring dirname in the
9912 `else' branch below isn't an issue. */
9914 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
9915 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
9917 fullname
= filename
;
9919 start_subfile (fullname
, comp_dir
);
9921 if (fullname
!= filename
)
9926 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
9927 struct dwarf2_cu
*cu
)
9929 struct objfile
*objfile
= cu
->objfile
;
9930 struct comp_unit_head
*cu_header
= &cu
->header
;
9932 /* NOTE drow/2003-01-30: There used to be a comment and some special
9933 code here to turn a symbol with DW_AT_external and a
9934 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
9935 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
9936 with some versions of binutils) where shared libraries could have
9937 relocations against symbols in their debug information - the
9938 minimal symbol would have the right address, but the debug info
9939 would not. It's no longer necessary, because we will explicitly
9940 apply relocations when we read in the debug information now. */
9942 /* A DW_AT_location attribute with no contents indicates that a
9943 variable has been optimized away. */
9944 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
9946 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
9950 /* Handle one degenerate form of location expression specially, to
9951 preserve GDB's previous behavior when section offsets are
9952 specified. If this is just a DW_OP_addr then mark this symbol
9955 if (attr_form_is_block (attr
)
9956 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
9957 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
9961 SYMBOL_VALUE_ADDRESS (sym
) =
9962 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
9963 SYMBOL_CLASS (sym
) = LOC_STATIC
;
9964 fixup_symbol_section (sym
, objfile
);
9965 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
9966 SYMBOL_SECTION (sym
));
9970 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
9971 expression evaluator, and use LOC_COMPUTED only when necessary
9972 (i.e. when the value of a register or memory location is
9973 referenced, or a thread-local block, etc.). Then again, it might
9974 not be worthwhile. I'm assuming that it isn't unless performance
9975 or memory numbers show me otherwise. */
9977 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
9978 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
9981 /* Given a pointer to a DWARF information entry, figure out if we need
9982 to make a symbol table entry for it, and if so, create a new entry
9983 and return a pointer to it.
9984 If TYPE is NULL, determine symbol type from the die, otherwise
9985 used the passed type.
9986 If SPACE is not NULL, use it to hold the new symbol. If it is
9987 NULL, allocate a new symbol on the objfile's obstack. */
9989 static struct symbol
*
9990 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
9991 struct symbol
*space
)
9993 struct objfile
*objfile
= cu
->objfile
;
9994 struct symbol
*sym
= NULL
;
9996 struct attribute
*attr
= NULL
;
9997 struct attribute
*attr2
= NULL
;
9999 struct pending
**list_to_add
= NULL
;
10001 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
10003 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10005 name
= dwarf2_name (die
, cu
);
10008 const char *linkagename
;
10009 int suppress_add
= 0;
10014 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
10015 OBJSTAT (objfile
, n_syms
++);
10017 /* Cache this symbol's name and the name's demangled form (if any). */
10018 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
10019 linkagename
= dwarf2_physname (name
, die
, cu
);
10020 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
10022 /* Fortran does not have mangling standard and the mangling does differ
10023 between gfortran, iFort etc. */
10024 if (cu
->language
== language_fortran
10025 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
10026 symbol_set_demangled_name (&(sym
->ginfo
),
10027 (char *) dwarf2_full_name (name
, die
, cu
),
10030 /* Default assumptions.
10031 Use the passed type or decode it from the die. */
10032 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
10033 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
10035 SYMBOL_TYPE (sym
) = type
;
10037 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
10038 attr
= dwarf2_attr (die
,
10039 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
10043 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
10046 attr
= dwarf2_attr (die
,
10047 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
10051 int file_index
= DW_UNSND (attr
);
10053 if (cu
->line_header
== NULL
10054 || file_index
> cu
->line_header
->num_file_names
)
10055 complaint (&symfile_complaints
,
10056 _("file index out of range"));
10057 else if (file_index
> 0)
10059 struct file_entry
*fe
;
10061 fe
= &cu
->line_header
->file_names
[file_index
- 1];
10062 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
10069 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
10072 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
10074 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
10075 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
10076 SYMBOL_CLASS (sym
) = LOC_LABEL
;
10077 add_symbol_to_list (sym
, cu
->list_in_scope
);
10079 case DW_TAG_subprogram
:
10080 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
10082 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
10083 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10084 if ((attr2
&& (DW_UNSND (attr2
) != 0))
10085 || cu
->language
== language_ada
)
10087 /* Subprograms marked external are stored as a global symbol.
10088 Ada subprograms, whether marked external or not, are always
10089 stored as a global symbol, because we want to be able to
10090 access them globally. For instance, we want to be able
10091 to break on a nested subprogram without having to
10092 specify the context. */
10093 list_to_add
= &global_symbols
;
10097 list_to_add
= cu
->list_in_scope
;
10100 case DW_TAG_inlined_subroutine
:
10101 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
10103 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
10104 SYMBOL_INLINED (sym
) = 1;
10105 /* Do not add the symbol to any lists. It will be found via
10106 BLOCK_FUNCTION from the blockvector. */
10108 case DW_TAG_template_value_param
:
10110 /* Fall through. */
10111 case DW_TAG_variable
:
10112 case DW_TAG_member
:
10113 /* Compilation with minimal debug info may result in variables
10114 with missing type entries. Change the misleading `void' type
10115 to something sensible. */
10116 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
10118 = objfile_type (objfile
)->nodebug_data_symbol
;
10120 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10121 /* In the case of DW_TAG_member, we should only be called for
10122 static const members. */
10123 if (die
->tag
== DW_TAG_member
)
10125 /* dwarf2_add_field uses die_is_declaration,
10126 so we do the same. */
10127 gdb_assert (die_is_declaration (die
, cu
));
10132 dwarf2_const_value (attr
, sym
, cu
);
10133 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10136 if (attr2
&& (DW_UNSND (attr2
) != 0))
10137 list_to_add
= &global_symbols
;
10139 list_to_add
= cu
->list_in_scope
;
10143 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
10146 var_decode_location (attr
, sym
, cu
);
10147 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10148 if (SYMBOL_CLASS (sym
) == LOC_STATIC
10149 && SYMBOL_VALUE_ADDRESS (sym
) == 0
10150 && !dwarf2_per_objfile
->has_section_at_zero
)
10152 /* When a static variable is eliminated by the linker,
10153 the corresponding debug information is not stripped
10154 out, but the variable address is set to null;
10155 do not add such variables into symbol table. */
10157 else if (attr2
&& (DW_UNSND (attr2
) != 0))
10159 /* Workaround gfortran PR debug/40040 - it uses
10160 DW_AT_location for variables in -fPIC libraries which may
10161 get overriden by other libraries/executable and get
10162 a different address. Resolve it by the minimal symbol
10163 which may come from inferior's executable using copy
10164 relocation. Make this workaround only for gfortran as for
10165 other compilers GDB cannot guess the minimal symbol
10166 Fortran mangling kind. */
10167 if (cu
->language
== language_fortran
&& die
->parent
10168 && die
->parent
->tag
== DW_TAG_module
10170 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
10171 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
10173 /* A variable with DW_AT_external is never static,
10174 but it may be block-scoped. */
10175 list_to_add
= (cu
->list_in_scope
== &file_symbols
10176 ? &global_symbols
: cu
->list_in_scope
);
10179 list_to_add
= cu
->list_in_scope
;
10183 /* We do not know the address of this symbol.
10184 If it is an external symbol and we have type information
10185 for it, enter the symbol as a LOC_UNRESOLVED symbol.
10186 The address of the variable will then be determined from
10187 the minimal symbol table whenever the variable is
10189 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10190 if (attr2
&& (DW_UNSND (attr2
) != 0)
10191 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
10193 /* A variable with DW_AT_external is never static, but it
10194 may be block-scoped. */
10195 list_to_add
= (cu
->list_in_scope
== &file_symbols
10196 ? &global_symbols
: cu
->list_in_scope
);
10198 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
10200 else if (!die_is_declaration (die
, cu
))
10202 /* Use the default LOC_OPTIMIZED_OUT class. */
10203 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
10205 list_to_add
= cu
->list_in_scope
;
10209 case DW_TAG_formal_parameter
:
10210 /* If we are inside a function, mark this as an argument. If
10211 not, we might be looking at an argument to an inlined function
10212 when we do not have enough information to show inlined frames;
10213 pretend it's a local variable in that case so that the user can
10215 if (context_stack_depth
> 0
10216 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
10217 SYMBOL_IS_ARGUMENT (sym
) = 1;
10218 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
10221 var_decode_location (attr
, sym
, cu
);
10223 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10226 dwarf2_const_value (attr
, sym
, cu
);
10228 attr
= dwarf2_attr (die
, DW_AT_variable_parameter
, cu
);
10229 if (attr
&& DW_UNSND (attr
))
10231 struct type
*ref_type
;
10233 ref_type
= lookup_reference_type (SYMBOL_TYPE (sym
));
10234 SYMBOL_TYPE (sym
) = ref_type
;
10237 list_to_add
= cu
->list_in_scope
;
10239 case DW_TAG_unspecified_parameters
:
10240 /* From varargs functions; gdb doesn't seem to have any
10241 interest in this information, so just ignore it for now.
10244 case DW_TAG_template_type_param
:
10246 /* Fall through. */
10247 case DW_TAG_class_type
:
10248 case DW_TAG_interface_type
:
10249 case DW_TAG_structure_type
:
10250 case DW_TAG_union_type
:
10251 case DW_TAG_set_type
:
10252 case DW_TAG_enumeration_type
:
10253 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10254 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
10257 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
10258 really ever be static objects: otherwise, if you try
10259 to, say, break of a class's method and you're in a file
10260 which doesn't mention that class, it won't work unless
10261 the check for all static symbols in lookup_symbol_aux
10262 saves you. See the OtherFileClass tests in
10263 gdb.c++/namespace.exp. */
10267 list_to_add
= (cu
->list_in_scope
== &file_symbols
10268 && (cu
->language
== language_cplus
10269 || cu
->language
== language_java
)
10270 ? &global_symbols
: cu
->list_in_scope
);
10273 /* The semantics of C++ state that "struct foo { ... }" also
10274 defines a typedef for "foo". A Java class declaration also
10275 defines a typedef for the class. */
10276 if (cu
->language
== language_cplus
10277 || cu
->language
== language_java
10278 || cu
->language
== language_ada
)
10280 /* The symbol's name is already allocated along with
10281 this objfile, so we don't need to duplicate it for
10283 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
10284 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
10288 case DW_TAG_typedef
:
10289 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10290 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
10291 list_to_add
= cu
->list_in_scope
;
10293 case DW_TAG_base_type
:
10294 case DW_TAG_subrange_type
:
10295 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10296 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
10297 list_to_add
= cu
->list_in_scope
;
10299 case DW_TAG_enumerator
:
10300 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10303 dwarf2_const_value (attr
, sym
, cu
);
10306 /* NOTE: carlton/2003-11-10: See comment above in the
10307 DW_TAG_class_type, etc. block. */
10309 list_to_add
= (cu
->list_in_scope
== &file_symbols
10310 && (cu
->language
== language_cplus
10311 || cu
->language
== language_java
)
10312 ? &global_symbols
: cu
->list_in_scope
);
10315 case DW_TAG_namespace
:
10316 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
10317 list_to_add
= &global_symbols
;
10320 /* Not a tag we recognize. Hopefully we aren't processing
10321 trash data, but since we must specifically ignore things
10322 we don't recognize, there is nothing else we should do at
10324 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
10325 dwarf_tag_name (die
->tag
));
10331 sym
->hash_next
= objfile
->template_symbols
;
10332 objfile
->template_symbols
= sym
;
10333 list_to_add
= NULL
;
10336 if (list_to_add
!= NULL
)
10337 add_symbol_to_list (sym
, list_to_add
);
10339 /* For the benefit of old versions of GCC, check for anonymous
10340 namespaces based on the demangled name. */
10341 if (!processing_has_namespace_info
10342 && cu
->language
== language_cplus
)
10343 cp_scan_for_anonymous_namespaces (sym
);
10348 /* A wrapper for new_symbol_full that always allocates a new symbol. */
10350 static struct symbol
*
10351 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
10353 return new_symbol_full (die
, type
, cu
, NULL
);
10356 /* Copy constant value from an attribute to a symbol. */
10359 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
10360 struct dwarf2_cu
*cu
)
10362 struct objfile
*objfile
= cu
->objfile
;
10363 struct comp_unit_head
*cu_header
= &cu
->header
;
10364 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
10365 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
10366 struct dwarf_block
*blk
;
10368 switch (attr
->form
)
10372 struct dwarf2_locexpr_baton
*baton
;
10375 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
10376 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
10377 cu_header
->addr_size
,
10378 TYPE_LENGTH (SYMBOL_TYPE
10380 /* Symbols of this form are reasonably rare, so we just
10381 piggyback on the existing location code rather than writing
10382 a new implementation of symbol_computed_ops. */
10383 baton
= obstack_alloc (&objfile
->objfile_obstack
,
10384 sizeof (struct dwarf2_locexpr_baton
));
10385 baton
->per_cu
= cu
->per_cu
;
10386 gdb_assert (baton
->per_cu
);
10388 baton
->size
= 2 + cu_header
->addr_size
;
10389 data
= obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
10390 baton
->data
= data
;
10392 data
[0] = DW_OP_addr
;
10393 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
10394 byte_order
, DW_ADDR (attr
));
10395 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
10397 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
10398 SYMBOL_LOCATION_BATON (sym
) = baton
;
10399 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
10402 case DW_FORM_string
:
10404 /* DW_STRING is already allocated on the obstack, point directly
10406 SYMBOL_VALUE_BYTES (sym
) = (gdb_byte
*) DW_STRING (attr
);
10407 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
10409 case DW_FORM_block1
:
10410 case DW_FORM_block2
:
10411 case DW_FORM_block4
:
10412 case DW_FORM_block
:
10413 case DW_FORM_exprloc
:
10414 blk
= DW_BLOCK (attr
);
10415 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
10416 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
10418 TYPE_LENGTH (SYMBOL_TYPE
10420 SYMBOL_VALUE_BYTES (sym
) =
10421 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
10422 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
10423 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
10426 /* The DW_AT_const_value attributes are supposed to carry the
10427 symbol's value "represented as it would be on the target
10428 architecture." By the time we get here, it's already been
10429 converted to host endianness, so we just need to sign- or
10430 zero-extend it as appropriate. */
10431 case DW_FORM_data1
:
10432 dwarf2_const_value_data (attr
, sym
, 8);
10434 case DW_FORM_data2
:
10435 dwarf2_const_value_data (attr
, sym
, 16);
10437 case DW_FORM_data4
:
10438 dwarf2_const_value_data (attr
, sym
, 32);
10440 case DW_FORM_data8
:
10441 dwarf2_const_value_data (attr
, sym
, 64);
10444 case DW_FORM_sdata
:
10445 SYMBOL_VALUE (sym
) = DW_SND (attr
);
10446 SYMBOL_CLASS (sym
) = LOC_CONST
;
10449 case DW_FORM_udata
:
10450 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
10451 SYMBOL_CLASS (sym
) = LOC_CONST
;
10455 complaint (&symfile_complaints
,
10456 _("unsupported const value attribute form: '%s'"),
10457 dwarf_form_name (attr
->form
));
10458 SYMBOL_VALUE (sym
) = 0;
10459 SYMBOL_CLASS (sym
) = LOC_CONST
;
10465 /* Given an attr with a DW_FORM_dataN value in host byte order,
10466 zero-extend it as appropriate for the symbol's type. The DWARF
10467 standard (v4) is not entirely clear about the meaning of using
10468 DW_FORM_dataN for a constant with a signed type, where the type is
10469 wider than the data. The conclusion of a discussion on the DWARF
10470 list was that this is unspecified. We choose to always zero-extend
10471 because that is the interpretation long in use by GCC. */
10473 dwarf2_const_value_data (struct attribute
*attr
,
10474 struct symbol
*sym
,
10477 LONGEST l
= DW_UNSND (attr
);
10479 if (bits
< sizeof (l
) * 8)
10480 l
&= ((LONGEST
) 1 << bits
) - 1;
10482 SYMBOL_VALUE (sym
) = l
;
10483 SYMBOL_CLASS (sym
) = LOC_CONST
;
10487 /* Return the type of the die in question using its DW_AT_type attribute. */
10489 static struct type
*
10490 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10492 struct attribute
*type_attr
;
10493 struct die_info
*type_die
;
10495 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
10498 /* A missing DW_AT_type represents a void type. */
10499 return objfile_type (cu
->objfile
)->builtin_void
;
10502 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
10504 return tag_type_to_type (type_die
, cu
);
10507 /* True iff CU's producer generates GNAT Ada auxiliary information
10508 that allows to find parallel types through that information instead
10509 of having to do expensive parallel lookups by type name. */
10512 need_gnat_info (struct dwarf2_cu
*cu
)
10514 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
10515 of GNAT produces this auxiliary information, without any indication
10516 that it is produced. Part of enhancing the FSF version of GNAT
10517 to produce that information will be to put in place an indicator
10518 that we can use in order to determine whether the descriptive type
10519 info is available or not. One suggestion that has been made is
10520 to use a new attribute, attached to the CU die. For now, assume
10521 that the descriptive type info is not available. */
10526 /* Return the auxiliary type of the die in question using its
10527 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
10528 attribute is not present. */
10530 static struct type
*
10531 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10533 struct attribute
*type_attr
;
10534 struct die_info
*type_die
;
10536 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
10540 type_die
= follow_die_ref (die
, type_attr
, &cu
);
10541 return tag_type_to_type (type_die
, cu
);
10544 /* If DIE has a descriptive_type attribute, then set the TYPE's
10545 descriptive type accordingly. */
10548 set_descriptive_type (struct type
*type
, struct die_info
*die
,
10549 struct dwarf2_cu
*cu
)
10551 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
10553 if (descriptive_type
)
10555 ALLOCATE_GNAT_AUX_TYPE (type
);
10556 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
10560 /* Return the containing type of the die in question using its
10561 DW_AT_containing_type attribute. */
10563 static struct type
*
10564 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10566 struct attribute
*type_attr
;
10567 struct die_info
*type_die
;
10569 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
10571 error (_("Dwarf Error: Problem turning containing type into gdb type "
10572 "[in module %s]"), cu
->objfile
->name
);
10574 type_die
= follow_die_ref_or_sig (die
, type_attr
, &cu
);
10575 return tag_type_to_type (type_die
, cu
);
10578 static struct type
*
10579 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10581 struct type
*this_type
;
10583 this_type
= read_type_die (die
, cu
);
10586 char *message
, *saved
;
10588 /* read_type_die already issued a complaint. */
10589 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
10593 saved
= obstack_copy0 (&cu
->objfile
->objfile_obstack
,
10594 message
, strlen (message
));
10597 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, cu
->objfile
);
10602 static struct type
*
10603 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10605 struct type
*this_type
;
10607 this_type
= get_die_type (die
, cu
);
10613 case DW_TAG_class_type
:
10614 case DW_TAG_interface_type
:
10615 case DW_TAG_structure_type
:
10616 case DW_TAG_union_type
:
10617 this_type
= read_structure_type (die
, cu
);
10619 case DW_TAG_enumeration_type
:
10620 this_type
= read_enumeration_type (die
, cu
);
10622 case DW_TAG_subprogram
:
10623 case DW_TAG_subroutine_type
:
10624 case DW_TAG_inlined_subroutine
:
10625 this_type
= read_subroutine_type (die
, cu
);
10627 case DW_TAG_array_type
:
10628 this_type
= read_array_type (die
, cu
);
10630 case DW_TAG_set_type
:
10631 this_type
= read_set_type (die
, cu
);
10633 case DW_TAG_pointer_type
:
10634 this_type
= read_tag_pointer_type (die
, cu
);
10636 case DW_TAG_ptr_to_member_type
:
10637 this_type
= read_tag_ptr_to_member_type (die
, cu
);
10639 case DW_TAG_reference_type
:
10640 this_type
= read_tag_reference_type (die
, cu
);
10642 case DW_TAG_const_type
:
10643 this_type
= read_tag_const_type (die
, cu
);
10645 case DW_TAG_volatile_type
:
10646 this_type
= read_tag_volatile_type (die
, cu
);
10648 case DW_TAG_string_type
:
10649 this_type
= read_tag_string_type (die
, cu
);
10651 case DW_TAG_typedef
:
10652 this_type
= read_typedef (die
, cu
);
10654 case DW_TAG_subrange_type
:
10655 this_type
= read_subrange_type (die
, cu
);
10657 case DW_TAG_base_type
:
10658 this_type
= read_base_type (die
, cu
);
10660 case DW_TAG_unspecified_type
:
10661 this_type
= read_unspecified_type (die
, cu
);
10663 case DW_TAG_namespace
:
10664 this_type
= read_namespace_type (die
, cu
);
10666 case DW_TAG_module
:
10667 this_type
= read_module_type (die
, cu
);
10670 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
10671 dwarf_tag_name (die
->tag
));
10678 /* Return the name of the namespace/class that DIE is defined within,
10679 or "" if we can't tell. The caller should not xfree the result.
10681 For example, if we're within the method foo() in the following
10691 then determine_prefix on foo's die will return "N::C". */
10694 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
10696 struct die_info
*parent
, *spec_die
;
10697 struct dwarf2_cu
*spec_cu
;
10698 struct type
*parent_type
;
10700 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
10701 && cu
->language
!= language_fortran
)
10704 /* We have to be careful in the presence of DW_AT_specification.
10705 For example, with GCC 3.4, given the code
10709 // Definition of N::foo.
10713 then we'll have a tree of DIEs like this:
10715 1: DW_TAG_compile_unit
10716 2: DW_TAG_namespace // N
10717 3: DW_TAG_subprogram // declaration of N::foo
10718 4: DW_TAG_subprogram // definition of N::foo
10719 DW_AT_specification // refers to die #3
10721 Thus, when processing die #4, we have to pretend that we're in
10722 the context of its DW_AT_specification, namely the contex of die
10725 spec_die
= die_specification (die
, &spec_cu
);
10726 if (spec_die
== NULL
)
10727 parent
= die
->parent
;
10730 parent
= spec_die
->parent
;
10734 if (parent
== NULL
)
10737 switch (parent
->tag
)
10739 case DW_TAG_namespace
:
10740 parent_type
= read_type_die (parent
, cu
);
10741 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
10742 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
10743 Work around this problem here. */
10744 if (cu
->language
== language_cplus
10745 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
10747 /* We give a name to even anonymous namespaces. */
10748 return TYPE_TAG_NAME (parent_type
);
10749 case DW_TAG_class_type
:
10750 case DW_TAG_interface_type
:
10751 case DW_TAG_structure_type
:
10752 case DW_TAG_union_type
:
10753 case DW_TAG_module
:
10754 parent_type
= read_type_die (parent
, cu
);
10755 if (TYPE_TAG_NAME (parent_type
) != NULL
)
10756 return TYPE_TAG_NAME (parent_type
);
10758 /* An anonymous structure is only allowed non-static data
10759 members; no typedefs, no member functions, et cetera.
10760 So it does not need a prefix. */
10763 return determine_prefix (parent
, cu
);
10767 /* Return a newly-allocated string formed by concatenating PREFIX and
10768 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
10769 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
10770 perform an obconcat, otherwise allocate storage for the result. The CU argument
10771 is used to determine the language and hence, the appropriate separator. */
10773 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
10776 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
10777 int physname
, struct dwarf2_cu
*cu
)
10779 const char *lead
= "";
10782 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
10784 else if (cu
->language
== language_java
)
10786 else if (cu
->language
== language_fortran
&& physname
)
10788 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
10789 DW_AT_MIPS_linkage_name is preferred and used instead. */
10797 if (prefix
== NULL
)
10799 if (suffix
== NULL
)
10804 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
10806 strcpy (retval
, lead
);
10807 strcat (retval
, prefix
);
10808 strcat (retval
, sep
);
10809 strcat (retval
, suffix
);
10814 /* We have an obstack. */
10815 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
10819 /* Return sibling of die, NULL if no sibling. */
10821 static struct die_info
*
10822 sibling_die (struct die_info
*die
)
10824 return die
->sibling
;
10827 /* Get name of a die, return NULL if not found. */
10830 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
10831 struct obstack
*obstack
)
10833 if (name
&& cu
->language
== language_cplus
)
10835 char *canon_name
= cp_canonicalize_string (name
);
10837 if (canon_name
!= NULL
)
10839 if (strcmp (canon_name
, name
) != 0)
10840 name
= obsavestring (canon_name
, strlen (canon_name
),
10842 xfree (canon_name
);
10849 /* Get name of a die, return NULL if not found. */
10852 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10854 struct attribute
*attr
;
10856 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10857 if (!attr
|| !DW_STRING (attr
))
10862 case DW_TAG_compile_unit
:
10863 /* Compilation units have a DW_AT_name that is a filename, not
10864 a source language identifier. */
10865 case DW_TAG_enumeration_type
:
10866 case DW_TAG_enumerator
:
10867 /* These tags always have simple identifiers already; no need
10868 to canonicalize them. */
10869 return DW_STRING (attr
);
10871 case DW_TAG_subprogram
:
10872 /* Java constructors will all be named "<init>", so return
10873 the class name when we see this special case. */
10874 if (cu
->language
== language_java
10875 && DW_STRING (attr
) != NULL
10876 && strcmp (DW_STRING (attr
), "<init>") == 0)
10878 struct dwarf2_cu
*spec_cu
= cu
;
10879 struct die_info
*spec_die
;
10881 /* GCJ will output '<init>' for Java constructor names.
10882 For this special case, return the name of the parent class. */
10884 /* GCJ may output suprogram DIEs with AT_specification set.
10885 If so, use the name of the specified DIE. */
10886 spec_die
= die_specification (die
, &spec_cu
);
10887 if (spec_die
!= NULL
)
10888 return dwarf2_name (spec_die
, spec_cu
);
10893 if (die
->tag
== DW_TAG_class_type
)
10894 return dwarf2_name (die
, cu
);
10896 while (die
->tag
!= DW_TAG_compile_unit
);
10900 case DW_TAG_class_type
:
10901 case DW_TAG_interface_type
:
10902 case DW_TAG_structure_type
:
10903 case DW_TAG_union_type
:
10904 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
10905 structures or unions. These were of the form "._%d" in GCC 4.1,
10906 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
10907 and GCC 4.4. We work around this problem by ignoring these. */
10908 if (strncmp (DW_STRING (attr
), "._", 2) == 0
10909 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0)
10917 if (!DW_STRING_IS_CANONICAL (attr
))
10920 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
10921 &cu
->objfile
->objfile_obstack
);
10922 DW_STRING_IS_CANONICAL (attr
) = 1;
10924 return DW_STRING (attr
);
10927 /* Return the die that this die in an extension of, or NULL if there
10928 is none. *EXT_CU is the CU containing DIE on input, and the CU
10929 containing the return value on output. */
10931 static struct die_info
*
10932 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
10934 struct attribute
*attr
;
10936 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
10940 return follow_die_ref (die
, attr
, ext_cu
);
10943 /* Convert a DIE tag into its string name. */
10946 dwarf_tag_name (unsigned tag
)
10950 case DW_TAG_padding
:
10951 return "DW_TAG_padding";
10952 case DW_TAG_array_type
:
10953 return "DW_TAG_array_type";
10954 case DW_TAG_class_type
:
10955 return "DW_TAG_class_type";
10956 case DW_TAG_entry_point
:
10957 return "DW_TAG_entry_point";
10958 case DW_TAG_enumeration_type
:
10959 return "DW_TAG_enumeration_type";
10960 case DW_TAG_formal_parameter
:
10961 return "DW_TAG_formal_parameter";
10962 case DW_TAG_imported_declaration
:
10963 return "DW_TAG_imported_declaration";
10965 return "DW_TAG_label";
10966 case DW_TAG_lexical_block
:
10967 return "DW_TAG_lexical_block";
10968 case DW_TAG_member
:
10969 return "DW_TAG_member";
10970 case DW_TAG_pointer_type
:
10971 return "DW_TAG_pointer_type";
10972 case DW_TAG_reference_type
:
10973 return "DW_TAG_reference_type";
10974 case DW_TAG_compile_unit
:
10975 return "DW_TAG_compile_unit";
10976 case DW_TAG_string_type
:
10977 return "DW_TAG_string_type";
10978 case DW_TAG_structure_type
:
10979 return "DW_TAG_structure_type";
10980 case DW_TAG_subroutine_type
:
10981 return "DW_TAG_subroutine_type";
10982 case DW_TAG_typedef
:
10983 return "DW_TAG_typedef";
10984 case DW_TAG_union_type
:
10985 return "DW_TAG_union_type";
10986 case DW_TAG_unspecified_parameters
:
10987 return "DW_TAG_unspecified_parameters";
10988 case DW_TAG_variant
:
10989 return "DW_TAG_variant";
10990 case DW_TAG_common_block
:
10991 return "DW_TAG_common_block";
10992 case DW_TAG_common_inclusion
:
10993 return "DW_TAG_common_inclusion";
10994 case DW_TAG_inheritance
:
10995 return "DW_TAG_inheritance";
10996 case DW_TAG_inlined_subroutine
:
10997 return "DW_TAG_inlined_subroutine";
10998 case DW_TAG_module
:
10999 return "DW_TAG_module";
11000 case DW_TAG_ptr_to_member_type
:
11001 return "DW_TAG_ptr_to_member_type";
11002 case DW_TAG_set_type
:
11003 return "DW_TAG_set_type";
11004 case DW_TAG_subrange_type
:
11005 return "DW_TAG_subrange_type";
11006 case DW_TAG_with_stmt
:
11007 return "DW_TAG_with_stmt";
11008 case DW_TAG_access_declaration
:
11009 return "DW_TAG_access_declaration";
11010 case DW_TAG_base_type
:
11011 return "DW_TAG_base_type";
11012 case DW_TAG_catch_block
:
11013 return "DW_TAG_catch_block";
11014 case DW_TAG_const_type
:
11015 return "DW_TAG_const_type";
11016 case DW_TAG_constant
:
11017 return "DW_TAG_constant";
11018 case DW_TAG_enumerator
:
11019 return "DW_TAG_enumerator";
11020 case DW_TAG_file_type
:
11021 return "DW_TAG_file_type";
11022 case DW_TAG_friend
:
11023 return "DW_TAG_friend";
11024 case DW_TAG_namelist
:
11025 return "DW_TAG_namelist";
11026 case DW_TAG_namelist_item
:
11027 return "DW_TAG_namelist_item";
11028 case DW_TAG_packed_type
:
11029 return "DW_TAG_packed_type";
11030 case DW_TAG_subprogram
:
11031 return "DW_TAG_subprogram";
11032 case DW_TAG_template_type_param
:
11033 return "DW_TAG_template_type_param";
11034 case DW_TAG_template_value_param
:
11035 return "DW_TAG_template_value_param";
11036 case DW_TAG_thrown_type
:
11037 return "DW_TAG_thrown_type";
11038 case DW_TAG_try_block
:
11039 return "DW_TAG_try_block";
11040 case DW_TAG_variant_part
:
11041 return "DW_TAG_variant_part";
11042 case DW_TAG_variable
:
11043 return "DW_TAG_variable";
11044 case DW_TAG_volatile_type
:
11045 return "DW_TAG_volatile_type";
11046 case DW_TAG_dwarf_procedure
:
11047 return "DW_TAG_dwarf_procedure";
11048 case DW_TAG_restrict_type
:
11049 return "DW_TAG_restrict_type";
11050 case DW_TAG_interface_type
:
11051 return "DW_TAG_interface_type";
11052 case DW_TAG_namespace
:
11053 return "DW_TAG_namespace";
11054 case DW_TAG_imported_module
:
11055 return "DW_TAG_imported_module";
11056 case DW_TAG_unspecified_type
:
11057 return "DW_TAG_unspecified_type";
11058 case DW_TAG_partial_unit
:
11059 return "DW_TAG_partial_unit";
11060 case DW_TAG_imported_unit
:
11061 return "DW_TAG_imported_unit";
11062 case DW_TAG_condition
:
11063 return "DW_TAG_condition";
11064 case DW_TAG_shared_type
:
11065 return "DW_TAG_shared_type";
11066 case DW_TAG_type_unit
:
11067 return "DW_TAG_type_unit";
11068 case DW_TAG_MIPS_loop
:
11069 return "DW_TAG_MIPS_loop";
11070 case DW_TAG_HP_array_descriptor
:
11071 return "DW_TAG_HP_array_descriptor";
11072 case DW_TAG_format_label
:
11073 return "DW_TAG_format_label";
11074 case DW_TAG_function_template
:
11075 return "DW_TAG_function_template";
11076 case DW_TAG_class_template
:
11077 return "DW_TAG_class_template";
11078 case DW_TAG_GNU_BINCL
:
11079 return "DW_TAG_GNU_BINCL";
11080 case DW_TAG_GNU_EINCL
:
11081 return "DW_TAG_GNU_EINCL";
11082 case DW_TAG_upc_shared_type
:
11083 return "DW_TAG_upc_shared_type";
11084 case DW_TAG_upc_strict_type
:
11085 return "DW_TAG_upc_strict_type";
11086 case DW_TAG_upc_relaxed_type
:
11087 return "DW_TAG_upc_relaxed_type";
11088 case DW_TAG_PGI_kanji_type
:
11089 return "DW_TAG_PGI_kanji_type";
11090 case DW_TAG_PGI_interface_block
:
11091 return "DW_TAG_PGI_interface_block";
11093 return "DW_TAG_<unknown>";
11097 /* Convert a DWARF attribute code into its string name. */
11100 dwarf_attr_name (unsigned attr
)
11104 case DW_AT_sibling
:
11105 return "DW_AT_sibling";
11106 case DW_AT_location
:
11107 return "DW_AT_location";
11109 return "DW_AT_name";
11110 case DW_AT_ordering
:
11111 return "DW_AT_ordering";
11112 case DW_AT_subscr_data
:
11113 return "DW_AT_subscr_data";
11114 case DW_AT_byte_size
:
11115 return "DW_AT_byte_size";
11116 case DW_AT_bit_offset
:
11117 return "DW_AT_bit_offset";
11118 case DW_AT_bit_size
:
11119 return "DW_AT_bit_size";
11120 case DW_AT_element_list
:
11121 return "DW_AT_element_list";
11122 case DW_AT_stmt_list
:
11123 return "DW_AT_stmt_list";
11125 return "DW_AT_low_pc";
11126 case DW_AT_high_pc
:
11127 return "DW_AT_high_pc";
11128 case DW_AT_language
:
11129 return "DW_AT_language";
11131 return "DW_AT_member";
11133 return "DW_AT_discr";
11134 case DW_AT_discr_value
:
11135 return "DW_AT_discr_value";
11136 case DW_AT_visibility
:
11137 return "DW_AT_visibility";
11139 return "DW_AT_import";
11140 case DW_AT_string_length
:
11141 return "DW_AT_string_length";
11142 case DW_AT_common_reference
:
11143 return "DW_AT_common_reference";
11144 case DW_AT_comp_dir
:
11145 return "DW_AT_comp_dir";
11146 case DW_AT_const_value
:
11147 return "DW_AT_const_value";
11148 case DW_AT_containing_type
:
11149 return "DW_AT_containing_type";
11150 case DW_AT_default_value
:
11151 return "DW_AT_default_value";
11153 return "DW_AT_inline";
11154 case DW_AT_is_optional
:
11155 return "DW_AT_is_optional";
11156 case DW_AT_lower_bound
:
11157 return "DW_AT_lower_bound";
11158 case DW_AT_producer
:
11159 return "DW_AT_producer";
11160 case DW_AT_prototyped
:
11161 return "DW_AT_prototyped";
11162 case DW_AT_return_addr
:
11163 return "DW_AT_return_addr";
11164 case DW_AT_start_scope
:
11165 return "DW_AT_start_scope";
11166 case DW_AT_bit_stride
:
11167 return "DW_AT_bit_stride";
11168 case DW_AT_upper_bound
:
11169 return "DW_AT_upper_bound";
11170 case DW_AT_abstract_origin
:
11171 return "DW_AT_abstract_origin";
11172 case DW_AT_accessibility
:
11173 return "DW_AT_accessibility";
11174 case DW_AT_address_class
:
11175 return "DW_AT_address_class";
11176 case DW_AT_artificial
:
11177 return "DW_AT_artificial";
11178 case DW_AT_base_types
:
11179 return "DW_AT_base_types";
11180 case DW_AT_calling_convention
:
11181 return "DW_AT_calling_convention";
11183 return "DW_AT_count";
11184 case DW_AT_data_member_location
:
11185 return "DW_AT_data_member_location";
11186 case DW_AT_decl_column
:
11187 return "DW_AT_decl_column";
11188 case DW_AT_decl_file
:
11189 return "DW_AT_decl_file";
11190 case DW_AT_decl_line
:
11191 return "DW_AT_decl_line";
11192 case DW_AT_declaration
:
11193 return "DW_AT_declaration";
11194 case DW_AT_discr_list
:
11195 return "DW_AT_discr_list";
11196 case DW_AT_encoding
:
11197 return "DW_AT_encoding";
11198 case DW_AT_external
:
11199 return "DW_AT_external";
11200 case DW_AT_frame_base
:
11201 return "DW_AT_frame_base";
11203 return "DW_AT_friend";
11204 case DW_AT_identifier_case
:
11205 return "DW_AT_identifier_case";
11206 case DW_AT_macro_info
:
11207 return "DW_AT_macro_info";
11208 case DW_AT_namelist_items
:
11209 return "DW_AT_namelist_items";
11210 case DW_AT_priority
:
11211 return "DW_AT_priority";
11212 case DW_AT_segment
:
11213 return "DW_AT_segment";
11214 case DW_AT_specification
:
11215 return "DW_AT_specification";
11216 case DW_AT_static_link
:
11217 return "DW_AT_static_link";
11219 return "DW_AT_type";
11220 case DW_AT_use_location
:
11221 return "DW_AT_use_location";
11222 case DW_AT_variable_parameter
:
11223 return "DW_AT_variable_parameter";
11224 case DW_AT_virtuality
:
11225 return "DW_AT_virtuality";
11226 case DW_AT_vtable_elem_location
:
11227 return "DW_AT_vtable_elem_location";
11228 /* DWARF 3 values. */
11229 case DW_AT_allocated
:
11230 return "DW_AT_allocated";
11231 case DW_AT_associated
:
11232 return "DW_AT_associated";
11233 case DW_AT_data_location
:
11234 return "DW_AT_data_location";
11235 case DW_AT_byte_stride
:
11236 return "DW_AT_byte_stride";
11237 case DW_AT_entry_pc
:
11238 return "DW_AT_entry_pc";
11239 case DW_AT_use_UTF8
:
11240 return "DW_AT_use_UTF8";
11241 case DW_AT_extension
:
11242 return "DW_AT_extension";
11244 return "DW_AT_ranges";
11245 case DW_AT_trampoline
:
11246 return "DW_AT_trampoline";
11247 case DW_AT_call_column
:
11248 return "DW_AT_call_column";
11249 case DW_AT_call_file
:
11250 return "DW_AT_call_file";
11251 case DW_AT_call_line
:
11252 return "DW_AT_call_line";
11253 case DW_AT_description
:
11254 return "DW_AT_description";
11255 case DW_AT_binary_scale
:
11256 return "DW_AT_binary_scale";
11257 case DW_AT_decimal_scale
:
11258 return "DW_AT_decimal_scale";
11260 return "DW_AT_small";
11261 case DW_AT_decimal_sign
:
11262 return "DW_AT_decimal_sign";
11263 case DW_AT_digit_count
:
11264 return "DW_AT_digit_count";
11265 case DW_AT_picture_string
:
11266 return "DW_AT_picture_string";
11267 case DW_AT_mutable
:
11268 return "DW_AT_mutable";
11269 case DW_AT_threads_scaled
:
11270 return "DW_AT_threads_scaled";
11271 case DW_AT_explicit
:
11272 return "DW_AT_explicit";
11273 case DW_AT_object_pointer
:
11274 return "DW_AT_object_pointer";
11275 case DW_AT_endianity
:
11276 return "DW_AT_endianity";
11277 case DW_AT_elemental
:
11278 return "DW_AT_elemental";
11280 return "DW_AT_pure";
11281 case DW_AT_recursive
:
11282 return "DW_AT_recursive";
11283 /* DWARF 4 values. */
11284 case DW_AT_signature
:
11285 return "DW_AT_signature";
11286 case DW_AT_linkage_name
:
11287 return "DW_AT_linkage_name";
11288 /* SGI/MIPS extensions. */
11289 #ifdef MIPS /* collides with DW_AT_HP_block_index */
11290 case DW_AT_MIPS_fde
:
11291 return "DW_AT_MIPS_fde";
11293 case DW_AT_MIPS_loop_begin
:
11294 return "DW_AT_MIPS_loop_begin";
11295 case DW_AT_MIPS_tail_loop_begin
:
11296 return "DW_AT_MIPS_tail_loop_begin";
11297 case DW_AT_MIPS_epilog_begin
:
11298 return "DW_AT_MIPS_epilog_begin";
11299 case DW_AT_MIPS_loop_unroll_factor
:
11300 return "DW_AT_MIPS_loop_unroll_factor";
11301 case DW_AT_MIPS_software_pipeline_depth
:
11302 return "DW_AT_MIPS_software_pipeline_depth";
11303 case DW_AT_MIPS_linkage_name
:
11304 return "DW_AT_MIPS_linkage_name";
11305 case DW_AT_MIPS_stride
:
11306 return "DW_AT_MIPS_stride";
11307 case DW_AT_MIPS_abstract_name
:
11308 return "DW_AT_MIPS_abstract_name";
11309 case DW_AT_MIPS_clone_origin
:
11310 return "DW_AT_MIPS_clone_origin";
11311 case DW_AT_MIPS_has_inlines
:
11312 return "DW_AT_MIPS_has_inlines";
11313 /* HP extensions. */
11314 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
11315 case DW_AT_HP_block_index
:
11316 return "DW_AT_HP_block_index";
11318 case DW_AT_HP_unmodifiable
:
11319 return "DW_AT_HP_unmodifiable";
11320 case DW_AT_HP_actuals_stmt_list
:
11321 return "DW_AT_HP_actuals_stmt_list";
11322 case DW_AT_HP_proc_per_section
:
11323 return "DW_AT_HP_proc_per_section";
11324 case DW_AT_HP_raw_data_ptr
:
11325 return "DW_AT_HP_raw_data_ptr";
11326 case DW_AT_HP_pass_by_reference
:
11327 return "DW_AT_HP_pass_by_reference";
11328 case DW_AT_HP_opt_level
:
11329 return "DW_AT_HP_opt_level";
11330 case DW_AT_HP_prof_version_id
:
11331 return "DW_AT_HP_prof_version_id";
11332 case DW_AT_HP_opt_flags
:
11333 return "DW_AT_HP_opt_flags";
11334 case DW_AT_HP_cold_region_low_pc
:
11335 return "DW_AT_HP_cold_region_low_pc";
11336 case DW_AT_HP_cold_region_high_pc
:
11337 return "DW_AT_HP_cold_region_high_pc";
11338 case DW_AT_HP_all_variables_modifiable
:
11339 return "DW_AT_HP_all_variables_modifiable";
11340 case DW_AT_HP_linkage_name
:
11341 return "DW_AT_HP_linkage_name";
11342 case DW_AT_HP_prof_flags
:
11343 return "DW_AT_HP_prof_flags";
11344 /* GNU extensions. */
11345 case DW_AT_sf_names
:
11346 return "DW_AT_sf_names";
11347 case DW_AT_src_info
:
11348 return "DW_AT_src_info";
11349 case DW_AT_mac_info
:
11350 return "DW_AT_mac_info";
11351 case DW_AT_src_coords
:
11352 return "DW_AT_src_coords";
11353 case DW_AT_body_begin
:
11354 return "DW_AT_body_begin";
11355 case DW_AT_body_end
:
11356 return "DW_AT_body_end";
11357 case DW_AT_GNU_vector
:
11358 return "DW_AT_GNU_vector";
11359 case DW_AT_GNU_odr_signature
:
11360 return "DW_AT_GNU_odr_signature";
11361 /* VMS extensions. */
11362 case DW_AT_VMS_rtnbeg_pd_address
:
11363 return "DW_AT_VMS_rtnbeg_pd_address";
11364 /* UPC extension. */
11365 case DW_AT_upc_threads_scaled
:
11366 return "DW_AT_upc_threads_scaled";
11367 /* PGI (STMicroelectronics) extensions. */
11368 case DW_AT_PGI_lbase
:
11369 return "DW_AT_PGI_lbase";
11370 case DW_AT_PGI_soffset
:
11371 return "DW_AT_PGI_soffset";
11372 case DW_AT_PGI_lstride
:
11373 return "DW_AT_PGI_lstride";
11375 return "DW_AT_<unknown>";
11379 /* Convert a DWARF value form code into its string name. */
11382 dwarf_form_name (unsigned form
)
11387 return "DW_FORM_addr";
11388 case DW_FORM_block2
:
11389 return "DW_FORM_block2";
11390 case DW_FORM_block4
:
11391 return "DW_FORM_block4";
11392 case DW_FORM_data2
:
11393 return "DW_FORM_data2";
11394 case DW_FORM_data4
:
11395 return "DW_FORM_data4";
11396 case DW_FORM_data8
:
11397 return "DW_FORM_data8";
11398 case DW_FORM_string
:
11399 return "DW_FORM_string";
11400 case DW_FORM_block
:
11401 return "DW_FORM_block";
11402 case DW_FORM_block1
:
11403 return "DW_FORM_block1";
11404 case DW_FORM_data1
:
11405 return "DW_FORM_data1";
11407 return "DW_FORM_flag";
11408 case DW_FORM_sdata
:
11409 return "DW_FORM_sdata";
11411 return "DW_FORM_strp";
11412 case DW_FORM_udata
:
11413 return "DW_FORM_udata";
11414 case DW_FORM_ref_addr
:
11415 return "DW_FORM_ref_addr";
11417 return "DW_FORM_ref1";
11419 return "DW_FORM_ref2";
11421 return "DW_FORM_ref4";
11423 return "DW_FORM_ref8";
11424 case DW_FORM_ref_udata
:
11425 return "DW_FORM_ref_udata";
11426 case DW_FORM_indirect
:
11427 return "DW_FORM_indirect";
11428 case DW_FORM_sec_offset
:
11429 return "DW_FORM_sec_offset";
11430 case DW_FORM_exprloc
:
11431 return "DW_FORM_exprloc";
11432 case DW_FORM_flag_present
:
11433 return "DW_FORM_flag_present";
11435 return "DW_FORM_sig8";
11437 return "DW_FORM_<unknown>";
11441 /* Convert a DWARF stack opcode into its string name. */
11444 dwarf_stack_op_name (unsigned op
, int def
)
11449 return "DW_OP_addr";
11451 return "DW_OP_deref";
11452 case DW_OP_const1u
:
11453 return "DW_OP_const1u";
11454 case DW_OP_const1s
:
11455 return "DW_OP_const1s";
11456 case DW_OP_const2u
:
11457 return "DW_OP_const2u";
11458 case DW_OP_const2s
:
11459 return "DW_OP_const2s";
11460 case DW_OP_const4u
:
11461 return "DW_OP_const4u";
11462 case DW_OP_const4s
:
11463 return "DW_OP_const4s";
11464 case DW_OP_const8u
:
11465 return "DW_OP_const8u";
11466 case DW_OP_const8s
:
11467 return "DW_OP_const8s";
11469 return "DW_OP_constu";
11471 return "DW_OP_consts";
11473 return "DW_OP_dup";
11475 return "DW_OP_drop";
11477 return "DW_OP_over";
11479 return "DW_OP_pick";
11481 return "DW_OP_swap";
11483 return "DW_OP_rot";
11485 return "DW_OP_xderef";
11487 return "DW_OP_abs";
11489 return "DW_OP_and";
11491 return "DW_OP_div";
11493 return "DW_OP_minus";
11495 return "DW_OP_mod";
11497 return "DW_OP_mul";
11499 return "DW_OP_neg";
11501 return "DW_OP_not";
11505 return "DW_OP_plus";
11506 case DW_OP_plus_uconst
:
11507 return "DW_OP_plus_uconst";
11509 return "DW_OP_shl";
11511 return "DW_OP_shr";
11513 return "DW_OP_shra";
11515 return "DW_OP_xor";
11517 return "DW_OP_bra";
11531 return "DW_OP_skip";
11533 return "DW_OP_lit0";
11535 return "DW_OP_lit1";
11537 return "DW_OP_lit2";
11539 return "DW_OP_lit3";
11541 return "DW_OP_lit4";
11543 return "DW_OP_lit5";
11545 return "DW_OP_lit6";
11547 return "DW_OP_lit7";
11549 return "DW_OP_lit8";
11551 return "DW_OP_lit9";
11553 return "DW_OP_lit10";
11555 return "DW_OP_lit11";
11557 return "DW_OP_lit12";
11559 return "DW_OP_lit13";
11561 return "DW_OP_lit14";
11563 return "DW_OP_lit15";
11565 return "DW_OP_lit16";
11567 return "DW_OP_lit17";
11569 return "DW_OP_lit18";
11571 return "DW_OP_lit19";
11573 return "DW_OP_lit20";
11575 return "DW_OP_lit21";
11577 return "DW_OP_lit22";
11579 return "DW_OP_lit23";
11581 return "DW_OP_lit24";
11583 return "DW_OP_lit25";
11585 return "DW_OP_lit26";
11587 return "DW_OP_lit27";
11589 return "DW_OP_lit28";
11591 return "DW_OP_lit29";
11593 return "DW_OP_lit30";
11595 return "DW_OP_lit31";
11597 return "DW_OP_reg0";
11599 return "DW_OP_reg1";
11601 return "DW_OP_reg2";
11603 return "DW_OP_reg3";
11605 return "DW_OP_reg4";
11607 return "DW_OP_reg5";
11609 return "DW_OP_reg6";
11611 return "DW_OP_reg7";
11613 return "DW_OP_reg8";
11615 return "DW_OP_reg9";
11617 return "DW_OP_reg10";
11619 return "DW_OP_reg11";
11621 return "DW_OP_reg12";
11623 return "DW_OP_reg13";
11625 return "DW_OP_reg14";
11627 return "DW_OP_reg15";
11629 return "DW_OP_reg16";
11631 return "DW_OP_reg17";
11633 return "DW_OP_reg18";
11635 return "DW_OP_reg19";
11637 return "DW_OP_reg20";
11639 return "DW_OP_reg21";
11641 return "DW_OP_reg22";
11643 return "DW_OP_reg23";
11645 return "DW_OP_reg24";
11647 return "DW_OP_reg25";
11649 return "DW_OP_reg26";
11651 return "DW_OP_reg27";
11653 return "DW_OP_reg28";
11655 return "DW_OP_reg29";
11657 return "DW_OP_reg30";
11659 return "DW_OP_reg31";
11661 return "DW_OP_breg0";
11663 return "DW_OP_breg1";
11665 return "DW_OP_breg2";
11667 return "DW_OP_breg3";
11669 return "DW_OP_breg4";
11671 return "DW_OP_breg5";
11673 return "DW_OP_breg6";
11675 return "DW_OP_breg7";
11677 return "DW_OP_breg8";
11679 return "DW_OP_breg9";
11681 return "DW_OP_breg10";
11683 return "DW_OP_breg11";
11685 return "DW_OP_breg12";
11687 return "DW_OP_breg13";
11689 return "DW_OP_breg14";
11691 return "DW_OP_breg15";
11693 return "DW_OP_breg16";
11695 return "DW_OP_breg17";
11697 return "DW_OP_breg18";
11699 return "DW_OP_breg19";
11701 return "DW_OP_breg20";
11703 return "DW_OP_breg21";
11705 return "DW_OP_breg22";
11707 return "DW_OP_breg23";
11709 return "DW_OP_breg24";
11711 return "DW_OP_breg25";
11713 return "DW_OP_breg26";
11715 return "DW_OP_breg27";
11717 return "DW_OP_breg28";
11719 return "DW_OP_breg29";
11721 return "DW_OP_breg30";
11723 return "DW_OP_breg31";
11725 return "DW_OP_regx";
11727 return "DW_OP_fbreg";
11729 return "DW_OP_bregx";
11731 return "DW_OP_piece";
11732 case DW_OP_deref_size
:
11733 return "DW_OP_deref_size";
11734 case DW_OP_xderef_size
:
11735 return "DW_OP_xderef_size";
11737 return "DW_OP_nop";
11738 /* DWARF 3 extensions. */
11739 case DW_OP_push_object_address
:
11740 return "DW_OP_push_object_address";
11742 return "DW_OP_call2";
11744 return "DW_OP_call4";
11745 case DW_OP_call_ref
:
11746 return "DW_OP_call_ref";
11747 case DW_OP_form_tls_address
:
11748 return "DW_OP_form_tls_address";
11749 case DW_OP_call_frame_cfa
:
11750 return "DW_OP_call_frame_cfa";
11751 case DW_OP_bit_piece
:
11752 return "DW_OP_bit_piece";
11753 /* DWARF 4 extensions. */
11754 case DW_OP_implicit_value
:
11755 return "DW_OP_implicit_value";
11756 case DW_OP_stack_value
:
11757 return "DW_OP_stack_value";
11758 /* GNU extensions. */
11759 case DW_OP_GNU_push_tls_address
:
11760 return "DW_OP_GNU_push_tls_address";
11761 case DW_OP_GNU_uninit
:
11762 return "DW_OP_GNU_uninit";
11764 return def
? "OP_<unknown>" : NULL
;
11769 dwarf_bool_name (unsigned mybool
)
11777 /* Convert a DWARF type code into its string name. */
11780 dwarf_type_encoding_name (unsigned enc
)
11785 return "DW_ATE_void";
11786 case DW_ATE_address
:
11787 return "DW_ATE_address";
11788 case DW_ATE_boolean
:
11789 return "DW_ATE_boolean";
11790 case DW_ATE_complex_float
:
11791 return "DW_ATE_complex_float";
11793 return "DW_ATE_float";
11794 case DW_ATE_signed
:
11795 return "DW_ATE_signed";
11796 case DW_ATE_signed_char
:
11797 return "DW_ATE_signed_char";
11798 case DW_ATE_unsigned
:
11799 return "DW_ATE_unsigned";
11800 case DW_ATE_unsigned_char
:
11801 return "DW_ATE_unsigned_char";
11803 case DW_ATE_imaginary_float
:
11804 return "DW_ATE_imaginary_float";
11805 case DW_ATE_packed_decimal
:
11806 return "DW_ATE_packed_decimal";
11807 case DW_ATE_numeric_string
:
11808 return "DW_ATE_numeric_string";
11809 case DW_ATE_edited
:
11810 return "DW_ATE_edited";
11811 case DW_ATE_signed_fixed
:
11812 return "DW_ATE_signed_fixed";
11813 case DW_ATE_unsigned_fixed
:
11814 return "DW_ATE_unsigned_fixed";
11815 case DW_ATE_decimal_float
:
11816 return "DW_ATE_decimal_float";
11819 return "DW_ATE_UTF";
11820 /* HP extensions. */
11821 case DW_ATE_HP_float80
:
11822 return "DW_ATE_HP_float80";
11823 case DW_ATE_HP_complex_float80
:
11824 return "DW_ATE_HP_complex_float80";
11825 case DW_ATE_HP_float128
:
11826 return "DW_ATE_HP_float128";
11827 case DW_ATE_HP_complex_float128
:
11828 return "DW_ATE_HP_complex_float128";
11829 case DW_ATE_HP_floathpintel
:
11830 return "DW_ATE_HP_floathpintel";
11831 case DW_ATE_HP_imaginary_float80
:
11832 return "DW_ATE_HP_imaginary_float80";
11833 case DW_ATE_HP_imaginary_float128
:
11834 return "DW_ATE_HP_imaginary_float128";
11836 return "DW_ATE_<unknown>";
11840 /* Convert a DWARF call frame info operation to its string name. */
11844 dwarf_cfi_name (unsigned cfi_opc
)
11848 case DW_CFA_advance_loc
:
11849 return "DW_CFA_advance_loc";
11850 case DW_CFA_offset
:
11851 return "DW_CFA_offset";
11852 case DW_CFA_restore
:
11853 return "DW_CFA_restore";
11855 return "DW_CFA_nop";
11856 case DW_CFA_set_loc
:
11857 return "DW_CFA_set_loc";
11858 case DW_CFA_advance_loc1
:
11859 return "DW_CFA_advance_loc1";
11860 case DW_CFA_advance_loc2
:
11861 return "DW_CFA_advance_loc2";
11862 case DW_CFA_advance_loc4
:
11863 return "DW_CFA_advance_loc4";
11864 case DW_CFA_offset_extended
:
11865 return "DW_CFA_offset_extended";
11866 case DW_CFA_restore_extended
:
11867 return "DW_CFA_restore_extended";
11868 case DW_CFA_undefined
:
11869 return "DW_CFA_undefined";
11870 case DW_CFA_same_value
:
11871 return "DW_CFA_same_value";
11872 case DW_CFA_register
:
11873 return "DW_CFA_register";
11874 case DW_CFA_remember_state
:
11875 return "DW_CFA_remember_state";
11876 case DW_CFA_restore_state
:
11877 return "DW_CFA_restore_state";
11878 case DW_CFA_def_cfa
:
11879 return "DW_CFA_def_cfa";
11880 case DW_CFA_def_cfa_register
:
11881 return "DW_CFA_def_cfa_register";
11882 case DW_CFA_def_cfa_offset
:
11883 return "DW_CFA_def_cfa_offset";
11885 case DW_CFA_def_cfa_expression
:
11886 return "DW_CFA_def_cfa_expression";
11887 case DW_CFA_expression
:
11888 return "DW_CFA_expression";
11889 case DW_CFA_offset_extended_sf
:
11890 return "DW_CFA_offset_extended_sf";
11891 case DW_CFA_def_cfa_sf
:
11892 return "DW_CFA_def_cfa_sf";
11893 case DW_CFA_def_cfa_offset_sf
:
11894 return "DW_CFA_def_cfa_offset_sf";
11895 case DW_CFA_val_offset
:
11896 return "DW_CFA_val_offset";
11897 case DW_CFA_val_offset_sf
:
11898 return "DW_CFA_val_offset_sf";
11899 case DW_CFA_val_expression
:
11900 return "DW_CFA_val_expression";
11901 /* SGI/MIPS specific. */
11902 case DW_CFA_MIPS_advance_loc8
:
11903 return "DW_CFA_MIPS_advance_loc8";
11904 /* GNU extensions. */
11905 case DW_CFA_GNU_window_save
:
11906 return "DW_CFA_GNU_window_save";
11907 case DW_CFA_GNU_args_size
:
11908 return "DW_CFA_GNU_args_size";
11909 case DW_CFA_GNU_negative_offset_extended
:
11910 return "DW_CFA_GNU_negative_offset_extended";
11912 return "DW_CFA_<unknown>";
11918 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
11922 print_spaces (indent
, f
);
11923 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
11924 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
11926 if (die
->parent
!= NULL
)
11928 print_spaces (indent
, f
);
11929 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
11930 die
->parent
->offset
);
11933 print_spaces (indent
, f
);
11934 fprintf_unfiltered (f
, " has children: %s\n",
11935 dwarf_bool_name (die
->child
!= NULL
));
11937 print_spaces (indent
, f
);
11938 fprintf_unfiltered (f
, " attributes:\n");
11940 for (i
= 0; i
< die
->num_attrs
; ++i
)
11942 print_spaces (indent
, f
);
11943 fprintf_unfiltered (f
, " %s (%s) ",
11944 dwarf_attr_name (die
->attrs
[i
].name
),
11945 dwarf_form_name (die
->attrs
[i
].form
));
11947 switch (die
->attrs
[i
].form
)
11949 case DW_FORM_ref_addr
:
11951 fprintf_unfiltered (f
, "address: ");
11952 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
11954 case DW_FORM_block2
:
11955 case DW_FORM_block4
:
11956 case DW_FORM_block
:
11957 case DW_FORM_block1
:
11958 fprintf_unfiltered (f
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
11960 case DW_FORM_exprloc
:
11961 fprintf_unfiltered (f
, "expression: size %u",
11962 DW_BLOCK (&die
->attrs
[i
])->size
);
11967 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
11968 (long) (DW_ADDR (&die
->attrs
[i
])));
11970 case DW_FORM_data1
:
11971 case DW_FORM_data2
:
11972 case DW_FORM_data4
:
11973 case DW_FORM_data8
:
11974 case DW_FORM_udata
:
11975 case DW_FORM_sdata
:
11976 fprintf_unfiltered (f
, "constant: %s",
11977 pulongest (DW_UNSND (&die
->attrs
[i
])));
11979 case DW_FORM_sec_offset
:
11980 fprintf_unfiltered (f
, "section offset: %s",
11981 pulongest (DW_UNSND (&die
->attrs
[i
])));
11984 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
11985 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
11986 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->offset
);
11988 fprintf_unfiltered (f
, "signatured type, offset: unknown");
11990 case DW_FORM_string
:
11992 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
11993 DW_STRING (&die
->attrs
[i
])
11994 ? DW_STRING (&die
->attrs
[i
]) : "",
11995 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
11998 if (DW_UNSND (&die
->attrs
[i
]))
11999 fprintf_unfiltered (f
, "flag: TRUE");
12001 fprintf_unfiltered (f
, "flag: FALSE");
12003 case DW_FORM_flag_present
:
12004 fprintf_unfiltered (f
, "flag: TRUE");
12006 case DW_FORM_indirect
:
12007 /* the reader will have reduced the indirect form to
12008 the "base form" so this form should not occur */
12009 fprintf_unfiltered (f
, "unexpected attribute form: DW_FORM_indirect");
12012 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
12013 die
->attrs
[i
].form
);
12016 fprintf_unfiltered (f
, "\n");
12021 dump_die_for_error (struct die_info
*die
)
12023 dump_die_shallow (gdb_stderr
, 0, die
);
12027 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
12029 int indent
= level
* 4;
12031 gdb_assert (die
!= NULL
);
12033 if (level
>= max_level
)
12036 dump_die_shallow (f
, indent
, die
);
12038 if (die
->child
!= NULL
)
12040 print_spaces (indent
, f
);
12041 fprintf_unfiltered (f
, " Children:");
12042 if (level
+ 1 < max_level
)
12044 fprintf_unfiltered (f
, "\n");
12045 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
12049 fprintf_unfiltered (f
, " [not printed, max nesting level reached]\n");
12053 if (die
->sibling
!= NULL
&& level
> 0)
12055 dump_die_1 (f
, level
, max_level
, die
->sibling
);
12059 /* This is called from the pdie macro in gdbinit.in.
12060 It's not static so gcc will keep a copy callable from gdb. */
12063 dump_die (struct die_info
*die
, int max_level
)
12065 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
12069 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
12073 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
12079 is_ref_attr (struct attribute
*attr
)
12081 switch (attr
->form
)
12083 case DW_FORM_ref_addr
:
12088 case DW_FORM_ref_udata
:
12095 static unsigned int
12096 dwarf2_get_ref_die_offset (struct attribute
*attr
)
12098 if (is_ref_attr (attr
))
12099 return DW_ADDR (attr
);
12101 complaint (&symfile_complaints
,
12102 _("unsupported die ref attribute form: '%s'"),
12103 dwarf_form_name (attr
->form
));
12107 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
12108 * the value held by the attribute is not constant. */
12111 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
12113 if (attr
->form
== DW_FORM_sdata
)
12114 return DW_SND (attr
);
12115 else if (attr
->form
== DW_FORM_udata
12116 || attr
->form
== DW_FORM_data1
12117 || attr
->form
== DW_FORM_data2
12118 || attr
->form
== DW_FORM_data4
12119 || attr
->form
== DW_FORM_data8
)
12120 return DW_UNSND (attr
);
12123 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
12124 dwarf_form_name (attr
->form
));
12125 return default_value
;
12129 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
12130 unit and add it to our queue.
12131 The result is non-zero if PER_CU was queued, otherwise the result is zero
12132 meaning either PER_CU is already queued or it is already loaded. */
12135 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
12136 struct dwarf2_per_cu_data
*per_cu
)
12138 /* Mark the dependence relation so that we don't flush PER_CU
12140 dwarf2_add_dependence (this_cu
, per_cu
);
12142 /* If it's already on the queue, we have nothing to do. */
12143 if (per_cu
->queued
)
12146 /* If the compilation unit is already loaded, just mark it as
12148 if (per_cu
->cu
!= NULL
)
12150 per_cu
->cu
->last_used
= 0;
12154 /* Add it to the queue. */
12155 queue_comp_unit (per_cu
, this_cu
->objfile
);
12160 /* Follow reference or signature attribute ATTR of SRC_DIE.
12161 On entry *REF_CU is the CU of SRC_DIE.
12162 On exit *REF_CU is the CU of the result. */
12164 static struct die_info
*
12165 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
12166 struct dwarf2_cu
**ref_cu
)
12168 struct die_info
*die
;
12170 if (is_ref_attr (attr
))
12171 die
= follow_die_ref (src_die
, attr
, ref_cu
);
12172 else if (attr
->form
== DW_FORM_sig8
)
12173 die
= follow_die_sig (src_die
, attr
, ref_cu
);
12176 dump_die_for_error (src_die
);
12177 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
12178 (*ref_cu
)->objfile
->name
);
12184 /* Follow reference OFFSET.
12185 On entry *REF_CU is the CU of source DIE referencing OFFSET.
12186 On exit *REF_CU is the CU of the result. */
12188 static struct die_info
*
12189 follow_die_offset (unsigned int offset
, struct dwarf2_cu
**ref_cu
)
12191 struct die_info temp_die
;
12192 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
12194 gdb_assert (cu
->per_cu
!= NULL
);
12196 if (cu
->per_cu
->from_debug_types
)
12198 /* .debug_types CUs cannot reference anything outside their CU.
12199 If they need to, they have to reference a signatured type via
12201 if (! offset_in_cu_p (&cu
->header
, offset
))
12205 else if (! offset_in_cu_p (&cu
->header
, offset
))
12207 struct dwarf2_per_cu_data
*per_cu
;
12209 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
12211 /* If necessary, add it to the queue and load its DIEs. */
12212 if (maybe_queue_comp_unit (cu
, per_cu
))
12213 load_full_comp_unit (per_cu
, cu
->objfile
);
12215 target_cu
= per_cu
->cu
;
12220 *ref_cu
= target_cu
;
12221 temp_die
.offset
= offset
;
12222 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
12225 /* Follow reference attribute ATTR of SRC_DIE.
12226 On entry *REF_CU is the CU of SRC_DIE.
12227 On exit *REF_CU is the CU of the result. */
12229 static struct die_info
*
12230 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
12231 struct dwarf2_cu
**ref_cu
)
12233 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
12234 struct dwarf2_cu
*cu
= *ref_cu
;
12235 struct die_info
*die
;
12237 die
= follow_die_offset (offset
, ref_cu
);
12239 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
12240 "at 0x%x [in module %s]"),
12241 offset
, src_die
->offset
, cu
->objfile
->name
);
12246 /* Return DWARF block and its CU referenced by OFFSET at PER_CU. Returned
12247 value is intended for DW_OP_call*. */
12249 struct dwarf2_locexpr_baton
12250 dwarf2_fetch_die_location_block (unsigned int offset
,
12251 struct dwarf2_per_cu_data
*per_cu
)
12253 struct dwarf2_cu
*cu
= per_cu
->cu
;
12254 struct die_info
*die
;
12255 struct attribute
*attr
;
12256 struct dwarf2_locexpr_baton retval
;
12258 die
= follow_die_offset (offset
, &cu
);
12260 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
12261 offset
, per_cu
->cu
->objfile
->name
);
12263 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
12266 /* DWARF: "If there is no such attribute, then there is no effect.". */
12268 retval
.data
= NULL
;
12273 if (!attr_form_is_block (attr
))
12274 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
12275 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
12276 offset
, per_cu
->cu
->objfile
->name
);
12278 retval
.data
= DW_BLOCK (attr
)->data
;
12279 retval
.size
= DW_BLOCK (attr
)->size
;
12281 retval
.per_cu
= cu
->per_cu
;
12285 /* Follow the signature attribute ATTR in SRC_DIE.
12286 On entry *REF_CU is the CU of SRC_DIE.
12287 On exit *REF_CU is the CU of the result. */
12289 static struct die_info
*
12290 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
12291 struct dwarf2_cu
**ref_cu
)
12293 struct objfile
*objfile
= (*ref_cu
)->objfile
;
12294 struct die_info temp_die
;
12295 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
12296 struct dwarf2_cu
*sig_cu
;
12297 struct die_info
*die
;
12299 /* sig_type will be NULL if the signatured type is missing from
12301 if (sig_type
== NULL
)
12302 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
12303 "at 0x%x [in module %s]"),
12304 src_die
->offset
, objfile
->name
);
12306 /* If necessary, add it to the queue and load its DIEs. */
12308 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
12309 read_signatured_type (objfile
, sig_type
);
12311 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
12313 sig_cu
= sig_type
->per_cu
.cu
;
12314 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
12315 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
12322 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced from DIE "
12323 "at 0x%x [in module %s]"),
12324 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
12327 /* Given an offset of a signatured type, return its signatured_type. */
12329 static struct signatured_type
*
12330 lookup_signatured_type_at_offset (struct objfile
*objfile
, unsigned int offset
)
12332 gdb_byte
*info_ptr
= dwarf2_per_objfile
->types
.buffer
+ offset
;
12333 unsigned int length
, initial_length_size
;
12334 unsigned int sig_offset
;
12335 struct signatured_type find_entry
, *type_sig
;
12337 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
12338 sig_offset
= (initial_length_size
12340 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
12341 + 1 /*address_size*/);
12342 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
12343 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
12345 /* This is only used to lookup previously recorded types.
12346 If we didn't find it, it's our bug. */
12347 gdb_assert (type_sig
!= NULL
);
12348 gdb_assert (offset
== type_sig
->offset
);
12353 /* Read in signatured type at OFFSET and build its CU and die(s). */
12356 read_signatured_type_at_offset (struct objfile
*objfile
,
12357 unsigned int offset
)
12359 struct signatured_type
*type_sig
;
12361 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
12363 /* We have the section offset, but we need the signature to do the
12364 hash table lookup. */
12365 type_sig
= lookup_signatured_type_at_offset (objfile
, offset
);
12367 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
12369 read_signatured_type (objfile
, type_sig
);
12371 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
12374 /* Read in a signatured type and build its CU and DIEs. */
12377 read_signatured_type (struct objfile
*objfile
,
12378 struct signatured_type
*type_sig
)
12380 gdb_byte
*types_ptr
;
12381 struct die_reader_specs reader_specs
;
12382 struct dwarf2_cu
*cu
;
12383 ULONGEST signature
;
12384 struct cleanup
*back_to
, *free_cu_cleanup
;
12385 struct attribute
*attr
;
12387 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
12388 types_ptr
= dwarf2_per_objfile
->types
.buffer
+ type_sig
->offset
;
12390 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
12392 cu
= xmalloc (sizeof (struct dwarf2_cu
));
12393 memset (cu
, 0, sizeof (struct dwarf2_cu
));
12394 obstack_init (&cu
->comp_unit_obstack
);
12395 cu
->objfile
= objfile
;
12396 type_sig
->per_cu
.cu
= cu
;
12397 cu
->per_cu
= &type_sig
->per_cu
;
12399 /* If an error occurs while loading, release our storage. */
12400 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
12402 types_ptr
= read_type_comp_unit_head (&cu
->header
, &signature
,
12403 types_ptr
, objfile
->obfd
);
12404 gdb_assert (signature
== type_sig
->signature
);
12407 = htab_create_alloc_ex (cu
->header
.length
/ 12,
12411 &cu
->comp_unit_obstack
,
12412 hashtab_obstack_allocate
,
12413 dummy_obstack_deallocate
);
12415 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
12416 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
12418 init_cu_die_reader (&reader_specs
, cu
);
12420 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
12423 /* We try not to read any attributes in this function, because not
12424 all objfiles needed for references have been loaded yet, and symbol
12425 table processing isn't initialized. But we have to set the CU language,
12426 or we won't be able to build types correctly. */
12427 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
12429 set_cu_language (DW_UNSND (attr
), cu
);
12431 set_cu_language (language_minimal
, cu
);
12433 do_cleanups (back_to
);
12435 /* We've successfully allocated this compilation unit. Let our caller
12436 clean it up when finished with it. */
12437 discard_cleanups (free_cu_cleanup
);
12439 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
12440 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
12443 /* Decode simple location descriptions.
12444 Given a pointer to a dwarf block that defines a location, compute
12445 the location and return the value.
12447 NOTE drow/2003-11-18: This function is called in two situations
12448 now: for the address of static or global variables (partial symbols
12449 only) and for offsets into structures which are expected to be
12450 (more or less) constant. The partial symbol case should go away,
12451 and only the constant case should remain. That will let this
12452 function complain more accurately. A few special modes are allowed
12453 without complaint for global variables (for instance, global
12454 register values and thread-local values).
12456 A location description containing no operations indicates that the
12457 object is optimized out. The return value is 0 for that case.
12458 FIXME drow/2003-11-16: No callers check for this case any more; soon all
12459 callers will only want a very basic result and this can become a
12462 Note that stack[0] is unused except as a default error return.
12463 Note that stack overflow is not yet handled. */
12466 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
12468 struct objfile
*objfile
= cu
->objfile
;
12470 int size
= blk
->size
;
12471 gdb_byte
*data
= blk
->data
;
12472 CORE_ADDR stack
[64];
12474 unsigned int bytes_read
, unsnd
;
12518 stack
[++stacki
] = op
- DW_OP_lit0
;
12553 stack
[++stacki
] = op
- DW_OP_reg0
;
12555 dwarf2_complex_location_expr_complaint ();
12559 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
12561 stack
[++stacki
] = unsnd
;
12563 dwarf2_complex_location_expr_complaint ();
12567 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
12572 case DW_OP_const1u
:
12573 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
12577 case DW_OP_const1s
:
12578 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
12582 case DW_OP_const2u
:
12583 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
12587 case DW_OP_const2s
:
12588 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
12592 case DW_OP_const4u
:
12593 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
12597 case DW_OP_const4s
:
12598 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
12603 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
12609 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
12614 stack
[stacki
+ 1] = stack
[stacki
];
12619 stack
[stacki
- 1] += stack
[stacki
];
12623 case DW_OP_plus_uconst
:
12624 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
12629 stack
[stacki
- 1] -= stack
[stacki
];
12634 /* If we're not the last op, then we definitely can't encode
12635 this using GDB's address_class enum. This is valid for partial
12636 global symbols, although the variable's address will be bogus
12639 dwarf2_complex_location_expr_complaint ();
12642 case DW_OP_GNU_push_tls_address
:
12643 /* The top of the stack has the offset from the beginning
12644 of the thread control block at which the variable is located. */
12645 /* Nothing should follow this operator, so the top of stack would
12647 /* This is valid for partial global symbols, but the variable's
12648 address will be bogus in the psymtab. */
12650 dwarf2_complex_location_expr_complaint ();
12653 case DW_OP_GNU_uninit
:
12657 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
12658 dwarf_stack_op_name (op
, 1));
12659 return (stack
[stacki
]);
12662 return (stack
[stacki
]);
12665 /* memory allocation interface */
12667 static struct dwarf_block
*
12668 dwarf_alloc_block (struct dwarf2_cu
*cu
)
12670 struct dwarf_block
*blk
;
12672 blk
= (struct dwarf_block
*)
12673 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
12677 static struct abbrev_info
*
12678 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
12680 struct abbrev_info
*abbrev
;
12682 abbrev
= (struct abbrev_info
*)
12683 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
12684 memset (abbrev
, 0, sizeof (struct abbrev_info
));
12688 static struct die_info
*
12689 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
12691 struct die_info
*die
;
12692 size_t size
= sizeof (struct die_info
);
12695 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
12697 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
12698 memset (die
, 0, sizeof (struct die_info
));
12703 /* Macro support. */
12706 /* Return the full name of file number I in *LH's file name table.
12707 Use COMP_DIR as the name of the current directory of the
12708 compilation. The result is allocated using xmalloc; the caller is
12709 responsible for freeing it. */
12711 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
12713 /* Is the file number a valid index into the line header's file name
12714 table? Remember that file numbers start with one, not zero. */
12715 if (1 <= file
&& file
<= lh
->num_file_names
)
12717 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
12719 if (IS_ABSOLUTE_PATH (fe
->name
))
12720 return xstrdup (fe
->name
);
12728 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
12734 dir_len
= strlen (dir
);
12735 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
12736 strcpy (full_name
, dir
);
12737 full_name
[dir_len
] = '/';
12738 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
12742 return xstrdup (fe
->name
);
12747 /* The compiler produced a bogus file number. We can at least
12748 record the macro definitions made in the file, even if we
12749 won't be able to find the file by name. */
12750 char fake_name
[80];
12752 sprintf (fake_name
, "<bad macro file number %d>", file
);
12754 complaint (&symfile_complaints
,
12755 _("bad file number in macro information (%d)"),
12758 return xstrdup (fake_name
);
12763 static struct macro_source_file
*
12764 macro_start_file (int file
, int line
,
12765 struct macro_source_file
*current_file
,
12766 const char *comp_dir
,
12767 struct line_header
*lh
, struct objfile
*objfile
)
12769 /* The full name of this source file. */
12770 char *full_name
= file_full_name (file
, lh
, comp_dir
);
12772 /* We don't create a macro table for this compilation unit
12773 at all until we actually get a filename. */
12774 if (! pending_macros
)
12775 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
12776 objfile
->macro_cache
);
12778 if (! current_file
)
12779 /* If we have no current file, then this must be the start_file
12780 directive for the compilation unit's main source file. */
12781 current_file
= macro_set_main (pending_macros
, full_name
);
12783 current_file
= macro_include (current_file
, line
, full_name
);
12787 return current_file
;
12791 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
12792 followed by a null byte. */
12794 copy_string (const char *buf
, int len
)
12796 char *s
= xmalloc (len
+ 1);
12798 memcpy (s
, buf
, len
);
12804 static const char *
12805 consume_improper_spaces (const char *p
, const char *body
)
12809 complaint (&symfile_complaints
,
12810 _("macro definition contains spaces in formal argument list:\n`%s'"),
12822 parse_macro_definition (struct macro_source_file
*file
, int line
,
12827 /* The body string takes one of two forms. For object-like macro
12828 definitions, it should be:
12830 <macro name> " " <definition>
12832 For function-like macro definitions, it should be:
12834 <macro name> "() " <definition>
12836 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
12838 Spaces may appear only where explicitly indicated, and in the
12841 The Dwarf 2 spec says that an object-like macro's name is always
12842 followed by a space, but versions of GCC around March 2002 omit
12843 the space when the macro's definition is the empty string.
12845 The Dwarf 2 spec says that there should be no spaces between the
12846 formal arguments in a function-like macro's formal argument list,
12847 but versions of GCC around March 2002 include spaces after the
12851 /* Find the extent of the macro name. The macro name is terminated
12852 by either a space or null character (for an object-like macro) or
12853 an opening paren (for a function-like macro). */
12854 for (p
= body
; *p
; p
++)
12855 if (*p
== ' ' || *p
== '(')
12858 if (*p
== ' ' || *p
== '\0')
12860 /* It's an object-like macro. */
12861 int name_len
= p
- body
;
12862 char *name
= copy_string (body
, name_len
);
12863 const char *replacement
;
12866 replacement
= body
+ name_len
+ 1;
12869 dwarf2_macro_malformed_definition_complaint (body
);
12870 replacement
= body
+ name_len
;
12873 macro_define_object (file
, line
, name
, replacement
);
12877 else if (*p
== '(')
12879 /* It's a function-like macro. */
12880 char *name
= copy_string (body
, p
- body
);
12883 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
12887 p
= consume_improper_spaces (p
, body
);
12889 /* Parse the formal argument list. */
12890 while (*p
&& *p
!= ')')
12892 /* Find the extent of the current argument name. */
12893 const char *arg_start
= p
;
12895 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
12898 if (! *p
|| p
== arg_start
)
12899 dwarf2_macro_malformed_definition_complaint (body
);
12902 /* Make sure argv has room for the new argument. */
12903 if (argc
>= argv_size
)
12906 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
12909 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
12912 p
= consume_improper_spaces (p
, body
);
12914 /* Consume the comma, if present. */
12919 p
= consume_improper_spaces (p
, body
);
12928 /* Perfectly formed definition, no complaints. */
12929 macro_define_function (file
, line
, name
,
12930 argc
, (const char **) argv
,
12932 else if (*p
== '\0')
12934 /* Complain, but do define it. */
12935 dwarf2_macro_malformed_definition_complaint (body
);
12936 macro_define_function (file
, line
, name
,
12937 argc
, (const char **) argv
,
12941 /* Just complain. */
12942 dwarf2_macro_malformed_definition_complaint (body
);
12945 /* Just complain. */
12946 dwarf2_macro_malformed_definition_complaint (body
);
12952 for (i
= 0; i
< argc
; i
++)
12958 dwarf2_macro_malformed_definition_complaint (body
);
12963 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
12964 char *comp_dir
, bfd
*abfd
,
12965 struct dwarf2_cu
*cu
)
12967 gdb_byte
*mac_ptr
, *mac_end
;
12968 struct macro_source_file
*current_file
= 0;
12969 enum dwarf_macinfo_record_type macinfo_type
;
12970 int at_commandline
;
12972 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
12973 &dwarf2_per_objfile
->macinfo
);
12974 if (dwarf2_per_objfile
->macinfo
.buffer
== NULL
)
12976 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
12980 /* First pass: Find the name of the base filename.
12981 This filename is needed in order to process all macros whose definition
12982 (or undefinition) comes from the command line. These macros are defined
12983 before the first DW_MACINFO_start_file entry, and yet still need to be
12984 associated to the base file.
12986 To determine the base file name, we scan the macro definitions until we
12987 reach the first DW_MACINFO_start_file entry. We then initialize
12988 CURRENT_FILE accordingly so that any macro definition found before the
12989 first DW_MACINFO_start_file can still be associated to the base file. */
12991 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
12992 mac_end
= dwarf2_per_objfile
->macinfo
.buffer
12993 + dwarf2_per_objfile
->macinfo
.size
;
12997 /* Do we at least have room for a macinfo type byte? */
12998 if (mac_ptr
>= mac_end
)
13000 /* Complaint is printed during the second pass as GDB will probably
13001 stop the first pass earlier upon finding DW_MACINFO_start_file. */
13005 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
13008 switch (macinfo_type
)
13010 /* A zero macinfo type indicates the end of the macro
13015 case DW_MACINFO_define
:
13016 case DW_MACINFO_undef
:
13017 /* Only skip the data by MAC_PTR. */
13019 unsigned int bytes_read
;
13021 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13022 mac_ptr
+= bytes_read
;
13023 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13024 mac_ptr
+= bytes_read
;
13028 case DW_MACINFO_start_file
:
13030 unsigned int bytes_read
;
13033 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13034 mac_ptr
+= bytes_read
;
13035 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13036 mac_ptr
+= bytes_read
;
13038 current_file
= macro_start_file (file
, line
, current_file
, comp_dir
,
13043 case DW_MACINFO_end_file
:
13044 /* No data to skip by MAC_PTR. */
13047 case DW_MACINFO_vendor_ext
:
13048 /* Only skip the data by MAC_PTR. */
13050 unsigned int bytes_read
;
13052 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13053 mac_ptr
+= bytes_read
;
13054 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13055 mac_ptr
+= bytes_read
;
13062 } while (macinfo_type
!= 0 && current_file
== NULL
);
13064 /* Second pass: Process all entries.
13066 Use the AT_COMMAND_LINE flag to determine whether we are still processing
13067 command-line macro definitions/undefinitions. This flag is unset when we
13068 reach the first DW_MACINFO_start_file entry. */
13070 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
13072 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
13073 GDB is still reading the definitions from command line. First
13074 DW_MACINFO_start_file will need to be ignored as it was already executed
13075 to create CURRENT_FILE for the main source holding also the command line
13076 definitions. On first met DW_MACINFO_start_file this flag is reset to
13077 normally execute all the remaining DW_MACINFO_start_file macinfos. */
13079 at_commandline
= 1;
13083 /* Do we at least have room for a macinfo type byte? */
13084 if (mac_ptr
>= mac_end
)
13086 dwarf2_macros_too_long_complaint ();
13090 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
13093 switch (macinfo_type
)
13095 /* A zero macinfo type indicates the end of the macro
13100 case DW_MACINFO_define
:
13101 case DW_MACINFO_undef
:
13103 unsigned int bytes_read
;
13107 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13108 mac_ptr
+= bytes_read
;
13109 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13110 mac_ptr
+= bytes_read
;
13112 if (! current_file
)
13114 /* DWARF violation as no main source is present. */
13115 complaint (&symfile_complaints
,
13116 _("debug info with no main source gives macro %s "
13118 macinfo_type
== DW_MACINFO_define
?
13120 macinfo_type
== DW_MACINFO_undef
?
13121 _("undefinition") :
13122 _("something-or-other"), line
, body
);
13125 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
13126 complaint (&symfile_complaints
,
13127 _("debug info gives %s macro %s with %s line %d: %s"),
13128 at_commandline
? _("command-line") : _("in-file"),
13129 macinfo_type
== DW_MACINFO_define
?
13131 macinfo_type
== DW_MACINFO_undef
?
13132 _("undefinition") :
13133 _("something-or-other"),
13134 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
13136 if (macinfo_type
== DW_MACINFO_define
)
13137 parse_macro_definition (current_file
, line
, body
);
13138 else if (macinfo_type
== DW_MACINFO_undef
)
13139 macro_undef (current_file
, line
, body
);
13143 case DW_MACINFO_start_file
:
13145 unsigned int bytes_read
;
13148 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13149 mac_ptr
+= bytes_read
;
13150 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13151 mac_ptr
+= bytes_read
;
13153 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
13154 complaint (&symfile_complaints
,
13155 _("debug info gives source %d included "
13156 "from %s at %s line %d"),
13157 file
, at_commandline
? _("command-line") : _("file"),
13158 line
== 0 ? _("zero") : _("non-zero"), line
);
13160 if (at_commandline
)
13162 /* This DW_MACINFO_start_file was executed in the pass one. */
13163 at_commandline
= 0;
13166 current_file
= macro_start_file (file
, line
,
13167 current_file
, comp_dir
,
13172 case DW_MACINFO_end_file
:
13173 if (! current_file
)
13174 complaint (&symfile_complaints
,
13175 _("macro debug info has an unmatched `close_file' directive"));
13178 current_file
= current_file
->included_by
;
13179 if (! current_file
)
13181 enum dwarf_macinfo_record_type next_type
;
13183 /* GCC circa March 2002 doesn't produce the zero
13184 type byte marking the end of the compilation
13185 unit. Complain if it's not there, but exit no
13188 /* Do we at least have room for a macinfo type byte? */
13189 if (mac_ptr
>= mac_end
)
13191 dwarf2_macros_too_long_complaint ();
13195 /* We don't increment mac_ptr here, so this is just
13197 next_type
= read_1_byte (abfd
, mac_ptr
);
13198 if (next_type
!= 0)
13199 complaint (&symfile_complaints
,
13200 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
13207 case DW_MACINFO_vendor_ext
:
13209 unsigned int bytes_read
;
13213 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
13214 mac_ptr
+= bytes_read
;
13215 string
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
13216 mac_ptr
+= bytes_read
;
13218 /* We don't recognize any vendor extensions. */
13222 } while (macinfo_type
!= 0);
13225 /* Check if the attribute's form is a DW_FORM_block*
13226 if so return true else false. */
13228 attr_form_is_block (struct attribute
*attr
)
13230 return (attr
== NULL
? 0 :
13231 attr
->form
== DW_FORM_block1
13232 || attr
->form
== DW_FORM_block2
13233 || attr
->form
== DW_FORM_block4
13234 || attr
->form
== DW_FORM_block
13235 || attr
->form
== DW_FORM_exprloc
);
13238 /* Return non-zero if ATTR's value is a section offset --- classes
13239 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
13240 You may use DW_UNSND (attr) to retrieve such offsets.
13242 Section 7.5.4, "Attribute Encodings", explains that no attribute
13243 may have a value that belongs to more than one of these classes; it
13244 would be ambiguous if we did, because we use the same forms for all
13247 attr_form_is_section_offset (struct attribute
*attr
)
13249 return (attr
->form
== DW_FORM_data4
13250 || attr
->form
== DW_FORM_data8
13251 || attr
->form
== DW_FORM_sec_offset
);
13255 /* Return non-zero if ATTR's value falls in the 'constant' class, or
13256 zero otherwise. When this function returns true, you can apply
13257 dwarf2_get_attr_constant_value to it.
13259 However, note that for some attributes you must check
13260 attr_form_is_section_offset before using this test. DW_FORM_data4
13261 and DW_FORM_data8 are members of both the constant class, and of
13262 the classes that contain offsets into other debug sections
13263 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
13264 that, if an attribute's can be either a constant or one of the
13265 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
13266 taken as section offsets, not constants. */
13268 attr_form_is_constant (struct attribute
*attr
)
13270 switch (attr
->form
)
13272 case DW_FORM_sdata
:
13273 case DW_FORM_udata
:
13274 case DW_FORM_data1
:
13275 case DW_FORM_data2
:
13276 case DW_FORM_data4
:
13277 case DW_FORM_data8
:
13285 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
13286 struct dwarf2_cu
*cu
)
13288 if (attr_form_is_section_offset (attr
)
13289 /* ".debug_loc" may not exist at all, or the offset may be outside
13290 the section. If so, fall through to the complaint in the
13292 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc
.size
)
13294 struct dwarf2_loclist_baton
*baton
;
13296 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
13297 sizeof (struct dwarf2_loclist_baton
));
13298 baton
->per_cu
= cu
->per_cu
;
13299 gdb_assert (baton
->per_cu
);
13301 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
13302 &dwarf2_per_objfile
->loc
);
13304 /* We don't know how long the location list is, but make sure we
13305 don't run off the edge of the section. */
13306 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
13307 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
13308 baton
->base_address
= cu
->base_address
;
13309 if (cu
->base_known
== 0)
13310 complaint (&symfile_complaints
,
13311 _("Location list used without specifying the CU base address."));
13313 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
13314 SYMBOL_LOCATION_BATON (sym
) = baton
;
13318 struct dwarf2_locexpr_baton
*baton
;
13320 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
13321 sizeof (struct dwarf2_locexpr_baton
));
13322 baton
->per_cu
= cu
->per_cu
;
13323 gdb_assert (baton
->per_cu
);
13325 if (attr_form_is_block (attr
))
13327 /* Note that we're just copying the block's data pointer
13328 here, not the actual data. We're still pointing into the
13329 info_buffer for SYM's objfile; right now we never release
13330 that buffer, but when we do clean up properly this may
13332 baton
->size
= DW_BLOCK (attr
)->size
;
13333 baton
->data
= DW_BLOCK (attr
)->data
;
13337 dwarf2_invalid_attrib_class_complaint ("location description",
13338 SYMBOL_NATURAL_NAME (sym
));
13340 baton
->data
= NULL
;
13343 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
13344 SYMBOL_LOCATION_BATON (sym
) = baton
;
13348 /* Return the OBJFILE associated with the compilation unit CU. If CU
13349 came from a separate debuginfo file, then the master objfile is
13353 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
13355 struct objfile
*objfile
= per_cu
->objfile
;
13357 /* Return the master objfile, so that we can report and look up the
13358 correct file containing this variable. */
13359 if (objfile
->separate_debug_objfile_backlink
)
13360 objfile
= objfile
->separate_debug_objfile_backlink
;
13365 /* Return the address size given in the compilation unit header for CU. */
13368 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
13371 return per_cu
->cu
->header
.addr_size
;
13374 /* If the CU is not currently read in, we re-read its header. */
13375 struct objfile
*objfile
= per_cu
->objfile
;
13376 struct dwarf2_per_objfile
*per_objfile
13377 = objfile_data (objfile
, dwarf2_objfile_data_key
);
13378 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
13379 struct comp_unit_head cu_header
;
13381 memset (&cu_header
, 0, sizeof cu_header
);
13382 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
13383 return cu_header
.addr_size
;
13387 /* Return the offset size given in the compilation unit header for CU. */
13390 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
13393 return per_cu
->cu
->header
.offset_size
;
13396 /* If the CU is not currently read in, we re-read its header. */
13397 struct objfile
*objfile
= per_cu
->objfile
;
13398 struct dwarf2_per_objfile
*per_objfile
13399 = objfile_data (objfile
, dwarf2_objfile_data_key
);
13400 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
13401 struct comp_unit_head cu_header
;
13403 memset (&cu_header
, 0, sizeof cu_header
);
13404 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
13405 return cu_header
.offset_size
;
13409 /* Return the text offset of the CU. The returned offset comes from
13410 this CU's objfile. If this objfile came from a separate debuginfo
13411 file, then the offset may be different from the corresponding
13412 offset in the parent objfile. */
13415 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
13417 struct objfile
*objfile
= per_cu
->objfile
;
13419 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13422 /* Locate the .debug_info compilation unit from CU's objfile which contains
13423 the DIE at OFFSET. Raises an error on failure. */
13425 static struct dwarf2_per_cu_data
*
13426 dwarf2_find_containing_comp_unit (unsigned int offset
,
13427 struct objfile
*objfile
)
13429 struct dwarf2_per_cu_data
*this_cu
;
13433 high
= dwarf2_per_objfile
->n_comp_units
- 1;
13436 int mid
= low
+ (high
- low
) / 2;
13438 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
13443 gdb_assert (low
== high
);
13444 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
13447 error (_("Dwarf Error: could not find partial DIE containing "
13448 "offset 0x%lx [in module %s]"),
13449 (long) offset
, bfd_get_filename (objfile
->obfd
));
13451 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
13452 return dwarf2_per_objfile
->all_comp_units
[low
-1];
13456 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
13457 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
13458 && offset
>= this_cu
->offset
+ this_cu
->length
)
13459 error (_("invalid dwarf2 offset %u"), offset
);
13460 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
13465 /* Locate the compilation unit from OBJFILE which is located at exactly
13466 OFFSET. Raises an error on failure. */
13468 static struct dwarf2_per_cu_data
*
13469 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
13471 struct dwarf2_per_cu_data
*this_cu
;
13473 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
13474 if (this_cu
->offset
!= offset
)
13475 error (_("no compilation unit with offset %u."), offset
);
13479 /* Malloc space for a dwarf2_cu for OBJFILE and initialize it. */
13481 static struct dwarf2_cu
*
13482 alloc_one_comp_unit (struct objfile
*objfile
)
13484 struct dwarf2_cu
*cu
= xcalloc (1, sizeof (struct dwarf2_cu
));
13485 cu
->objfile
= objfile
;
13486 obstack_init (&cu
->comp_unit_obstack
);
13490 /* Release one cached compilation unit, CU. We unlink it from the tree
13491 of compilation units, but we don't remove it from the read_in_chain;
13492 the caller is responsible for that.
13493 NOTE: DATA is a void * because this function is also used as a
13494 cleanup routine. */
13497 free_one_comp_unit (void *data
)
13499 struct dwarf2_cu
*cu
= data
;
13501 if (cu
->per_cu
!= NULL
)
13502 cu
->per_cu
->cu
= NULL
;
13505 obstack_free (&cu
->comp_unit_obstack
, NULL
);
13510 /* This cleanup function is passed the address of a dwarf2_cu on the stack
13511 when we're finished with it. We can't free the pointer itself, but be
13512 sure to unlink it from the cache. Also release any associated storage
13513 and perform cache maintenance.
13515 Only used during partial symbol parsing. */
13518 free_stack_comp_unit (void *data
)
13520 struct dwarf2_cu
*cu
= data
;
13522 obstack_free (&cu
->comp_unit_obstack
, NULL
);
13523 cu
->partial_dies
= NULL
;
13525 if (cu
->per_cu
!= NULL
)
13527 /* This compilation unit is on the stack in our caller, so we
13528 should not xfree it. Just unlink it. */
13529 cu
->per_cu
->cu
= NULL
;
13532 /* If we had a per-cu pointer, then we may have other compilation
13533 units loaded, so age them now. */
13534 age_cached_comp_units ();
13538 /* Free all cached compilation units. */
13541 free_cached_comp_units (void *data
)
13543 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
13545 per_cu
= dwarf2_per_objfile
->read_in_chain
;
13546 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
13547 while (per_cu
!= NULL
)
13549 struct dwarf2_per_cu_data
*next_cu
;
13551 next_cu
= per_cu
->cu
->read_in_chain
;
13553 free_one_comp_unit (per_cu
->cu
);
13554 *last_chain
= next_cu
;
13560 /* Increase the age counter on each cached compilation unit, and free
13561 any that are too old. */
13564 age_cached_comp_units (void)
13566 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
13568 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
13569 per_cu
= dwarf2_per_objfile
->read_in_chain
;
13570 while (per_cu
!= NULL
)
13572 per_cu
->cu
->last_used
++;
13573 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
13574 dwarf2_mark (per_cu
->cu
);
13575 per_cu
= per_cu
->cu
->read_in_chain
;
13578 per_cu
= dwarf2_per_objfile
->read_in_chain
;
13579 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
13580 while (per_cu
!= NULL
)
13582 struct dwarf2_per_cu_data
*next_cu
;
13584 next_cu
= per_cu
->cu
->read_in_chain
;
13586 if (!per_cu
->cu
->mark
)
13588 free_one_comp_unit (per_cu
->cu
);
13589 *last_chain
= next_cu
;
13592 last_chain
= &per_cu
->cu
->read_in_chain
;
13598 /* Remove a single compilation unit from the cache. */
13601 free_one_cached_comp_unit (void *target_cu
)
13603 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
13605 per_cu
= dwarf2_per_objfile
->read_in_chain
;
13606 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
13607 while (per_cu
!= NULL
)
13609 struct dwarf2_per_cu_data
*next_cu
;
13611 next_cu
= per_cu
->cu
->read_in_chain
;
13613 if (per_cu
->cu
== target_cu
)
13615 free_one_comp_unit (per_cu
->cu
);
13616 *last_chain
= next_cu
;
13620 last_chain
= &per_cu
->cu
->read_in_chain
;
13626 /* Release all extra memory associated with OBJFILE. */
13629 dwarf2_free_objfile (struct objfile
*objfile
)
13631 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
13633 if (dwarf2_per_objfile
== NULL
)
13636 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
13637 free_cached_comp_units (NULL
);
13639 if (dwarf2_per_objfile
->using_index
)
13643 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
13646 struct dwarf2_per_cu_data
*cu
= dwarf2_per_objfile
->all_comp_units
[i
];
13648 if (!cu
->v
.quick
->lines
)
13651 for (j
= 0; j
< cu
->v
.quick
->lines
->num_file_names
; ++j
)
13653 if (cu
->v
.quick
->file_names
)
13654 xfree ((void *) cu
->v
.quick
->file_names
[j
]);
13655 if (cu
->v
.quick
->full_names
)
13656 xfree ((void *) cu
->v
.quick
->full_names
[j
]);
13659 free_line_header (cu
->v
.quick
->lines
);
13663 /* Everything else should be on the objfile obstack. */
13666 /* A pair of DIE offset and GDB type pointer. We store these
13667 in a hash table separate from the DIEs, and preserve them
13668 when the DIEs are flushed out of cache. */
13670 struct dwarf2_offset_and_type
13672 unsigned int offset
;
13676 /* Hash function for a dwarf2_offset_and_type. */
13679 offset_and_type_hash (const void *item
)
13681 const struct dwarf2_offset_and_type
*ofs
= item
;
13683 return ofs
->offset
;
13686 /* Equality function for a dwarf2_offset_and_type. */
13689 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
13691 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
13692 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
13694 return ofs_lhs
->offset
== ofs_rhs
->offset
;
13697 /* Set the type associated with DIE to TYPE. Save it in CU's hash
13698 table if necessary. For convenience, return TYPE.
13700 The DIEs reading must have careful ordering to:
13701 * Not cause infite loops trying to read in DIEs as a prerequisite for
13702 reading current DIE.
13703 * Not trying to dereference contents of still incompletely read in types
13704 while reading in other DIEs.
13705 * Enable referencing still incompletely read in types just by a pointer to
13706 the type without accessing its fields.
13708 Therefore caller should follow these rules:
13709 * Try to fetch any prerequisite types we may need to build this DIE type
13710 before building the type and calling set_die_type.
13711 * After building typer call set_die_type for current DIE as soon as
13712 possible before fetching more types to complete the current type.
13713 * Make the type as complete as possible before fetching more types. */
13715 static struct type
*
13716 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
13718 struct dwarf2_offset_and_type
**slot
, ofs
;
13720 /* For Ada types, make sure that the gnat-specific data is always
13721 initialized (if not already set). There are a few types where
13722 we should not be doing so, because the type-specific area is
13723 already used to hold some other piece of info (eg: TYPE_CODE_FLT
13724 where the type-specific area is used to store the floatformat).
13725 But this is not a problem, because the gnat-specific information
13726 is actually not needed for these types. */
13727 if (need_gnat_info (cu
)
13728 && TYPE_CODE (type
) != TYPE_CODE_FUNC
13729 && TYPE_CODE (type
) != TYPE_CODE_FLT
13730 && !HAVE_GNAT_AUX_INFO (type
))
13731 INIT_GNAT_SPECIFIC (type
);
13733 if (cu
->type_hash
== NULL
)
13735 gdb_assert (cu
->per_cu
!= NULL
);
13736 cu
->per_cu
->type_hash
13737 = htab_create_alloc_ex (cu
->header
.length
/ 24,
13738 offset_and_type_hash
,
13739 offset_and_type_eq
,
13741 &cu
->objfile
->objfile_obstack
,
13742 hashtab_obstack_allocate
,
13743 dummy_obstack_deallocate
);
13744 cu
->type_hash
= cu
->per_cu
->type_hash
;
13747 ofs
.offset
= die
->offset
;
13749 slot
= (struct dwarf2_offset_and_type
**)
13750 htab_find_slot_with_hash (cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
13752 complaint (&symfile_complaints
,
13753 _("A problem internal to GDB: DIE 0x%x has type already set"),
13755 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
13760 /* Find the type for DIE in CU's type_hash, or return NULL if DIE does
13761 not have a saved type. */
13763 static struct type
*
13764 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13766 struct dwarf2_offset_and_type
*slot
, ofs
;
13767 htab_t type_hash
= cu
->type_hash
;
13769 if (type_hash
== NULL
)
13772 ofs
.offset
= die
->offset
;
13773 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
13780 /* Add a dependence relationship from CU to REF_PER_CU. */
13783 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
13784 struct dwarf2_per_cu_data
*ref_per_cu
)
13788 if (cu
->dependencies
== NULL
)
13790 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
13791 NULL
, &cu
->comp_unit_obstack
,
13792 hashtab_obstack_allocate
,
13793 dummy_obstack_deallocate
);
13795 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
13797 *slot
= ref_per_cu
;
13800 /* Subroutine of dwarf2_mark to pass to htab_traverse.
13801 Set the mark field in every compilation unit in the
13802 cache that we must keep because we are keeping CU. */
13805 dwarf2_mark_helper (void **slot
, void *data
)
13807 struct dwarf2_per_cu_data
*per_cu
;
13809 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
13810 if (per_cu
->cu
->mark
)
13812 per_cu
->cu
->mark
= 1;
13814 if (per_cu
->cu
->dependencies
!= NULL
)
13815 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
13820 /* Set the mark field in CU and in every other compilation unit in the
13821 cache that we must keep because we are keeping CU. */
13824 dwarf2_mark (struct dwarf2_cu
*cu
)
13829 if (cu
->dependencies
!= NULL
)
13830 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
13834 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
13838 per_cu
->cu
->mark
= 0;
13839 per_cu
= per_cu
->cu
->read_in_chain
;
13843 /* Trivial hash function for partial_die_info: the hash value of a DIE
13844 is its offset in .debug_info for this objfile. */
13847 partial_die_hash (const void *item
)
13849 const struct partial_die_info
*part_die
= item
;
13851 return part_die
->offset
;
13854 /* Trivial comparison function for partial_die_info structures: two DIEs
13855 are equal if they have the same offset. */
13858 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
13860 const struct partial_die_info
*part_die_lhs
= item_lhs
;
13861 const struct partial_die_info
*part_die_rhs
= item_rhs
;
13863 return part_die_lhs
->offset
== part_die_rhs
->offset
;
13866 static struct cmd_list_element
*set_dwarf2_cmdlist
;
13867 static struct cmd_list_element
*show_dwarf2_cmdlist
;
13870 set_dwarf2_cmd (char *args
, int from_tty
)
13872 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
13876 show_dwarf2_cmd (char *args
, int from_tty
)
13878 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
13881 /* If section described by INFO was mmapped, munmap it now. */
13884 munmap_section_buffer (struct dwarf2_section_info
*info
)
13886 if (info
->was_mmapped
)
13889 intptr_t begin
= (intptr_t) info
->buffer
;
13890 intptr_t map_begin
= begin
& ~(pagesize
- 1);
13891 size_t map_length
= info
->size
+ begin
- map_begin
;
13893 gdb_assert (munmap ((void *) map_begin
, map_length
) == 0);
13895 /* Without HAVE_MMAP, we should never be here to begin with. */
13901 /* munmap debug sections for OBJFILE, if necessary. */
13904 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
13906 struct dwarf2_per_objfile
*data
= d
;
13908 munmap_section_buffer (&data
->info
);
13909 munmap_section_buffer (&data
->abbrev
);
13910 munmap_section_buffer (&data
->line
);
13911 munmap_section_buffer (&data
->str
);
13912 munmap_section_buffer (&data
->macinfo
);
13913 munmap_section_buffer (&data
->ranges
);
13914 munmap_section_buffer (&data
->loc
);
13915 munmap_section_buffer (&data
->frame
);
13916 munmap_section_buffer (&data
->eh_frame
);
13917 munmap_section_buffer (&data
->gdb_index
);
13922 /* The contents of the hash table we create when building the string
13924 struct strtab_entry
13926 offset_type offset
;
13930 /* Hash function for a strtab_entry. */
13932 hash_strtab_entry (const void *e
)
13934 const struct strtab_entry
*entry
= e
;
13935 return mapped_index_string_hash (entry
->str
);
13938 /* Equality function for a strtab_entry. */
13940 eq_strtab_entry (const void *a
, const void *b
)
13942 const struct strtab_entry
*ea
= a
;
13943 const struct strtab_entry
*eb
= b
;
13944 return !strcmp (ea
->str
, eb
->str
);
13947 /* Create a strtab_entry hash table. */
13949 create_strtab (void)
13951 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
13952 xfree
, xcalloc
, xfree
);
13955 /* Add a string to the constant pool. Return the string's offset in
13958 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
13961 struct strtab_entry entry
;
13962 struct strtab_entry
*result
;
13965 slot
= htab_find_slot (table
, &entry
, INSERT
);
13970 result
= XNEW (struct strtab_entry
);
13971 result
->offset
= obstack_object_size (cpool
);
13973 obstack_grow_str0 (cpool
, str
);
13976 return result
->offset
;
13979 /* An entry in the symbol table. */
13980 struct symtab_index_entry
13982 /* The name of the symbol. */
13984 /* The offset of the name in the constant pool. */
13985 offset_type index_offset
;
13986 /* A sorted vector of the indices of all the CUs that hold an object
13988 VEC (offset_type
) *cu_indices
;
13991 /* The symbol table. This is a power-of-2-sized hash table. */
13992 struct mapped_symtab
13994 offset_type n_elements
;
13996 struct symtab_index_entry
**data
;
13999 /* Hash function for a symtab_index_entry. */
14001 hash_symtab_entry (const void *e
)
14003 const struct symtab_index_entry
*entry
= e
;
14004 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
14005 sizeof (offset_type
) * VEC_length (offset_type
,
14006 entry
->cu_indices
),
14010 /* Equality function for a symtab_index_entry. */
14012 eq_symtab_entry (const void *a
, const void *b
)
14014 const struct symtab_index_entry
*ea
= a
;
14015 const struct symtab_index_entry
*eb
= b
;
14016 int len
= VEC_length (offset_type
, ea
->cu_indices
);
14017 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
14019 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
14020 VEC_address (offset_type
, eb
->cu_indices
),
14021 sizeof (offset_type
) * len
);
14024 /* Destroy a symtab_index_entry. */
14026 delete_symtab_entry (void *p
)
14028 struct symtab_index_entry
*entry
= p
;
14029 VEC_free (offset_type
, entry
->cu_indices
);
14033 /* Create a hash table holding symtab_index_entry objects. */
14035 create_index_table (void)
14037 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
14038 delete_symtab_entry
, xcalloc
, xfree
);
14041 /* Create a new mapped symtab object. */
14042 static struct mapped_symtab
*
14043 create_mapped_symtab (void)
14045 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
14046 symtab
->n_elements
= 0;
14047 symtab
->size
= 1024;
14048 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
14052 /* Destroy a mapped_symtab. */
14054 cleanup_mapped_symtab (void *p
)
14056 struct mapped_symtab
*symtab
= p
;
14057 /* The contents of the array are freed when the other hash table is
14059 xfree (symtab
->data
);
14063 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
14065 static struct symtab_index_entry
**
14066 find_slot (struct mapped_symtab
*symtab
, const char *name
)
14068 offset_type index
, step
, hash
= mapped_index_string_hash (name
);
14070 index
= hash
& (symtab
->size
- 1);
14071 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
14075 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
14076 return &symtab
->data
[index
];
14077 index
= (index
+ step
) & (symtab
->size
- 1);
14081 /* Expand SYMTAB's hash table. */
14083 hash_expand (struct mapped_symtab
*symtab
)
14085 offset_type old_size
= symtab
->size
;
14087 struct symtab_index_entry
**old_entries
= symtab
->data
;
14090 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
14092 for (i
= 0; i
< old_size
; ++i
)
14094 if (old_entries
[i
])
14096 struct symtab_index_entry
**slot
= find_slot (symtab
,
14097 old_entries
[i
]->name
);
14098 *slot
= old_entries
[i
];
14102 xfree (old_entries
);
14105 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
14106 is the index of the CU in which the symbol appears. */
14108 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
14109 offset_type cu_index
)
14111 struct symtab_index_entry
**slot
;
14113 ++symtab
->n_elements
;
14114 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
14115 hash_expand (symtab
);
14117 slot
= find_slot (symtab
, name
);
14120 *slot
= XNEW (struct symtab_index_entry
);
14121 (*slot
)->name
= name
;
14122 (*slot
)->cu_indices
= NULL
;
14124 /* Don't push an index twice. Due to how we add entries we only
14125 have to check the last one. */
14126 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
14127 || VEC_length (offset_type
, (*slot
)->cu_indices
) != cu_index
)
14128 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
14131 /* Add a vector of indices to the constant pool. */
14133 add_indices_to_cpool (htab_t index_table
, struct obstack
*cpool
,
14134 struct symtab_index_entry
*entry
)
14138 slot
= htab_find_slot (index_table
, entry
, INSERT
);
14141 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
14142 offset_type val
= MAYBE_SWAP (len
);
14147 entry
->index_offset
= obstack_object_size (cpool
);
14149 obstack_grow (cpool
, &val
, sizeof (val
));
14151 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
14154 val
= MAYBE_SWAP (iter
);
14155 obstack_grow (cpool
, &val
, sizeof (val
));
14160 struct symtab_index_entry
*old_entry
= *slot
;
14161 entry
->index_offset
= old_entry
->index_offset
;
14164 return entry
->index_offset
;
14167 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
14168 constant pool entries going into the obstack CPOOL. */
14170 write_hash_table (struct mapped_symtab
*symtab
,
14171 struct obstack
*output
, struct obstack
*cpool
)
14174 htab_t index_table
;
14177 index_table
= create_index_table ();
14178 str_table
= create_strtab ();
14179 /* We add all the index vectors to the constant pool first, to
14180 ensure alignment is ok. */
14181 for (i
= 0; i
< symtab
->size
; ++i
)
14183 if (symtab
->data
[i
])
14184 add_indices_to_cpool (index_table
, cpool
, symtab
->data
[i
]);
14187 /* Now write out the hash table. */
14188 for (i
= 0; i
< symtab
->size
; ++i
)
14190 offset_type str_off
, vec_off
;
14192 if (symtab
->data
[i
])
14194 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
14195 vec_off
= symtab
->data
[i
]->index_offset
;
14199 /* While 0 is a valid constant pool index, it is not valid
14200 to have 0 for both offsets. */
14205 str_off
= MAYBE_SWAP (str_off
);
14206 vec_off
= MAYBE_SWAP (vec_off
);
14208 obstack_grow (output
, &str_off
, sizeof (str_off
));
14209 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
14212 htab_delete (str_table
);
14213 htab_delete (index_table
);
14216 /* Write an address entry to ADDR_OBSTACK. The addresses are taken
14217 from PST; CU_INDEX is the index of the CU in the vector of all
14220 add_address_entry (struct objfile
*objfile
,
14221 struct obstack
*addr_obstack
, struct partial_symtab
*pst
,
14222 unsigned int cu_index
)
14224 offset_type offset
;
14226 CORE_ADDR baseaddr
;
14228 /* Don't bother recording empty ranges. */
14229 if (pst
->textlow
== pst
->texthigh
)
14232 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14234 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, pst
->textlow
- baseaddr
);
14235 obstack_grow (addr_obstack
, addr
, 8);
14236 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, pst
->texthigh
- baseaddr
);
14237 obstack_grow (addr_obstack
, addr
, 8);
14238 offset
= MAYBE_SWAP (cu_index
);
14239 obstack_grow (addr_obstack
, &offset
, sizeof (offset_type
));
14242 /* Add a list of partial symbols to SYMTAB. */
14244 write_psymbols (struct mapped_symtab
*symtab
,
14245 struct partial_symbol
**psymp
,
14247 offset_type cu_index
)
14249 for (; count
-- > 0; ++psymp
)
14251 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
14252 error (_("Ada is not currently supported by the index"));
14253 add_index_entry (symtab
, SYMBOL_NATURAL_NAME (*psymp
), cu_index
);
14257 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
14258 exception if there is an error. */
14260 write_obstack (FILE *file
, struct obstack
*obstack
)
14262 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
14264 != obstack_object_size (obstack
))
14265 error (_("couldn't data write to file"));
14268 /* Unlink a file if the argument is not NULL. */
14270 unlink_if_set (void *p
)
14272 char **filename
= p
;
14274 unlink (*filename
);
14277 /* A helper struct used when iterating over debug_types. */
14278 struct signatured_type_index_data
14280 struct objfile
*objfile
;
14281 struct mapped_symtab
*symtab
;
14282 struct obstack
*types_list
;
14286 /* A helper function that writes a single signatured_type to an
14289 write_one_signatured_type (void **slot
, void *d
)
14291 struct signatured_type_index_data
*info
= d
;
14292 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
14293 struct dwarf2_per_cu_data
*cu
= &entry
->per_cu
;
14294 struct partial_symtab
*psymtab
= cu
->v
.psymtab
;
14297 write_psymbols (info
->symtab
,
14298 info
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
14299 psymtab
->n_global_syms
, info
->cu_index
);
14300 write_psymbols (info
->symtab
,
14301 info
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
14302 psymtab
->n_static_syms
, info
->cu_index
);
14304 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->offset
);
14305 obstack_grow (info
->types_list
, val
, 8);
14306 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->type_offset
);
14307 obstack_grow (info
->types_list
, val
, 8);
14308 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
14309 obstack_grow (info
->types_list
, val
, 8);
14316 /* Create an index file for OBJFILE in the directory DIR. */
14318 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
14320 struct cleanup
*cleanup
;
14321 char *filename
, *cleanup_filename
;
14322 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
14323 struct obstack cu_list
, types_cu_list
;
14326 struct mapped_symtab
*symtab
;
14327 offset_type val
, size_of_contents
, total_len
;
14331 if (!objfile
->psymtabs
)
14333 if (dwarf2_per_objfile
->using_index
)
14334 error (_("Cannot use an index to create the index"));
14336 if (stat (objfile
->name
, &st
) < 0)
14337 perror_with_name (_("Could not stat"));
14339 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
14340 INDEX_SUFFIX
, (char *) NULL
);
14341 cleanup
= make_cleanup (xfree
, filename
);
14343 out_file
= fopen (filename
, "wb");
14345 error (_("Can't open `%s' for writing"), filename
);
14347 cleanup_filename
= filename
;
14348 make_cleanup (unlink_if_set
, &cleanup_filename
);
14350 symtab
= create_mapped_symtab ();
14351 make_cleanup (cleanup_mapped_symtab
, symtab
);
14353 obstack_init (&addr_obstack
);
14354 make_cleanup_obstack_free (&addr_obstack
);
14356 obstack_init (&cu_list
);
14357 make_cleanup_obstack_free (&cu_list
);
14359 obstack_init (&types_cu_list
);
14360 make_cleanup_obstack_free (&types_cu_list
);
14362 /* The list is already sorted, so we don't need to do additional
14363 work here. Also, the debug_types entries do not appear in
14364 all_comp_units, but only in their own hash table. */
14365 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
14367 struct dwarf2_per_cu_data
*cu
= dwarf2_per_objfile
->all_comp_units
[i
];
14368 struct partial_symtab
*psymtab
= cu
->v
.psymtab
;
14371 write_psymbols (symtab
,
14372 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
14373 psymtab
->n_global_syms
, i
);
14374 write_psymbols (symtab
,
14375 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
14376 psymtab
->n_static_syms
, i
);
14378 add_address_entry (objfile
, &addr_obstack
, psymtab
, i
);
14380 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, cu
->offset
);
14381 obstack_grow (&cu_list
, val
, 8);
14382 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, cu
->length
);
14383 obstack_grow (&cu_list
, val
, 8);
14386 /* Write out the .debug_type entries, if any. */
14387 if (dwarf2_per_objfile
->signatured_types
)
14389 struct signatured_type_index_data sig_data
;
14391 sig_data
.objfile
= objfile
;
14392 sig_data
.symtab
= symtab
;
14393 sig_data
.types_list
= &types_cu_list
;
14394 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
14395 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
14396 write_one_signatured_type
, &sig_data
);
14399 obstack_init (&constant_pool
);
14400 make_cleanup_obstack_free (&constant_pool
);
14401 obstack_init (&symtab_obstack
);
14402 make_cleanup_obstack_free (&symtab_obstack
);
14403 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
14405 obstack_init (&contents
);
14406 make_cleanup_obstack_free (&contents
);
14407 size_of_contents
= 6 * sizeof (offset_type
);
14408 total_len
= size_of_contents
;
14410 /* The version number. */
14411 val
= MAYBE_SWAP (2);
14412 obstack_grow (&contents
, &val
, sizeof (val
));
14414 /* The offset of the CU list from the start of the file. */
14415 val
= MAYBE_SWAP (total_len
);
14416 obstack_grow (&contents
, &val
, sizeof (val
));
14417 total_len
+= obstack_object_size (&cu_list
);
14419 /* The offset of the types CU list from the start of the file. */
14420 val
= MAYBE_SWAP (total_len
);
14421 obstack_grow (&contents
, &val
, sizeof (val
));
14422 total_len
+= obstack_object_size (&types_cu_list
);
14424 /* The offset of the address table from the start of the file. */
14425 val
= MAYBE_SWAP (total_len
);
14426 obstack_grow (&contents
, &val
, sizeof (val
));
14427 total_len
+= obstack_object_size (&addr_obstack
);
14429 /* The offset of the symbol table from the start of the file. */
14430 val
= MAYBE_SWAP (total_len
);
14431 obstack_grow (&contents
, &val
, sizeof (val
));
14432 total_len
+= obstack_object_size (&symtab_obstack
);
14434 /* The offset of the constant pool from the start of the file. */
14435 val
= MAYBE_SWAP (total_len
);
14436 obstack_grow (&contents
, &val
, sizeof (val
));
14437 total_len
+= obstack_object_size (&constant_pool
);
14439 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
14441 write_obstack (out_file
, &contents
);
14442 write_obstack (out_file
, &cu_list
);
14443 write_obstack (out_file
, &types_cu_list
);
14444 write_obstack (out_file
, &addr_obstack
);
14445 write_obstack (out_file
, &symtab_obstack
);
14446 write_obstack (out_file
, &constant_pool
);
14450 /* We want to keep the file, so we set cleanup_filename to NULL
14451 here. See unlink_if_set. */
14452 cleanup_filename
= NULL
;
14454 do_cleanups (cleanup
);
14457 /* The mapped index file format is designed to be directly mmap()able
14458 on any architecture. In most cases, a datum is represented using a
14459 little-endian 32-bit integer value, called an offset_type. Big
14460 endian machines must byte-swap the values before using them.
14461 Exceptions to this rule are noted. The data is laid out such that
14462 alignment is always respected.
14464 A mapped index consists of several sections.
14466 1. The file header. This is a sequence of values, of offset_type
14467 unless otherwise noted:
14468 [0] The version number. Currently 1 or 2. The differences are
14469 noted below. Version 1 did not account for .debug_types sections;
14470 the presence of a .debug_types section invalidates any version 1
14471 index that may exist.
14472 [1] The offset, from the start of the file, of the CU list.
14473 [1.5] In version 2, the offset, from the start of the file, of the
14474 types CU list. This offset does not appear in version 1. Note
14475 that this can be empty, in which case this offset will be equal to
14477 [2] The offset, from the start of the file, of the address section.
14478 [3] The offset, from the start of the file, of the symbol table.
14479 [4] The offset, from the start of the file, of the constant pool.
14481 2. The CU list. This is a sequence of pairs of 64-bit
14482 little-endian values, sorted by the CU offset. The first element
14483 in each pair is the offset of a CU in the .debug_info section. The
14484 second element in each pair is the length of that CU. References
14485 to a CU elsewhere in the map are done using a CU index, which is
14486 just the 0-based index into this table. Note that if there are
14487 type CUs, then conceptually CUs and type CUs form a single list for
14488 the purposes of CU indices.
14490 2.5 The types CU list. This does not appear in a version 1 index.
14491 This is a sequence of triplets of 64-bit little-endian values. In
14492 a triplet, the first value is the CU offset, the second value is
14493 the type offset in the CU, and the third value is the type
14494 signature. The types CU list is not sorted.
14496 3. The address section. The address section consists of a sequence
14497 of address entries. Each address entry has three elements.
14498 [0] The low address. This is a 64-bit little-endian value.
14499 [1] The high address. This is a 64-bit little-endian value.
14500 [2] The CU index. This is an offset_type value.
14502 4. The symbol table. This is a hash table. The size of the hash
14503 table is always a power of 2. The initial hash and the step are
14504 currently defined by the `find_slot' function.
14506 Each slot in the hash table consists of a pair of offset_type
14507 values. The first value is the offset of the symbol's name in the
14508 constant pool. The second value is the offset of the CU vector in
14511 If both values are 0, then this slot in the hash table is empty.
14512 This is ok because while 0 is a valid constant pool index, it
14513 cannot be a valid index for both a string and a CU vector.
14515 A string in the constant pool is stored as a \0-terminated string,
14518 A CU vector in the constant pool is a sequence of offset_type
14519 values. The first value is the number of CU indices in the vector.
14520 Each subsequent value is the index of a CU in the CU list. This
14521 element in the hash table is used to indicate which CUs define the
14524 5. The constant pool. This is simply a bunch of bytes. It is
14525 organized so that alignment is correct: CU vectors are stored
14526 first, followed by strings. */
14528 save_gdb_index_command (char *arg
, int from_tty
)
14530 struct objfile
*objfile
;
14533 error (_("usage: save gdb-index DIRECTORY"));
14535 ALL_OBJFILES (objfile
)
14539 /* If the objfile does not correspond to an actual file, skip it. */
14540 if (stat (objfile
->name
, &st
) < 0)
14543 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
14544 if (dwarf2_per_objfile
)
14546 volatile struct gdb_exception except
;
14548 TRY_CATCH (except
, RETURN_MASK_ERROR
)
14550 write_psymtabs_to_index (objfile
, arg
);
14552 if (except
.reason
< 0)
14553 exception_fprintf (gdb_stderr
, except
,
14554 _("Error while writing index for `%s': "),
14562 int dwarf2_always_disassemble
;
14565 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
14566 struct cmd_list_element
*c
, const char *value
)
14568 fprintf_filtered (file
, _("\
14569 Whether to always disassemble DWARF expressions is %s.\n"),
14573 void _initialize_dwarf2_read (void);
14576 _initialize_dwarf2_read (void)
14578 struct cmd_list_element
*c
;
14580 dwarf2_objfile_data_key
14581 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
14583 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
14584 Set DWARF 2 specific variables.\n\
14585 Configure DWARF 2 variables such as the cache size"),
14586 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
14587 0/*allow-unknown*/, &maintenance_set_cmdlist
);
14589 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
14590 Show DWARF 2 specific variables\n\
14591 Show DWARF 2 variables such as the cache size"),
14592 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
14593 0/*allow-unknown*/, &maintenance_show_cmdlist
);
14595 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
14596 &dwarf2_max_cache_age
, _("\
14597 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
14598 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
14599 A higher limit means that cached compilation units will be stored\n\
14600 in memory longer, and more total memory will be used. Zero disables\n\
14601 caching, which can slow down startup."),
14603 show_dwarf2_max_cache_age
,
14604 &set_dwarf2_cmdlist
,
14605 &show_dwarf2_cmdlist
);
14607 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
14608 &dwarf2_always_disassemble
, _("\
14609 Set whether `info address' always disassembles DWARF expressions."), _("\
14610 Show whether `info address' always disassembles DWARF expressions."), _("\
14611 When enabled, DWARF expressions are always printed in an assembly-like\n\
14612 syntax. When disabled, expressions will be printed in a more\n\
14613 conversational style, when possible."),
14615 show_dwarf2_always_disassemble
,
14616 &set_dwarf2_cmdlist
,
14617 &show_dwarf2_cmdlist
);
14619 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
14620 Set debugging of the dwarf2 DIE reader."), _("\
14621 Show debugging of the dwarf2 DIE reader."), _("\
14622 When enabled (non-zero), DIEs are dumped after they are read in.\n\
14623 The value is the maximum depth to print."),
14626 &setdebuglist
, &showdebuglist
);
14628 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
14629 _("Save a .gdb-index file"),
14631 set_cmd_completer (c
, filename_completer
);