1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006
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
12 support in dwarfread.c
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 2 of the License, or (at
19 your option) any later version.
21 This program is distributed in the hope that it will be useful, but
22 WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 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, write to the Free Software
28 Foundation, Inc., 51 Franklin Street, Fifth Floor,
29 Boston, MA 02110-1301, USA. */
36 #include "elf/dwarf2.h"
39 #include "expression.h"
40 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
45 #include "dwarf2expr.h"
46 #include "dwarf2loc.h"
47 #include "cp-support.h"
53 #include "gdb_string.h"
54 #include "gdb_assert.h"
55 #include <sys/types.h>
57 /* A note on memory usage for this file.
59 At the present time, this code reads the debug info sections into
60 the objfile's objfile_obstack. A definite improvement for startup
61 time, on platforms which do not emit relocations for debug
62 sections, would be to use mmap instead. The object's complete
63 debug information is loaded into memory, partly to simplify
64 absolute DIE references.
66 Whether using obstacks or mmap, the sections should remain loaded
67 until the objfile is released, and pointers into the section data
68 can be used for any other data associated to the objfile (symbol
69 names, type names, location expressions to name a few). */
71 #ifndef DWARF2_REG_TO_REGNUM
72 #define DWARF2_REG_TO_REGNUM(REG) (REG)
76 /* .debug_info header for a compilation unit
77 Because of alignment constraints, this structure has padding and cannot
78 be mapped directly onto the beginning of the .debug_info section. */
79 typedef struct comp_unit_header
81 unsigned int length
; /* length of the .debug_info
83 unsigned short version
; /* version number -- 2 for DWARF
85 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
86 unsigned char addr_size
; /* byte size of an address -- 4 */
89 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
92 /* .debug_pubnames header
93 Because of alignment constraints, this structure has padding and cannot
94 be mapped directly onto the beginning of the .debug_info section. */
95 typedef struct pubnames_header
97 unsigned int length
; /* length of the .debug_pubnames
99 unsigned char version
; /* version number -- 2 for DWARF
101 unsigned int info_offset
; /* offset into .debug_info section */
102 unsigned int info_size
; /* byte size of .debug_info section
106 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
108 /* .debug_pubnames header
109 Because of alignment constraints, this structure has padding and cannot
110 be mapped directly onto the beginning of the .debug_info section. */
111 typedef struct aranges_header
113 unsigned int length
; /* byte len of the .debug_aranges
115 unsigned short version
; /* version number -- 2 for DWARF
117 unsigned int info_offset
; /* offset into .debug_info section */
118 unsigned char addr_size
; /* byte size of an address */
119 unsigned char seg_size
; /* byte size of segment descriptor */
122 #define _ACTUAL_ARANGES_HEADER_SIZE 12
124 /* .debug_line statement program prologue
125 Because of alignment constraints, this structure has padding and cannot
126 be mapped directly onto the beginning of the .debug_info section. */
127 typedef struct statement_prologue
129 unsigned int total_length
; /* byte length of the statement
131 unsigned short version
; /* version number -- 2 for DWARF
133 unsigned int prologue_length
; /* # bytes between prologue &
135 unsigned char minimum_instruction_length
; /* byte size of
137 unsigned char default_is_stmt
; /* initial value of is_stmt
140 unsigned char line_range
;
141 unsigned char opcode_base
; /* number assigned to first special
143 unsigned char *standard_opcode_lengths
;
147 static const struct objfile_data
*dwarf2_objfile_data_key
;
149 struct dwarf2_per_objfile
151 /* Sizes of debugging sections. */
152 unsigned int info_size
;
153 unsigned int abbrev_size
;
154 unsigned int line_size
;
155 unsigned int pubnames_size
;
156 unsigned int aranges_size
;
157 unsigned int loc_size
;
158 unsigned int macinfo_size
;
159 unsigned int str_size
;
160 unsigned int ranges_size
;
161 unsigned int frame_size
;
162 unsigned int eh_frame_size
;
164 /* Loaded data from the sections. */
165 gdb_byte
*info_buffer
;
166 gdb_byte
*abbrev_buffer
;
167 gdb_byte
*line_buffer
;
168 gdb_byte
*str_buffer
;
169 gdb_byte
*macinfo_buffer
;
170 gdb_byte
*ranges_buffer
;
171 gdb_byte
*loc_buffer
;
173 /* A list of all the compilation units. This is used to locate
174 the target compilation unit of a particular reference. */
175 struct dwarf2_per_cu_data
**all_comp_units
;
177 /* The number of compilation units in ALL_COMP_UNITS. */
180 /* A chain of compilation units that are currently read in, so that
181 they can be freed later. */
182 struct dwarf2_per_cu_data
*read_in_chain
;
184 /* A flag indicating wether this objfile has a section loaded at a
186 int has_section_at_zero
;
189 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
191 static asection
*dwarf_info_section
;
192 static asection
*dwarf_abbrev_section
;
193 static asection
*dwarf_line_section
;
194 static asection
*dwarf_pubnames_section
;
195 static asection
*dwarf_aranges_section
;
196 static asection
*dwarf_loc_section
;
197 static asection
*dwarf_macinfo_section
;
198 static asection
*dwarf_str_section
;
199 static asection
*dwarf_ranges_section
;
200 asection
*dwarf_frame_section
;
201 asection
*dwarf_eh_frame_section
;
203 /* names of the debugging sections */
205 #define INFO_SECTION ".debug_info"
206 #define ABBREV_SECTION ".debug_abbrev"
207 #define LINE_SECTION ".debug_line"
208 #define PUBNAMES_SECTION ".debug_pubnames"
209 #define ARANGES_SECTION ".debug_aranges"
210 #define LOC_SECTION ".debug_loc"
211 #define MACINFO_SECTION ".debug_macinfo"
212 #define STR_SECTION ".debug_str"
213 #define RANGES_SECTION ".debug_ranges"
214 #define FRAME_SECTION ".debug_frame"
215 #define EH_FRAME_SECTION ".eh_frame"
217 /* local data types */
219 /* We hold several abbreviation tables in memory at the same time. */
220 #ifndef ABBREV_HASH_SIZE
221 #define ABBREV_HASH_SIZE 121
224 /* The data in a compilation unit header, after target2host
225 translation, looks like this. */
226 struct comp_unit_head
228 unsigned long length
;
230 unsigned int abbrev_offset
;
231 unsigned char addr_size
;
232 unsigned char signed_addr_p
;
234 /* Size of file offsets; either 4 or 8. */
235 unsigned int offset_size
;
237 /* Size of the length field; either 4 or 12. */
238 unsigned int initial_length_size
;
240 /* Offset to the first byte of this compilation unit header in the
241 .debug_info section, for resolving relative reference dies. */
244 /* Pointer to this compilation unit header in the .debug_info
246 gdb_byte
*cu_head_ptr
;
248 /* Pointer to the first die of this compilation unit. This will be
249 the first byte following the compilation unit header. */
250 gdb_byte
*first_die_ptr
;
252 /* Pointer to the next compilation unit header in the program. */
253 struct comp_unit_head
*next
;
255 /* Base address of this compilation unit. */
256 CORE_ADDR base_address
;
258 /* Non-zero if base_address has been set. */
262 /* Fixed size for the DIE hash table. */
263 #ifndef REF_HASH_SIZE
264 #define REF_HASH_SIZE 1021
267 /* Internal state when decoding a particular compilation unit. */
270 /* The objfile containing this compilation unit. */
271 struct objfile
*objfile
;
273 /* The header of the compilation unit.
275 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
276 should logically be moved to the dwarf2_cu structure. */
277 struct comp_unit_head header
;
279 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
281 /* The language we are debugging. */
282 enum language language
;
283 const struct language_defn
*language_defn
;
285 const char *producer
;
287 /* The generic symbol table building routines have separate lists for
288 file scope symbols and all all other scopes (local scopes). So
289 we need to select the right one to pass to add_symbol_to_list().
290 We do it by keeping a pointer to the correct list in list_in_scope.
292 FIXME: The original dwarf code just treated the file scope as the
293 first local scope, and all other local scopes as nested local
294 scopes, and worked fine. Check to see if we really need to
295 distinguish these in buildsym.c. */
296 struct pending
**list_in_scope
;
298 /* Maintain an array of referenced fundamental types for the current
299 compilation unit being read. For DWARF version 1, we have to construct
300 the fundamental types on the fly, since no information about the
301 fundamental types is supplied. Each such fundamental type is created by
302 calling a language dependent routine to create the type, and then a
303 pointer to that type is then placed in the array at the index specified
304 by it's FT_<TYPENAME> value. The array has a fixed size set by the
305 FT_NUM_MEMBERS compile time constant, which is the number of predefined
306 fundamental types gdb knows how to construct. */
307 struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
309 /* DWARF abbreviation table associated with this compilation unit. */
310 struct abbrev_info
**dwarf2_abbrevs
;
312 /* Storage for the abbrev table. */
313 struct obstack abbrev_obstack
;
315 /* Hash table holding all the loaded partial DIEs. */
318 /* Storage for things with the same lifetime as this read-in compilation
319 unit, including partial DIEs. */
320 struct obstack comp_unit_obstack
;
322 /* When multiple dwarf2_cu structures are living in memory, this field
323 chains them all together, so that they can be released efficiently.
324 We will probably also want a generation counter so that most-recently-used
325 compilation units are cached... */
326 struct dwarf2_per_cu_data
*read_in_chain
;
328 /* Backchain to our per_cu entry if the tree has been built. */
329 struct dwarf2_per_cu_data
*per_cu
;
331 /* How many compilation units ago was this CU last referenced? */
334 /* A hash table of die offsets for following references. */
335 struct die_info
*die_ref_table
[REF_HASH_SIZE
];
337 /* Full DIEs if read in. */
338 struct die_info
*dies
;
340 /* A set of pointers to dwarf2_per_cu_data objects for compilation
341 units referenced by this one. Only set during full symbol processing;
342 partial symbol tables do not have dependencies. */
345 /* Mark used when releasing cached dies. */
346 unsigned int mark
: 1;
348 /* This flag will be set if this compilation unit might include
349 inter-compilation-unit references. */
350 unsigned int has_form_ref_addr
: 1;
352 /* This flag will be set if this compilation unit includes any
353 DW_TAG_namespace DIEs. If we know that there are explicit
354 DIEs for namespaces, we don't need to try to infer them
355 from mangled names. */
356 unsigned int has_namespace_info
: 1;
359 /* Persistent data held for a compilation unit, even when not
360 processing it. We put a pointer to this structure in the
361 read_symtab_private field of the psymtab. If we encounter
362 inter-compilation-unit references, we also maintain a sorted
363 list of all compilation units. */
365 struct dwarf2_per_cu_data
367 /* The start offset and length of this compilation unit. 2**30-1
368 bytes should suffice to store the length of any compilation unit
369 - if it doesn't, GDB will fall over anyway. */
370 unsigned long offset
;
371 unsigned long length
: 30;
373 /* Flag indicating this compilation unit will be read in before
374 any of the current compilation units are processed. */
375 unsigned long queued
: 1;
377 /* This flag will be set if we need to load absolutely all DIEs
378 for this compilation unit, instead of just the ones we think
379 are interesting. It gets set if we look for a DIE in the
380 hash table and don't find it. */
381 unsigned int load_all_dies
: 1;
383 /* Set iff currently read in. */
384 struct dwarf2_cu
*cu
;
386 /* If full symbols for this CU have been read in, then this field
387 holds a map of DIE offsets to types. It isn't always possible
388 to reconstruct this information later, so we have to preserve
392 /* The partial symbol table associated with this compilation unit,
393 or NULL for partial units (which do not have an associated
395 struct partial_symtab
*psymtab
;
398 /* The line number information for a compilation unit (found in the
399 .debug_line section) begins with a "statement program header",
400 which contains the following information. */
403 unsigned int total_length
;
404 unsigned short version
;
405 unsigned int header_length
;
406 unsigned char minimum_instruction_length
;
407 unsigned char default_is_stmt
;
409 unsigned char line_range
;
410 unsigned char opcode_base
;
412 /* standard_opcode_lengths[i] is the number of operands for the
413 standard opcode whose value is i. This means that
414 standard_opcode_lengths[0] is unused, and the last meaningful
415 element is standard_opcode_lengths[opcode_base - 1]. */
416 unsigned char *standard_opcode_lengths
;
418 /* The include_directories table. NOTE! These strings are not
419 allocated with xmalloc; instead, they are pointers into
420 debug_line_buffer. If you try to free them, `free' will get
422 unsigned int num_include_dirs
, include_dirs_size
;
425 /* The file_names table. NOTE! These strings are not allocated
426 with xmalloc; instead, they are pointers into debug_line_buffer.
427 Don't try to free them directly. */
428 unsigned int num_file_names
, file_names_size
;
432 unsigned int dir_index
;
433 unsigned int mod_time
;
435 int included_p
; /* Non-zero if referenced by the Line Number Program. */
438 /* The start and end of the statement program following this
439 header. These point into dwarf2_per_objfile->line_buffer. */
440 gdb_byte
*statement_program_start
, *statement_program_end
;
443 /* When we construct a partial symbol table entry we only
444 need this much information. */
445 struct partial_die_info
447 /* Offset of this DIE. */
450 /* DWARF-2 tag for this DIE. */
451 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
453 /* Language code associated with this DIE. This is only used
454 for the compilation unit DIE. */
455 unsigned int language
: 8;
457 /* Assorted flags describing the data found in this DIE. */
458 unsigned int has_children
: 1;
459 unsigned int is_external
: 1;
460 unsigned int is_declaration
: 1;
461 unsigned int has_type
: 1;
462 unsigned int has_specification
: 1;
463 unsigned int has_stmt_list
: 1;
464 unsigned int has_pc_info
: 1;
466 /* Flag set if the SCOPE field of this structure has been
468 unsigned int scope_set
: 1;
470 /* The name of this DIE. Normally the value of DW_AT_name, but
471 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
476 /* The scope to prepend to our children. This is generally
477 allocated on the comp_unit_obstack, so will disappear
478 when this compilation unit leaves the cache. */
481 /* The location description associated with this DIE, if any. */
482 struct dwarf_block
*locdesc
;
484 /* If HAS_PC_INFO, the PC range associated with this DIE. */
488 /* Pointer into the info_buffer pointing at the target of
489 DW_AT_sibling, if any. */
492 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
493 DW_AT_specification (or DW_AT_abstract_origin or
495 unsigned int spec_offset
;
497 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
498 unsigned int line_offset
;
500 /* Pointers to this DIE's parent, first child, and next sibling,
502 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
505 /* This data structure holds the information of an abbrev. */
508 unsigned int number
; /* number identifying abbrev */
509 enum dwarf_tag tag
; /* dwarf tag */
510 unsigned short has_children
; /* boolean */
511 unsigned short num_attrs
; /* number of attributes */
512 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
513 struct abbrev_info
*next
; /* next in chain */
518 enum dwarf_attribute name
;
519 enum dwarf_form form
;
522 /* This data structure holds a complete die structure. */
525 enum dwarf_tag tag
; /* Tag indicating type of die */
526 unsigned int abbrev
; /* Abbrev number */
527 unsigned int offset
; /* Offset in .debug_info section */
528 unsigned int num_attrs
; /* Number of attributes */
529 struct attribute
*attrs
; /* An array of attributes */
530 struct die_info
*next_ref
; /* Next die in ref hash table */
532 /* The dies in a compilation unit form an n-ary tree. PARENT
533 points to this die's parent; CHILD points to the first child of
534 this node; and all the children of a given node are chained
535 together via their SIBLING fields, terminated by a die whose
537 struct die_info
*child
; /* Its first child, if any. */
538 struct die_info
*sibling
; /* Its next sibling, if any. */
539 struct die_info
*parent
; /* Its parent, if any. */
541 struct type
*type
; /* Cached type information */
544 /* Attributes have a name and a value */
547 enum dwarf_attribute name
;
548 enum dwarf_form form
;
552 struct dwarf_block
*blk
;
560 struct function_range
563 CORE_ADDR lowpc
, highpc
;
565 struct function_range
*next
;
568 /* Get at parts of an attribute structure */
570 #define DW_STRING(attr) ((attr)->u.str)
571 #define DW_UNSND(attr) ((attr)->u.unsnd)
572 #define DW_BLOCK(attr) ((attr)->u.blk)
573 #define DW_SND(attr) ((attr)->u.snd)
574 #define DW_ADDR(attr) ((attr)->u.addr)
576 /* Blocks are a bunch of untyped bytes. */
583 #ifndef ATTR_ALLOC_CHUNK
584 #define ATTR_ALLOC_CHUNK 4
587 /* Allocate fields for structs, unions and enums in this size. */
588 #ifndef DW_FIELD_ALLOC_CHUNK
589 #define DW_FIELD_ALLOC_CHUNK 4
592 /* A zeroed version of a partial die for initialization purposes. */
593 static struct partial_die_info zeroed_partial_die
;
595 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
596 but this would require a corresponding change in unpack_field_as_long
598 static int bits_per_byte
= 8;
600 /* The routines that read and process dies for a C struct or C++ class
601 pass lists of data member fields and lists of member function fields
602 in an instance of a field_info structure, as defined below. */
605 /* List of data member and baseclasses fields. */
608 struct nextfield
*next
;
615 /* Number of fields. */
618 /* Number of baseclasses. */
621 /* Set if the accesibility of one of the fields is not public. */
622 int non_public_fields
;
624 /* Member function fields array, entries are allocated in the order they
625 are encountered in the object file. */
628 struct nextfnfield
*next
;
629 struct fn_field fnfield
;
633 /* Member function fieldlist array, contains name of possibly overloaded
634 member function, number of overloaded member functions and a pointer
635 to the head of the member function field chain. */
640 struct nextfnfield
*head
;
644 /* Number of entries in the fnfieldlists array. */
648 /* One item on the queue of compilation units to read in full symbols
650 struct dwarf2_queue_item
652 struct dwarf2_per_cu_data
*per_cu
;
653 struct dwarf2_queue_item
*next
;
656 /* The current queue. */
657 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
659 /* Loaded secondary compilation units are kept in memory until they
660 have not been referenced for the processing of this many
661 compilation units. Set this to zero to disable caching. Cache
662 sizes of up to at least twenty will improve startup time for
663 typical inter-CU-reference binaries, at an obvious memory cost. */
664 static int dwarf2_max_cache_age
= 5;
666 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
667 struct cmd_list_element
*c
, const char *value
)
669 fprintf_filtered (file
, _("\
670 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
675 /* Various complaints about symbol reading that don't abort the process */
678 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
680 complaint (&symfile_complaints
,
681 _("statement list doesn't fit in .debug_line section"));
685 dwarf2_complex_location_expr_complaint (void)
687 complaint (&symfile_complaints
, _("location expression too complex"));
691 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
694 complaint (&symfile_complaints
,
695 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
700 dwarf2_macros_too_long_complaint (void)
702 complaint (&symfile_complaints
,
703 _("macro info runs off end of `.debug_macinfo' section"));
707 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
709 complaint (&symfile_complaints
,
710 _("macro debug info contains a malformed macro definition:\n`%s'"),
715 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
717 complaint (&symfile_complaints
,
718 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
721 /* local function prototypes */
723 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
726 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
729 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
732 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
733 struct partial_die_info
*,
734 struct partial_symtab
*);
736 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
738 static void scan_partial_symbols (struct partial_die_info
*,
739 CORE_ADDR
*, CORE_ADDR
*,
742 static void add_partial_symbol (struct partial_die_info
*,
745 static int pdi_needs_namespace (enum dwarf_tag tag
);
747 static void add_partial_namespace (struct partial_die_info
*pdi
,
748 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
749 struct dwarf2_cu
*cu
);
751 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
752 struct dwarf2_cu
*cu
);
754 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
757 struct dwarf2_cu
*cu
);
759 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
761 static void psymtab_to_symtab_1 (struct partial_symtab
*);
763 gdb_byte
*dwarf2_read_section (struct objfile
*, asection
*);
765 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
767 static void dwarf2_free_abbrev_table (void *);
769 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
772 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
775 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
778 static gdb_byte
*read_partial_die (struct partial_die_info
*,
779 struct abbrev_info
*abbrev
, unsigned int,
780 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
782 static struct partial_die_info
*find_partial_die (unsigned long,
785 static void fixup_partial_die (struct partial_die_info
*,
788 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
789 struct dwarf2_cu
*, int *);
791 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
792 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
794 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
795 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
797 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
799 static int read_1_signed_byte (bfd
*, gdb_byte
*);
801 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
803 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
805 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
807 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
810 static LONGEST
read_initial_length (bfd
*, gdb_byte
*,
811 struct comp_unit_head
*, unsigned int *);
813 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
816 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
818 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
820 static char *read_indirect_string (bfd
*, gdb_byte
*,
821 const struct comp_unit_head
*,
824 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
826 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
828 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
830 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
832 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
835 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
836 struct dwarf2_cu
*cu
);
838 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
840 static struct die_info
*die_specification (struct die_info
*die
,
843 static void free_line_header (struct line_header
*lh
);
845 static void add_file_name (struct line_header
*, char *, unsigned int,
846 unsigned int, unsigned int);
848 static struct line_header
*(dwarf_decode_line_header
849 (unsigned int offset
,
850 bfd
*abfd
, struct dwarf2_cu
*cu
));
852 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
853 struct dwarf2_cu
*, struct partial_symtab
*);
855 static void dwarf2_start_subfile (char *, char *, char *);
857 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
860 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
863 static void dwarf2_const_value_data (struct attribute
*attr
,
867 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
869 static struct type
*die_containing_type (struct die_info
*,
872 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
874 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
876 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
878 static char *typename_concat (struct obstack
*,
883 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
885 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
887 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
889 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
891 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
893 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
895 static int dwarf2_get_pc_bounds (struct die_info
*,
896 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
898 static void get_scope_pc_bounds (struct die_info
*,
899 CORE_ADDR
*, CORE_ADDR
*,
902 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
905 static void dwarf2_attach_fields_to_type (struct field_info
*,
906 struct type
*, struct dwarf2_cu
*);
908 static void dwarf2_add_member_fn (struct field_info
*,
909 struct die_info
*, struct type
*,
912 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
913 struct type
*, struct dwarf2_cu
*);
915 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
917 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
919 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
921 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
923 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
925 static const char *namespace_name (struct die_info
*die
,
926 int *is_anonymous
, struct dwarf2_cu
*);
928 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
930 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
932 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
934 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
936 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
938 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
941 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
943 static void read_tag_ptr_to_member_type (struct die_info
*,
946 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
948 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
950 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
952 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
954 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
956 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
958 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
960 gdb_byte
**new_info_ptr
,
961 struct die_info
*parent
);
963 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
965 gdb_byte
**new_info_ptr
,
966 struct die_info
*parent
);
968 static void free_die_list (struct die_info
*);
970 static void process_die (struct die_info
*, struct dwarf2_cu
*);
972 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
974 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
976 static struct die_info
*dwarf2_extension (struct die_info
*die
,
979 static char *dwarf_tag_name (unsigned int);
981 static char *dwarf_attr_name (unsigned int);
983 static char *dwarf_form_name (unsigned int);
985 static char *dwarf_stack_op_name (unsigned int);
987 static char *dwarf_bool_name (unsigned int);
989 static char *dwarf_type_encoding_name (unsigned int);
992 static char *dwarf_cfi_name (unsigned int);
994 struct die_info
*copy_die (struct die_info
*);
997 static struct die_info
*sibling_die (struct die_info
*);
999 static void dump_die (struct die_info
*);
1001 static void dump_die_list (struct die_info
*);
1003 static void store_in_ref_table (unsigned int, struct die_info
*,
1004 struct dwarf2_cu
*);
1006 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
1007 struct dwarf2_cu
*);
1009 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
1011 static struct die_info
*follow_die_ref (struct die_info
*,
1013 struct dwarf2_cu
*);
1015 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
1016 struct dwarf2_cu
*);
1018 /* memory allocation interface */
1020 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1022 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1024 static struct die_info
*dwarf_alloc_die (void);
1026 static void initialize_cu_func_list (struct dwarf2_cu
*);
1028 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1029 struct dwarf2_cu
*);
1031 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1032 char *, bfd
*, struct dwarf2_cu
*);
1034 static int attr_form_is_block (struct attribute
*);
1037 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
1038 struct dwarf2_cu
*cu
);
1040 static gdb_byte
*skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
1041 struct dwarf2_cu
*cu
);
1043 static void free_stack_comp_unit (void *);
1045 static hashval_t
partial_die_hash (const void *item
);
1047 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1049 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1050 (unsigned long offset
, struct objfile
*objfile
);
1052 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1053 (unsigned long offset
, struct objfile
*objfile
);
1055 static void free_one_comp_unit (void *);
1057 static void free_cached_comp_units (void *);
1059 static void age_cached_comp_units (void);
1061 static void free_one_cached_comp_unit (void *);
1063 static void set_die_type (struct die_info
*, struct type
*,
1064 struct dwarf2_cu
*);
1066 static void reset_die_and_siblings_types (struct die_info
*,
1067 struct dwarf2_cu
*);
1069 static void create_all_comp_units (struct objfile
*);
1071 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*,
1074 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1076 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1077 struct dwarf2_per_cu_data
*);
1079 static void dwarf2_mark (struct dwarf2_cu
*);
1081 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1083 static void read_set_type (struct die_info
*, struct dwarf2_cu
*);
1086 /* Try to locate the sections we need for DWARF 2 debugging
1087 information and return true if we have enough to do something. */
1090 dwarf2_has_info (struct objfile
*objfile
)
1092 struct dwarf2_per_objfile
*data
;
1094 /* Initialize per-objfile state. */
1095 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1096 memset (data
, 0, sizeof (*data
));
1097 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1098 dwarf2_per_objfile
= data
;
1100 dwarf_info_section
= 0;
1101 dwarf_abbrev_section
= 0;
1102 dwarf_line_section
= 0;
1103 dwarf_str_section
= 0;
1104 dwarf_macinfo_section
= 0;
1105 dwarf_frame_section
= 0;
1106 dwarf_eh_frame_section
= 0;
1107 dwarf_ranges_section
= 0;
1108 dwarf_loc_section
= 0;
1110 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1111 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1114 /* This function is mapped across the sections and remembers the
1115 offset and size of each of the debugging sections we are interested
1119 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1121 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1123 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1124 dwarf_info_section
= sectp
;
1126 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1128 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1129 dwarf_abbrev_section
= sectp
;
1131 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1133 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1134 dwarf_line_section
= sectp
;
1136 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1138 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1139 dwarf_pubnames_section
= sectp
;
1141 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1143 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1144 dwarf_aranges_section
= sectp
;
1146 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1148 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1149 dwarf_loc_section
= sectp
;
1151 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1153 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1154 dwarf_macinfo_section
= sectp
;
1156 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1158 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1159 dwarf_str_section
= sectp
;
1161 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1163 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1164 dwarf_frame_section
= sectp
;
1166 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1168 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1169 if (aflag
& SEC_HAS_CONTENTS
)
1171 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1172 dwarf_eh_frame_section
= sectp
;
1175 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1177 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1178 dwarf_ranges_section
= sectp
;
1181 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1182 && bfd_section_vma (abfd
, sectp
) == 0)
1183 dwarf2_per_objfile
->has_section_at_zero
= 1;
1186 /* Build a partial symbol table. */
1189 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1191 /* We definitely need the .debug_info and .debug_abbrev sections */
1193 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1194 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1196 if (dwarf_line_section
)
1197 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1199 dwarf2_per_objfile
->line_buffer
= NULL
;
1201 if (dwarf_str_section
)
1202 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1204 dwarf2_per_objfile
->str_buffer
= NULL
;
1206 if (dwarf_macinfo_section
)
1207 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1208 dwarf_macinfo_section
);
1210 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1212 if (dwarf_ranges_section
)
1213 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1215 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1217 if (dwarf_loc_section
)
1218 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1220 dwarf2_per_objfile
->loc_buffer
= NULL
;
1223 || (objfile
->global_psymbols
.size
== 0
1224 && objfile
->static_psymbols
.size
== 0))
1226 init_psymbol_list (objfile
, 1024);
1230 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1232 /* Things are significantly easier if we have .debug_aranges and
1233 .debug_pubnames sections */
1235 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1239 /* only test this case for now */
1241 /* In this case we have to work a bit harder */
1242 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1247 /* Build the partial symbol table from the information in the
1248 .debug_pubnames and .debug_aranges sections. */
1251 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1253 bfd
*abfd
= objfile
->obfd
;
1254 char *aranges_buffer
, *pubnames_buffer
;
1255 char *aranges_ptr
, *pubnames_ptr
;
1256 unsigned int entry_length
, version
, info_offset
, info_size
;
1258 pubnames_buffer
= dwarf2_read_section (objfile
,
1259 dwarf_pubnames_section
);
1260 pubnames_ptr
= pubnames_buffer
;
1261 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1263 struct comp_unit_head cu_header
;
1264 unsigned int bytes_read
;
1266 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1268 pubnames_ptr
+= bytes_read
;
1269 version
= read_1_byte (abfd
, pubnames_ptr
);
1271 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1273 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1277 aranges_buffer
= dwarf2_read_section (objfile
,
1278 dwarf_aranges_section
);
1283 /* Read in the comp unit header information from the debug_info at
1287 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1288 gdb_byte
*info_ptr
, bfd
*abfd
)
1291 unsigned int bytes_read
;
1292 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1294 info_ptr
+= bytes_read
;
1295 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1297 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1299 info_ptr
+= bytes_read
;
1300 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1302 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1303 if (signed_addr
< 0)
1304 internal_error (__FILE__
, __LINE__
,
1305 _("read_comp_unit_head: dwarf from non elf file"));
1306 cu_header
->signed_addr_p
= signed_addr
;
1311 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1314 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1316 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1318 if (header
->version
!= 2 && header
->version
!= 3)
1319 error (_("Dwarf Error: wrong version in compilation unit header "
1320 "(is %d, should be %d) [in module %s]"), header
->version
,
1321 2, bfd_get_filename (abfd
));
1323 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1324 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1325 "(offset 0x%lx + 6) [in module %s]"),
1326 (long) header
->abbrev_offset
,
1327 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1328 bfd_get_filename (abfd
));
1330 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1331 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1332 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1333 "(offset 0x%lx + 0) [in module %s]"),
1334 (long) header
->length
,
1335 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1336 bfd_get_filename (abfd
));
1341 /* Allocate a new partial symtab for file named NAME and mark this new
1342 partial symtab as being an include of PST. */
1345 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1346 struct objfile
*objfile
)
1348 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1350 subpst
->section_offsets
= pst
->section_offsets
;
1351 subpst
->textlow
= 0;
1352 subpst
->texthigh
= 0;
1354 subpst
->dependencies
= (struct partial_symtab
**)
1355 obstack_alloc (&objfile
->objfile_obstack
,
1356 sizeof (struct partial_symtab
*));
1357 subpst
->dependencies
[0] = pst
;
1358 subpst
->number_of_dependencies
= 1;
1360 subpst
->globals_offset
= 0;
1361 subpst
->n_global_syms
= 0;
1362 subpst
->statics_offset
= 0;
1363 subpst
->n_static_syms
= 0;
1364 subpst
->symtab
= NULL
;
1365 subpst
->read_symtab
= pst
->read_symtab
;
1368 /* No private part is necessary for include psymtabs. This property
1369 can be used to differentiate between such include psymtabs and
1370 the regular ones. */
1371 subpst
->read_symtab_private
= NULL
;
1374 /* Read the Line Number Program data and extract the list of files
1375 included by the source file represented by PST. Build an include
1376 partial symtab for each of these included files.
1378 This procedure assumes that there *is* a Line Number Program in
1379 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1380 before calling this procedure. */
1383 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1384 struct partial_die_info
*pdi
,
1385 struct partial_symtab
*pst
)
1387 struct objfile
*objfile
= cu
->objfile
;
1388 bfd
*abfd
= objfile
->obfd
;
1389 struct line_header
*lh
;
1391 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1393 return; /* No linetable, so no includes. */
1395 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1397 free_line_header (lh
);
1401 /* Build the partial symbol table by doing a quick pass through the
1402 .debug_info and .debug_abbrev sections. */
1405 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1407 /* Instead of reading this into a big buffer, we should probably use
1408 mmap() on architectures that support it. (FIXME) */
1409 bfd
*abfd
= objfile
->obfd
;
1411 gdb_byte
*beg_of_comp_unit
;
1412 struct partial_die_info comp_unit_die
;
1413 struct partial_symtab
*pst
;
1414 struct cleanup
*back_to
;
1415 CORE_ADDR lowpc
, highpc
, baseaddr
;
1417 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1419 /* Any cached compilation units will be linked by the per-objfile
1420 read_in_chain. Make sure to free them when we're done. */
1421 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1423 create_all_comp_units (objfile
);
1425 /* Since the objects we're extracting from .debug_info vary in
1426 length, only the individual functions to extract them (like
1427 read_comp_unit_head and load_partial_die) can really know whether
1428 the buffer is large enough to hold another complete object.
1430 At the moment, they don't actually check that. If .debug_info
1431 holds just one extra byte after the last compilation unit's dies,
1432 then read_comp_unit_head will happily read off the end of the
1433 buffer. read_partial_die is similarly casual. Those functions
1436 For this loop condition, simply checking whether there's any data
1437 left at all should be sufficient. */
1438 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1439 + dwarf2_per_objfile
->info_size
))
1441 struct cleanup
*back_to_inner
;
1442 struct dwarf2_cu cu
;
1443 struct abbrev_info
*abbrev
;
1444 unsigned int bytes_read
;
1445 struct dwarf2_per_cu_data
*this_cu
;
1447 beg_of_comp_unit
= info_ptr
;
1449 memset (&cu
, 0, sizeof (cu
));
1451 obstack_init (&cu
.comp_unit_obstack
);
1453 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1455 cu
.objfile
= objfile
;
1456 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1458 /* Complete the cu_header */
1459 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1460 cu
.header
.first_die_ptr
= info_ptr
;
1461 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1463 cu
.list_in_scope
= &file_symbols
;
1465 /* Read the abbrevs for this compilation unit into a table */
1466 dwarf2_read_abbrevs (abfd
, &cu
);
1467 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1469 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1471 /* Read the compilation unit die */
1472 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1473 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1474 abfd
, info_ptr
, &cu
);
1476 if (comp_unit_die
.tag
== DW_TAG_partial_unit
)
1478 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1479 + cu
.header
.initial_length_size
);
1480 do_cleanups (back_to_inner
);
1484 /* Set the language we're debugging */
1485 set_cu_language (comp_unit_die
.language
, &cu
);
1487 /* Allocate a new partial symbol table structure */
1488 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1489 comp_unit_die
.name
? comp_unit_die
.name
: "",
1490 comp_unit_die
.lowpc
,
1491 objfile
->global_psymbols
.next
,
1492 objfile
->static_psymbols
.next
);
1494 if (comp_unit_die
.dirname
)
1495 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1497 pst
->read_symtab_private
= (char *) this_cu
;
1499 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1501 /* Store the function that reads in the rest of the symbol table */
1502 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1504 /* If this compilation unit was already read in, free the
1505 cached copy in order to read it in again. This is
1506 necessary because we skipped some symbols when we first
1507 read in the compilation unit (see load_partial_dies).
1508 This problem could be avoided, but the benefit is
1510 if (this_cu
->cu
!= NULL
)
1511 free_one_cached_comp_unit (this_cu
->cu
);
1513 cu
.per_cu
= this_cu
;
1515 /* Note that this is a pointer to our stack frame, being
1516 added to a global data structure. It will be cleaned up
1517 in free_stack_comp_unit when we finish with this
1518 compilation unit. */
1521 this_cu
->psymtab
= pst
;
1523 /* Check if comp unit has_children.
1524 If so, read the rest of the partial symbols from this comp unit.
1525 If not, there's no more debug_info for this comp unit. */
1526 if (comp_unit_die
.has_children
)
1528 struct partial_die_info
*first_die
;
1530 lowpc
= ((CORE_ADDR
) -1);
1531 highpc
= ((CORE_ADDR
) 0);
1533 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1535 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1537 /* If we didn't find a lowpc, set it to highpc to avoid
1538 complaints from `maint check'. */
1539 if (lowpc
== ((CORE_ADDR
) -1))
1542 /* If the compilation unit didn't have an explicit address range,
1543 then use the information extracted from its child dies. */
1544 if (! comp_unit_die
.has_pc_info
)
1546 comp_unit_die
.lowpc
= lowpc
;
1547 comp_unit_die
.highpc
= highpc
;
1550 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1551 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1553 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1554 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1555 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1556 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1557 sort_pst_symbols (pst
);
1559 /* If there is already a psymtab or symtab for a file of this
1560 name, remove it. (If there is a symtab, more drastic things
1561 also happen.) This happens in VxWorks. */
1562 free_named_symtabs (pst
->filename
);
1564 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1565 + cu
.header
.initial_length_size
;
1567 if (comp_unit_die
.has_stmt_list
)
1569 /* Get the list of files included in the current compilation unit,
1570 and build a psymtab for each of them. */
1571 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1574 do_cleanups (back_to_inner
);
1576 do_cleanups (back_to
);
1579 /* Load the DIEs for a secondary CU into memory. */
1582 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1584 bfd
*abfd
= objfile
->obfd
;
1585 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1586 struct partial_die_info comp_unit_die
;
1587 struct dwarf2_cu
*cu
;
1588 struct abbrev_info
*abbrev
;
1589 unsigned int bytes_read
;
1590 struct cleanup
*back_to
;
1592 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1593 beg_of_comp_unit
= info_ptr
;
1595 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1596 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1598 obstack_init (&cu
->comp_unit_obstack
);
1600 cu
->objfile
= objfile
;
1601 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1603 /* Complete the cu_header. */
1604 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1605 cu
->header
.first_die_ptr
= info_ptr
;
1606 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1608 /* Read the abbrevs for this compilation unit into a table. */
1609 dwarf2_read_abbrevs (abfd
, cu
);
1610 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1612 /* Read the compilation unit die. */
1613 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1614 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1615 abfd
, info_ptr
, cu
);
1617 /* Set the language we're debugging. */
1618 set_cu_language (comp_unit_die
.language
, cu
);
1620 /* Link this compilation unit into the compilation unit tree. */
1622 cu
->per_cu
= this_cu
;
1624 /* Check if comp unit has_children.
1625 If so, read the rest of the partial symbols from this comp unit.
1626 If not, there's no more debug_info for this comp unit. */
1627 if (comp_unit_die
.has_children
)
1628 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1630 do_cleanups (back_to
);
1633 /* Create a list of all compilation units in OBJFILE. We do this only
1634 if an inter-comp-unit reference is found; presumably if there is one,
1635 there will be many, and one will occur early in the .debug_info section.
1636 So there's no point in building this list incrementally. */
1639 create_all_comp_units (struct objfile
*objfile
)
1643 struct dwarf2_per_cu_data
**all_comp_units
;
1644 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1648 all_comp_units
= xmalloc (n_allocated
1649 * sizeof (struct dwarf2_per_cu_data
*));
1651 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1653 struct comp_unit_head cu_header
;
1654 gdb_byte
*beg_of_comp_unit
;
1655 struct dwarf2_per_cu_data
*this_cu
;
1656 unsigned long offset
;
1657 unsigned int bytes_read
;
1659 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1661 /* Read just enough information to find out where the next
1662 compilation unit is. */
1663 cu_header
.initial_length_size
= 0;
1664 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1665 &cu_header
, &bytes_read
);
1667 /* Save the compilation unit for later lookup. */
1668 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1669 sizeof (struct dwarf2_per_cu_data
));
1670 memset (this_cu
, 0, sizeof (*this_cu
));
1671 this_cu
->offset
= offset
;
1672 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1674 if (n_comp_units
== n_allocated
)
1677 all_comp_units
= xrealloc (all_comp_units
,
1679 * sizeof (struct dwarf2_per_cu_data
*));
1681 all_comp_units
[n_comp_units
++] = this_cu
;
1683 info_ptr
= info_ptr
+ this_cu
->length
;
1686 dwarf2_per_objfile
->all_comp_units
1687 = obstack_alloc (&objfile
->objfile_obstack
,
1688 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1689 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1690 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1691 xfree (all_comp_units
);
1692 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1695 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1696 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1700 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1701 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1703 struct objfile
*objfile
= cu
->objfile
;
1704 bfd
*abfd
= objfile
->obfd
;
1705 struct partial_die_info
*pdi
;
1707 /* Now, march along the PDI's, descending into ones which have
1708 interesting children but skipping the children of the other ones,
1709 until we reach the end of the compilation unit. */
1715 fixup_partial_die (pdi
, cu
);
1717 /* Anonymous namespaces have no name but have interesting
1718 children, so we need to look at them. Ditto for anonymous
1721 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1722 || pdi
->tag
== DW_TAG_enumeration_type
)
1726 case DW_TAG_subprogram
:
1727 if (pdi
->has_pc_info
)
1729 if (pdi
->lowpc
< *lowpc
)
1731 *lowpc
= pdi
->lowpc
;
1733 if (pdi
->highpc
> *highpc
)
1735 *highpc
= pdi
->highpc
;
1737 if (!pdi
->is_declaration
)
1739 add_partial_symbol (pdi
, cu
);
1743 case DW_TAG_variable
:
1744 case DW_TAG_typedef
:
1745 case DW_TAG_union_type
:
1746 if (!pdi
->is_declaration
)
1748 add_partial_symbol (pdi
, cu
);
1751 case DW_TAG_class_type
:
1752 case DW_TAG_structure_type
:
1753 if (!pdi
->is_declaration
)
1755 add_partial_symbol (pdi
, cu
);
1758 case DW_TAG_enumeration_type
:
1759 if (!pdi
->is_declaration
)
1760 add_partial_enumeration (pdi
, cu
);
1762 case DW_TAG_base_type
:
1763 case DW_TAG_subrange_type
:
1764 /* File scope base type definitions are added to the partial
1766 add_partial_symbol (pdi
, cu
);
1768 case DW_TAG_namespace
:
1769 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1776 /* If the die has a sibling, skip to the sibling. */
1778 pdi
= pdi
->die_sibling
;
1782 /* Functions used to compute the fully scoped name of a partial DIE.
1784 Normally, this is simple. For C++, the parent DIE's fully scoped
1785 name is concatenated with "::" and the partial DIE's name. For
1786 Java, the same thing occurs except that "." is used instead of "::".
1787 Enumerators are an exception; they use the scope of their parent
1788 enumeration type, i.e. the name of the enumeration type is not
1789 prepended to the enumerator.
1791 There are two complexities. One is DW_AT_specification; in this
1792 case "parent" means the parent of the target of the specification,
1793 instead of the direct parent of the DIE. The other is compilers
1794 which do not emit DW_TAG_namespace; in this case we try to guess
1795 the fully qualified name of structure types from their members'
1796 linkage names. This must be done using the DIE's children rather
1797 than the children of any DW_AT_specification target. We only need
1798 to do this for structures at the top level, i.e. if the target of
1799 any DW_AT_specification (if any; otherwise the DIE itself) does not
1802 /* Compute the scope prefix associated with PDI's parent, in
1803 compilation unit CU. The result will be allocated on CU's
1804 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1805 field. NULL is returned if no prefix is necessary. */
1807 partial_die_parent_scope (struct partial_die_info
*pdi
,
1808 struct dwarf2_cu
*cu
)
1810 char *grandparent_scope
;
1811 struct partial_die_info
*parent
, *real_pdi
;
1813 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1814 then this means the parent of the specification DIE. */
1817 while (real_pdi
->has_specification
)
1818 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1820 parent
= real_pdi
->die_parent
;
1824 if (parent
->scope_set
)
1825 return parent
->scope
;
1827 fixup_partial_die (parent
, cu
);
1829 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1831 if (parent
->tag
== DW_TAG_namespace
1832 || parent
->tag
== DW_TAG_structure_type
1833 || parent
->tag
== DW_TAG_class_type
1834 || parent
->tag
== DW_TAG_union_type
)
1836 if (grandparent_scope
== NULL
)
1837 parent
->scope
= parent
->name
;
1839 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1842 else if (parent
->tag
== DW_TAG_enumeration_type
)
1843 /* Enumerators should not get the name of the enumeration as a prefix. */
1844 parent
->scope
= grandparent_scope
;
1847 /* FIXME drow/2004-04-01: What should we be doing with
1848 function-local names? For partial symbols, we should probably be
1850 complaint (&symfile_complaints
,
1851 _("unhandled containing DIE tag %d for DIE at %d"),
1852 parent
->tag
, pdi
->offset
);
1853 parent
->scope
= grandparent_scope
;
1856 parent
->scope_set
= 1;
1857 return parent
->scope
;
1860 /* Return the fully scoped name associated with PDI, from compilation unit
1861 CU. The result will be allocated with malloc. */
1863 partial_die_full_name (struct partial_die_info
*pdi
,
1864 struct dwarf2_cu
*cu
)
1868 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1869 if (parent_scope
== NULL
)
1872 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1876 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1878 struct objfile
*objfile
= cu
->objfile
;
1881 const char *my_prefix
;
1882 const struct partial_symbol
*psym
= NULL
;
1884 int built_actual_name
= 0;
1886 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1890 if (pdi_needs_namespace (pdi
->tag
))
1892 actual_name
= partial_die_full_name (pdi
, cu
);
1894 built_actual_name
= 1;
1897 if (actual_name
== NULL
)
1898 actual_name
= pdi
->name
;
1902 case DW_TAG_subprogram
:
1903 if (pdi
->is_external
)
1905 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1906 mst_text, objfile); */
1907 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1908 VAR_DOMAIN
, LOC_BLOCK
,
1909 &objfile
->global_psymbols
,
1910 0, pdi
->lowpc
+ baseaddr
,
1911 cu
->language
, objfile
);
1915 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1916 mst_file_text, objfile); */
1917 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1918 VAR_DOMAIN
, LOC_BLOCK
,
1919 &objfile
->static_psymbols
,
1920 0, pdi
->lowpc
+ baseaddr
,
1921 cu
->language
, objfile
);
1924 case DW_TAG_variable
:
1925 if (pdi
->is_external
)
1928 Don't enter into the minimal symbol tables as there is
1929 a minimal symbol table entry from the ELF symbols already.
1930 Enter into partial symbol table if it has a location
1931 descriptor or a type.
1932 If the location descriptor is missing, new_symbol will create
1933 a LOC_UNRESOLVED symbol, the address of the variable will then
1934 be determined from the minimal symbol table whenever the variable
1936 The address for the partial symbol table entry is not
1937 used by GDB, but it comes in handy for debugging partial symbol
1941 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1942 if (pdi
->locdesc
|| pdi
->has_type
)
1943 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1944 VAR_DOMAIN
, LOC_STATIC
,
1945 &objfile
->global_psymbols
,
1947 cu
->language
, objfile
);
1951 /* Static Variable. Skip symbols without location descriptors. */
1952 if (pdi
->locdesc
== NULL
)
1954 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1955 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1956 mst_file_data, objfile); */
1957 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1958 VAR_DOMAIN
, LOC_STATIC
,
1959 &objfile
->static_psymbols
,
1961 cu
->language
, objfile
);
1964 case DW_TAG_typedef
:
1965 case DW_TAG_base_type
:
1966 case DW_TAG_subrange_type
:
1967 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1968 VAR_DOMAIN
, LOC_TYPEDEF
,
1969 &objfile
->static_psymbols
,
1970 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1972 case DW_TAG_namespace
:
1973 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1974 VAR_DOMAIN
, LOC_TYPEDEF
,
1975 &objfile
->global_psymbols
,
1976 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1978 case DW_TAG_class_type
:
1979 case DW_TAG_structure_type
:
1980 case DW_TAG_union_type
:
1981 case DW_TAG_enumeration_type
:
1982 /* Skip aggregate types without children, these are external
1984 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1985 static vs. global. */
1986 if (pdi
->has_children
== 0)
1988 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1989 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1990 (cu
->language
== language_cplus
1991 || cu
->language
== language_java
)
1992 ? &objfile
->global_psymbols
1993 : &objfile
->static_psymbols
,
1994 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1996 if (cu
->language
== language_cplus
1997 || cu
->language
== language_java
)
1999 /* For C++ and Java, these implicitly act as typedefs as well. */
2000 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2001 VAR_DOMAIN
, LOC_TYPEDEF
,
2002 &objfile
->global_psymbols
,
2003 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2006 case DW_TAG_enumerator
:
2007 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2008 VAR_DOMAIN
, LOC_CONST
,
2009 (cu
->language
== language_cplus
2010 || cu
->language
== language_java
)
2011 ? &objfile
->global_psymbols
2012 : &objfile
->static_psymbols
,
2013 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2019 /* Check to see if we should scan the name for possible namespace
2020 info. Only do this if this is C++, if we don't have namespace
2021 debugging info in the file, if the psym is of an appropriate type
2022 (otherwise we'll have psym == NULL), and if we actually had a
2023 mangled name to begin with. */
2025 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2026 cases which do not set PSYM above? */
2028 if (cu
->language
== language_cplus
2029 && cu
->has_namespace_info
== 0
2031 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2032 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2035 if (built_actual_name
)
2036 xfree (actual_name
);
2039 /* Determine whether a die of type TAG living in a C++ class or
2040 namespace needs to have the name of the scope prepended to the
2041 name listed in the die. */
2044 pdi_needs_namespace (enum dwarf_tag tag
)
2048 case DW_TAG_namespace
:
2049 case DW_TAG_typedef
:
2050 case DW_TAG_class_type
:
2051 case DW_TAG_structure_type
:
2052 case DW_TAG_union_type
:
2053 case DW_TAG_enumeration_type
:
2054 case DW_TAG_enumerator
:
2061 /* Read a partial die corresponding to a namespace; also, add a symbol
2062 corresponding to that namespace to the symbol table. NAMESPACE is
2063 the name of the enclosing namespace. */
2066 add_partial_namespace (struct partial_die_info
*pdi
,
2067 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2068 struct dwarf2_cu
*cu
)
2070 struct objfile
*objfile
= cu
->objfile
;
2072 /* Add a symbol for the namespace. */
2074 add_partial_symbol (pdi
, cu
);
2076 /* Now scan partial symbols in that namespace. */
2078 if (pdi
->has_children
)
2079 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2082 /* See if we can figure out if the class lives in a namespace. We do
2083 this by looking for a member function; its demangled name will
2084 contain namespace info, if there is any. */
2087 guess_structure_name (struct partial_die_info
*struct_pdi
,
2088 struct dwarf2_cu
*cu
)
2090 if ((cu
->language
== language_cplus
2091 || cu
->language
== language_java
)
2092 && cu
->has_namespace_info
== 0
2093 && struct_pdi
->has_children
)
2095 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2096 what template types look like, because the demangler
2097 frequently doesn't give the same name as the debug info. We
2098 could fix this by only using the demangled name to get the
2099 prefix (but see comment in read_structure_type). */
2101 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2102 struct partial_die_info
*real_pdi
;
2104 /* If this DIE (this DIE's specification, if any) has a parent, then
2105 we should not do this. We'll prepend the parent's fully qualified
2106 name when we create the partial symbol. */
2108 real_pdi
= struct_pdi
;
2109 while (real_pdi
->has_specification
)
2110 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2112 if (real_pdi
->die_parent
!= NULL
)
2115 while (child_pdi
!= NULL
)
2117 if (child_pdi
->tag
== DW_TAG_subprogram
)
2119 char *actual_class_name
2120 = language_class_name_from_physname (cu
->language_defn
,
2122 if (actual_class_name
!= NULL
)
2125 = obsavestring (actual_class_name
,
2126 strlen (actual_class_name
),
2127 &cu
->comp_unit_obstack
);
2128 xfree (actual_class_name
);
2133 child_pdi
= child_pdi
->die_sibling
;
2138 /* Read a partial die corresponding to an enumeration type. */
2141 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2142 struct dwarf2_cu
*cu
)
2144 struct objfile
*objfile
= cu
->objfile
;
2145 bfd
*abfd
= objfile
->obfd
;
2146 struct partial_die_info
*pdi
;
2148 if (enum_pdi
->name
!= NULL
)
2149 add_partial_symbol (enum_pdi
, cu
);
2151 pdi
= enum_pdi
->die_child
;
2154 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2155 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2157 add_partial_symbol (pdi
, cu
);
2158 pdi
= pdi
->die_sibling
;
2162 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2163 Return the corresponding abbrev, or NULL if the number is zero (indicating
2164 an empty DIE). In either case *BYTES_READ will be set to the length of
2165 the initial number. */
2167 static struct abbrev_info
*
2168 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2169 struct dwarf2_cu
*cu
)
2171 bfd
*abfd
= cu
->objfile
->obfd
;
2172 unsigned int abbrev_number
;
2173 struct abbrev_info
*abbrev
;
2175 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2177 if (abbrev_number
== 0)
2180 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2183 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2184 bfd_get_filename (abfd
));
2190 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2191 pointer to the end of a series of DIEs, terminated by an empty
2192 DIE. Any children of the skipped DIEs will also be skipped. */
2195 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2197 struct abbrev_info
*abbrev
;
2198 unsigned int bytes_read
;
2202 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2204 return info_ptr
+ bytes_read
;
2206 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2210 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2211 should point just after the initial uleb128 of a DIE, and the
2212 abbrev corresponding to that skipped uleb128 should be passed in
2213 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2217 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2218 struct dwarf2_cu
*cu
)
2220 unsigned int bytes_read
;
2221 struct attribute attr
;
2222 bfd
*abfd
= cu
->objfile
->obfd
;
2223 unsigned int form
, i
;
2225 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2227 /* The only abbrev we care about is DW_AT_sibling. */
2228 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2230 read_attribute (&attr
, &abbrev
->attrs
[i
],
2231 abfd
, info_ptr
, cu
);
2232 if (attr
.form
== DW_FORM_ref_addr
)
2233 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2235 return dwarf2_per_objfile
->info_buffer
2236 + dwarf2_get_ref_die_offset (&attr
, cu
);
2239 /* If it isn't DW_AT_sibling, skip this attribute. */
2240 form
= abbrev
->attrs
[i
].form
;
2245 case DW_FORM_ref_addr
:
2246 info_ptr
+= cu
->header
.addr_size
;
2265 case DW_FORM_string
:
2266 read_string (abfd
, info_ptr
, &bytes_read
);
2267 info_ptr
+= bytes_read
;
2270 info_ptr
+= cu
->header
.offset_size
;
2273 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2274 info_ptr
+= bytes_read
;
2276 case DW_FORM_block1
:
2277 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2279 case DW_FORM_block2
:
2280 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2282 case DW_FORM_block4
:
2283 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2287 case DW_FORM_ref_udata
:
2288 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2290 case DW_FORM_indirect
:
2291 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2292 info_ptr
+= bytes_read
;
2293 /* We need to continue parsing from here, so just go back to
2295 goto skip_attribute
;
2298 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2299 dwarf_form_name (form
),
2300 bfd_get_filename (abfd
));
2304 if (abbrev
->has_children
)
2305 return skip_children (info_ptr
, cu
);
2310 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2311 the next DIE after ORIG_PDI. */
2314 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2315 bfd
*abfd
, struct dwarf2_cu
*cu
)
2317 /* Do we know the sibling already? */
2319 if (orig_pdi
->sibling
)
2320 return orig_pdi
->sibling
;
2322 /* Are there any children to deal with? */
2324 if (!orig_pdi
->has_children
)
2327 /* Skip the children the long way. */
2329 return skip_children (info_ptr
, cu
);
2332 /* Expand this partial symbol table into a full symbol table. */
2335 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2337 /* FIXME: This is barely more than a stub. */
2342 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2348 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2349 gdb_flush (gdb_stdout
);
2352 /* Restore our global data. */
2353 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2354 dwarf2_objfile_data_key
);
2356 psymtab_to_symtab_1 (pst
);
2358 /* Finish up the debug error message. */
2360 printf_filtered (_("done.\n"));
2365 /* Add PER_CU to the queue. */
2368 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2370 struct dwarf2_queue_item
*item
;
2373 item
= xmalloc (sizeof (*item
));
2374 item
->per_cu
= per_cu
;
2377 if (dwarf2_queue
== NULL
)
2378 dwarf2_queue
= item
;
2380 dwarf2_queue_tail
->next
= item
;
2382 dwarf2_queue_tail
= item
;
2385 /* Process the queue. */
2388 process_queue (struct objfile
*objfile
)
2390 struct dwarf2_queue_item
*item
, *next_item
;
2392 /* Initially, there is just one item on the queue. Load its DIEs,
2393 and the DIEs of any other compilation units it requires,
2396 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2398 /* Read in this compilation unit. This may add new items to
2399 the end of the queue. */
2400 load_full_comp_unit (item
->per_cu
, objfile
);
2402 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2403 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2405 /* If this compilation unit has already had full symbols created,
2406 reset the TYPE fields in each DIE. */
2407 if (item
->per_cu
->type_hash
)
2408 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2412 /* Now everything left on the queue needs to be read in. Process
2413 them, one at a time, removing from the queue as we finish. */
2414 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2416 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2417 process_full_comp_unit (item
->per_cu
);
2419 item
->per_cu
->queued
= 0;
2420 next_item
= item
->next
;
2424 dwarf2_queue_tail
= NULL
;
2427 /* Free all allocated queue entries. This function only releases anything if
2428 an error was thrown; if the queue was processed then it would have been
2429 freed as we went along. */
2432 dwarf2_release_queue (void *dummy
)
2434 struct dwarf2_queue_item
*item
, *last
;
2436 item
= dwarf2_queue
;
2439 /* Anything still marked queued is likely to be in an
2440 inconsistent state, so discard it. */
2441 if (item
->per_cu
->queued
)
2443 if (item
->per_cu
->cu
!= NULL
)
2444 free_one_cached_comp_unit (item
->per_cu
->cu
);
2445 item
->per_cu
->queued
= 0;
2453 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2456 /* Read in full symbols for PST, and anything it depends on. */
2459 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2461 struct dwarf2_per_cu_data
*per_cu
;
2462 struct cleanup
*back_to
;
2465 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2466 if (!pst
->dependencies
[i
]->readin
)
2468 /* Inform about additional files that need to be read in. */
2471 /* FIXME: i18n: Need to make this a single string. */
2472 fputs_filtered (" ", gdb_stdout
);
2474 fputs_filtered ("and ", gdb_stdout
);
2476 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2477 wrap_here (""); /* Flush output */
2478 gdb_flush (gdb_stdout
);
2480 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2483 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2487 /* It's an include file, no symbols to read for it.
2488 Everything is in the parent symtab. */
2493 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2495 queue_comp_unit (per_cu
);
2497 process_queue (pst
->objfile
);
2499 /* Age the cache, releasing compilation units that have not
2500 been used recently. */
2501 age_cached_comp_units ();
2503 do_cleanups (back_to
);
2506 /* Load the DIEs associated with PST and PER_CU into memory. */
2508 static struct dwarf2_cu
*
2509 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2511 bfd
*abfd
= objfile
->obfd
;
2512 struct dwarf2_cu
*cu
;
2513 unsigned long offset
;
2515 struct cleanup
*back_to
, *free_cu_cleanup
;
2516 struct attribute
*attr
;
2519 /* Set local variables from the partial symbol table info. */
2520 offset
= per_cu
->offset
;
2522 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2524 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2525 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2527 /* If an error occurs while loading, release our storage. */
2528 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2530 cu
->objfile
= objfile
;
2532 /* read in the comp_unit header */
2533 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2535 /* Read the abbrevs for this compilation unit */
2536 dwarf2_read_abbrevs (abfd
, cu
);
2537 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2539 cu
->header
.offset
= offset
;
2541 cu
->per_cu
= per_cu
;
2544 /* We use this obstack for block values in dwarf_alloc_block. */
2545 obstack_init (&cu
->comp_unit_obstack
);
2547 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2549 /* We try not to read any attributes in this function, because not
2550 all objfiles needed for references have been loaded yet, and symbol
2551 table processing isn't initialized. But we have to set the CU language,
2552 or we won't be able to build types correctly. */
2553 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2555 set_cu_language (DW_UNSND (attr
), cu
);
2557 set_cu_language (language_minimal
, cu
);
2559 do_cleanups (back_to
);
2561 /* We've successfully allocated this compilation unit. Let our caller
2562 clean it up when finished with it. */
2563 discard_cleanups (free_cu_cleanup
);
2568 /* Generate full symbol information for PST and CU, whose DIEs have
2569 already been loaded into memory. */
2572 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2574 struct partial_symtab
*pst
= per_cu
->psymtab
;
2575 struct dwarf2_cu
*cu
= per_cu
->cu
;
2576 struct objfile
*objfile
= pst
->objfile
;
2577 bfd
*abfd
= objfile
->obfd
;
2578 CORE_ADDR lowpc
, highpc
;
2579 struct symtab
*symtab
;
2580 struct cleanup
*back_to
;
2581 struct attribute
*attr
;
2584 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2586 /* We're in the global namespace. */
2587 processing_current_prefix
= "";
2590 back_to
= make_cleanup (really_free_pendings
, NULL
);
2592 cu
->list_in_scope
= &file_symbols
;
2594 /* Find the base address of the compilation unit for range lists and
2595 location lists. It will normally be specified by DW_AT_low_pc.
2596 In DWARF-3 draft 4, the base address could be overridden by
2597 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2598 compilation units with discontinuous ranges. */
2600 cu
->header
.base_known
= 0;
2601 cu
->header
.base_address
= 0;
2603 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2606 cu
->header
.base_address
= DW_ADDR (attr
);
2607 cu
->header
.base_known
= 1;
2611 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2614 cu
->header
.base_address
= DW_ADDR (attr
);
2615 cu
->header
.base_known
= 1;
2619 /* Do line number decoding in read_file_scope () */
2620 process_die (cu
->dies
, cu
);
2622 /* Some compilers don't define a DW_AT_high_pc attribute for the
2623 compilation unit. If the DW_AT_high_pc is missing, synthesize
2624 it, by scanning the DIE's below the compilation unit. */
2625 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2627 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2629 /* Set symtab language to language from DW_AT_language.
2630 If the compilation is from a C file generated by language preprocessors,
2631 do not set the language if it was already deduced by start_subfile. */
2633 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2635 symtab
->language
= cu
->language
;
2637 pst
->symtab
= symtab
;
2640 do_cleanups (back_to
);
2643 /* Process a die and its children. */
2646 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2650 case DW_TAG_padding
:
2652 case DW_TAG_compile_unit
:
2653 read_file_scope (die
, cu
);
2655 case DW_TAG_subprogram
:
2656 read_subroutine_type (die
, cu
);
2657 read_func_scope (die
, cu
);
2659 case DW_TAG_inlined_subroutine
:
2660 /* FIXME: These are ignored for now.
2661 They could be used to set breakpoints on all inlined instances
2662 of a function and make GDB `next' properly over inlined functions. */
2664 case DW_TAG_lexical_block
:
2665 case DW_TAG_try_block
:
2666 case DW_TAG_catch_block
:
2667 read_lexical_block_scope (die
, cu
);
2669 case DW_TAG_class_type
:
2670 case DW_TAG_structure_type
:
2671 case DW_TAG_union_type
:
2672 read_structure_type (die
, cu
);
2673 process_structure_scope (die
, cu
);
2675 case DW_TAG_enumeration_type
:
2676 read_enumeration_type (die
, cu
);
2677 process_enumeration_scope (die
, cu
);
2680 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2681 a symbol or process any children. Therefore it doesn't do anything
2682 that won't be done on-demand by read_type_die. */
2683 case DW_TAG_subroutine_type
:
2684 read_subroutine_type (die
, cu
);
2686 case DW_TAG_set_type
:
2687 read_set_type (die
, cu
);
2689 case DW_TAG_array_type
:
2690 read_array_type (die
, cu
);
2692 case DW_TAG_pointer_type
:
2693 read_tag_pointer_type (die
, cu
);
2695 case DW_TAG_ptr_to_member_type
:
2696 read_tag_ptr_to_member_type (die
, cu
);
2698 case DW_TAG_reference_type
:
2699 read_tag_reference_type (die
, cu
);
2701 case DW_TAG_string_type
:
2702 read_tag_string_type (die
, cu
);
2706 case DW_TAG_base_type
:
2707 read_base_type (die
, cu
);
2708 /* Add a typedef symbol for the type definition, if it has a
2710 new_symbol (die
, die
->type
, cu
);
2712 case DW_TAG_subrange_type
:
2713 read_subrange_type (die
, cu
);
2714 /* Add a typedef symbol for the type definition, if it has a
2716 new_symbol (die
, die
->type
, cu
);
2718 case DW_TAG_common_block
:
2719 read_common_block (die
, cu
);
2721 case DW_TAG_common_inclusion
:
2723 case DW_TAG_namespace
:
2724 processing_has_namespace_info
= 1;
2725 read_namespace (die
, cu
);
2727 case DW_TAG_imported_declaration
:
2728 case DW_TAG_imported_module
:
2729 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2730 information contained in these. DW_TAG_imported_declaration
2731 dies shouldn't have children; DW_TAG_imported_module dies
2732 shouldn't in the C++ case, but conceivably could in the
2733 Fortran case, so we'll have to replace this gdb_assert if
2734 Fortran compilers start generating that info. */
2735 processing_has_namespace_info
= 1;
2736 gdb_assert (die
->child
== NULL
);
2739 new_symbol (die
, NULL
, cu
);
2745 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2747 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2751 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2753 struct objfile
*objfile
= cu
->objfile
;
2754 struct comp_unit_head
*cu_header
= &cu
->header
;
2755 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2756 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2757 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2758 struct attribute
*attr
;
2759 char *name
= "<unknown>";
2760 char *comp_dir
= NULL
;
2761 struct die_info
*child_die
;
2762 bfd
*abfd
= objfile
->obfd
;
2763 struct line_header
*line_header
= 0;
2766 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2768 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2770 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2771 from finish_block. */
2772 if (lowpc
== ((CORE_ADDR
) -1))
2777 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2780 name
= DW_STRING (attr
);
2782 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2785 comp_dir
= DW_STRING (attr
);
2788 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2789 directory, get rid of it. */
2790 char *cp
= strchr (comp_dir
, ':');
2792 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2797 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2800 set_cu_language (DW_UNSND (attr
), cu
);
2803 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2805 cu
->producer
= DW_STRING (attr
);
2807 /* We assume that we're processing GCC output. */
2808 processing_gcc_compilation
= 2;
2810 /* The compilation unit may be in a different language or objfile,
2811 zero out all remembered fundamental types. */
2812 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2814 start_symtab (name
, comp_dir
, lowpc
);
2815 record_debugformat ("DWARF 2");
2816 record_producer (cu
->producer
);
2818 initialize_cu_func_list (cu
);
2820 /* Process all dies in compilation unit. */
2821 if (die
->child
!= NULL
)
2823 child_die
= die
->child
;
2824 while (child_die
&& child_die
->tag
)
2826 process_die (child_die
, cu
);
2827 child_die
= sibling_die (child_die
);
2831 /* Decode line number information if present. */
2832 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2835 unsigned int line_offset
= DW_UNSND (attr
);
2836 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2839 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2840 (void *) line_header
);
2841 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2845 /* Decode macro information, if present. Dwarf 2 macro information
2846 refers to information in the line number info statement program
2847 header, so we can only read it if we've read the header
2849 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2850 if (attr
&& line_header
)
2852 unsigned int macro_offset
= DW_UNSND (attr
);
2853 dwarf_decode_macros (line_header
, macro_offset
,
2854 comp_dir
, abfd
, cu
);
2856 do_cleanups (back_to
);
2860 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2861 struct dwarf2_cu
*cu
)
2863 struct function_range
*thisfn
;
2865 thisfn
= (struct function_range
*)
2866 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2867 thisfn
->name
= name
;
2868 thisfn
->lowpc
= lowpc
;
2869 thisfn
->highpc
= highpc
;
2870 thisfn
->seen_line
= 0;
2871 thisfn
->next
= NULL
;
2873 if (cu
->last_fn
== NULL
)
2874 cu
->first_fn
= thisfn
;
2876 cu
->last_fn
->next
= thisfn
;
2878 cu
->last_fn
= thisfn
;
2882 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2884 struct objfile
*objfile
= cu
->objfile
;
2885 struct context_stack
*new;
2888 struct die_info
*child_die
;
2889 struct attribute
*attr
;
2891 const char *previous_prefix
= processing_current_prefix
;
2892 struct cleanup
*back_to
= NULL
;
2895 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2897 name
= dwarf2_linkage_name (die
, cu
);
2899 /* Ignore functions with missing or empty names and functions with
2900 missing or invalid low and high pc attributes. */
2901 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2904 if (cu
->language
== language_cplus
2905 || cu
->language
== language_java
)
2907 struct die_info
*spec_die
= die_specification (die
, cu
);
2909 /* NOTE: carlton/2004-01-23: We have to be careful in the
2910 presence of DW_AT_specification. For example, with GCC 3.4,
2915 // Definition of N::foo.
2919 then we'll have a tree of DIEs like this:
2921 1: DW_TAG_compile_unit
2922 2: DW_TAG_namespace // N
2923 3: DW_TAG_subprogram // declaration of N::foo
2924 4: DW_TAG_subprogram // definition of N::foo
2925 DW_AT_specification // refers to die #3
2927 Thus, when processing die #4, we have to pretend that we're
2928 in the context of its DW_AT_specification, namely the contex
2931 if (spec_die
!= NULL
)
2933 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2934 processing_current_prefix
= specification_prefix
;
2935 back_to
= make_cleanup (xfree
, specification_prefix
);
2942 /* Record the function range for dwarf_decode_lines. */
2943 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2945 new = push_context (0, lowpc
);
2946 new->name
= new_symbol (die
, die
->type
, cu
);
2948 /* If there is a location expression for DW_AT_frame_base, record
2950 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2952 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2953 expression is being recorded directly in the function's symbol
2954 and not in a separate frame-base object. I guess this hack is
2955 to avoid adding some sort of frame-base adjunct/annex to the
2956 function's symbol :-(. The problem with doing this is that it
2957 results in a function symbol with a location expression that
2958 has nothing to do with the location of the function, ouch! The
2959 relationship should be: a function's symbol has-a frame base; a
2960 frame-base has-a location expression. */
2961 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2963 cu
->list_in_scope
= &local_symbols
;
2965 if (die
->child
!= NULL
)
2967 child_die
= die
->child
;
2968 while (child_die
&& child_die
->tag
)
2970 process_die (child_die
, cu
);
2971 child_die
= sibling_die (child_die
);
2975 new = pop_context ();
2976 /* Make a block for the local symbols within. */
2977 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2978 lowpc
, highpc
, objfile
);
2980 /* In C++, we can have functions nested inside functions (e.g., when
2981 a function declares a class that has methods). This means that
2982 when we finish processing a function scope, we may need to go
2983 back to building a containing block's symbol lists. */
2984 local_symbols
= new->locals
;
2985 param_symbols
= new->params
;
2987 /* If we've finished processing a top-level function, subsequent
2988 symbols go in the file symbol list. */
2989 if (outermost_context_p ())
2990 cu
->list_in_scope
= &file_symbols
;
2992 processing_current_prefix
= previous_prefix
;
2993 if (back_to
!= NULL
)
2994 do_cleanups (back_to
);
2997 /* Process all the DIES contained within a lexical block scope. Start
2998 a new scope, process the dies, and then close the scope. */
3001 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3003 struct objfile
*objfile
= cu
->objfile
;
3004 struct context_stack
*new;
3005 CORE_ADDR lowpc
, highpc
;
3006 struct die_info
*child_die
;
3009 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3011 /* Ignore blocks with missing or invalid low and high pc attributes. */
3012 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3013 as multiple lexical blocks? Handling children in a sane way would
3014 be nasty. Might be easier to properly extend generic blocks to
3016 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3021 push_context (0, lowpc
);
3022 if (die
->child
!= NULL
)
3024 child_die
= die
->child
;
3025 while (child_die
&& child_die
->tag
)
3027 process_die (child_die
, cu
);
3028 child_die
= sibling_die (child_die
);
3031 new = pop_context ();
3033 if (local_symbols
!= NULL
)
3035 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3038 local_symbols
= new->locals
;
3041 /* Get low and high pc attributes from a die. Return 1 if the attributes
3042 are present and valid, otherwise, return 0. Return -1 if the range is
3043 discontinuous, i.e. derived from DW_AT_ranges information. */
3045 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3046 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3048 struct objfile
*objfile
= cu
->objfile
;
3049 struct comp_unit_head
*cu_header
= &cu
->header
;
3050 struct attribute
*attr
;
3051 bfd
*obfd
= objfile
->obfd
;
3056 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3059 high
= DW_ADDR (attr
);
3060 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3062 low
= DW_ADDR (attr
);
3064 /* Found high w/o low attribute. */
3067 /* Found consecutive range of addresses. */
3072 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3075 unsigned int addr_size
= cu_header
->addr_size
;
3076 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3077 /* Value of the DW_AT_ranges attribute is the offset in the
3078 .debug_ranges section. */
3079 unsigned int offset
= DW_UNSND (attr
);
3080 /* Base address selection entry. */
3088 found_base
= cu_header
->base_known
;
3089 base
= cu_header
->base_address
;
3091 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3093 complaint (&symfile_complaints
,
3094 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3098 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3100 /* Read in the largest possible address. */
3101 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3102 if ((marker
& mask
) == mask
)
3104 /* If we found the largest possible address, then
3105 read the base address. */
3106 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3107 buffer
+= 2 * addr_size
;
3108 offset
+= 2 * addr_size
;
3116 CORE_ADDR range_beginning
, range_end
;
3118 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3119 buffer
+= addr_size
;
3120 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3121 buffer
+= addr_size
;
3122 offset
+= 2 * addr_size
;
3124 /* An end of list marker is a pair of zero addresses. */
3125 if (range_beginning
== 0 && range_end
== 0)
3126 /* Found the end of list entry. */
3129 /* Each base address selection entry is a pair of 2 values.
3130 The first is the largest possible address, the second is
3131 the base address. Check for a base address here. */
3132 if ((range_beginning
& mask
) == mask
)
3134 /* If we found the largest possible address, then
3135 read the base address. */
3136 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3143 /* We have no valid base address for the ranges
3145 complaint (&symfile_complaints
,
3146 _("Invalid .debug_ranges data (no base address)"));
3150 range_beginning
+= base
;
3153 /* FIXME: This is recording everything as a low-high
3154 segment of consecutive addresses. We should have a
3155 data structure for discontiguous block ranges
3159 low
= range_beginning
;
3165 if (range_beginning
< low
)
3166 low
= range_beginning
;
3167 if (range_end
> high
)
3173 /* If the first entry is an end-of-list marker, the range
3174 describes an empty scope, i.e. no instructions. */
3184 /* When using the GNU linker, .gnu.linkonce. sections are used to
3185 eliminate duplicate copies of functions and vtables and such.
3186 The linker will arbitrarily choose one and discard the others.
3187 The AT_*_pc values for such functions refer to local labels in
3188 these sections. If the section from that file was discarded, the
3189 labels are not in the output, so the relocs get a value of 0.
3190 If this is a discarded function, mark the pc bounds as invalid,
3191 so that GDB will ignore it. */
3192 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3200 /* Get the low and high pc's represented by the scope DIE, and store
3201 them in *LOWPC and *HIGHPC. If the correct values can't be
3202 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3205 get_scope_pc_bounds (struct die_info
*die
,
3206 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3207 struct dwarf2_cu
*cu
)
3209 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3210 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3211 CORE_ADDR current_low
, current_high
;
3213 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3215 best_low
= current_low
;
3216 best_high
= current_high
;
3220 struct die_info
*child
= die
->child
;
3222 while (child
&& child
->tag
)
3224 switch (child
->tag
) {
3225 case DW_TAG_subprogram
:
3226 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3228 best_low
= min (best_low
, current_low
);
3229 best_high
= max (best_high
, current_high
);
3232 case DW_TAG_namespace
:
3233 /* FIXME: carlton/2004-01-16: Should we do this for
3234 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3235 that current GCC's always emit the DIEs corresponding
3236 to definitions of methods of classes as children of a
3237 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3238 the DIEs giving the declarations, which could be
3239 anywhere). But I don't see any reason why the
3240 standards says that they have to be there. */
3241 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3243 if (current_low
!= ((CORE_ADDR
) -1))
3245 best_low
= min (best_low
, current_low
);
3246 best_high
= max (best_high
, current_high
);
3254 child
= sibling_die (child
);
3259 *highpc
= best_high
;
3262 /* Add an aggregate field to the field list. */
3265 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3266 struct dwarf2_cu
*cu
)
3268 struct objfile
*objfile
= cu
->objfile
;
3269 struct nextfield
*new_field
;
3270 struct attribute
*attr
;
3272 char *fieldname
= "";
3274 /* Allocate a new field list entry and link it in. */
3275 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3276 make_cleanup (xfree
, new_field
);
3277 memset (new_field
, 0, sizeof (struct nextfield
));
3278 new_field
->next
= fip
->fields
;
3279 fip
->fields
= new_field
;
3282 /* Handle accessibility and virtuality of field.
3283 The default accessibility for members is public, the default
3284 accessibility for inheritance is private. */
3285 if (die
->tag
!= DW_TAG_inheritance
)
3286 new_field
->accessibility
= DW_ACCESS_public
;
3288 new_field
->accessibility
= DW_ACCESS_private
;
3289 new_field
->virtuality
= DW_VIRTUALITY_none
;
3291 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3293 new_field
->accessibility
= DW_UNSND (attr
);
3294 if (new_field
->accessibility
!= DW_ACCESS_public
)
3295 fip
->non_public_fields
= 1;
3296 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3298 new_field
->virtuality
= DW_UNSND (attr
);
3300 fp
= &new_field
->field
;
3302 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3304 /* Data member other than a C++ static data member. */
3306 /* Get type of field. */
3307 fp
->type
= die_type (die
, cu
);
3309 FIELD_STATIC_KIND (*fp
) = 0;
3311 /* Get bit size of field (zero if none). */
3312 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3315 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3319 FIELD_BITSIZE (*fp
) = 0;
3322 /* Get bit offset of field. */
3323 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3326 FIELD_BITPOS (*fp
) =
3327 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3330 FIELD_BITPOS (*fp
) = 0;
3331 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3334 if (BITS_BIG_ENDIAN
)
3336 /* For big endian bits, the DW_AT_bit_offset gives the
3337 additional bit offset from the MSB of the containing
3338 anonymous object to the MSB of the field. We don't
3339 have to do anything special since we don't need to
3340 know the size of the anonymous object. */
3341 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3345 /* For little endian bits, compute the bit offset to the
3346 MSB of the anonymous object, subtract off the number of
3347 bits from the MSB of the field to the MSB of the
3348 object, and then subtract off the number of bits of
3349 the field itself. The result is the bit offset of
3350 the LSB of the field. */
3352 int bit_offset
= DW_UNSND (attr
);
3354 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3357 /* The size of the anonymous object containing
3358 the bit field is explicit, so use the
3359 indicated size (in bytes). */
3360 anonymous_size
= DW_UNSND (attr
);
3364 /* The size of the anonymous object containing
3365 the bit field must be inferred from the type
3366 attribute of the data member containing the
3368 anonymous_size
= TYPE_LENGTH (fp
->type
);
3370 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3371 - bit_offset
- FIELD_BITSIZE (*fp
);
3375 /* Get name of field. */
3376 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3377 if (attr
&& DW_STRING (attr
))
3378 fieldname
= DW_STRING (attr
);
3380 /* The name is already allocated along with this objfile, so we don't
3381 need to duplicate it for the type. */
3382 fp
->name
= fieldname
;
3384 /* Change accessibility for artificial fields (e.g. virtual table
3385 pointer or virtual base class pointer) to private. */
3386 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3388 new_field
->accessibility
= DW_ACCESS_private
;
3389 fip
->non_public_fields
= 1;
3392 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3394 /* C++ static member. */
3396 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3397 is a declaration, but all versions of G++ as of this writing
3398 (so through at least 3.2.1) incorrectly generate
3399 DW_TAG_variable tags. */
3403 /* Get name of field. */
3404 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3405 if (attr
&& DW_STRING (attr
))
3406 fieldname
= DW_STRING (attr
);
3410 /* Get physical name. */
3411 physname
= dwarf2_linkage_name (die
, cu
);
3413 /* The name is already allocated along with this objfile, so we don't
3414 need to duplicate it for the type. */
3415 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3416 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3417 FIELD_NAME (*fp
) = fieldname
;
3419 else if (die
->tag
== DW_TAG_inheritance
)
3421 /* C++ base class field. */
3422 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3424 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3426 FIELD_BITSIZE (*fp
) = 0;
3427 FIELD_STATIC_KIND (*fp
) = 0;
3428 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3429 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3430 fip
->nbaseclasses
++;
3434 /* Create the vector of fields, and attach it to the type. */
3437 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3438 struct dwarf2_cu
*cu
)
3440 int nfields
= fip
->nfields
;
3442 /* Record the field count, allocate space for the array of fields,
3443 and create blank accessibility bitfields if necessary. */
3444 TYPE_NFIELDS (type
) = nfields
;
3445 TYPE_FIELDS (type
) = (struct field
*)
3446 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3447 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3449 if (fip
->non_public_fields
)
3451 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3453 TYPE_FIELD_PRIVATE_BITS (type
) =
3454 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3455 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3457 TYPE_FIELD_PROTECTED_BITS (type
) =
3458 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3459 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3461 TYPE_FIELD_IGNORE_BITS (type
) =
3462 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3463 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3466 /* If the type has baseclasses, allocate and clear a bit vector for
3467 TYPE_FIELD_VIRTUAL_BITS. */
3468 if (fip
->nbaseclasses
)
3470 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3471 unsigned char *pointer
;
3473 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3474 pointer
= TYPE_ALLOC (type
, num_bytes
);
3475 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3476 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3477 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3480 /* Copy the saved-up fields into the field vector. Start from the head
3481 of the list, adding to the tail of the field array, so that they end
3482 up in the same order in the array in which they were added to the list. */
3483 while (nfields
-- > 0)
3485 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3486 switch (fip
->fields
->accessibility
)
3488 case DW_ACCESS_private
:
3489 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3492 case DW_ACCESS_protected
:
3493 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3496 case DW_ACCESS_public
:
3500 /* Unknown accessibility. Complain and treat it as public. */
3502 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3503 fip
->fields
->accessibility
);
3507 if (nfields
< fip
->nbaseclasses
)
3509 switch (fip
->fields
->virtuality
)
3511 case DW_VIRTUALITY_virtual
:
3512 case DW_VIRTUALITY_pure_virtual
:
3513 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3517 fip
->fields
= fip
->fields
->next
;
3521 /* Add a member function to the proper fieldlist. */
3524 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3525 struct type
*type
, struct dwarf2_cu
*cu
)
3527 struct objfile
*objfile
= cu
->objfile
;
3528 struct attribute
*attr
;
3529 struct fnfieldlist
*flp
;
3531 struct fn_field
*fnp
;
3534 struct nextfnfield
*new_fnfield
;
3536 /* Get name of member function. */
3537 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3538 if (attr
&& DW_STRING (attr
))
3539 fieldname
= DW_STRING (attr
);
3543 /* Get the mangled name. */
3544 physname
= dwarf2_linkage_name (die
, cu
);
3546 /* Look up member function name in fieldlist. */
3547 for (i
= 0; i
< fip
->nfnfields
; i
++)
3549 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3553 /* Create new list element if necessary. */
3554 if (i
< fip
->nfnfields
)
3555 flp
= &fip
->fnfieldlists
[i
];
3558 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3560 fip
->fnfieldlists
= (struct fnfieldlist
*)
3561 xrealloc (fip
->fnfieldlists
,
3562 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3563 * sizeof (struct fnfieldlist
));
3564 if (fip
->nfnfields
== 0)
3565 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3567 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3568 flp
->name
= fieldname
;
3574 /* Create a new member function field and chain it to the field list
3576 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3577 make_cleanup (xfree
, new_fnfield
);
3578 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3579 new_fnfield
->next
= flp
->head
;
3580 flp
->head
= new_fnfield
;
3583 /* Fill in the member function field info. */
3584 fnp
= &new_fnfield
->fnfield
;
3585 /* The name is already allocated along with this objfile, so we don't
3586 need to duplicate it for the type. */
3587 fnp
->physname
= physname
? physname
: "";
3588 fnp
->type
= alloc_type (objfile
);
3589 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3591 int nparams
= TYPE_NFIELDS (die
->type
);
3593 /* TYPE is the domain of this method, and DIE->TYPE is the type
3594 of the method itself (TYPE_CODE_METHOD). */
3595 smash_to_method_type (fnp
->type
, type
,
3596 TYPE_TARGET_TYPE (die
->type
),
3597 TYPE_FIELDS (die
->type
),
3598 TYPE_NFIELDS (die
->type
),
3599 TYPE_VARARGS (die
->type
));
3601 /* Handle static member functions.
3602 Dwarf2 has no clean way to discern C++ static and non-static
3603 member functions. G++ helps GDB by marking the first
3604 parameter for non-static member functions (which is the
3605 this pointer) as artificial. We obtain this information
3606 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3607 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3608 fnp
->voffset
= VOFFSET_STATIC
;
3611 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3614 /* Get fcontext from DW_AT_containing_type if present. */
3615 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3616 fnp
->fcontext
= die_containing_type (die
, cu
);
3618 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3619 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3621 /* Get accessibility. */
3622 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3625 switch (DW_UNSND (attr
))
3627 case DW_ACCESS_private
:
3628 fnp
->is_private
= 1;
3630 case DW_ACCESS_protected
:
3631 fnp
->is_protected
= 1;
3636 /* Check for artificial methods. */
3637 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3638 if (attr
&& DW_UNSND (attr
) != 0)
3639 fnp
->is_artificial
= 1;
3641 /* Get index in virtual function table if it is a virtual member function. */
3642 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3645 /* Support the .debug_loc offsets */
3646 if (attr_form_is_block (attr
))
3648 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3650 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3652 dwarf2_complex_location_expr_complaint ();
3656 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3662 /* Create the vector of member function fields, and attach it to the type. */
3665 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3666 struct dwarf2_cu
*cu
)
3668 struct fnfieldlist
*flp
;
3669 int total_length
= 0;
3672 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3673 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3674 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3676 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3678 struct nextfnfield
*nfp
= flp
->head
;
3679 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3682 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3683 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3684 fn_flp
->fn_fields
= (struct fn_field
*)
3685 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3686 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3687 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3689 total_length
+= flp
->length
;
3692 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3693 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3696 /* Returns non-zero if NAME is the name of a vtable member in CU's
3697 language, zero otherwise. */
3699 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3701 static const char vptr
[] = "_vptr";
3702 static const char vtable
[] = "vtable";
3704 /* Look for the C++ and Java forms of the vtable. */
3705 if ((cu
->language
== language_java
3706 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3707 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3708 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3714 /* GCC outputs unnamed structures that are really pointers to member
3715 functions, with the ABI-specified layout. If DIE (from CU) describes
3716 such a structure, set its type, and return nonzero. Otherwise return
3719 GCC shouldn't do this; it should just output pointer to member DIEs.
3720 This is GCC PR debug/28767. */
3723 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
3725 struct objfile
*objfile
= cu
->objfile
;
3727 struct die_info
*pfn_die
, *delta_die
;
3728 struct attribute
*pfn_name
, *delta_name
;
3729 struct type
*pfn_type
, *domain_type
;
3731 /* Check for a structure with no name and two children. */
3732 if (die
->tag
!= DW_TAG_structure_type
3733 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
3734 || die
->child
== NULL
3735 || die
->child
->sibling
== NULL
3736 || (die
->child
->sibling
->sibling
!= NULL
3737 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
3740 /* Check for __pfn and __delta members. */
3741 pfn_die
= die
->child
;
3742 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
3743 if (pfn_die
->tag
!= DW_TAG_member
3745 || DW_STRING (pfn_name
) == NULL
3746 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
3749 delta_die
= pfn_die
->sibling
;
3750 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
3751 if (delta_die
->tag
!= DW_TAG_member
3752 || delta_name
== NULL
3753 || DW_STRING (delta_name
) == NULL
3754 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
3757 /* Find the type of the method. */
3758 pfn_type
= die_type (pfn_die
, cu
);
3759 if (pfn_type
== NULL
3760 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
3761 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
3764 /* Look for the "this" argument. */
3765 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
3766 if (TYPE_NFIELDS (pfn_type
) == 0
3767 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
3770 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
3771 type
= alloc_type (objfile
);
3772 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
3773 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
3774 TYPE_VARARGS (pfn_type
));
3775 type
= lookup_methodptr_type (type
);
3776 set_die_type (die
, type
, cu
);
3781 /* Called when we find the DIE that starts a structure or union scope
3782 (definition) to process all dies that define the members of the
3785 NOTE: we need to call struct_type regardless of whether or not the
3786 DIE has an at_name attribute, since it might be an anonymous
3787 structure or union. This gets the type entered into our set of
3790 However, if the structure is incomplete (an opaque struct/union)
3791 then suppress creating a symbol table entry for it since gdb only
3792 wants to find the one with the complete definition. Note that if
3793 it is complete, we just call new_symbol, which does it's own
3794 checking about whether the struct/union is anonymous or not (and
3795 suppresses creating a symbol table entry itself). */
3798 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3800 struct objfile
*objfile
= cu
->objfile
;
3802 struct attribute
*attr
;
3803 const char *previous_prefix
= processing_current_prefix
;
3804 struct cleanup
*back_to
= NULL
;
3809 if (quirk_gcc_member_function_pointer (die
, cu
))
3812 type
= alloc_type (objfile
);
3813 INIT_CPLUS_SPECIFIC (type
);
3814 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3815 if (attr
&& DW_STRING (attr
))
3817 if (cu
->language
== language_cplus
3818 || cu
->language
== language_java
)
3820 char *new_prefix
= determine_class_name (die
, cu
);
3821 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3822 strlen (new_prefix
),
3823 &objfile
->objfile_obstack
);
3824 back_to
= make_cleanup (xfree
, new_prefix
);
3825 processing_current_prefix
= new_prefix
;
3829 /* The name is already allocated along with this objfile, so
3830 we don't need to duplicate it for the type. */
3831 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3835 if (die
->tag
== DW_TAG_structure_type
)
3837 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3839 else if (die
->tag
== DW_TAG_union_type
)
3841 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3845 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3847 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3850 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3853 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3857 TYPE_LENGTH (type
) = 0;
3860 if (die_is_declaration (die
, cu
))
3861 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3863 /* We need to add the type field to the die immediately so we don't
3864 infinitely recurse when dealing with pointers to the structure
3865 type within the structure itself. */
3866 set_die_type (die
, type
, cu
);
3868 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3870 struct field_info fi
;
3871 struct die_info
*child_die
;
3872 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3874 memset (&fi
, 0, sizeof (struct field_info
));
3876 child_die
= die
->child
;
3878 while (child_die
&& child_die
->tag
)
3880 if (child_die
->tag
== DW_TAG_member
3881 || child_die
->tag
== DW_TAG_variable
)
3883 /* NOTE: carlton/2002-11-05: A C++ static data member
3884 should be a DW_TAG_member that is a declaration, but
3885 all versions of G++ as of this writing (so through at
3886 least 3.2.1) incorrectly generate DW_TAG_variable
3887 tags for them instead. */
3888 dwarf2_add_field (&fi
, child_die
, cu
);
3890 else if (child_die
->tag
== DW_TAG_subprogram
)
3892 /* C++ member function. */
3893 read_type_die (child_die
, cu
);
3894 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3896 else if (child_die
->tag
== DW_TAG_inheritance
)
3898 /* C++ base class field. */
3899 dwarf2_add_field (&fi
, child_die
, cu
);
3901 child_die
= sibling_die (child_die
);
3904 /* Attach fields and member functions to the type. */
3906 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3909 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3911 /* Get the type which refers to the base class (possibly this
3912 class itself) which contains the vtable pointer for the current
3913 class from the DW_AT_containing_type attribute. */
3915 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3917 struct type
*t
= die_containing_type (die
, cu
);
3919 TYPE_VPTR_BASETYPE (type
) = t
;
3924 /* Our own class provides vtbl ptr. */
3925 for (i
= TYPE_NFIELDS (t
) - 1;
3926 i
>= TYPE_N_BASECLASSES (t
);
3929 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3931 if (is_vtable_name (fieldname
, cu
))
3933 TYPE_VPTR_FIELDNO (type
) = i
;
3938 /* Complain if virtual function table field not found. */
3939 if (i
< TYPE_N_BASECLASSES (t
))
3940 complaint (&symfile_complaints
,
3941 _("virtual function table pointer not found when defining class '%s'"),
3942 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3947 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3950 else if (cu
->producer
3951 && strncmp (cu
->producer
,
3952 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3954 /* The IBM XLC compiler does not provide direct indication
3955 of the containing type, but the vtable pointer is
3956 always named __vfp. */
3960 for (i
= TYPE_NFIELDS (type
) - 1;
3961 i
>= TYPE_N_BASECLASSES (type
);
3964 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3966 TYPE_VPTR_FIELDNO (type
) = i
;
3967 TYPE_VPTR_BASETYPE (type
) = type
;
3974 do_cleanups (back_to
);
3977 processing_current_prefix
= previous_prefix
;
3978 if (back_to
!= NULL
)
3979 do_cleanups (back_to
);
3983 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3985 struct objfile
*objfile
= cu
->objfile
;
3986 const char *previous_prefix
= processing_current_prefix
;
3987 struct die_info
*child_die
= die
->child
;
3989 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3990 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3992 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3993 snapshots) has been known to create a die giving a declaration
3994 for a class that has, as a child, a die giving a definition for a
3995 nested class. So we have to process our children even if the
3996 current die is a declaration. Normally, of course, a declaration
3997 won't have any children at all. */
3999 while (child_die
!= NULL
&& child_die
->tag
)
4001 if (child_die
->tag
== DW_TAG_member
4002 || child_die
->tag
== DW_TAG_variable
4003 || child_die
->tag
== DW_TAG_inheritance
)
4008 process_die (child_die
, cu
);
4010 child_die
= sibling_die (child_die
);
4013 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
4014 new_symbol (die
, die
->type
, cu
);
4016 processing_current_prefix
= previous_prefix
;
4019 /* Given a DW_AT_enumeration_type die, set its type. We do not
4020 complete the type's fields yet, or create any symbols. */
4023 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4025 struct objfile
*objfile
= cu
->objfile
;
4027 struct attribute
*attr
;
4032 type
= alloc_type (objfile
);
4034 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4035 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4036 if (attr
&& DW_STRING (attr
))
4038 char *name
= DW_STRING (attr
);
4040 if (processing_has_namespace_info
)
4042 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
4043 processing_current_prefix
,
4048 /* The name is already allocated along with this objfile, so
4049 we don't need to duplicate it for the type. */
4050 TYPE_TAG_NAME (type
) = name
;
4054 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4057 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4061 TYPE_LENGTH (type
) = 0;
4064 set_die_type (die
, type
, cu
);
4067 /* Determine the name of the type represented by DIE, which should be
4068 a named C++ or Java compound type. Return the name in question; the caller
4069 is responsible for xfree()'ing it. */
4072 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4074 struct cleanup
*back_to
= NULL
;
4075 struct die_info
*spec_die
= die_specification (die
, cu
);
4076 char *new_prefix
= NULL
;
4078 /* If this is the definition of a class that is declared by another
4079 die, then processing_current_prefix may not be accurate; see
4080 read_func_scope for a similar example. */
4081 if (spec_die
!= NULL
)
4083 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4084 processing_current_prefix
= specification_prefix
;
4085 back_to
= make_cleanup (xfree
, specification_prefix
);
4088 /* If we don't have namespace debug info, guess the name by trying
4089 to demangle the names of members, just like we did in
4090 guess_structure_name. */
4091 if (!processing_has_namespace_info
)
4093 struct die_info
*child
;
4095 for (child
= die
->child
;
4096 child
!= NULL
&& child
->tag
!= 0;
4097 child
= sibling_die (child
))
4099 if (child
->tag
== DW_TAG_subprogram
)
4102 = language_class_name_from_physname (cu
->language_defn
,
4106 if (new_prefix
!= NULL
)
4112 if (new_prefix
== NULL
)
4114 const char *name
= dwarf2_name (die
, cu
);
4115 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4116 name
? name
: "<<anonymous>>",
4120 if (back_to
!= NULL
)
4121 do_cleanups (back_to
);
4126 /* Given a pointer to a die which begins an enumeration, process all
4127 the dies that define the members of the enumeration, and create the
4128 symbol for the enumeration type.
4130 NOTE: We reverse the order of the element list. */
4133 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4135 struct objfile
*objfile
= cu
->objfile
;
4136 struct die_info
*child_die
;
4137 struct field
*fields
;
4138 struct attribute
*attr
;
4141 int unsigned_enum
= 1;
4145 if (die
->child
!= NULL
)
4147 child_die
= die
->child
;
4148 while (child_die
&& child_die
->tag
)
4150 if (child_die
->tag
!= DW_TAG_enumerator
)
4152 process_die (child_die
, cu
);
4156 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4159 sym
= new_symbol (child_die
, die
->type
, cu
);
4160 if (SYMBOL_VALUE (sym
) < 0)
4163 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4165 fields
= (struct field
*)
4167 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4168 * sizeof (struct field
));
4171 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4172 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4173 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4174 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4175 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4181 child_die
= sibling_die (child_die
);
4186 TYPE_NFIELDS (die
->type
) = num_fields
;
4187 TYPE_FIELDS (die
->type
) = (struct field
*)
4188 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4189 memcpy (TYPE_FIELDS (die
->type
), fields
,
4190 sizeof (struct field
) * num_fields
);
4194 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4197 new_symbol (die
, die
->type
, cu
);
4200 /* Extract all information from a DW_TAG_array_type DIE and put it in
4201 the DIE's type field. For now, this only handles one dimensional
4205 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4207 struct objfile
*objfile
= cu
->objfile
;
4208 struct die_info
*child_die
;
4209 struct type
*type
= NULL
;
4210 struct type
*element_type
, *range_type
, *index_type
;
4211 struct type
**range_types
= NULL
;
4212 struct attribute
*attr
;
4214 struct cleanup
*back_to
;
4216 /* Return if we've already decoded this type. */
4222 element_type
= die_type (die
, cu
);
4224 /* Irix 6.2 native cc creates array types without children for
4225 arrays with unspecified length. */
4226 if (die
->child
== NULL
)
4228 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4229 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4230 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4235 back_to
= make_cleanup (null_cleanup
, NULL
);
4236 child_die
= die
->child
;
4237 while (child_die
&& child_die
->tag
)
4239 if (child_die
->tag
== DW_TAG_subrange_type
)
4241 read_subrange_type (child_die
, cu
);
4243 if (child_die
->type
!= NULL
)
4245 /* The range type was succesfully read. Save it for
4246 the array type creation. */
4247 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4249 range_types
= (struct type
**)
4250 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4251 * sizeof (struct type
*));
4253 make_cleanup (free_current_contents
, &range_types
);
4255 range_types
[ndim
++] = child_die
->type
;
4258 child_die
= sibling_die (child_die
);
4261 /* Dwarf2 dimensions are output from left to right, create the
4262 necessary array types in backwards order. */
4264 type
= element_type
;
4266 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4270 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4275 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4278 /* Understand Dwarf2 support for vector types (like they occur on
4279 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4280 array type. This is not part of the Dwarf2/3 standard yet, but a
4281 custom vendor extension. The main difference between a regular
4282 array and the vector variant is that vectors are passed by value
4284 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4286 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4288 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4289 if (attr
&& DW_STRING (attr
))
4290 TYPE_NAME (type
) = DW_STRING (attr
);
4292 do_cleanups (back_to
);
4294 /* Install the type in the die. */
4295 set_die_type (die
, type
, cu
);
4298 static enum dwarf_array_dim_ordering
4299 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4301 struct attribute
*attr
;
4303 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4305 if (attr
) return DW_SND (attr
);
4308 GNU F77 is a special case, as at 08/2004 array type info is the
4309 opposite order to the dwarf2 specification, but data is still
4310 laid out as per normal fortran.
4312 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4316 if (cu
->language
== language_fortran
&&
4317 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4319 return DW_ORD_row_major
;
4322 switch (cu
->language_defn
->la_array_ordering
)
4324 case array_column_major
:
4325 return DW_ORD_col_major
;
4326 case array_row_major
:
4328 return DW_ORD_row_major
;
4332 /* Extract all information from a DW_TAG_set_type DIE and put it in
4333 the DIE's type field. */
4336 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4338 if (die
->type
== NULL
)
4339 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4342 /* First cut: install each common block member as a global variable. */
4345 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4347 struct die_info
*child_die
;
4348 struct attribute
*attr
;
4350 CORE_ADDR base
= (CORE_ADDR
) 0;
4352 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4355 /* Support the .debug_loc offsets */
4356 if (attr_form_is_block (attr
))
4358 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4360 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4362 dwarf2_complex_location_expr_complaint ();
4366 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4367 "common block member");
4370 if (die
->child
!= NULL
)
4372 child_die
= die
->child
;
4373 while (child_die
&& child_die
->tag
)
4375 sym
= new_symbol (child_die
, NULL
, cu
);
4376 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4379 SYMBOL_VALUE_ADDRESS (sym
) =
4380 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4381 add_symbol_to_list (sym
, &global_symbols
);
4383 child_die
= sibling_die (child_die
);
4388 /* Read a C++ namespace. */
4391 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4393 struct objfile
*objfile
= cu
->objfile
;
4394 const char *previous_prefix
= processing_current_prefix
;
4397 struct die_info
*current_die
;
4398 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4400 name
= namespace_name (die
, &is_anonymous
, cu
);
4402 /* Now build the name of the current namespace. */
4404 if (previous_prefix
[0] == '\0')
4406 processing_current_prefix
= name
;
4410 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4411 make_cleanup (xfree
, temp_name
);
4412 processing_current_prefix
= temp_name
;
4415 /* Add a symbol associated to this if we haven't seen the namespace
4416 before. Also, add a using directive if it's an anonymous
4419 if (dwarf2_extension (die
, cu
) == NULL
)
4423 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4424 this cast will hopefully become unnecessary. */
4425 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4426 (char *) processing_current_prefix
,
4428 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4430 new_symbol (die
, type
, cu
);
4431 set_die_type (die
, type
, cu
);
4434 cp_add_using_directive (processing_current_prefix
,
4435 strlen (previous_prefix
),
4436 strlen (processing_current_prefix
));
4439 if (die
->child
!= NULL
)
4441 struct die_info
*child_die
= die
->child
;
4443 while (child_die
&& child_die
->tag
)
4445 process_die (child_die
, cu
);
4446 child_die
= sibling_die (child_die
);
4450 processing_current_prefix
= previous_prefix
;
4451 do_cleanups (back_to
);
4454 /* Return the name of the namespace represented by DIE. Set
4455 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4459 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4461 struct die_info
*current_die
;
4462 const char *name
= NULL
;
4464 /* Loop through the extensions until we find a name. */
4466 for (current_die
= die
;
4467 current_die
!= NULL
;
4468 current_die
= dwarf2_extension (die
, cu
))
4470 name
= dwarf2_name (current_die
, cu
);
4475 /* Is it an anonymous namespace? */
4477 *is_anonymous
= (name
== NULL
);
4479 name
= "(anonymous namespace)";
4484 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4485 the user defined type vector. */
4488 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4490 struct comp_unit_head
*cu_header
= &cu
->header
;
4492 struct attribute
*attr_byte_size
;
4493 struct attribute
*attr_address_class
;
4494 int byte_size
, addr_class
;
4501 type
= lookup_pointer_type (die_type (die
, cu
));
4503 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4505 byte_size
= DW_UNSND (attr_byte_size
);
4507 byte_size
= cu_header
->addr_size
;
4509 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4510 if (attr_address_class
)
4511 addr_class
= DW_UNSND (attr_address_class
);
4513 addr_class
= DW_ADDR_none
;
4515 /* If the pointer size or address class is different than the
4516 default, create a type variant marked as such and set the
4517 length accordingly. */
4518 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4520 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4524 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4525 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4526 type
= make_type_with_address_space (type
, type_flags
);
4528 else if (TYPE_LENGTH (type
) != byte_size
)
4530 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4533 /* Should we also complain about unhandled address classes? */
4537 TYPE_LENGTH (type
) = byte_size
;
4538 set_die_type (die
, type
, cu
);
4541 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4542 the user defined type vector. */
4545 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4547 struct objfile
*objfile
= cu
->objfile
;
4549 struct type
*to_type
;
4550 struct type
*domain
;
4557 to_type
= die_type (die
, cu
);
4558 domain
= die_containing_type (die
, cu
);
4560 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
4561 type
= lookup_methodptr_type (to_type
);
4563 type
= lookup_memberptr_type (to_type
, domain
);
4565 set_die_type (die
, type
, cu
);
4568 /* Extract all information from a DW_TAG_reference_type DIE and add to
4569 the user defined type vector. */
4572 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4574 struct comp_unit_head
*cu_header
= &cu
->header
;
4576 struct attribute
*attr
;
4583 type
= lookup_reference_type (die_type (die
, cu
));
4584 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4587 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4591 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4593 set_die_type (die
, type
, cu
);
4597 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4599 struct type
*base_type
;
4606 base_type
= die_type (die
, cu
);
4607 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4612 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4614 struct type
*base_type
;
4621 base_type
= die_type (die
, cu
);
4622 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4626 /* Extract all information from a DW_TAG_string_type DIE and add to
4627 the user defined type vector. It isn't really a user defined type,
4628 but it behaves like one, with other DIE's using an AT_user_def_type
4629 attribute to reference it. */
4632 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4634 struct objfile
*objfile
= cu
->objfile
;
4635 struct type
*type
, *range_type
, *index_type
, *char_type
;
4636 struct attribute
*attr
;
4637 unsigned int length
;
4644 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4647 length
= DW_UNSND (attr
);
4651 /* check for the DW_AT_byte_size attribute */
4652 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4655 length
= DW_UNSND (attr
);
4662 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4663 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4664 if (cu
->language
== language_fortran
)
4666 /* Need to create a unique string type for bounds
4668 type
= create_string_type (0, range_type
);
4672 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4673 type
= create_string_type (char_type
, range_type
);
4675 set_die_type (die
, type
, cu
);
4678 /* Handle DIES due to C code like:
4682 int (*funcp)(int a, long l);
4686 ('funcp' generates a DW_TAG_subroutine_type DIE)
4690 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4692 struct type
*type
; /* Type that this function returns */
4693 struct type
*ftype
; /* Function that returns above type */
4694 struct attribute
*attr
;
4696 /* Decode the type that this subroutine returns */
4701 type
= die_type (die
, cu
);
4702 ftype
= make_function_type (type
, (struct type
**) 0);
4704 /* All functions in C++ and Java have prototypes. */
4705 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4706 if ((attr
&& (DW_UNSND (attr
) != 0))
4707 || cu
->language
== language_cplus
4708 || cu
->language
== language_java
)
4709 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4711 if (die
->child
!= NULL
)
4713 struct die_info
*child_die
;
4717 /* Count the number of parameters.
4718 FIXME: GDB currently ignores vararg functions, but knows about
4719 vararg member functions. */
4720 child_die
= die
->child
;
4721 while (child_die
&& child_die
->tag
)
4723 if (child_die
->tag
== DW_TAG_formal_parameter
)
4725 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4726 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4727 child_die
= sibling_die (child_die
);
4730 /* Allocate storage for parameters and fill them in. */
4731 TYPE_NFIELDS (ftype
) = nparams
;
4732 TYPE_FIELDS (ftype
) = (struct field
*)
4733 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4735 child_die
= die
->child
;
4736 while (child_die
&& child_die
->tag
)
4738 if (child_die
->tag
== DW_TAG_formal_parameter
)
4740 /* Dwarf2 has no clean way to discern C++ static and non-static
4741 member functions. G++ helps GDB by marking the first
4742 parameter for non-static member functions (which is the
4743 this pointer) as artificial. We pass this information
4744 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4745 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4747 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4749 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4750 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4753 child_die
= sibling_die (child_die
);
4757 set_die_type (die
, ftype
, cu
);
4761 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4763 struct objfile
*objfile
= cu
->objfile
;
4764 struct attribute
*attr
;
4769 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4770 if (attr
&& DW_STRING (attr
))
4772 name
= DW_STRING (attr
);
4774 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4775 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4777 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4781 /* Find a representation of a given base type and install
4782 it in the TYPE field of the die. */
4785 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4787 struct objfile
*objfile
= cu
->objfile
;
4789 struct attribute
*attr
;
4790 int encoding
= 0, size
= 0;
4792 /* If we've already decoded this die, this is a no-op. */
4798 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4801 encoding
= DW_UNSND (attr
);
4803 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4806 size
= DW_UNSND (attr
);
4808 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4809 if (attr
&& DW_STRING (attr
))
4811 enum type_code code
= TYPE_CODE_INT
;
4816 case DW_ATE_address
:
4817 /* Turn DW_ATE_address into a void * pointer. */
4818 code
= TYPE_CODE_PTR
;
4819 type_flags
|= TYPE_FLAG_UNSIGNED
;
4821 case DW_ATE_boolean
:
4822 code
= TYPE_CODE_BOOL
;
4823 type_flags
|= TYPE_FLAG_UNSIGNED
;
4825 case DW_ATE_complex_float
:
4826 code
= TYPE_CODE_COMPLEX
;
4829 code
= TYPE_CODE_FLT
;
4833 case DW_ATE_unsigned
:
4834 type_flags
|= TYPE_FLAG_UNSIGNED
;
4836 case DW_ATE_signed_char
:
4837 if (cu
->language
== language_m2
)
4838 code
= TYPE_CODE_CHAR
;
4840 case DW_ATE_unsigned_char
:
4841 if (cu
->language
== language_m2
)
4842 code
= TYPE_CODE_CHAR
;
4843 type_flags
|= TYPE_FLAG_UNSIGNED
;
4846 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4847 dwarf_type_encoding_name (encoding
));
4850 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4851 if (encoding
== DW_ATE_address
)
4852 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4854 else if (encoding
== DW_ATE_complex_float
)
4857 TYPE_TARGET_TYPE (type
)
4858 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4859 else if (size
== 16)
4860 TYPE_TARGET_TYPE (type
)
4861 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4863 TYPE_TARGET_TYPE (type
)
4864 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4869 type
= dwarf_base_type (encoding
, size
, cu
);
4871 set_die_type (die
, type
, cu
);
4874 /* Read the given DW_AT_subrange DIE. */
4877 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4879 struct type
*base_type
;
4880 struct type
*range_type
;
4881 struct attribute
*attr
;
4885 /* If we have already decoded this die, then nothing more to do. */
4889 base_type
= die_type (die
, cu
);
4890 if (base_type
== NULL
)
4892 complaint (&symfile_complaints
,
4893 _("DW_AT_type missing from DW_TAG_subrange_type"));
4897 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4898 base_type
= alloc_type (NULL
);
4900 if (cu
->language
== language_fortran
)
4902 /* FORTRAN implies a lower bound of 1, if not given. */
4906 /* FIXME: For variable sized arrays either of these could be
4907 a variable rather than a constant value. We'll allow it,
4908 but we don't know how to handle it. */
4909 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4911 low
= dwarf2_get_attr_constant_value (attr
, 0);
4913 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4916 if (attr
->form
== DW_FORM_block1
)
4918 /* GCC encodes arrays with unspecified or dynamic length
4919 with a DW_FORM_block1 attribute.
4920 FIXME: GDB does not yet know how to handle dynamic
4921 arrays properly, treat them as arrays with unspecified
4924 FIXME: jimb/2003-09-22: GDB does not really know
4925 how to handle arrays of unspecified length
4926 either; we just represent them as zero-length
4927 arrays. Choose an appropriate upper bound given
4928 the lower bound we've computed above. */
4932 high
= dwarf2_get_attr_constant_value (attr
, 1);
4935 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4937 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4938 if (attr
&& DW_STRING (attr
))
4939 TYPE_NAME (range_type
) = DW_STRING (attr
);
4941 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4943 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4945 set_die_type (die
, range_type
, cu
);
4949 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4952 struct attribute
*attr
;
4957 /* For now, we only support the C meaning of an unspecified type: void. */
4959 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4960 type
= init_type (TYPE_CODE_VOID
, 0, 0, attr
? DW_STRING (attr
) : "",
4963 set_die_type (die
, type
, cu
);
4966 /* Read a whole compilation unit into a linked list of dies. */
4968 static struct die_info
*
4969 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4971 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4974 /* Read a single die and all its descendents. Set the die's sibling
4975 field to NULL; set other fields in the die correctly, and set all
4976 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4977 location of the info_ptr after reading all of those dies. PARENT
4978 is the parent of the die in question. */
4980 static struct die_info
*
4981 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
4982 struct dwarf2_cu
*cu
,
4983 gdb_byte
**new_info_ptr
,
4984 struct die_info
*parent
)
4986 struct die_info
*die
;
4990 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4991 store_in_ref_table (die
->offset
, die
, cu
);
4995 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
5001 *new_info_ptr
= cur_ptr
;
5004 die
->sibling
= NULL
;
5005 die
->parent
= parent
;
5009 /* Read a die, all of its descendents, and all of its siblings; set
5010 all of the fields of all of the dies correctly. Arguments are as
5011 in read_die_and_children. */
5013 static struct die_info
*
5014 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5015 struct dwarf2_cu
*cu
,
5016 gdb_byte
**new_info_ptr
,
5017 struct die_info
*parent
)
5019 struct die_info
*first_die
, *last_sibling
;
5023 first_die
= last_sibling
= NULL
;
5027 struct die_info
*die
5028 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5036 last_sibling
->sibling
= die
;
5041 *new_info_ptr
= cur_ptr
;
5051 /* Free a linked list of dies. */
5054 free_die_list (struct die_info
*dies
)
5056 struct die_info
*die
, *next
;
5061 if (die
->child
!= NULL
)
5062 free_die_list (die
->child
);
5063 next
= die
->sibling
;
5070 /* Read the contents of the section at OFFSET and of size SIZE from the
5071 object file specified by OBJFILE into the objfile_obstack and return it. */
5074 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
5076 bfd
*abfd
= objfile
->obfd
;
5077 gdb_byte
*buf
, *retbuf
;
5078 bfd_size_type size
= bfd_get_section_size (sectp
);
5083 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5084 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5088 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5089 || bfd_bread (buf
, size
, abfd
) != size
)
5090 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5091 bfd_get_filename (abfd
));
5096 /* In DWARF version 2, the description of the debugging information is
5097 stored in a separate .debug_abbrev section. Before we read any
5098 dies from a section we read in all abbreviations and install them
5099 in a hash table. This function also sets flags in CU describing
5100 the data found in the abbrev table. */
5103 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5105 struct comp_unit_head
*cu_header
= &cu
->header
;
5106 gdb_byte
*abbrev_ptr
;
5107 struct abbrev_info
*cur_abbrev
;
5108 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5109 unsigned int abbrev_form
, hash_number
;
5110 struct attr_abbrev
*cur_attrs
;
5111 unsigned int allocated_attrs
;
5113 /* Initialize dwarf2 abbrevs */
5114 obstack_init (&cu
->abbrev_obstack
);
5115 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5117 * sizeof (struct abbrev_info
*)));
5118 memset (cu
->dwarf2_abbrevs
, 0,
5119 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5121 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5122 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5123 abbrev_ptr
+= bytes_read
;
5125 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5126 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5128 /* loop until we reach an abbrev number of 0 */
5129 while (abbrev_number
)
5131 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5133 /* read in abbrev header */
5134 cur_abbrev
->number
= abbrev_number
;
5135 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5136 abbrev_ptr
+= bytes_read
;
5137 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5140 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5141 cu
->has_namespace_info
= 1;
5143 /* now read in declarations */
5144 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5145 abbrev_ptr
+= bytes_read
;
5146 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5147 abbrev_ptr
+= bytes_read
;
5150 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5152 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5154 = xrealloc (cur_attrs
, (allocated_attrs
5155 * sizeof (struct attr_abbrev
)));
5158 /* Record whether this compilation unit might have
5159 inter-compilation-unit references. If we don't know what form
5160 this attribute will have, then it might potentially be a
5161 DW_FORM_ref_addr, so we conservatively expect inter-CU
5164 if (abbrev_form
== DW_FORM_ref_addr
5165 || abbrev_form
== DW_FORM_indirect
)
5166 cu
->has_form_ref_addr
= 1;
5168 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5169 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5170 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5171 abbrev_ptr
+= bytes_read
;
5172 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5173 abbrev_ptr
+= bytes_read
;
5176 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5177 (cur_abbrev
->num_attrs
5178 * sizeof (struct attr_abbrev
)));
5179 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5180 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5182 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5183 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5184 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5186 /* Get next abbreviation.
5187 Under Irix6 the abbreviations for a compilation unit are not
5188 always properly terminated with an abbrev number of 0.
5189 Exit loop if we encounter an abbreviation which we have
5190 already read (which means we are about to read the abbreviations
5191 for the next compile unit) or if the end of the abbreviation
5192 table is reached. */
5193 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5194 >= dwarf2_per_objfile
->abbrev_size
)
5196 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5197 abbrev_ptr
+= bytes_read
;
5198 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5205 /* Release the memory used by the abbrev table for a compilation unit. */
5208 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5210 struct dwarf2_cu
*cu
= ptr_to_cu
;
5212 obstack_free (&cu
->abbrev_obstack
, NULL
);
5213 cu
->dwarf2_abbrevs
= NULL
;
5216 /* Lookup an abbrev_info structure in the abbrev hash table. */
5218 static struct abbrev_info
*
5219 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5221 unsigned int hash_number
;
5222 struct abbrev_info
*abbrev
;
5224 hash_number
= number
% ABBREV_HASH_SIZE
;
5225 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5229 if (abbrev
->number
== number
)
5232 abbrev
= abbrev
->next
;
5237 /* Returns nonzero if TAG represents a type that we might generate a partial
5241 is_type_tag_for_partial (int tag
)
5246 /* Some types that would be reasonable to generate partial symbols for,
5247 that we don't at present. */
5248 case DW_TAG_array_type
:
5249 case DW_TAG_file_type
:
5250 case DW_TAG_ptr_to_member_type
:
5251 case DW_TAG_set_type
:
5252 case DW_TAG_string_type
:
5253 case DW_TAG_subroutine_type
:
5255 case DW_TAG_base_type
:
5256 case DW_TAG_class_type
:
5257 case DW_TAG_enumeration_type
:
5258 case DW_TAG_structure_type
:
5259 case DW_TAG_subrange_type
:
5260 case DW_TAG_typedef
:
5261 case DW_TAG_union_type
:
5268 /* Load all DIEs that are interesting for partial symbols into memory. */
5270 static struct partial_die_info
*
5271 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5272 struct dwarf2_cu
*cu
)
5274 struct partial_die_info
*part_die
;
5275 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5276 struct abbrev_info
*abbrev
;
5277 unsigned int bytes_read
;
5278 unsigned int load_all
= 0;
5280 int nesting_level
= 1;
5285 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5289 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5293 &cu
->comp_unit_obstack
,
5294 hashtab_obstack_allocate
,
5295 dummy_obstack_deallocate
);
5297 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5298 sizeof (struct partial_die_info
));
5302 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5304 /* A NULL abbrev means the end of a series of children. */
5307 if (--nesting_level
== 0)
5309 /* PART_DIE was probably the last thing allocated on the
5310 comp_unit_obstack, so we could call obstack_free
5311 here. We don't do that because the waste is small,
5312 and will be cleaned up when we're done with this
5313 compilation unit. This way, we're also more robust
5314 against other users of the comp_unit_obstack. */
5317 info_ptr
+= bytes_read
;
5318 last_die
= parent_die
;
5319 parent_die
= parent_die
->die_parent
;
5323 /* Check whether this DIE is interesting enough to save. Normally
5324 we would not be interested in members here, but there may be
5325 later variables referencing them via DW_AT_specification (for
5328 && !is_type_tag_for_partial (abbrev
->tag
)
5329 && abbrev
->tag
!= DW_TAG_enumerator
5330 && abbrev
->tag
!= DW_TAG_subprogram
5331 && abbrev
->tag
!= DW_TAG_variable
5332 && abbrev
->tag
!= DW_TAG_namespace
5333 && abbrev
->tag
!= DW_TAG_member
)
5335 /* Otherwise we skip to the next sibling, if any. */
5336 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5340 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5341 abfd
, info_ptr
, cu
);
5343 /* This two-pass algorithm for processing partial symbols has a
5344 high cost in cache pressure. Thus, handle some simple cases
5345 here which cover the majority of C partial symbols. DIEs
5346 which neither have specification tags in them, nor could have
5347 specification tags elsewhere pointing at them, can simply be
5348 processed and discarded.
5350 This segment is also optional; scan_partial_symbols and
5351 add_partial_symbol will handle these DIEs if we chain
5352 them in normally. When compilers which do not emit large
5353 quantities of duplicate debug information are more common,
5354 this code can probably be removed. */
5356 /* Any complete simple types at the top level (pretty much all
5357 of them, for a language without namespaces), can be processed
5359 if (parent_die
== NULL
5360 && part_die
->has_specification
== 0
5361 && part_die
->is_declaration
== 0
5362 && (part_die
->tag
== DW_TAG_typedef
5363 || part_die
->tag
== DW_TAG_base_type
5364 || part_die
->tag
== DW_TAG_subrange_type
))
5366 if (building_psymtab
&& part_die
->name
!= NULL
)
5367 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5368 VAR_DOMAIN
, LOC_TYPEDEF
,
5369 &cu
->objfile
->static_psymbols
,
5370 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5371 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5375 /* If we're at the second level, and we're an enumerator, and
5376 our parent has no specification (meaning possibly lives in a
5377 namespace elsewhere), then we can add the partial symbol now
5378 instead of queueing it. */
5379 if (part_die
->tag
== DW_TAG_enumerator
5380 && parent_die
!= NULL
5381 && parent_die
->die_parent
== NULL
5382 && parent_die
->tag
== DW_TAG_enumeration_type
5383 && parent_die
->has_specification
== 0)
5385 if (part_die
->name
== NULL
)
5386 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5387 else if (building_psymtab
)
5388 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5389 VAR_DOMAIN
, LOC_CONST
,
5390 (cu
->language
== language_cplus
5391 || cu
->language
== language_java
)
5392 ? &cu
->objfile
->global_psymbols
5393 : &cu
->objfile
->static_psymbols
,
5394 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5396 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5400 /* We'll save this DIE so link it in. */
5401 part_die
->die_parent
= parent_die
;
5402 part_die
->die_sibling
= NULL
;
5403 part_die
->die_child
= NULL
;
5405 if (last_die
&& last_die
== parent_die
)
5406 last_die
->die_child
= part_die
;
5408 last_die
->die_sibling
= part_die
;
5410 last_die
= part_die
;
5412 if (first_die
== NULL
)
5413 first_die
= part_die
;
5415 /* Maybe add the DIE to the hash table. Not all DIEs that we
5416 find interesting need to be in the hash table, because we
5417 also have the parent/sibling/child chains; only those that we
5418 might refer to by offset later during partial symbol reading.
5420 For now this means things that might have be the target of a
5421 DW_AT_specification, DW_AT_abstract_origin, or
5422 DW_AT_extension. DW_AT_extension will refer only to
5423 namespaces; DW_AT_abstract_origin refers to functions (and
5424 many things under the function DIE, but we do not recurse
5425 into function DIEs during partial symbol reading) and
5426 possibly variables as well; DW_AT_specification refers to
5427 declarations. Declarations ought to have the DW_AT_declaration
5428 flag. It happens that GCC forgets to put it in sometimes, but
5429 only for functions, not for types.
5431 Adding more things than necessary to the hash table is harmless
5432 except for the performance cost. Adding too few will result in
5433 wasted time in find_partial_die, when we reread the compilation
5434 unit with load_all_dies set. */
5437 || abbrev
->tag
== DW_TAG_subprogram
5438 || abbrev
->tag
== DW_TAG_variable
5439 || abbrev
->tag
== DW_TAG_namespace
5440 || part_die
->is_declaration
)
5444 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5445 part_die
->offset
, INSERT
);
5449 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5450 sizeof (struct partial_die_info
));
5452 /* For some DIEs we want to follow their children (if any). For C
5453 we have no reason to follow the children of structures; for other
5454 languages we have to, both so that we can get at method physnames
5455 to infer fully qualified class names, and for DW_AT_specification. */
5456 if (last_die
->has_children
5458 || last_die
->tag
== DW_TAG_namespace
5459 || last_die
->tag
== DW_TAG_enumeration_type
5460 || (cu
->language
!= language_c
5461 && (last_die
->tag
== DW_TAG_class_type
5462 || last_die
->tag
== DW_TAG_structure_type
5463 || last_die
->tag
== DW_TAG_union_type
))))
5466 parent_die
= last_die
;
5470 /* Otherwise we skip to the next sibling, if any. */
5471 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5473 /* Back to the top, do it again. */
5477 /* Read a minimal amount of information into the minimal die structure. */
5480 read_partial_die (struct partial_die_info
*part_die
,
5481 struct abbrev_info
*abbrev
,
5482 unsigned int abbrev_len
, bfd
*abfd
,
5483 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5485 unsigned int bytes_read
, i
;
5486 struct attribute attr
;
5487 int has_low_pc_attr
= 0;
5488 int has_high_pc_attr
= 0;
5490 memset (part_die
, 0, sizeof (struct partial_die_info
));
5492 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5494 info_ptr
+= abbrev_len
;
5499 part_die
->tag
= abbrev
->tag
;
5500 part_die
->has_children
= abbrev
->has_children
;
5502 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5504 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5506 /* Store the data if it is of an attribute we want to keep in a
5507 partial symbol table. */
5512 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5513 if (part_die
->name
== NULL
)
5514 part_die
->name
= DW_STRING (&attr
);
5516 case DW_AT_comp_dir
:
5517 if (part_die
->dirname
== NULL
)
5518 part_die
->dirname
= DW_STRING (&attr
);
5520 case DW_AT_MIPS_linkage_name
:
5521 part_die
->name
= DW_STRING (&attr
);
5524 has_low_pc_attr
= 1;
5525 part_die
->lowpc
= DW_ADDR (&attr
);
5528 has_high_pc_attr
= 1;
5529 part_die
->highpc
= DW_ADDR (&attr
);
5531 case DW_AT_location
:
5532 /* Support the .debug_loc offsets */
5533 if (attr_form_is_block (&attr
))
5535 part_die
->locdesc
= DW_BLOCK (&attr
);
5537 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5539 dwarf2_complex_location_expr_complaint ();
5543 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5544 "partial symbol information");
5547 case DW_AT_language
:
5548 part_die
->language
= DW_UNSND (&attr
);
5550 case DW_AT_external
:
5551 part_die
->is_external
= DW_UNSND (&attr
);
5553 case DW_AT_declaration
:
5554 part_die
->is_declaration
= DW_UNSND (&attr
);
5557 part_die
->has_type
= 1;
5559 case DW_AT_abstract_origin
:
5560 case DW_AT_specification
:
5561 case DW_AT_extension
:
5562 part_die
->has_specification
= 1;
5563 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5566 /* Ignore absolute siblings, they might point outside of
5567 the current compile unit. */
5568 if (attr
.form
== DW_FORM_ref_addr
)
5569 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5571 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5572 + dwarf2_get_ref_die_offset (&attr
, cu
);
5574 case DW_AT_stmt_list
:
5575 part_die
->has_stmt_list
= 1;
5576 part_die
->line_offset
= DW_UNSND (&attr
);
5583 /* When using the GNU linker, .gnu.linkonce. sections are used to
5584 eliminate duplicate copies of functions and vtables and such.
5585 The linker will arbitrarily choose one and discard the others.
5586 The AT_*_pc values for such functions refer to local labels in
5587 these sections. If the section from that file was discarded, the
5588 labels are not in the output, so the relocs get a value of 0.
5589 If this is a discarded function, mark the pc bounds as invalid,
5590 so that GDB will ignore it. */
5591 if (has_low_pc_attr
&& has_high_pc_attr
5592 && part_die
->lowpc
< part_die
->highpc
5593 && (part_die
->lowpc
!= 0
5594 || dwarf2_per_objfile
->has_section_at_zero
))
5595 part_die
->has_pc_info
= 1;
5599 /* Find a cached partial DIE at OFFSET in CU. */
5601 static struct partial_die_info
*
5602 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5604 struct partial_die_info
*lookup_die
= NULL
;
5605 struct partial_die_info part_die
;
5607 part_die
.offset
= offset
;
5608 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5613 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5615 static struct partial_die_info
*
5616 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5618 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5619 struct partial_die_info
*pd
= NULL
;
5621 if (offset
>= cu
->header
.offset
5622 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5624 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5629 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5631 if (per_cu
->cu
== NULL
)
5633 load_comp_unit (per_cu
, cu
->objfile
);
5634 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5635 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5638 per_cu
->cu
->last_used
= 0;
5639 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5641 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5643 struct cleanup
*back_to
;
5644 struct partial_die_info comp_unit_die
;
5645 struct abbrev_info
*abbrev
;
5646 unsigned int bytes_read
;
5649 per_cu
->load_all_dies
= 1;
5651 /* Re-read the DIEs. */
5652 back_to
= make_cleanup (null_cleanup
, 0);
5653 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5655 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5656 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5658 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5659 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5660 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5661 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5663 if (comp_unit_die
.has_children
)
5664 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5665 do_cleanups (back_to
);
5667 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5671 internal_error (__FILE__
, __LINE__
,
5672 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5673 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5677 /* Adjust PART_DIE before generating a symbol for it. This function
5678 may set the is_external flag or change the DIE's name. */
5681 fixup_partial_die (struct partial_die_info
*part_die
,
5682 struct dwarf2_cu
*cu
)
5684 /* If we found a reference attribute and the DIE has no name, try
5685 to find a name in the referred to DIE. */
5687 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5689 struct partial_die_info
*spec_die
;
5691 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5693 fixup_partial_die (spec_die
, cu
);
5697 part_die
->name
= spec_die
->name
;
5699 /* Copy DW_AT_external attribute if it is set. */
5700 if (spec_die
->is_external
)
5701 part_die
->is_external
= spec_die
->is_external
;
5705 /* Set default names for some unnamed DIEs. */
5706 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5707 || part_die
->tag
== DW_TAG_class_type
))
5708 part_die
->name
= "(anonymous class)";
5710 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5711 part_die
->name
= "(anonymous namespace)";
5713 if (part_die
->tag
== DW_TAG_structure_type
5714 || part_die
->tag
== DW_TAG_class_type
5715 || part_die
->tag
== DW_TAG_union_type
)
5716 guess_structure_name (part_die
, cu
);
5719 /* Read the die from the .debug_info section buffer. Set DIEP to
5720 point to a newly allocated die with its information, except for its
5721 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5722 whether the die has children or not. */
5725 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5726 struct dwarf2_cu
*cu
, int *has_children
)
5728 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5729 struct abbrev_info
*abbrev
;
5730 struct die_info
*die
;
5732 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5733 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5734 info_ptr
+= bytes_read
;
5737 die
= dwarf_alloc_die ();
5739 die
->abbrev
= abbrev_number
;
5746 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5749 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5751 bfd_get_filename (abfd
));
5753 die
= dwarf_alloc_die ();
5754 die
->offset
= offset
;
5755 die
->tag
= abbrev
->tag
;
5756 die
->abbrev
= abbrev_number
;
5759 die
->num_attrs
= abbrev
->num_attrs
;
5760 die
->attrs
= (struct attribute
*)
5761 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5763 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5765 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5766 abfd
, info_ptr
, cu
);
5768 /* If this attribute is an absolute reference to a different
5769 compilation unit, make sure that compilation unit is loaded
5771 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5772 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5773 || (DW_ADDR (&die
->attrs
[i
])
5774 >= cu
->header
.offset
+ cu
->header
.length
)))
5776 struct dwarf2_per_cu_data
*per_cu
;
5777 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5780 /* Mark the dependence relation so that we don't flush PER_CU
5782 dwarf2_add_dependence (cu
, per_cu
);
5784 /* If it's already on the queue, we have nothing to do. */
5788 /* If the compilation unit is already loaded, just mark it as
5790 if (per_cu
->cu
!= NULL
)
5792 per_cu
->cu
->last_used
= 0;
5796 /* Add it to the queue. */
5797 queue_comp_unit (per_cu
);
5802 *has_children
= abbrev
->has_children
;
5806 /* Read an attribute value described by an attribute form. */
5809 read_attribute_value (struct attribute
*attr
, unsigned form
,
5810 bfd
*abfd
, gdb_byte
*info_ptr
,
5811 struct dwarf2_cu
*cu
)
5813 struct comp_unit_head
*cu_header
= &cu
->header
;
5814 unsigned int bytes_read
;
5815 struct dwarf_block
*blk
;
5821 case DW_FORM_ref_addr
:
5822 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5823 info_ptr
+= bytes_read
;
5825 case DW_FORM_block2
:
5826 blk
= dwarf_alloc_block (cu
);
5827 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5829 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5830 info_ptr
+= blk
->size
;
5831 DW_BLOCK (attr
) = blk
;
5833 case DW_FORM_block4
:
5834 blk
= dwarf_alloc_block (cu
);
5835 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5837 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5838 info_ptr
+= blk
->size
;
5839 DW_BLOCK (attr
) = blk
;
5842 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5846 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5850 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5853 case DW_FORM_string
:
5854 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5855 info_ptr
+= bytes_read
;
5858 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5860 info_ptr
+= bytes_read
;
5863 blk
= dwarf_alloc_block (cu
);
5864 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5865 info_ptr
+= bytes_read
;
5866 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5867 info_ptr
+= blk
->size
;
5868 DW_BLOCK (attr
) = blk
;
5870 case DW_FORM_block1
:
5871 blk
= dwarf_alloc_block (cu
);
5872 blk
->size
= read_1_byte (abfd
, info_ptr
);
5874 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5875 info_ptr
+= blk
->size
;
5876 DW_BLOCK (attr
) = blk
;
5879 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5883 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5887 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5888 info_ptr
+= bytes_read
;
5891 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5892 info_ptr
+= bytes_read
;
5895 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5899 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5903 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5907 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5910 case DW_FORM_ref_udata
:
5911 DW_ADDR (attr
) = (cu
->header
.offset
5912 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5913 info_ptr
+= bytes_read
;
5915 case DW_FORM_indirect
:
5916 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5917 info_ptr
+= bytes_read
;
5918 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5921 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5922 dwarf_form_name (form
),
5923 bfd_get_filename (abfd
));
5928 /* Read an attribute described by an abbreviated attribute. */
5931 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5932 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5934 attr
->name
= abbrev
->name
;
5935 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5938 /* read dwarf information from a buffer */
5941 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5943 return bfd_get_8 (abfd
, buf
);
5947 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5949 return bfd_get_signed_8 (abfd
, buf
);
5953 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5955 return bfd_get_16 (abfd
, buf
);
5959 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5961 return bfd_get_signed_16 (abfd
, buf
);
5965 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5967 return bfd_get_32 (abfd
, buf
);
5971 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5973 return bfd_get_signed_32 (abfd
, buf
);
5976 static unsigned long
5977 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
5979 return bfd_get_64 (abfd
, buf
);
5983 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
5984 unsigned int *bytes_read
)
5986 struct comp_unit_head
*cu_header
= &cu
->header
;
5987 CORE_ADDR retval
= 0;
5989 if (cu_header
->signed_addr_p
)
5991 switch (cu_header
->addr_size
)
5994 retval
= bfd_get_signed_16 (abfd
, buf
);
5997 retval
= bfd_get_signed_32 (abfd
, buf
);
6000 retval
= bfd_get_signed_64 (abfd
, buf
);
6003 internal_error (__FILE__
, __LINE__
,
6004 _("read_address: bad switch, signed [in module %s]"),
6005 bfd_get_filename (abfd
));
6010 switch (cu_header
->addr_size
)
6013 retval
= bfd_get_16 (abfd
, buf
);
6016 retval
= bfd_get_32 (abfd
, buf
);
6019 retval
= bfd_get_64 (abfd
, buf
);
6022 internal_error (__FILE__
, __LINE__
,
6023 _("read_address: bad switch, unsigned [in module %s]"),
6024 bfd_get_filename (abfd
));
6028 *bytes_read
= cu_header
->addr_size
;
6032 /* Read the initial length from a section. The (draft) DWARF 3
6033 specification allows the initial length to take up either 4 bytes
6034 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6035 bytes describe the length and all offsets will be 8 bytes in length
6038 An older, non-standard 64-bit format is also handled by this
6039 function. The older format in question stores the initial length
6040 as an 8-byte quantity without an escape value. Lengths greater
6041 than 2^32 aren't very common which means that the initial 4 bytes
6042 is almost always zero. Since a length value of zero doesn't make
6043 sense for the 32-bit format, this initial zero can be considered to
6044 be an escape value which indicates the presence of the older 64-bit
6045 format. As written, the code can't detect (old format) lengths
6046 greater than 4GB. If it becomes necessary to handle lengths
6047 somewhat larger than 4GB, we could allow other small values (such
6048 as the non-sensical values of 1, 2, and 3) to also be used as
6049 escape values indicating the presence of the old format.
6051 The value returned via bytes_read should be used to increment the
6052 relevant pointer after calling read_initial_length().
6054 As a side effect, this function sets the fields initial_length_size
6055 and offset_size in cu_header to the values appropriate for the
6056 length field. (The format of the initial length field determines
6057 the width of file offsets to be fetched later with read_offset().)
6059 [ Note: read_initial_length() and read_offset() are based on the
6060 document entitled "DWARF Debugging Information Format", revision
6061 3, draft 8, dated November 19, 2001. This document was obtained
6064 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6066 This document is only a draft and is subject to change. (So beware.)
6068 Details regarding the older, non-standard 64-bit format were
6069 determined empirically by examining 64-bit ELF files produced by
6070 the SGI toolchain on an IRIX 6.5 machine.
6072 - Kevin, July 16, 2002
6076 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
6077 unsigned int *bytes_read
)
6079 LONGEST length
= bfd_get_32 (abfd
, buf
);
6081 if (length
== 0xffffffff)
6083 length
= bfd_get_64 (abfd
, buf
+ 4);
6086 else if (length
== 0)
6088 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6089 length
= bfd_get_64 (abfd
, buf
);
6099 gdb_assert (cu_header
->initial_length_size
== 0
6100 || cu_header
->initial_length_size
== 4
6101 || cu_header
->initial_length_size
== 8
6102 || cu_header
->initial_length_size
== 12);
6104 if (cu_header
->initial_length_size
!= 0
6105 && cu_header
->initial_length_size
!= *bytes_read
)
6106 complaint (&symfile_complaints
,
6107 _("intermixed 32-bit and 64-bit DWARF sections"));
6109 cu_header
->initial_length_size
= *bytes_read
;
6110 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6116 /* Read an offset from the data stream. The size of the offset is
6117 given by cu_header->offset_size. */
6120 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6121 unsigned int *bytes_read
)
6125 switch (cu_header
->offset_size
)
6128 retval
= bfd_get_32 (abfd
, buf
);
6132 retval
= bfd_get_64 (abfd
, buf
);
6136 internal_error (__FILE__
, __LINE__
,
6137 _("read_offset: bad switch [in module %s]"),
6138 bfd_get_filename (abfd
));
6145 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6147 /* If the size of a host char is 8 bits, we can return a pointer
6148 to the buffer, otherwise we have to copy the data to a buffer
6149 allocated on the temporary obstack. */
6150 gdb_assert (HOST_CHAR_BIT
== 8);
6155 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6157 /* If the size of a host char is 8 bits, we can return a pointer
6158 to the string, otherwise we have to copy the string to a buffer
6159 allocated on the temporary obstack. */
6160 gdb_assert (HOST_CHAR_BIT
== 8);
6163 *bytes_read_ptr
= 1;
6166 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6167 return (char *) buf
;
6171 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6172 const struct comp_unit_head
*cu_header
,
6173 unsigned int *bytes_read_ptr
)
6175 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6178 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6180 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6181 bfd_get_filename (abfd
));
6184 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6186 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6187 bfd_get_filename (abfd
));
6190 gdb_assert (HOST_CHAR_BIT
== 8);
6191 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6193 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6196 static unsigned long
6197 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6199 unsigned long result
;
6200 unsigned int num_read
;
6210 byte
= bfd_get_8 (abfd
, buf
);
6213 result
|= ((unsigned long)(byte
& 127) << shift
);
6214 if ((byte
& 128) == 0)
6220 *bytes_read_ptr
= num_read
;
6225 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6228 int i
, shift
, num_read
;
6237 byte
= bfd_get_8 (abfd
, buf
);
6240 result
|= ((long)(byte
& 127) << shift
);
6242 if ((byte
& 128) == 0)
6247 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6248 result
|= -(((long)1) << shift
);
6249 *bytes_read_ptr
= num_read
;
6253 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6256 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6262 byte
= bfd_get_8 (abfd
, buf
);
6264 if ((byte
& 128) == 0)
6270 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6276 cu
->language
= language_c
;
6278 case DW_LANG_C_plus_plus
:
6279 cu
->language
= language_cplus
;
6281 case DW_LANG_Fortran77
:
6282 case DW_LANG_Fortran90
:
6283 case DW_LANG_Fortran95
:
6284 cu
->language
= language_fortran
;
6286 case DW_LANG_Mips_Assembler
:
6287 cu
->language
= language_asm
;
6290 cu
->language
= language_java
;
6294 cu
->language
= language_ada
;
6296 case DW_LANG_Modula2
:
6297 cu
->language
= language_m2
;
6299 case DW_LANG_Cobol74
:
6300 case DW_LANG_Cobol85
:
6301 case DW_LANG_Pascal83
:
6303 cu
->language
= language_minimal
;
6306 cu
->language_defn
= language_def (cu
->language
);
6309 /* Return the named attribute or NULL if not there. */
6311 static struct attribute
*
6312 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6315 struct attribute
*spec
= NULL
;
6317 for (i
= 0; i
< die
->num_attrs
; ++i
)
6319 if (die
->attrs
[i
].name
== name
)
6320 return &die
->attrs
[i
];
6321 if (die
->attrs
[i
].name
== DW_AT_specification
6322 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6323 spec
= &die
->attrs
[i
];
6327 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6332 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6333 and holds a non-zero value. This function should only be used for
6334 DW_FORM_flag attributes. */
6337 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6339 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6341 return (attr
&& DW_UNSND (attr
));
6345 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6347 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6348 which value is non-zero. However, we have to be careful with
6349 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6350 (via dwarf2_flag_true_p) follows this attribute. So we may
6351 end up accidently finding a declaration attribute that belongs
6352 to a different DIE referenced by the specification attribute,
6353 even though the given DIE does not have a declaration attribute. */
6354 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6355 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6358 /* Return the die giving the specification for DIE, if there is
6361 static struct die_info
*
6362 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6364 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6366 if (spec_attr
== NULL
)
6369 return follow_die_ref (die
, spec_attr
, cu
);
6372 /* Free the line_header structure *LH, and any arrays and strings it
6375 free_line_header (struct line_header
*lh
)
6377 if (lh
->standard_opcode_lengths
)
6378 xfree (lh
->standard_opcode_lengths
);
6380 /* Remember that all the lh->file_names[i].name pointers are
6381 pointers into debug_line_buffer, and don't need to be freed. */
6383 xfree (lh
->file_names
);
6385 /* Similarly for the include directory names. */
6386 if (lh
->include_dirs
)
6387 xfree (lh
->include_dirs
);
6393 /* Add an entry to LH's include directory table. */
6395 add_include_dir (struct line_header
*lh
, char *include_dir
)
6397 /* Grow the array if necessary. */
6398 if (lh
->include_dirs_size
== 0)
6400 lh
->include_dirs_size
= 1; /* for testing */
6401 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6402 * sizeof (*lh
->include_dirs
));
6404 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6406 lh
->include_dirs_size
*= 2;
6407 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6408 (lh
->include_dirs_size
6409 * sizeof (*lh
->include_dirs
)));
6412 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6416 /* Add an entry to LH's file name table. */
6418 add_file_name (struct line_header
*lh
,
6420 unsigned int dir_index
,
6421 unsigned int mod_time
,
6422 unsigned int length
)
6424 struct file_entry
*fe
;
6426 /* Grow the array if necessary. */
6427 if (lh
->file_names_size
== 0)
6429 lh
->file_names_size
= 1; /* for testing */
6430 lh
->file_names
= xmalloc (lh
->file_names_size
6431 * sizeof (*lh
->file_names
));
6433 else if (lh
->num_file_names
>= lh
->file_names_size
)
6435 lh
->file_names_size
*= 2;
6436 lh
->file_names
= xrealloc (lh
->file_names
,
6437 (lh
->file_names_size
6438 * sizeof (*lh
->file_names
)));
6441 fe
= &lh
->file_names
[lh
->num_file_names
++];
6443 fe
->dir_index
= dir_index
;
6444 fe
->mod_time
= mod_time
;
6445 fe
->length
= length
;
6450 /* Read the statement program header starting at OFFSET in
6451 .debug_line, according to the endianness of ABFD. Return a pointer
6452 to a struct line_header, allocated using xmalloc.
6454 NOTE: the strings in the include directory and file name tables of
6455 the returned object point into debug_line_buffer, and must not be
6457 static struct line_header
*
6458 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6459 struct dwarf2_cu
*cu
)
6461 struct cleanup
*back_to
;
6462 struct line_header
*lh
;
6464 unsigned int bytes_read
;
6466 char *cur_dir
, *cur_file
;
6468 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6470 complaint (&symfile_complaints
, _("missing .debug_line section"));
6474 /* Make sure that at least there's room for the total_length field.
6475 That could be 12 bytes long, but we're just going to fudge that. */
6476 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6478 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6482 lh
= xmalloc (sizeof (*lh
));
6483 memset (lh
, 0, sizeof (*lh
));
6484 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6487 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6489 /* Read in the header. */
6491 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6492 line_ptr
+= bytes_read
;
6493 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6494 + dwarf2_per_objfile
->line_size
))
6496 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6499 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6500 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6502 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6503 line_ptr
+= bytes_read
;
6504 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6506 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6508 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6510 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6512 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6514 lh
->standard_opcode_lengths
6515 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6517 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6518 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6520 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6524 /* Read directory table. */
6525 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6527 line_ptr
+= bytes_read
;
6528 add_include_dir (lh
, cur_dir
);
6530 line_ptr
+= bytes_read
;
6532 /* Read file name table. */
6533 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6535 unsigned int dir_index
, mod_time
, length
;
6537 line_ptr
+= bytes_read
;
6538 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6539 line_ptr
+= bytes_read
;
6540 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6541 line_ptr
+= bytes_read
;
6542 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6543 line_ptr
+= bytes_read
;
6545 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6547 line_ptr
+= bytes_read
;
6548 lh
->statement_program_start
= line_ptr
;
6550 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6551 + dwarf2_per_objfile
->line_size
))
6552 complaint (&symfile_complaints
,
6553 _("line number info header doesn't fit in `.debug_line' section"));
6555 discard_cleanups (back_to
);
6559 /* This function exists to work around a bug in certain compilers
6560 (particularly GCC 2.95), in which the first line number marker of a
6561 function does not show up until after the prologue, right before
6562 the second line number marker. This function shifts ADDRESS down
6563 to the beginning of the function if necessary, and is called on
6564 addresses passed to record_line. */
6567 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6569 struct function_range
*fn
;
6571 /* Find the function_range containing address. */
6576 cu
->cached_fn
= cu
->first_fn
;
6580 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6586 while (fn
&& fn
!= cu
->cached_fn
)
6587 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6597 if (address
!= fn
->lowpc
)
6598 complaint (&symfile_complaints
,
6599 _("misplaced first line number at 0x%lx for '%s'"),
6600 (unsigned long) address
, fn
->name
);
6605 /* Decode the Line Number Program (LNP) for the given line_header
6606 structure and CU. The actual information extracted and the type
6607 of structures created from the LNP depends on the value of PST.
6609 1. If PST is NULL, then this procedure uses the data from the program
6610 to create all necessary symbol tables, and their linetables.
6611 The compilation directory of the file is passed in COMP_DIR,
6612 and must not be NULL.
6614 2. If PST is not NULL, this procedure reads the program to determine
6615 the list of files included by the unit represented by PST, and
6616 builds all the associated partial symbol tables. In this case,
6617 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6618 is not used to compute the full name of the symtab, and therefore
6619 omitting it when building the partial symtab does not introduce
6620 the potential for inconsistency - a partial symtab and its associated
6621 symbtab having a different fullname -). */
6624 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6625 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6629 unsigned int bytes_read
;
6630 unsigned char op_code
, extended_op
, adj_opcode
;
6632 struct objfile
*objfile
= cu
->objfile
;
6633 const int decode_for_pst_p
= (pst
!= NULL
);
6634 struct subfile
*last_subfile
= NULL
;
6636 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6638 line_ptr
= lh
->statement_program_start
;
6639 line_end
= lh
->statement_program_end
;
6641 /* Read the statement sequences until there's nothing left. */
6642 while (line_ptr
< line_end
)
6644 /* state machine registers */
6645 CORE_ADDR address
= 0;
6646 unsigned int file
= 1;
6647 unsigned int line
= 1;
6648 unsigned int column
= 0;
6649 int is_stmt
= lh
->default_is_stmt
;
6650 int basic_block
= 0;
6651 int end_sequence
= 0;
6653 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6655 /* Start a subfile for the current file of the state machine. */
6656 /* lh->include_dirs and lh->file_names are 0-based, but the
6657 directory and file name numbers in the statement program
6659 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6663 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6665 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6668 /* Decode the table. */
6669 while (!end_sequence
)
6671 op_code
= read_1_byte (abfd
, line_ptr
);
6674 if (op_code
>= lh
->opcode_base
)
6676 /* Special operand. */
6677 adj_opcode
= op_code
- lh
->opcode_base
;
6678 address
+= (adj_opcode
/ lh
->line_range
)
6679 * lh
->minimum_instruction_length
;
6680 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6681 lh
->file_names
[file
- 1].included_p
= 1;
6682 if (!decode_for_pst_p
)
6684 if (last_subfile
!= current_subfile
)
6687 record_line (last_subfile
, 0, address
);
6688 last_subfile
= current_subfile
;
6690 /* Append row to matrix using current values. */
6691 record_line (current_subfile
, line
,
6692 check_cu_functions (address
, cu
));
6696 else switch (op_code
)
6698 case DW_LNS_extended_op
:
6699 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6700 line_ptr
+= bytes_read
;
6701 extended_op
= read_1_byte (abfd
, line_ptr
);
6703 switch (extended_op
)
6705 case DW_LNE_end_sequence
:
6707 lh
->file_names
[file
- 1].included_p
= 1;
6708 if (!decode_for_pst_p
)
6709 record_line (current_subfile
, 0, address
);
6711 case DW_LNE_set_address
:
6712 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6713 line_ptr
+= bytes_read
;
6714 address
+= baseaddr
;
6716 case DW_LNE_define_file
:
6719 unsigned int dir_index
, mod_time
, length
;
6721 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6722 line_ptr
+= bytes_read
;
6724 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6725 line_ptr
+= bytes_read
;
6727 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6728 line_ptr
+= bytes_read
;
6730 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6731 line_ptr
+= bytes_read
;
6732 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6736 complaint (&symfile_complaints
,
6737 _("mangled .debug_line section"));
6742 lh
->file_names
[file
- 1].included_p
= 1;
6743 if (!decode_for_pst_p
)
6745 if (last_subfile
!= current_subfile
)
6748 record_line (last_subfile
, 0, address
);
6749 last_subfile
= current_subfile
;
6751 record_line (current_subfile
, line
,
6752 check_cu_functions (address
, cu
));
6756 case DW_LNS_advance_pc
:
6757 address
+= lh
->minimum_instruction_length
6758 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6759 line_ptr
+= bytes_read
;
6761 case DW_LNS_advance_line
:
6762 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6763 line_ptr
+= bytes_read
;
6765 case DW_LNS_set_file
:
6767 /* The arrays lh->include_dirs and lh->file_names are
6768 0-based, but the directory and file name numbers in
6769 the statement program are 1-based. */
6770 struct file_entry
*fe
;
6773 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6774 line_ptr
+= bytes_read
;
6775 fe
= &lh
->file_names
[file
- 1];
6777 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6779 if (!decode_for_pst_p
)
6781 last_subfile
= current_subfile
;
6782 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6786 case DW_LNS_set_column
:
6787 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6788 line_ptr
+= bytes_read
;
6790 case DW_LNS_negate_stmt
:
6791 is_stmt
= (!is_stmt
);
6793 case DW_LNS_set_basic_block
:
6796 /* Add to the address register of the state machine the
6797 address increment value corresponding to special opcode
6798 255. I.e., this value is scaled by the minimum
6799 instruction length since special opcode 255 would have
6800 scaled the the increment. */
6801 case DW_LNS_const_add_pc
:
6802 address
+= (lh
->minimum_instruction_length
6803 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6805 case DW_LNS_fixed_advance_pc
:
6806 address
+= read_2_bytes (abfd
, line_ptr
);
6811 /* Unknown standard opcode, ignore it. */
6814 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6816 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6817 line_ptr
+= bytes_read
;
6824 if (decode_for_pst_p
)
6828 /* Now that we're done scanning the Line Header Program, we can
6829 create the psymtab of each included file. */
6830 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6831 if (lh
->file_names
[file_index
].included_p
== 1)
6833 const struct file_entry fe
= lh
->file_names
[file_index
];
6834 char *include_name
= fe
.name
;
6835 char *dir_name
= NULL
;
6836 char *pst_filename
= pst
->filename
;
6839 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6841 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6843 include_name
= concat (dir_name
, SLASH_STRING
,
6844 include_name
, (char *)NULL
);
6845 make_cleanup (xfree
, include_name
);
6848 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6850 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6851 pst_filename
, (char *)NULL
);
6852 make_cleanup (xfree
, pst_filename
);
6855 if (strcmp (include_name
, pst_filename
) != 0)
6856 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6861 /* Start a subfile for DWARF. FILENAME is the name of the file and
6862 DIRNAME the name of the source directory which contains FILENAME
6863 or NULL if not known. COMP_DIR is the compilation directory for the
6864 linetable's compilation unit or NULL if not known.
6865 This routine tries to keep line numbers from identical absolute and
6866 relative file names in a common subfile.
6868 Using the `list' example from the GDB testsuite, which resides in
6869 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6870 of /srcdir/list0.c yields the following debugging information for list0.c:
6872 DW_AT_name: /srcdir/list0.c
6873 DW_AT_comp_dir: /compdir
6874 files.files[0].name: list0.h
6875 files.files[0].dir: /srcdir
6876 files.files[1].name: list0.c
6877 files.files[1].dir: /srcdir
6879 The line number information for list0.c has to end up in a single
6880 subfile, so that `break /srcdir/list0.c:1' works as expected.
6881 start_subfile will ensure that this happens provided that we pass the
6882 concatenation of files.files[1].dir and files.files[1].name as the
6886 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
6890 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6891 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6892 second argument to start_subfile. To be consistent, we do the
6893 same here. In order not to lose the line information directory,
6894 we concatenate it to the filename when it makes sense.
6895 Note that the Dwarf3 standard says (speaking of filenames in line
6896 information): ``The directory index is ignored for file names
6897 that represent full path names''. Thus ignoring dirname in the
6898 `else' branch below isn't an issue. */
6900 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6901 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
6903 fullname
= filename
;
6905 start_subfile (fullname
, comp_dir
);
6907 if (fullname
!= filename
)
6912 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6913 struct dwarf2_cu
*cu
)
6915 struct objfile
*objfile
= cu
->objfile
;
6916 struct comp_unit_head
*cu_header
= &cu
->header
;
6918 /* NOTE drow/2003-01-30: There used to be a comment and some special
6919 code here to turn a symbol with DW_AT_external and a
6920 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6921 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6922 with some versions of binutils) where shared libraries could have
6923 relocations against symbols in their debug information - the
6924 minimal symbol would have the right address, but the debug info
6925 would not. It's no longer necessary, because we will explicitly
6926 apply relocations when we read in the debug information now. */
6928 /* A DW_AT_location attribute with no contents indicates that a
6929 variable has been optimized away. */
6930 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6932 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6936 /* Handle one degenerate form of location expression specially, to
6937 preserve GDB's previous behavior when section offsets are
6938 specified. If this is just a DW_OP_addr then mark this symbol
6941 if (attr_form_is_block (attr
)
6942 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6943 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6947 SYMBOL_VALUE_ADDRESS (sym
) =
6948 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6949 fixup_symbol_section (sym
, objfile
);
6950 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6951 SYMBOL_SECTION (sym
));
6952 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6956 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6957 expression evaluator, and use LOC_COMPUTED only when necessary
6958 (i.e. when the value of a register or memory location is
6959 referenced, or a thread-local block, etc.). Then again, it might
6960 not be worthwhile. I'm assuming that it isn't unless performance
6961 or memory numbers show me otherwise. */
6963 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6964 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6967 /* Given a pointer to a DWARF information entry, figure out if we need
6968 to make a symbol table entry for it, and if so, create a new entry
6969 and return a pointer to it.
6970 If TYPE is NULL, determine symbol type from the die, otherwise
6971 used the passed type. */
6973 static struct symbol
*
6974 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6976 struct objfile
*objfile
= cu
->objfile
;
6977 struct symbol
*sym
= NULL
;
6979 struct attribute
*attr
= NULL
;
6980 struct attribute
*attr2
= NULL
;
6983 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6985 if (die
->tag
!= DW_TAG_namespace
)
6986 name
= dwarf2_linkage_name (die
, cu
);
6988 name
= TYPE_NAME (type
);
6992 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6993 sizeof (struct symbol
));
6994 OBJSTAT (objfile
, n_syms
++);
6995 memset (sym
, 0, sizeof (struct symbol
));
6997 /* Cache this symbol's name and the name's demangled form (if any). */
6998 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6999 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
7001 /* Default assumptions.
7002 Use the passed type or decode it from the die. */
7003 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7004 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7006 SYMBOL_TYPE (sym
) = type
;
7008 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
7009 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
7012 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
7017 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7020 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
7022 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7024 case DW_TAG_subprogram
:
7025 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7027 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7028 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7029 if (attr2
&& (DW_UNSND (attr2
) != 0))
7031 add_symbol_to_list (sym
, &global_symbols
);
7035 add_symbol_to_list (sym
, cu
->list_in_scope
);
7038 case DW_TAG_variable
:
7039 /* Compilation with minimal debug info may result in variables
7040 with missing type entries. Change the misleading `void' type
7041 to something sensible. */
7042 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7043 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
7044 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
7045 "<variable, no debug info>",
7047 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7050 dwarf2_const_value (attr
, sym
, cu
);
7051 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7052 if (attr2
&& (DW_UNSND (attr2
) != 0))
7053 add_symbol_to_list (sym
, &global_symbols
);
7055 add_symbol_to_list (sym
, cu
->list_in_scope
);
7058 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7061 var_decode_location (attr
, sym
, cu
);
7062 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7063 if (attr2
&& (DW_UNSND (attr2
) != 0))
7064 add_symbol_to_list (sym
, &global_symbols
);
7066 add_symbol_to_list (sym
, cu
->list_in_scope
);
7070 /* We do not know the address of this symbol.
7071 If it is an external symbol and we have type information
7072 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7073 The address of the variable will then be determined from
7074 the minimal symbol table whenever the variable is
7076 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7077 if (attr2
&& (DW_UNSND (attr2
) != 0)
7078 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7080 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7081 add_symbol_to_list (sym
, &global_symbols
);
7085 case DW_TAG_formal_parameter
:
7086 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7089 var_decode_location (attr
, sym
, cu
);
7090 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7091 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
7092 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
7094 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7097 dwarf2_const_value (attr
, sym
, cu
);
7099 add_symbol_to_list (sym
, cu
->list_in_scope
);
7101 case DW_TAG_unspecified_parameters
:
7102 /* From varargs functions; gdb doesn't seem to have any
7103 interest in this information, so just ignore it for now.
7106 case DW_TAG_class_type
:
7107 case DW_TAG_structure_type
:
7108 case DW_TAG_union_type
:
7109 case DW_TAG_set_type
:
7110 case DW_TAG_enumeration_type
:
7111 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7112 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7114 /* Make sure that the symbol includes appropriate enclosing
7115 classes/namespaces in its name. These are calculated in
7116 read_structure_type, and the correct name is saved in
7119 if (cu
->language
== language_cplus
7120 || cu
->language
== language_java
)
7122 struct type
*type
= SYMBOL_TYPE (sym
);
7124 if (TYPE_TAG_NAME (type
) != NULL
)
7126 /* FIXME: carlton/2003-11-10: Should this use
7127 SYMBOL_SET_NAMES instead? (The same problem also
7128 arises further down in this function.) */
7129 /* The type's name is already allocated along with
7130 this objfile, so we don't need to duplicate it
7132 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7137 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7138 really ever be static objects: otherwise, if you try
7139 to, say, break of a class's method and you're in a file
7140 which doesn't mention that class, it won't work unless
7141 the check for all static symbols in lookup_symbol_aux
7142 saves you. See the OtherFileClass tests in
7143 gdb.c++/namespace.exp. */
7145 struct pending
**list_to_add
;
7147 list_to_add
= (cu
->list_in_scope
== &file_symbols
7148 && (cu
->language
== language_cplus
7149 || cu
->language
== language_java
)
7150 ? &global_symbols
: cu
->list_in_scope
);
7152 add_symbol_to_list (sym
, list_to_add
);
7154 /* The semantics of C++ state that "struct foo { ... }" also
7155 defines a typedef for "foo". A Java class declaration also
7156 defines a typedef for the class. Synthesize a typedef symbol
7157 so that "ptype foo" works as expected. */
7158 if (cu
->language
== language_cplus
7159 || cu
->language
== language_java
)
7161 struct symbol
*typedef_sym
= (struct symbol
*)
7162 obstack_alloc (&objfile
->objfile_obstack
,
7163 sizeof (struct symbol
));
7164 *typedef_sym
= *sym
;
7165 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7166 /* The symbol's name is already allocated along with
7167 this objfile, so we don't need to duplicate it for
7169 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7170 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7171 add_symbol_to_list (typedef_sym
, list_to_add
);
7175 case DW_TAG_typedef
:
7176 if (processing_has_namespace_info
7177 && processing_current_prefix
[0] != '\0')
7179 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7180 processing_current_prefix
,
7183 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7184 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7185 add_symbol_to_list (sym
, cu
->list_in_scope
);
7187 case DW_TAG_base_type
:
7188 case DW_TAG_subrange_type
:
7189 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7190 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7191 add_symbol_to_list (sym
, cu
->list_in_scope
);
7193 case DW_TAG_enumerator
:
7194 if (processing_has_namespace_info
7195 && processing_current_prefix
[0] != '\0')
7197 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7198 processing_current_prefix
,
7201 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7204 dwarf2_const_value (attr
, sym
, cu
);
7207 /* NOTE: carlton/2003-11-10: See comment above in the
7208 DW_TAG_class_type, etc. block. */
7210 struct pending
**list_to_add
;
7212 list_to_add
= (cu
->list_in_scope
== &file_symbols
7213 && (cu
->language
== language_cplus
7214 || cu
->language
== language_java
)
7215 ? &global_symbols
: cu
->list_in_scope
);
7217 add_symbol_to_list (sym
, list_to_add
);
7220 case DW_TAG_namespace
:
7221 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7222 add_symbol_to_list (sym
, &global_symbols
);
7225 /* Not a tag we recognize. Hopefully we aren't processing
7226 trash data, but since we must specifically ignore things
7227 we don't recognize, there is nothing else we should do at
7229 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7230 dwarf_tag_name (die
->tag
));
7237 /* Copy constant value from an attribute to a symbol. */
7240 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7241 struct dwarf2_cu
*cu
)
7243 struct objfile
*objfile
= cu
->objfile
;
7244 struct comp_unit_head
*cu_header
= &cu
->header
;
7245 struct dwarf_block
*blk
;
7250 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7251 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7252 cu_header
->addr_size
,
7253 TYPE_LENGTH (SYMBOL_TYPE
7255 SYMBOL_VALUE_BYTES (sym
) =
7256 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7257 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7258 it's body - store_unsigned_integer. */
7259 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7261 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7263 case DW_FORM_block1
:
7264 case DW_FORM_block2
:
7265 case DW_FORM_block4
:
7267 blk
= DW_BLOCK (attr
);
7268 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7269 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7271 TYPE_LENGTH (SYMBOL_TYPE
7273 SYMBOL_VALUE_BYTES (sym
) =
7274 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7275 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7276 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7279 /* The DW_AT_const_value attributes are supposed to carry the
7280 symbol's value "represented as it would be on the target
7281 architecture." By the time we get here, it's already been
7282 converted to host endianness, so we just need to sign- or
7283 zero-extend it as appropriate. */
7285 dwarf2_const_value_data (attr
, sym
, 8);
7288 dwarf2_const_value_data (attr
, sym
, 16);
7291 dwarf2_const_value_data (attr
, sym
, 32);
7294 dwarf2_const_value_data (attr
, sym
, 64);
7298 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7299 SYMBOL_CLASS (sym
) = LOC_CONST
;
7303 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7304 SYMBOL_CLASS (sym
) = LOC_CONST
;
7308 complaint (&symfile_complaints
,
7309 _("unsupported const value attribute form: '%s'"),
7310 dwarf_form_name (attr
->form
));
7311 SYMBOL_VALUE (sym
) = 0;
7312 SYMBOL_CLASS (sym
) = LOC_CONST
;
7318 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7319 or zero-extend it as appropriate for the symbol's type. */
7321 dwarf2_const_value_data (struct attribute
*attr
,
7325 LONGEST l
= DW_UNSND (attr
);
7327 if (bits
< sizeof (l
) * 8)
7329 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7330 l
&= ((LONGEST
) 1 << bits
) - 1;
7332 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7335 SYMBOL_VALUE (sym
) = l
;
7336 SYMBOL_CLASS (sym
) = LOC_CONST
;
7340 /* Return the type of the die in question using its DW_AT_type attribute. */
7342 static struct type
*
7343 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7346 struct attribute
*type_attr
;
7347 struct die_info
*type_die
;
7349 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7352 /* A missing DW_AT_type represents a void type. */
7353 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7356 type_die
= follow_die_ref (die
, type_attr
, cu
);
7358 type
= tag_type_to_type (type_die
, cu
);
7361 dump_die (type_die
);
7362 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7368 /* Return the containing type of the die in question using its
7369 DW_AT_containing_type attribute. */
7371 static struct type
*
7372 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7374 struct type
*type
= NULL
;
7375 struct attribute
*type_attr
;
7376 struct die_info
*type_die
= NULL
;
7378 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7381 type_die
= follow_die_ref (die
, type_attr
, cu
);
7382 type
= tag_type_to_type (type_die
, cu
);
7387 dump_die (type_die
);
7388 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7394 static struct type
*
7395 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7403 read_type_die (die
, cu
);
7407 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7415 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7417 char *prefix
= determine_prefix (die
, cu
);
7418 const char *old_prefix
= processing_current_prefix
;
7419 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7420 processing_current_prefix
= prefix
;
7424 case DW_TAG_class_type
:
7425 case DW_TAG_structure_type
:
7426 case DW_TAG_union_type
:
7427 read_structure_type (die
, cu
);
7429 case DW_TAG_enumeration_type
:
7430 read_enumeration_type (die
, cu
);
7432 case DW_TAG_subprogram
:
7433 case DW_TAG_subroutine_type
:
7434 read_subroutine_type (die
, cu
);
7436 case DW_TAG_array_type
:
7437 read_array_type (die
, cu
);
7439 case DW_TAG_set_type
:
7440 read_set_type (die
, cu
);
7442 case DW_TAG_pointer_type
:
7443 read_tag_pointer_type (die
, cu
);
7445 case DW_TAG_ptr_to_member_type
:
7446 read_tag_ptr_to_member_type (die
, cu
);
7448 case DW_TAG_reference_type
:
7449 read_tag_reference_type (die
, cu
);
7451 case DW_TAG_const_type
:
7452 read_tag_const_type (die
, cu
);
7454 case DW_TAG_volatile_type
:
7455 read_tag_volatile_type (die
, cu
);
7457 case DW_TAG_string_type
:
7458 read_tag_string_type (die
, cu
);
7460 case DW_TAG_typedef
:
7461 read_typedef (die
, cu
);
7463 case DW_TAG_subrange_type
:
7464 read_subrange_type (die
, cu
);
7466 case DW_TAG_base_type
:
7467 read_base_type (die
, cu
);
7469 case DW_TAG_unspecified_type
:
7470 read_unspecified_type (die
, cu
);
7473 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7474 dwarf_tag_name (die
->tag
));
7478 processing_current_prefix
= old_prefix
;
7479 do_cleanups (back_to
);
7482 /* Return the name of the namespace/class that DIE is defined within,
7483 or "" if we can't tell. The caller should xfree the result. */
7485 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7486 therein) for an example of how to use this function to deal with
7487 DW_AT_specification. */
7490 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7492 struct die_info
*parent
;
7494 if (cu
->language
!= language_cplus
7495 && cu
->language
!= language_java
)
7498 parent
= die
->parent
;
7502 return xstrdup ("");
7506 switch (parent
->tag
) {
7507 case DW_TAG_namespace
:
7509 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7510 before doing this check? */
7511 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7513 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7518 char *parent_prefix
= determine_prefix (parent
, cu
);
7519 char *retval
= typename_concat (NULL
, parent_prefix
,
7520 namespace_name (parent
, &dummy
,
7523 xfree (parent_prefix
);
7528 case DW_TAG_class_type
:
7529 case DW_TAG_structure_type
:
7531 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7533 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7537 const char *old_prefix
= processing_current_prefix
;
7538 char *new_prefix
= determine_prefix (parent
, cu
);
7541 processing_current_prefix
= new_prefix
;
7542 retval
= determine_class_name (parent
, cu
);
7543 processing_current_prefix
= old_prefix
;
7550 return determine_prefix (parent
, cu
);
7555 /* Return a newly-allocated string formed by concatenating PREFIX and
7556 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7557 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7558 perform an obconcat, otherwise allocate storage for the result. The CU argument
7559 is used to determine the language and hence, the appropriate separator. */
7561 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7564 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7565 struct dwarf2_cu
*cu
)
7569 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7571 else if (cu
->language
== language_java
)
7578 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7583 strcpy (retval
, prefix
);
7584 strcat (retval
, sep
);
7587 strcat (retval
, suffix
);
7593 /* We have an obstack. */
7594 return obconcat (obs
, prefix
, sep
, suffix
);
7598 static struct type
*
7599 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7601 struct objfile
*objfile
= cu
->objfile
;
7603 /* FIXME - this should not produce a new (struct type *)
7604 every time. It should cache base types. */
7608 case DW_ATE_address
:
7609 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7611 case DW_ATE_boolean
:
7612 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7614 case DW_ATE_complex_float
:
7617 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7621 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7627 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7631 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7638 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7641 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7645 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7649 case DW_ATE_signed_char
:
7650 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7652 case DW_ATE_unsigned
:
7656 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7659 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7663 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7667 case DW_ATE_unsigned_char
:
7668 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7671 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7678 copy_die (struct die_info
*old_die
)
7680 struct die_info
*new_die
;
7683 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7684 memset (new_die
, 0, sizeof (struct die_info
));
7686 new_die
->tag
= old_die
->tag
;
7687 new_die
->has_children
= old_die
->has_children
;
7688 new_die
->abbrev
= old_die
->abbrev
;
7689 new_die
->offset
= old_die
->offset
;
7690 new_die
->type
= NULL
;
7692 num_attrs
= old_die
->num_attrs
;
7693 new_die
->num_attrs
= num_attrs
;
7694 new_die
->attrs
= (struct attribute
*)
7695 xmalloc (num_attrs
* sizeof (struct attribute
));
7697 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7699 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7700 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7701 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7704 new_die
->next
= NULL
;
7709 /* Return sibling of die, NULL if no sibling. */
7711 static struct die_info
*
7712 sibling_die (struct die_info
*die
)
7714 return die
->sibling
;
7717 /* Get linkage name of a die, return NULL if not found. */
7720 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7722 struct attribute
*attr
;
7724 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7725 if (attr
&& DW_STRING (attr
))
7726 return DW_STRING (attr
);
7727 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7728 if (attr
&& DW_STRING (attr
))
7729 return DW_STRING (attr
);
7733 /* Get name of a die, return NULL if not found. */
7736 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7738 struct attribute
*attr
;
7740 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7741 if (attr
&& DW_STRING (attr
))
7742 return DW_STRING (attr
);
7746 /* Return the die that this die in an extension of, or NULL if there
7749 static struct die_info
*
7750 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7752 struct attribute
*attr
;
7754 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7758 return follow_die_ref (die
, attr
, cu
);
7761 /* Convert a DIE tag into its string name. */
7764 dwarf_tag_name (unsigned tag
)
7768 case DW_TAG_padding
:
7769 return "DW_TAG_padding";
7770 case DW_TAG_array_type
:
7771 return "DW_TAG_array_type";
7772 case DW_TAG_class_type
:
7773 return "DW_TAG_class_type";
7774 case DW_TAG_entry_point
:
7775 return "DW_TAG_entry_point";
7776 case DW_TAG_enumeration_type
:
7777 return "DW_TAG_enumeration_type";
7778 case DW_TAG_formal_parameter
:
7779 return "DW_TAG_formal_parameter";
7780 case DW_TAG_imported_declaration
:
7781 return "DW_TAG_imported_declaration";
7783 return "DW_TAG_label";
7784 case DW_TAG_lexical_block
:
7785 return "DW_TAG_lexical_block";
7787 return "DW_TAG_member";
7788 case DW_TAG_pointer_type
:
7789 return "DW_TAG_pointer_type";
7790 case DW_TAG_reference_type
:
7791 return "DW_TAG_reference_type";
7792 case DW_TAG_compile_unit
:
7793 return "DW_TAG_compile_unit";
7794 case DW_TAG_string_type
:
7795 return "DW_TAG_string_type";
7796 case DW_TAG_structure_type
:
7797 return "DW_TAG_structure_type";
7798 case DW_TAG_subroutine_type
:
7799 return "DW_TAG_subroutine_type";
7800 case DW_TAG_typedef
:
7801 return "DW_TAG_typedef";
7802 case DW_TAG_union_type
:
7803 return "DW_TAG_union_type";
7804 case DW_TAG_unspecified_parameters
:
7805 return "DW_TAG_unspecified_parameters";
7806 case DW_TAG_variant
:
7807 return "DW_TAG_variant";
7808 case DW_TAG_common_block
:
7809 return "DW_TAG_common_block";
7810 case DW_TAG_common_inclusion
:
7811 return "DW_TAG_common_inclusion";
7812 case DW_TAG_inheritance
:
7813 return "DW_TAG_inheritance";
7814 case DW_TAG_inlined_subroutine
:
7815 return "DW_TAG_inlined_subroutine";
7817 return "DW_TAG_module";
7818 case DW_TAG_ptr_to_member_type
:
7819 return "DW_TAG_ptr_to_member_type";
7820 case DW_TAG_set_type
:
7821 return "DW_TAG_set_type";
7822 case DW_TAG_subrange_type
:
7823 return "DW_TAG_subrange_type";
7824 case DW_TAG_with_stmt
:
7825 return "DW_TAG_with_stmt";
7826 case DW_TAG_access_declaration
:
7827 return "DW_TAG_access_declaration";
7828 case DW_TAG_base_type
:
7829 return "DW_TAG_base_type";
7830 case DW_TAG_catch_block
:
7831 return "DW_TAG_catch_block";
7832 case DW_TAG_const_type
:
7833 return "DW_TAG_const_type";
7834 case DW_TAG_constant
:
7835 return "DW_TAG_constant";
7836 case DW_TAG_enumerator
:
7837 return "DW_TAG_enumerator";
7838 case DW_TAG_file_type
:
7839 return "DW_TAG_file_type";
7841 return "DW_TAG_friend";
7842 case DW_TAG_namelist
:
7843 return "DW_TAG_namelist";
7844 case DW_TAG_namelist_item
:
7845 return "DW_TAG_namelist_item";
7846 case DW_TAG_packed_type
:
7847 return "DW_TAG_packed_type";
7848 case DW_TAG_subprogram
:
7849 return "DW_TAG_subprogram";
7850 case DW_TAG_template_type_param
:
7851 return "DW_TAG_template_type_param";
7852 case DW_TAG_template_value_param
:
7853 return "DW_TAG_template_value_param";
7854 case DW_TAG_thrown_type
:
7855 return "DW_TAG_thrown_type";
7856 case DW_TAG_try_block
:
7857 return "DW_TAG_try_block";
7858 case DW_TAG_variant_part
:
7859 return "DW_TAG_variant_part";
7860 case DW_TAG_variable
:
7861 return "DW_TAG_variable";
7862 case DW_TAG_volatile_type
:
7863 return "DW_TAG_volatile_type";
7864 case DW_TAG_dwarf_procedure
:
7865 return "DW_TAG_dwarf_procedure";
7866 case DW_TAG_restrict_type
:
7867 return "DW_TAG_restrict_type";
7868 case DW_TAG_interface_type
:
7869 return "DW_TAG_interface_type";
7870 case DW_TAG_namespace
:
7871 return "DW_TAG_namespace";
7872 case DW_TAG_imported_module
:
7873 return "DW_TAG_imported_module";
7874 case DW_TAG_unspecified_type
:
7875 return "DW_TAG_unspecified_type";
7876 case DW_TAG_partial_unit
:
7877 return "DW_TAG_partial_unit";
7878 case DW_TAG_imported_unit
:
7879 return "DW_TAG_imported_unit";
7880 case DW_TAG_condition
:
7881 return "DW_TAG_condition";
7882 case DW_TAG_shared_type
:
7883 return "DW_TAG_shared_type";
7884 case DW_TAG_MIPS_loop
:
7885 return "DW_TAG_MIPS_loop";
7886 case DW_TAG_HP_array_descriptor
:
7887 return "DW_TAG_HP_array_descriptor";
7888 case DW_TAG_format_label
:
7889 return "DW_TAG_format_label";
7890 case DW_TAG_function_template
:
7891 return "DW_TAG_function_template";
7892 case DW_TAG_class_template
:
7893 return "DW_TAG_class_template";
7894 case DW_TAG_GNU_BINCL
:
7895 return "DW_TAG_GNU_BINCL";
7896 case DW_TAG_GNU_EINCL
:
7897 return "DW_TAG_GNU_EINCL";
7898 case DW_TAG_upc_shared_type
:
7899 return "DW_TAG_upc_shared_type";
7900 case DW_TAG_upc_strict_type
:
7901 return "DW_TAG_upc_strict_type";
7902 case DW_TAG_upc_relaxed_type
:
7903 return "DW_TAG_upc_relaxed_type";
7904 case DW_TAG_PGI_kanji_type
:
7905 return "DW_TAG_PGI_kanji_type";
7906 case DW_TAG_PGI_interface_block
:
7907 return "DW_TAG_PGI_interface_block";
7909 return "DW_TAG_<unknown>";
7913 /* Convert a DWARF attribute code into its string name. */
7916 dwarf_attr_name (unsigned attr
)
7921 return "DW_AT_sibling";
7922 case DW_AT_location
:
7923 return "DW_AT_location";
7925 return "DW_AT_name";
7926 case DW_AT_ordering
:
7927 return "DW_AT_ordering";
7928 case DW_AT_subscr_data
:
7929 return "DW_AT_subscr_data";
7930 case DW_AT_byte_size
:
7931 return "DW_AT_byte_size";
7932 case DW_AT_bit_offset
:
7933 return "DW_AT_bit_offset";
7934 case DW_AT_bit_size
:
7935 return "DW_AT_bit_size";
7936 case DW_AT_element_list
:
7937 return "DW_AT_element_list";
7938 case DW_AT_stmt_list
:
7939 return "DW_AT_stmt_list";
7941 return "DW_AT_low_pc";
7943 return "DW_AT_high_pc";
7944 case DW_AT_language
:
7945 return "DW_AT_language";
7947 return "DW_AT_member";
7949 return "DW_AT_discr";
7950 case DW_AT_discr_value
:
7951 return "DW_AT_discr_value";
7952 case DW_AT_visibility
:
7953 return "DW_AT_visibility";
7955 return "DW_AT_import";
7956 case DW_AT_string_length
:
7957 return "DW_AT_string_length";
7958 case DW_AT_common_reference
:
7959 return "DW_AT_common_reference";
7960 case DW_AT_comp_dir
:
7961 return "DW_AT_comp_dir";
7962 case DW_AT_const_value
:
7963 return "DW_AT_const_value";
7964 case DW_AT_containing_type
:
7965 return "DW_AT_containing_type";
7966 case DW_AT_default_value
:
7967 return "DW_AT_default_value";
7969 return "DW_AT_inline";
7970 case DW_AT_is_optional
:
7971 return "DW_AT_is_optional";
7972 case DW_AT_lower_bound
:
7973 return "DW_AT_lower_bound";
7974 case DW_AT_producer
:
7975 return "DW_AT_producer";
7976 case DW_AT_prototyped
:
7977 return "DW_AT_prototyped";
7978 case DW_AT_return_addr
:
7979 return "DW_AT_return_addr";
7980 case DW_AT_start_scope
:
7981 return "DW_AT_start_scope";
7982 case DW_AT_stride_size
:
7983 return "DW_AT_stride_size";
7984 case DW_AT_upper_bound
:
7985 return "DW_AT_upper_bound";
7986 case DW_AT_abstract_origin
:
7987 return "DW_AT_abstract_origin";
7988 case DW_AT_accessibility
:
7989 return "DW_AT_accessibility";
7990 case DW_AT_address_class
:
7991 return "DW_AT_address_class";
7992 case DW_AT_artificial
:
7993 return "DW_AT_artificial";
7994 case DW_AT_base_types
:
7995 return "DW_AT_base_types";
7996 case DW_AT_calling_convention
:
7997 return "DW_AT_calling_convention";
7999 return "DW_AT_count";
8000 case DW_AT_data_member_location
:
8001 return "DW_AT_data_member_location";
8002 case DW_AT_decl_column
:
8003 return "DW_AT_decl_column";
8004 case DW_AT_decl_file
:
8005 return "DW_AT_decl_file";
8006 case DW_AT_decl_line
:
8007 return "DW_AT_decl_line";
8008 case DW_AT_declaration
:
8009 return "DW_AT_declaration";
8010 case DW_AT_discr_list
:
8011 return "DW_AT_discr_list";
8012 case DW_AT_encoding
:
8013 return "DW_AT_encoding";
8014 case DW_AT_external
:
8015 return "DW_AT_external";
8016 case DW_AT_frame_base
:
8017 return "DW_AT_frame_base";
8019 return "DW_AT_friend";
8020 case DW_AT_identifier_case
:
8021 return "DW_AT_identifier_case";
8022 case DW_AT_macro_info
:
8023 return "DW_AT_macro_info";
8024 case DW_AT_namelist_items
:
8025 return "DW_AT_namelist_items";
8026 case DW_AT_priority
:
8027 return "DW_AT_priority";
8029 return "DW_AT_segment";
8030 case DW_AT_specification
:
8031 return "DW_AT_specification";
8032 case DW_AT_static_link
:
8033 return "DW_AT_static_link";
8035 return "DW_AT_type";
8036 case DW_AT_use_location
:
8037 return "DW_AT_use_location";
8038 case DW_AT_variable_parameter
:
8039 return "DW_AT_variable_parameter";
8040 case DW_AT_virtuality
:
8041 return "DW_AT_virtuality";
8042 case DW_AT_vtable_elem_location
:
8043 return "DW_AT_vtable_elem_location";
8044 /* DWARF 3 values. */
8045 case DW_AT_allocated
:
8046 return "DW_AT_allocated";
8047 case DW_AT_associated
:
8048 return "DW_AT_associated";
8049 case DW_AT_data_location
:
8050 return "DW_AT_data_location";
8052 return "DW_AT_stride";
8053 case DW_AT_entry_pc
:
8054 return "DW_AT_entry_pc";
8055 case DW_AT_use_UTF8
:
8056 return "DW_AT_use_UTF8";
8057 case DW_AT_extension
:
8058 return "DW_AT_extension";
8060 return "DW_AT_ranges";
8061 case DW_AT_trampoline
:
8062 return "DW_AT_trampoline";
8063 case DW_AT_call_column
:
8064 return "DW_AT_call_column";
8065 case DW_AT_call_file
:
8066 return "DW_AT_call_file";
8067 case DW_AT_call_line
:
8068 return "DW_AT_call_line";
8069 case DW_AT_description
:
8070 return "DW_AT_description";
8071 case DW_AT_binary_scale
:
8072 return "DW_AT_binary_scale";
8073 case DW_AT_decimal_scale
:
8074 return "DW_AT_decimal_scale";
8076 return "DW_AT_small";
8077 case DW_AT_decimal_sign
:
8078 return "DW_AT_decimal_sign";
8079 case DW_AT_digit_count
:
8080 return "DW_AT_digit_count";
8081 case DW_AT_picture_string
:
8082 return "DW_AT_picture_string";
8084 return "DW_AT_mutable";
8085 case DW_AT_threads_scaled
:
8086 return "DW_AT_threads_scaled";
8087 case DW_AT_explicit
:
8088 return "DW_AT_explicit";
8089 case DW_AT_object_pointer
:
8090 return "DW_AT_object_pointer";
8091 case DW_AT_endianity
:
8092 return "DW_AT_endianity";
8093 case DW_AT_elemental
:
8094 return "DW_AT_elemental";
8096 return "DW_AT_pure";
8097 case DW_AT_recursive
:
8098 return "DW_AT_recursive";
8100 /* SGI/MIPS extensions. */
8101 case DW_AT_MIPS_fde
:
8102 return "DW_AT_MIPS_fde";
8103 case DW_AT_MIPS_loop_begin
:
8104 return "DW_AT_MIPS_loop_begin";
8105 case DW_AT_MIPS_tail_loop_begin
:
8106 return "DW_AT_MIPS_tail_loop_begin";
8107 case DW_AT_MIPS_epilog_begin
:
8108 return "DW_AT_MIPS_epilog_begin";
8109 case DW_AT_MIPS_loop_unroll_factor
:
8110 return "DW_AT_MIPS_loop_unroll_factor";
8111 case DW_AT_MIPS_software_pipeline_depth
:
8112 return "DW_AT_MIPS_software_pipeline_depth";
8113 case DW_AT_MIPS_linkage_name
:
8114 return "DW_AT_MIPS_linkage_name";
8115 case DW_AT_MIPS_stride
:
8116 return "DW_AT_MIPS_stride";
8117 case DW_AT_MIPS_abstract_name
:
8118 return "DW_AT_MIPS_abstract_name";
8119 case DW_AT_MIPS_clone_origin
:
8120 return "DW_AT_MIPS_clone_origin";
8121 case DW_AT_MIPS_has_inlines
:
8122 return "DW_AT_MIPS_has_inlines";
8124 /* HP extensions. */
8125 case DW_AT_HP_block_index
:
8126 return "DW_AT_HP_block_index";
8127 case DW_AT_HP_unmodifiable
:
8128 return "DW_AT_HP_unmodifiable";
8129 case DW_AT_HP_actuals_stmt_list
:
8130 return "DW_AT_HP_actuals_stmt_list";
8131 case DW_AT_HP_proc_per_section
:
8132 return "DW_AT_HP_proc_per_section";
8133 case DW_AT_HP_raw_data_ptr
:
8134 return "DW_AT_HP_raw_data_ptr";
8135 case DW_AT_HP_pass_by_reference
:
8136 return "DW_AT_HP_pass_by_reference";
8137 case DW_AT_HP_opt_level
:
8138 return "DW_AT_HP_opt_level";
8139 case DW_AT_HP_prof_version_id
:
8140 return "DW_AT_HP_prof_version_id";
8141 case DW_AT_HP_opt_flags
:
8142 return "DW_AT_HP_opt_flags";
8143 case DW_AT_HP_cold_region_low_pc
:
8144 return "DW_AT_HP_cold_region_low_pc";
8145 case DW_AT_HP_cold_region_high_pc
:
8146 return "DW_AT_HP_cold_region_high_pc";
8147 case DW_AT_HP_all_variables_modifiable
:
8148 return "DW_AT_HP_all_variables_modifiable";
8149 case DW_AT_HP_linkage_name
:
8150 return "DW_AT_HP_linkage_name";
8151 case DW_AT_HP_prof_flags
:
8152 return "DW_AT_HP_prof_flags";
8153 /* GNU extensions. */
8154 case DW_AT_sf_names
:
8155 return "DW_AT_sf_names";
8156 case DW_AT_src_info
:
8157 return "DW_AT_src_info";
8158 case DW_AT_mac_info
:
8159 return "DW_AT_mac_info";
8160 case DW_AT_src_coords
:
8161 return "DW_AT_src_coords";
8162 case DW_AT_body_begin
:
8163 return "DW_AT_body_begin";
8164 case DW_AT_body_end
:
8165 return "DW_AT_body_end";
8166 case DW_AT_GNU_vector
:
8167 return "DW_AT_GNU_vector";
8168 /* VMS extensions. */
8169 case DW_AT_VMS_rtnbeg_pd_address
:
8170 return "DW_AT_VMS_rtnbeg_pd_address";
8171 /* UPC extension. */
8172 case DW_AT_upc_threads_scaled
:
8173 return "DW_AT_upc_threads_scaled";
8174 /* PGI (STMicroelectronics) extensions. */
8175 case DW_AT_PGI_lbase
:
8176 return "DW_AT_PGI_lbase";
8177 case DW_AT_PGI_soffset
:
8178 return "DW_AT_PGI_soffset";
8179 case DW_AT_PGI_lstride
:
8180 return "DW_AT_PGI_lstride";
8182 return "DW_AT_<unknown>";
8186 /* Convert a DWARF value form code into its string name. */
8189 dwarf_form_name (unsigned form
)
8194 return "DW_FORM_addr";
8195 case DW_FORM_block2
:
8196 return "DW_FORM_block2";
8197 case DW_FORM_block4
:
8198 return "DW_FORM_block4";
8200 return "DW_FORM_data2";
8202 return "DW_FORM_data4";
8204 return "DW_FORM_data8";
8205 case DW_FORM_string
:
8206 return "DW_FORM_string";
8208 return "DW_FORM_block";
8209 case DW_FORM_block1
:
8210 return "DW_FORM_block1";
8212 return "DW_FORM_data1";
8214 return "DW_FORM_flag";
8216 return "DW_FORM_sdata";
8218 return "DW_FORM_strp";
8220 return "DW_FORM_udata";
8221 case DW_FORM_ref_addr
:
8222 return "DW_FORM_ref_addr";
8224 return "DW_FORM_ref1";
8226 return "DW_FORM_ref2";
8228 return "DW_FORM_ref4";
8230 return "DW_FORM_ref8";
8231 case DW_FORM_ref_udata
:
8232 return "DW_FORM_ref_udata";
8233 case DW_FORM_indirect
:
8234 return "DW_FORM_indirect";
8236 return "DW_FORM_<unknown>";
8240 /* Convert a DWARF stack opcode into its string name. */
8243 dwarf_stack_op_name (unsigned op
)
8248 return "DW_OP_addr";
8250 return "DW_OP_deref";
8252 return "DW_OP_const1u";
8254 return "DW_OP_const1s";
8256 return "DW_OP_const2u";
8258 return "DW_OP_const2s";
8260 return "DW_OP_const4u";
8262 return "DW_OP_const4s";
8264 return "DW_OP_const8u";
8266 return "DW_OP_const8s";
8268 return "DW_OP_constu";
8270 return "DW_OP_consts";
8274 return "DW_OP_drop";
8276 return "DW_OP_over";
8278 return "DW_OP_pick";
8280 return "DW_OP_swap";
8284 return "DW_OP_xderef";
8292 return "DW_OP_minus";
8304 return "DW_OP_plus";
8305 case DW_OP_plus_uconst
:
8306 return "DW_OP_plus_uconst";
8312 return "DW_OP_shra";
8330 return "DW_OP_skip";
8332 return "DW_OP_lit0";
8334 return "DW_OP_lit1";
8336 return "DW_OP_lit2";
8338 return "DW_OP_lit3";
8340 return "DW_OP_lit4";
8342 return "DW_OP_lit5";
8344 return "DW_OP_lit6";
8346 return "DW_OP_lit7";
8348 return "DW_OP_lit8";
8350 return "DW_OP_lit9";
8352 return "DW_OP_lit10";
8354 return "DW_OP_lit11";
8356 return "DW_OP_lit12";
8358 return "DW_OP_lit13";
8360 return "DW_OP_lit14";
8362 return "DW_OP_lit15";
8364 return "DW_OP_lit16";
8366 return "DW_OP_lit17";
8368 return "DW_OP_lit18";
8370 return "DW_OP_lit19";
8372 return "DW_OP_lit20";
8374 return "DW_OP_lit21";
8376 return "DW_OP_lit22";
8378 return "DW_OP_lit23";
8380 return "DW_OP_lit24";
8382 return "DW_OP_lit25";
8384 return "DW_OP_lit26";
8386 return "DW_OP_lit27";
8388 return "DW_OP_lit28";
8390 return "DW_OP_lit29";
8392 return "DW_OP_lit30";
8394 return "DW_OP_lit31";
8396 return "DW_OP_reg0";
8398 return "DW_OP_reg1";
8400 return "DW_OP_reg2";
8402 return "DW_OP_reg3";
8404 return "DW_OP_reg4";
8406 return "DW_OP_reg5";
8408 return "DW_OP_reg6";
8410 return "DW_OP_reg7";
8412 return "DW_OP_reg8";
8414 return "DW_OP_reg9";
8416 return "DW_OP_reg10";
8418 return "DW_OP_reg11";
8420 return "DW_OP_reg12";
8422 return "DW_OP_reg13";
8424 return "DW_OP_reg14";
8426 return "DW_OP_reg15";
8428 return "DW_OP_reg16";
8430 return "DW_OP_reg17";
8432 return "DW_OP_reg18";
8434 return "DW_OP_reg19";
8436 return "DW_OP_reg20";
8438 return "DW_OP_reg21";
8440 return "DW_OP_reg22";
8442 return "DW_OP_reg23";
8444 return "DW_OP_reg24";
8446 return "DW_OP_reg25";
8448 return "DW_OP_reg26";
8450 return "DW_OP_reg27";
8452 return "DW_OP_reg28";
8454 return "DW_OP_reg29";
8456 return "DW_OP_reg30";
8458 return "DW_OP_reg31";
8460 return "DW_OP_breg0";
8462 return "DW_OP_breg1";
8464 return "DW_OP_breg2";
8466 return "DW_OP_breg3";
8468 return "DW_OP_breg4";
8470 return "DW_OP_breg5";
8472 return "DW_OP_breg6";
8474 return "DW_OP_breg7";
8476 return "DW_OP_breg8";
8478 return "DW_OP_breg9";
8480 return "DW_OP_breg10";
8482 return "DW_OP_breg11";
8484 return "DW_OP_breg12";
8486 return "DW_OP_breg13";
8488 return "DW_OP_breg14";
8490 return "DW_OP_breg15";
8492 return "DW_OP_breg16";
8494 return "DW_OP_breg17";
8496 return "DW_OP_breg18";
8498 return "DW_OP_breg19";
8500 return "DW_OP_breg20";
8502 return "DW_OP_breg21";
8504 return "DW_OP_breg22";
8506 return "DW_OP_breg23";
8508 return "DW_OP_breg24";
8510 return "DW_OP_breg25";
8512 return "DW_OP_breg26";
8514 return "DW_OP_breg27";
8516 return "DW_OP_breg28";
8518 return "DW_OP_breg29";
8520 return "DW_OP_breg30";
8522 return "DW_OP_breg31";
8524 return "DW_OP_regx";
8526 return "DW_OP_fbreg";
8528 return "DW_OP_bregx";
8530 return "DW_OP_piece";
8531 case DW_OP_deref_size
:
8532 return "DW_OP_deref_size";
8533 case DW_OP_xderef_size
:
8534 return "DW_OP_xderef_size";
8537 /* DWARF 3 extensions. */
8538 case DW_OP_push_object_address
:
8539 return "DW_OP_push_object_address";
8541 return "DW_OP_call2";
8543 return "DW_OP_call4";
8544 case DW_OP_call_ref
:
8545 return "DW_OP_call_ref";
8546 /* GNU extensions. */
8547 case DW_OP_form_tls_address
:
8548 return "DW_OP_form_tls_address";
8549 case DW_OP_call_frame_cfa
:
8550 return "DW_OP_call_frame_cfa";
8551 case DW_OP_bit_piece
:
8552 return "DW_OP_bit_piece";
8553 case DW_OP_GNU_push_tls_address
:
8554 return "DW_OP_GNU_push_tls_address";
8555 /* HP extensions. */
8556 case DW_OP_HP_is_value
:
8557 return "DW_OP_HP_is_value";
8558 case DW_OP_HP_fltconst4
:
8559 return "DW_OP_HP_fltconst4";
8560 case DW_OP_HP_fltconst8
:
8561 return "DW_OP_HP_fltconst8";
8562 case DW_OP_HP_mod_range
:
8563 return "DW_OP_HP_mod_range";
8564 case DW_OP_HP_unmod_range
:
8565 return "DW_OP_HP_unmod_range";
8567 return "DW_OP_HP_tls";
8569 return "OP_<unknown>";
8574 dwarf_bool_name (unsigned mybool
)
8582 /* Convert a DWARF type code into its string name. */
8585 dwarf_type_encoding_name (unsigned enc
)
8590 return "DW_ATE_void";
8591 case DW_ATE_address
:
8592 return "DW_ATE_address";
8593 case DW_ATE_boolean
:
8594 return "DW_ATE_boolean";
8595 case DW_ATE_complex_float
:
8596 return "DW_ATE_complex_float";
8598 return "DW_ATE_float";
8600 return "DW_ATE_signed";
8601 case DW_ATE_signed_char
:
8602 return "DW_ATE_signed_char";
8603 case DW_ATE_unsigned
:
8604 return "DW_ATE_unsigned";
8605 case DW_ATE_unsigned_char
:
8606 return "DW_ATE_unsigned_char";
8608 case DW_ATE_imaginary_float
:
8609 return "DW_ATE_imaginary_float";
8610 case DW_ATE_packed_decimal
:
8611 return "DW_ATE_packed_decimal";
8612 case DW_ATE_numeric_string
:
8613 return "DW_ATE_numeric_string";
8615 return "DW_ATE_edited";
8616 case DW_ATE_signed_fixed
:
8617 return "DW_ATE_signed_fixed";
8618 case DW_ATE_unsigned_fixed
:
8619 return "DW_ATE_unsigned_fixed";
8620 case DW_ATE_decimal_float
:
8621 return "DW_ATE_decimal_float";
8622 /* HP extensions. */
8623 case DW_ATE_HP_float80
:
8624 return "DW_ATE_HP_float80";
8625 case DW_ATE_HP_complex_float80
:
8626 return "DW_ATE_HP_complex_float80";
8627 case DW_ATE_HP_float128
:
8628 return "DW_ATE_HP_float128";
8629 case DW_ATE_HP_complex_float128
:
8630 return "DW_ATE_HP_complex_float128";
8631 case DW_ATE_HP_floathpintel
:
8632 return "DW_ATE_HP_floathpintel";
8633 case DW_ATE_HP_imaginary_float80
:
8634 return "DW_ATE_HP_imaginary_float80";
8635 case DW_ATE_HP_imaginary_float128
:
8636 return "DW_ATE_HP_imaginary_float128";
8638 return "DW_ATE_<unknown>";
8642 /* Convert a DWARF call frame info operation to its string name. */
8646 dwarf_cfi_name (unsigned cfi_opc
)
8650 case DW_CFA_advance_loc
:
8651 return "DW_CFA_advance_loc";
8653 return "DW_CFA_offset";
8654 case DW_CFA_restore
:
8655 return "DW_CFA_restore";
8657 return "DW_CFA_nop";
8658 case DW_CFA_set_loc
:
8659 return "DW_CFA_set_loc";
8660 case DW_CFA_advance_loc1
:
8661 return "DW_CFA_advance_loc1";
8662 case DW_CFA_advance_loc2
:
8663 return "DW_CFA_advance_loc2";
8664 case DW_CFA_advance_loc4
:
8665 return "DW_CFA_advance_loc4";
8666 case DW_CFA_offset_extended
:
8667 return "DW_CFA_offset_extended";
8668 case DW_CFA_restore_extended
:
8669 return "DW_CFA_restore_extended";
8670 case DW_CFA_undefined
:
8671 return "DW_CFA_undefined";
8672 case DW_CFA_same_value
:
8673 return "DW_CFA_same_value";
8674 case DW_CFA_register
:
8675 return "DW_CFA_register";
8676 case DW_CFA_remember_state
:
8677 return "DW_CFA_remember_state";
8678 case DW_CFA_restore_state
:
8679 return "DW_CFA_restore_state";
8680 case DW_CFA_def_cfa
:
8681 return "DW_CFA_def_cfa";
8682 case DW_CFA_def_cfa_register
:
8683 return "DW_CFA_def_cfa_register";
8684 case DW_CFA_def_cfa_offset
:
8685 return "DW_CFA_def_cfa_offset";
8687 case DW_CFA_def_cfa_expression
:
8688 return "DW_CFA_def_cfa_expression";
8689 case DW_CFA_expression
:
8690 return "DW_CFA_expression";
8691 case DW_CFA_offset_extended_sf
:
8692 return "DW_CFA_offset_extended_sf";
8693 case DW_CFA_def_cfa_sf
:
8694 return "DW_CFA_def_cfa_sf";
8695 case DW_CFA_def_cfa_offset_sf
:
8696 return "DW_CFA_def_cfa_offset_sf";
8697 case DW_CFA_val_offset
:
8698 return "DW_CFA_val_offset";
8699 case DW_CFA_val_offset_sf
:
8700 return "DW_CFA_val_offset_sf";
8701 case DW_CFA_val_expression
:
8702 return "DW_CFA_val_expression";
8703 /* SGI/MIPS specific. */
8704 case DW_CFA_MIPS_advance_loc8
:
8705 return "DW_CFA_MIPS_advance_loc8";
8706 /* GNU extensions. */
8707 case DW_CFA_GNU_window_save
:
8708 return "DW_CFA_GNU_window_save";
8709 case DW_CFA_GNU_args_size
:
8710 return "DW_CFA_GNU_args_size";
8711 case DW_CFA_GNU_negative_offset_extended
:
8712 return "DW_CFA_GNU_negative_offset_extended";
8714 return "DW_CFA_<unknown>";
8720 dump_die (struct die_info
*die
)
8724 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8725 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8726 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8727 dwarf_bool_name (die
->child
!= NULL
));
8729 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8730 for (i
= 0; i
< die
->num_attrs
; ++i
)
8732 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8733 dwarf_attr_name (die
->attrs
[i
].name
),
8734 dwarf_form_name (die
->attrs
[i
].form
));
8735 switch (die
->attrs
[i
].form
)
8737 case DW_FORM_ref_addr
:
8739 fprintf_unfiltered (gdb_stderr
, "address: ");
8740 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8742 case DW_FORM_block2
:
8743 case DW_FORM_block4
:
8745 case DW_FORM_block1
:
8746 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8751 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8752 (long) (DW_ADDR (&die
->attrs
[i
])));
8760 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8762 case DW_FORM_string
:
8764 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8765 DW_STRING (&die
->attrs
[i
])
8766 ? DW_STRING (&die
->attrs
[i
]) : "");
8769 if (DW_UNSND (&die
->attrs
[i
]))
8770 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8772 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8774 case DW_FORM_indirect
:
8775 /* the reader will have reduced the indirect form to
8776 the "base form" so this form should not occur */
8777 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8780 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8781 die
->attrs
[i
].form
);
8783 fprintf_unfiltered (gdb_stderr
, "\n");
8788 dump_die_list (struct die_info
*die
)
8793 if (die
->child
!= NULL
)
8794 dump_die_list (die
->child
);
8795 if (die
->sibling
!= NULL
)
8796 dump_die_list (die
->sibling
);
8801 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8802 struct dwarf2_cu
*cu
)
8805 struct die_info
*old
;
8807 h
= (offset
% REF_HASH_SIZE
);
8808 old
= cu
->die_ref_table
[h
];
8809 die
->next_ref
= old
;
8810 cu
->die_ref_table
[h
] = die
;
8814 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8816 unsigned int result
= 0;
8820 case DW_FORM_ref_addr
:
8825 case DW_FORM_ref_udata
:
8826 result
= DW_ADDR (attr
);
8829 complaint (&symfile_complaints
,
8830 _("unsupported die ref attribute form: '%s'"),
8831 dwarf_form_name (attr
->form
));
8836 /* Return the constant value held by the given attribute. Return -1
8837 if the value held by the attribute is not constant. */
8840 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8842 if (attr
->form
== DW_FORM_sdata
)
8843 return DW_SND (attr
);
8844 else if (attr
->form
== DW_FORM_udata
8845 || attr
->form
== DW_FORM_data1
8846 || attr
->form
== DW_FORM_data2
8847 || attr
->form
== DW_FORM_data4
8848 || attr
->form
== DW_FORM_data8
)
8849 return DW_UNSND (attr
);
8852 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8853 dwarf_form_name (attr
->form
));
8854 return default_value
;
8858 static struct die_info
*
8859 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8860 struct dwarf2_cu
*cu
)
8862 struct die_info
*die
;
8863 unsigned int offset
;
8865 struct die_info temp_die
;
8866 struct dwarf2_cu
*target_cu
;
8868 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8870 if (DW_ADDR (attr
) < cu
->header
.offset
8871 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8873 struct dwarf2_per_cu_data
*per_cu
;
8874 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8876 target_cu
= per_cu
->cu
;
8881 h
= (offset
% REF_HASH_SIZE
);
8882 die
= target_cu
->die_ref_table
[h
];
8885 if (die
->offset
== offset
)
8887 die
= die
->next_ref
;
8890 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8891 "at 0x%lx [in module %s]"),
8892 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8897 static struct type
*
8898 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8899 struct dwarf2_cu
*cu
)
8901 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8903 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8904 typeid, objfile
->name
);
8907 /* Look for this particular type in the fundamental type vector. If
8908 one is not found, create and install one appropriate for the
8909 current language and the current target machine. */
8911 if (cu
->ftypes
[typeid] == NULL
)
8913 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8916 return (cu
->ftypes
[typeid]);
8919 /* Decode simple location descriptions.
8920 Given a pointer to a dwarf block that defines a location, compute
8921 the location and return the value.
8923 NOTE drow/2003-11-18: This function is called in two situations
8924 now: for the address of static or global variables (partial symbols
8925 only) and for offsets into structures which are expected to be
8926 (more or less) constant. The partial symbol case should go away,
8927 and only the constant case should remain. That will let this
8928 function complain more accurately. A few special modes are allowed
8929 without complaint for global variables (for instance, global
8930 register values and thread-local values).
8932 A location description containing no operations indicates that the
8933 object is optimized out. The return value is 0 for that case.
8934 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8935 callers will only want a very basic result and this can become a
8938 Note that stack[0] is unused except as a default error return.
8939 Note that stack overflow is not yet handled. */
8942 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8944 struct objfile
*objfile
= cu
->objfile
;
8945 struct comp_unit_head
*cu_header
= &cu
->header
;
8947 int size
= blk
->size
;
8948 gdb_byte
*data
= blk
->data
;
8949 CORE_ADDR stack
[64];
8951 unsigned int bytes_read
, unsnd
;
8995 stack
[++stacki
] = op
- DW_OP_lit0
;
9030 stack
[++stacki
] = op
- DW_OP_reg0
;
9032 dwarf2_complex_location_expr_complaint ();
9036 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9038 stack
[++stacki
] = unsnd
;
9040 dwarf2_complex_location_expr_complaint ();
9044 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
9050 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
9055 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
9060 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
9065 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
9070 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
9075 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
9080 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
9086 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
9091 stack
[stacki
+ 1] = stack
[stacki
];
9096 stack
[stacki
- 1] += stack
[stacki
];
9100 case DW_OP_plus_uconst
:
9101 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9106 stack
[stacki
- 1] -= stack
[stacki
];
9111 /* If we're not the last op, then we definitely can't encode
9112 this using GDB's address_class enum. This is valid for partial
9113 global symbols, although the variable's address will be bogus
9116 dwarf2_complex_location_expr_complaint ();
9119 case DW_OP_GNU_push_tls_address
:
9120 /* The top of the stack has the offset from the beginning
9121 of the thread control block at which the variable is located. */
9122 /* Nothing should follow this operator, so the top of stack would
9124 /* This is valid for partial global symbols, but the variable's
9125 address will be bogus in the psymtab. */
9127 dwarf2_complex_location_expr_complaint ();
9131 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
9132 dwarf_stack_op_name (op
));
9133 return (stack
[stacki
]);
9136 return (stack
[stacki
]);
9139 /* memory allocation interface */
9141 static struct dwarf_block
*
9142 dwarf_alloc_block (struct dwarf2_cu
*cu
)
9144 struct dwarf_block
*blk
;
9146 blk
= (struct dwarf_block
*)
9147 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
9151 static struct abbrev_info
*
9152 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
9154 struct abbrev_info
*abbrev
;
9156 abbrev
= (struct abbrev_info
*)
9157 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
9158 memset (abbrev
, 0, sizeof (struct abbrev_info
));
9162 static struct die_info
*
9163 dwarf_alloc_die (void)
9165 struct die_info
*die
;
9167 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
9168 memset (die
, 0, sizeof (struct die_info
));
9173 /* Macro support. */
9176 /* Return the full name of file number I in *LH's file name table.
9177 Use COMP_DIR as the name of the current directory of the
9178 compilation. The result is allocated using xmalloc; the caller is
9179 responsible for freeing it. */
9181 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
9183 /* Is the file number a valid index into the line header's file name
9184 table? Remember that file numbers start with one, not zero. */
9185 if (1 <= file
&& file
<= lh
->num_file_names
)
9187 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9189 if (IS_ABSOLUTE_PATH (fe
->name
))
9190 return xstrdup (fe
->name
);
9198 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9204 dir_len
= strlen (dir
);
9205 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
9206 strcpy (full_name
, dir
);
9207 full_name
[dir_len
] = '/';
9208 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
9212 return xstrdup (fe
->name
);
9217 /* The compiler produced a bogus file number. We can at least
9218 record the macro definitions made in the file, even if we
9219 won't be able to find the file by name. */
9221 sprintf (fake_name
, "<bad macro file number %d>", file
);
9223 complaint (&symfile_complaints
,
9224 _("bad file number in macro information (%d)"),
9227 return xstrdup (fake_name
);
9232 static struct macro_source_file
*
9233 macro_start_file (int file
, int line
,
9234 struct macro_source_file
*current_file
,
9235 const char *comp_dir
,
9236 struct line_header
*lh
, struct objfile
*objfile
)
9238 /* The full name of this source file. */
9239 char *full_name
= file_full_name (file
, lh
, comp_dir
);
9241 /* We don't create a macro table for this compilation unit
9242 at all until we actually get a filename. */
9243 if (! pending_macros
)
9244 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
9245 objfile
->macro_cache
);
9248 /* If we have no current file, then this must be the start_file
9249 directive for the compilation unit's main source file. */
9250 current_file
= macro_set_main (pending_macros
, full_name
);
9252 current_file
= macro_include (current_file
, line
, full_name
);
9256 return current_file
;
9260 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9261 followed by a null byte. */
9263 copy_string (const char *buf
, int len
)
9265 char *s
= xmalloc (len
+ 1);
9266 memcpy (s
, buf
, len
);
9274 consume_improper_spaces (const char *p
, const char *body
)
9278 complaint (&symfile_complaints
,
9279 _("macro definition contains spaces in formal argument list:\n`%s'"),
9291 parse_macro_definition (struct macro_source_file
*file
, int line
,
9296 /* The body string takes one of two forms. For object-like macro
9297 definitions, it should be:
9299 <macro name> " " <definition>
9301 For function-like macro definitions, it should be:
9303 <macro name> "() " <definition>
9305 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9307 Spaces may appear only where explicitly indicated, and in the
9310 The Dwarf 2 spec says that an object-like macro's name is always
9311 followed by a space, but versions of GCC around March 2002 omit
9312 the space when the macro's definition is the empty string.
9314 The Dwarf 2 spec says that there should be no spaces between the
9315 formal arguments in a function-like macro's formal argument list,
9316 but versions of GCC around March 2002 include spaces after the
9320 /* Find the extent of the macro name. The macro name is terminated
9321 by either a space or null character (for an object-like macro) or
9322 an opening paren (for a function-like macro). */
9323 for (p
= body
; *p
; p
++)
9324 if (*p
== ' ' || *p
== '(')
9327 if (*p
== ' ' || *p
== '\0')
9329 /* It's an object-like macro. */
9330 int name_len
= p
- body
;
9331 char *name
= copy_string (body
, name_len
);
9332 const char *replacement
;
9335 replacement
= body
+ name_len
+ 1;
9338 dwarf2_macro_malformed_definition_complaint (body
);
9339 replacement
= body
+ name_len
;
9342 macro_define_object (file
, line
, name
, replacement
);
9348 /* It's a function-like macro. */
9349 char *name
= copy_string (body
, p
- body
);
9352 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9356 p
= consume_improper_spaces (p
, body
);
9358 /* Parse the formal argument list. */
9359 while (*p
&& *p
!= ')')
9361 /* Find the extent of the current argument name. */
9362 const char *arg_start
= p
;
9364 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9367 if (! *p
|| p
== arg_start
)
9368 dwarf2_macro_malformed_definition_complaint (body
);
9371 /* Make sure argv has room for the new argument. */
9372 if (argc
>= argv_size
)
9375 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9378 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9381 p
= consume_improper_spaces (p
, body
);
9383 /* Consume the comma, if present. */
9388 p
= consume_improper_spaces (p
, body
);
9397 /* Perfectly formed definition, no complaints. */
9398 macro_define_function (file
, line
, name
,
9399 argc
, (const char **) argv
,
9401 else if (*p
== '\0')
9403 /* Complain, but do define it. */
9404 dwarf2_macro_malformed_definition_complaint (body
);
9405 macro_define_function (file
, line
, name
,
9406 argc
, (const char **) argv
,
9410 /* Just complain. */
9411 dwarf2_macro_malformed_definition_complaint (body
);
9414 /* Just complain. */
9415 dwarf2_macro_malformed_definition_complaint (body
);
9421 for (i
= 0; i
< argc
; i
++)
9427 dwarf2_macro_malformed_definition_complaint (body
);
9432 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9433 char *comp_dir
, bfd
*abfd
,
9434 struct dwarf2_cu
*cu
)
9436 gdb_byte
*mac_ptr
, *mac_end
;
9437 struct macro_source_file
*current_file
= 0;
9439 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9441 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9445 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9446 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9447 + dwarf2_per_objfile
->macinfo_size
;
9451 enum dwarf_macinfo_record_type macinfo_type
;
9453 /* Do we at least have room for a macinfo type byte? */
9454 if (mac_ptr
>= mac_end
)
9456 dwarf2_macros_too_long_complaint ();
9460 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9463 switch (macinfo_type
)
9465 /* A zero macinfo type indicates the end of the macro
9470 case DW_MACINFO_define
:
9471 case DW_MACINFO_undef
:
9473 unsigned int bytes_read
;
9477 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9478 mac_ptr
+= bytes_read
;
9479 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9480 mac_ptr
+= bytes_read
;
9483 complaint (&symfile_complaints
,
9484 _("debug info gives macro %s outside of any file: %s"),
9486 DW_MACINFO_define
? "definition" : macinfo_type
==
9487 DW_MACINFO_undef
? "undefinition" :
9488 "something-or-other", body
);
9491 if (macinfo_type
== DW_MACINFO_define
)
9492 parse_macro_definition (current_file
, line
, body
);
9493 else if (macinfo_type
== DW_MACINFO_undef
)
9494 macro_undef (current_file
, line
, body
);
9499 case DW_MACINFO_start_file
:
9501 unsigned int bytes_read
;
9504 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9505 mac_ptr
+= bytes_read
;
9506 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9507 mac_ptr
+= bytes_read
;
9509 current_file
= macro_start_file (file
, line
,
9510 current_file
, comp_dir
,
9515 case DW_MACINFO_end_file
:
9517 complaint (&symfile_complaints
,
9518 _("macro debug info has an unmatched `close_file' directive"));
9521 current_file
= current_file
->included_by
;
9524 enum dwarf_macinfo_record_type next_type
;
9526 /* GCC circa March 2002 doesn't produce the zero
9527 type byte marking the end of the compilation
9528 unit. Complain if it's not there, but exit no
9531 /* Do we at least have room for a macinfo type byte? */
9532 if (mac_ptr
>= mac_end
)
9534 dwarf2_macros_too_long_complaint ();
9538 /* We don't increment mac_ptr here, so this is just
9540 next_type
= read_1_byte (abfd
, mac_ptr
);
9542 complaint (&symfile_complaints
,
9543 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9550 case DW_MACINFO_vendor_ext
:
9552 unsigned int bytes_read
;
9556 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9557 mac_ptr
+= bytes_read
;
9558 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9559 mac_ptr
+= bytes_read
;
9561 /* We don't recognize any vendor extensions. */
9568 /* Check if the attribute's form is a DW_FORM_block*
9569 if so return true else false. */
9571 attr_form_is_block (struct attribute
*attr
)
9573 return (attr
== NULL
? 0 :
9574 attr
->form
== DW_FORM_block1
9575 || attr
->form
== DW_FORM_block2
9576 || attr
->form
== DW_FORM_block4
9577 || attr
->form
== DW_FORM_block
);
9581 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9582 struct dwarf2_cu
*cu
)
9584 if ((attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9585 /* ".debug_loc" may not exist at all, or the offset may be outside
9586 the section. If so, fall through to the complaint in the
9588 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9590 struct dwarf2_loclist_baton
*baton
;
9592 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9593 sizeof (struct dwarf2_loclist_baton
));
9594 baton
->objfile
= cu
->objfile
;
9596 /* We don't know how long the location list is, but make sure we
9597 don't run off the edge of the section. */
9598 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9599 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9600 baton
->base_address
= cu
->header
.base_address
;
9601 if (cu
->header
.base_known
== 0)
9602 complaint (&symfile_complaints
,
9603 _("Location list used without specifying the CU base address."));
9605 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9606 SYMBOL_LOCATION_BATON (sym
) = baton
;
9610 struct dwarf2_locexpr_baton
*baton
;
9612 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9613 sizeof (struct dwarf2_locexpr_baton
));
9614 baton
->objfile
= cu
->objfile
;
9616 if (attr_form_is_block (attr
))
9618 /* Note that we're just copying the block's data pointer
9619 here, not the actual data. We're still pointing into the
9620 info_buffer for SYM's objfile; right now we never release
9621 that buffer, but when we do clean up properly this may
9623 baton
->size
= DW_BLOCK (attr
)->size
;
9624 baton
->data
= DW_BLOCK (attr
)->data
;
9628 dwarf2_invalid_attrib_class_complaint ("location description",
9629 SYMBOL_NATURAL_NAME (sym
));
9634 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9635 SYMBOL_LOCATION_BATON (sym
) = baton
;
9639 /* Locate the compilation unit from CU's objfile which contains the
9640 DIE at OFFSET. Raises an error on failure. */
9642 static struct dwarf2_per_cu_data
*
9643 dwarf2_find_containing_comp_unit (unsigned long offset
,
9644 struct objfile
*objfile
)
9646 struct dwarf2_per_cu_data
*this_cu
;
9650 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9653 int mid
= low
+ (high
- low
) / 2;
9654 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9659 gdb_assert (low
== high
);
9660 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9663 error (_("Dwarf Error: could not find partial DIE containing "
9664 "offset 0x%lx [in module %s]"),
9665 (long) offset
, bfd_get_filename (objfile
->obfd
));
9667 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9668 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9672 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9673 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9674 && offset
>= this_cu
->offset
+ this_cu
->length
)
9675 error (_("invalid dwarf2 offset %ld"), offset
);
9676 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9681 /* Locate the compilation unit from OBJFILE which is located at exactly
9682 OFFSET. Raises an error on failure. */
9684 static struct dwarf2_per_cu_data
*
9685 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9687 struct dwarf2_per_cu_data
*this_cu
;
9688 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9689 if (this_cu
->offset
!= offset
)
9690 error (_("no compilation unit with offset %ld."), offset
);
9694 /* Release one cached compilation unit, CU. We unlink it from the tree
9695 of compilation units, but we don't remove it from the read_in_chain;
9696 the caller is responsible for that. */
9699 free_one_comp_unit (void *data
)
9701 struct dwarf2_cu
*cu
= data
;
9703 if (cu
->per_cu
!= NULL
)
9704 cu
->per_cu
->cu
= NULL
;
9707 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9709 free_die_list (cu
->dies
);
9714 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9715 when we're finished with it. We can't free the pointer itself, but be
9716 sure to unlink it from the cache. Also release any associated storage
9717 and perform cache maintenance.
9719 Only used during partial symbol parsing. */
9722 free_stack_comp_unit (void *data
)
9724 struct dwarf2_cu
*cu
= data
;
9726 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9727 cu
->partial_dies
= NULL
;
9729 if (cu
->per_cu
!= NULL
)
9731 /* This compilation unit is on the stack in our caller, so we
9732 should not xfree it. Just unlink it. */
9733 cu
->per_cu
->cu
= NULL
;
9736 /* If we had a per-cu pointer, then we may have other compilation
9737 units loaded, so age them now. */
9738 age_cached_comp_units ();
9742 /* Free all cached compilation units. */
9745 free_cached_comp_units (void *data
)
9747 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9749 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9750 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9751 while (per_cu
!= NULL
)
9753 struct dwarf2_per_cu_data
*next_cu
;
9755 next_cu
= per_cu
->cu
->read_in_chain
;
9757 free_one_comp_unit (per_cu
->cu
);
9758 *last_chain
= next_cu
;
9764 /* Increase the age counter on each cached compilation unit, and free
9765 any that are too old. */
9768 age_cached_comp_units (void)
9770 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9772 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9773 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9774 while (per_cu
!= NULL
)
9776 per_cu
->cu
->last_used
++;
9777 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9778 dwarf2_mark (per_cu
->cu
);
9779 per_cu
= per_cu
->cu
->read_in_chain
;
9782 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9783 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9784 while (per_cu
!= NULL
)
9786 struct dwarf2_per_cu_data
*next_cu
;
9788 next_cu
= per_cu
->cu
->read_in_chain
;
9790 if (!per_cu
->cu
->mark
)
9792 free_one_comp_unit (per_cu
->cu
);
9793 *last_chain
= next_cu
;
9796 last_chain
= &per_cu
->cu
->read_in_chain
;
9802 /* Remove a single compilation unit from the cache. */
9805 free_one_cached_comp_unit (void *target_cu
)
9807 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9809 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9810 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9811 while (per_cu
!= NULL
)
9813 struct dwarf2_per_cu_data
*next_cu
;
9815 next_cu
= per_cu
->cu
->read_in_chain
;
9817 if (per_cu
->cu
== target_cu
)
9819 free_one_comp_unit (per_cu
->cu
);
9820 *last_chain
= next_cu
;
9824 last_chain
= &per_cu
->cu
->read_in_chain
;
9830 /* A pair of DIE offset and GDB type pointer. We store these
9831 in a hash table separate from the DIEs, and preserve them
9832 when the DIEs are flushed out of cache. */
9834 struct dwarf2_offset_and_type
9836 unsigned int offset
;
9840 /* Hash function for a dwarf2_offset_and_type. */
9843 offset_and_type_hash (const void *item
)
9845 const struct dwarf2_offset_and_type
*ofs
= item
;
9849 /* Equality function for a dwarf2_offset_and_type. */
9852 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9854 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9855 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9856 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9859 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9860 table if necessary. */
9863 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9865 struct dwarf2_offset_and_type
**slot
, ofs
;
9869 if (cu
->per_cu
== NULL
)
9872 if (cu
->per_cu
->type_hash
== NULL
)
9873 cu
->per_cu
->type_hash
9874 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9875 offset_and_type_hash
,
9878 &cu
->objfile
->objfile_obstack
,
9879 hashtab_obstack_allocate
,
9880 dummy_obstack_deallocate
);
9882 ofs
.offset
= die
->offset
;
9884 slot
= (struct dwarf2_offset_and_type
**)
9885 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9886 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9890 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9891 have a saved type. */
9893 static struct type
*
9894 get_die_type (struct die_info
*die
, htab_t type_hash
)
9896 struct dwarf2_offset_and_type
*slot
, ofs
;
9898 ofs
.offset
= die
->offset
;
9899 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9906 /* Restore the types of the DIE tree starting at START_DIE from the hash
9907 table saved in CU. */
9910 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9912 struct die_info
*die
;
9914 if (cu
->per_cu
->type_hash
== NULL
)
9917 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9919 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9920 if (die
->child
!= NULL
)
9921 reset_die_and_siblings_types (die
->child
, cu
);
9925 /* Set the mark field in CU and in every other compilation unit in the
9926 cache that we must keep because we are keeping CU. */
9928 /* Add a dependence relationship from CU to REF_PER_CU. */
9931 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9932 struct dwarf2_per_cu_data
*ref_per_cu
)
9936 if (cu
->dependencies
== NULL
)
9938 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9939 NULL
, &cu
->comp_unit_obstack
,
9940 hashtab_obstack_allocate
,
9941 dummy_obstack_deallocate
);
9943 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9948 /* Set the mark field in CU and in every other compilation unit in the
9949 cache that we must keep because we are keeping CU. */
9952 dwarf2_mark_helper (void **slot
, void *data
)
9954 struct dwarf2_per_cu_data
*per_cu
;
9956 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9957 if (per_cu
->cu
->mark
)
9959 per_cu
->cu
->mark
= 1;
9961 if (per_cu
->cu
->dependencies
!= NULL
)
9962 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9968 dwarf2_mark (struct dwarf2_cu
*cu
)
9973 if (cu
->dependencies
!= NULL
)
9974 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9978 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9982 per_cu
->cu
->mark
= 0;
9983 per_cu
= per_cu
->cu
->read_in_chain
;
9987 /* Trivial hash function for partial_die_info: the hash value of a DIE
9988 is its offset in .debug_info for this objfile. */
9991 partial_die_hash (const void *item
)
9993 const struct partial_die_info
*part_die
= item
;
9994 return part_die
->offset
;
9997 /* Trivial comparison function for partial_die_info structures: two DIEs
9998 are equal if they have the same offset. */
10001 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
10003 const struct partial_die_info
*part_die_lhs
= item_lhs
;
10004 const struct partial_die_info
*part_die_rhs
= item_rhs
;
10005 return part_die_lhs
->offset
== part_die_rhs
->offset
;
10008 static struct cmd_list_element
*set_dwarf2_cmdlist
;
10009 static struct cmd_list_element
*show_dwarf2_cmdlist
;
10012 set_dwarf2_cmd (char *args
, int from_tty
)
10014 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
10018 show_dwarf2_cmd (char *args
, int from_tty
)
10020 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
10023 void _initialize_dwarf2_read (void);
10026 _initialize_dwarf2_read (void)
10028 dwarf2_objfile_data_key
= register_objfile_data ();
10030 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
10031 Set DWARF 2 specific variables.\n\
10032 Configure DWARF 2 variables such as the cache size"),
10033 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
10034 0/*allow-unknown*/, &maintenance_set_cmdlist
);
10036 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
10037 Show DWARF 2 specific variables\n\
10038 Show DWARF 2 variables such as the cache size"),
10039 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
10040 0/*allow-unknown*/, &maintenance_show_cmdlist
);
10042 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
10043 &dwarf2_max_cache_age
, _("\
10044 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
10045 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
10046 A higher limit means that cached compilation units will be stored\n\
10047 in memory longer, and more total memory will be used. Zero disables\n\
10048 caching, which can slow down startup."),
10050 show_dwarf2_max_cache_age
,
10051 &set_dwarf2_cmdlist
,
10052 &show_dwarf2_cmdlist
);