1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
7 Inc. with support from Florida State University (under contract
8 with the Ada Joint Program Office), and Silicon Graphics, Inc.
9 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
10 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
13 This file is part of GDB.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 3 of the License, or
18 (at your option) any later version.
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program. If not, see <http://www.gnu.org/licenses/>. */
33 #include "elf/dwarf2.h"
36 #include "expression.h"
37 #include "filenames.h" /* for DOSish file names */
40 #include "complaints.h"
42 #include "dwarf2expr.h"
43 #include "dwarf2loc.h"
44 #include "cp-support.h"
50 #include "gdb_string.h"
51 #include "gdb_assert.h"
52 #include <sys/types.h>
54 /* A note on memory usage for this file.
56 At the present time, this code reads the debug info sections into
57 the objfile's objfile_obstack. A definite improvement for startup
58 time, on platforms which do not emit relocations for debug
59 sections, would be to use mmap instead. The object's complete
60 debug information is loaded into memory, partly to simplify
61 absolute DIE references.
63 Whether using obstacks or mmap, the sections should remain loaded
64 until the objfile is released, and pointers into the section data
65 can be used for any other data associated to the objfile (symbol
66 names, type names, location expressions to name a few). */
69 /* .debug_info header for a compilation unit
70 Because of alignment constraints, this structure has padding and cannot
71 be mapped directly onto the beginning of the .debug_info section. */
72 typedef struct comp_unit_header
74 unsigned int length
; /* length of the .debug_info
76 unsigned short version
; /* version number -- 2 for DWARF
78 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
79 unsigned char addr_size
; /* byte size of an address -- 4 */
82 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
85 /* .debug_pubnames header
86 Because of alignment constraints, this structure has padding and cannot
87 be mapped directly onto the beginning of the .debug_info section. */
88 typedef struct pubnames_header
90 unsigned int length
; /* length of the .debug_pubnames
92 unsigned char version
; /* version number -- 2 for DWARF
94 unsigned int info_offset
; /* offset into .debug_info section */
95 unsigned int info_size
; /* byte size of .debug_info section
99 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
101 /* .debug_pubnames header
102 Because of alignment constraints, this structure has padding and cannot
103 be mapped directly onto the beginning of the .debug_info section. */
104 typedef struct aranges_header
106 unsigned int length
; /* byte len of the .debug_aranges
108 unsigned short version
; /* version number -- 2 for DWARF
110 unsigned int info_offset
; /* offset into .debug_info section */
111 unsigned char addr_size
; /* byte size of an address */
112 unsigned char seg_size
; /* byte size of segment descriptor */
115 #define _ACTUAL_ARANGES_HEADER_SIZE 12
117 /* .debug_line statement program prologue
118 Because of alignment constraints, this structure has padding and cannot
119 be mapped directly onto the beginning of the .debug_info section. */
120 typedef struct statement_prologue
122 unsigned int total_length
; /* byte length of the statement
124 unsigned short version
; /* version number -- 2 for DWARF
126 unsigned int prologue_length
; /* # bytes between prologue &
128 unsigned char minimum_instruction_length
; /* byte size of
130 unsigned char default_is_stmt
; /* initial value of is_stmt
133 unsigned char line_range
;
134 unsigned char opcode_base
; /* number assigned to first special
136 unsigned char *standard_opcode_lengths
;
140 static const struct objfile_data
*dwarf2_objfile_data_key
;
142 struct dwarf2_per_objfile
144 /* Sizes of debugging sections. */
145 unsigned int info_size
;
146 unsigned int abbrev_size
;
147 unsigned int line_size
;
148 unsigned int pubnames_size
;
149 unsigned int aranges_size
;
150 unsigned int loc_size
;
151 unsigned int macinfo_size
;
152 unsigned int str_size
;
153 unsigned int ranges_size
;
154 unsigned int frame_size
;
155 unsigned int eh_frame_size
;
157 /* Loaded data from the sections. */
158 gdb_byte
*info_buffer
;
159 gdb_byte
*abbrev_buffer
;
160 gdb_byte
*line_buffer
;
161 gdb_byte
*str_buffer
;
162 gdb_byte
*macinfo_buffer
;
163 gdb_byte
*ranges_buffer
;
164 gdb_byte
*loc_buffer
;
166 /* A list of all the compilation units. This is used to locate
167 the target compilation unit of a particular reference. */
168 struct dwarf2_per_cu_data
**all_comp_units
;
170 /* The number of compilation units in ALL_COMP_UNITS. */
173 /* A chain of compilation units that are currently read in, so that
174 they can be freed later. */
175 struct dwarf2_per_cu_data
*read_in_chain
;
177 /* A flag indicating wether this objfile has a section loaded at a
179 int has_section_at_zero
;
182 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
184 static asection
*dwarf_info_section
;
185 static asection
*dwarf_abbrev_section
;
186 static asection
*dwarf_line_section
;
187 static asection
*dwarf_pubnames_section
;
188 static asection
*dwarf_aranges_section
;
189 static asection
*dwarf_loc_section
;
190 static asection
*dwarf_macinfo_section
;
191 static asection
*dwarf_str_section
;
192 static asection
*dwarf_ranges_section
;
193 asection
*dwarf_frame_section
;
194 asection
*dwarf_eh_frame_section
;
196 /* names of the debugging sections */
198 #define INFO_SECTION ".debug_info"
199 #define ABBREV_SECTION ".debug_abbrev"
200 #define LINE_SECTION ".debug_line"
201 #define PUBNAMES_SECTION ".debug_pubnames"
202 #define ARANGES_SECTION ".debug_aranges"
203 #define LOC_SECTION ".debug_loc"
204 #define MACINFO_SECTION ".debug_macinfo"
205 #define STR_SECTION ".debug_str"
206 #define RANGES_SECTION ".debug_ranges"
207 #define FRAME_SECTION ".debug_frame"
208 #define EH_FRAME_SECTION ".eh_frame"
210 /* local data types */
212 /* We hold several abbreviation tables in memory at the same time. */
213 #ifndef ABBREV_HASH_SIZE
214 #define ABBREV_HASH_SIZE 121
217 /* The data in a compilation unit header, after target2host
218 translation, looks like this. */
219 struct comp_unit_head
221 unsigned long length
;
223 unsigned int abbrev_offset
;
224 unsigned char addr_size
;
225 unsigned char signed_addr_p
;
227 /* Size of file offsets; either 4 or 8. */
228 unsigned int offset_size
;
230 /* Size of the length field; either 4 or 12. */
231 unsigned int initial_length_size
;
233 /* Offset to the first byte of this compilation unit header in the
234 .debug_info section, for resolving relative reference dies. */
237 /* Pointer to this compilation unit header in the .debug_info
239 gdb_byte
*cu_head_ptr
;
241 /* Pointer to the first die of this compilation unit. This will be
242 the first byte following the compilation unit header. */
243 gdb_byte
*first_die_ptr
;
245 /* Pointer to the next compilation unit header in the program. */
246 struct comp_unit_head
*next
;
248 /* Base address of this compilation unit. */
249 CORE_ADDR base_address
;
251 /* Non-zero if base_address has been set. */
255 /* Fixed size for the DIE hash table. */
256 #ifndef REF_HASH_SIZE
257 #define REF_HASH_SIZE 1021
260 /* Internal state when decoding a particular compilation unit. */
263 /* The objfile containing this compilation unit. */
264 struct objfile
*objfile
;
266 /* The header of the compilation unit.
268 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
269 should logically be moved to the dwarf2_cu structure. */
270 struct comp_unit_head header
;
272 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
274 /* The language we are debugging. */
275 enum language language
;
276 const struct language_defn
*language_defn
;
278 const char *producer
;
280 /* The generic symbol table building routines have separate lists for
281 file scope symbols and all all other scopes (local scopes). So
282 we need to select the right one to pass to add_symbol_to_list().
283 We do it by keeping a pointer to the correct list in list_in_scope.
285 FIXME: The original dwarf code just treated the file scope as the
286 first local scope, and all other local scopes as nested local
287 scopes, and worked fine. Check to see if we really need to
288 distinguish these in buildsym.c. */
289 struct pending
**list_in_scope
;
291 /* DWARF abbreviation table associated with this compilation unit. */
292 struct abbrev_info
**dwarf2_abbrevs
;
294 /* Storage for the abbrev table. */
295 struct obstack abbrev_obstack
;
297 /* Hash table holding all the loaded partial DIEs. */
300 /* Storage for things with the same lifetime as this read-in compilation
301 unit, including partial DIEs. */
302 struct obstack comp_unit_obstack
;
304 /* When multiple dwarf2_cu structures are living in memory, this field
305 chains them all together, so that they can be released efficiently.
306 We will probably also want a generation counter so that most-recently-used
307 compilation units are cached... */
308 struct dwarf2_per_cu_data
*read_in_chain
;
310 /* Backchain to our per_cu entry if the tree has been built. */
311 struct dwarf2_per_cu_data
*per_cu
;
313 /* How many compilation units ago was this CU last referenced? */
316 /* A hash table of die offsets for following references. */
317 struct die_info
*die_ref_table
[REF_HASH_SIZE
];
319 /* Full DIEs if read in. */
320 struct die_info
*dies
;
322 /* A set of pointers to dwarf2_per_cu_data objects for compilation
323 units referenced by this one. Only set during full symbol processing;
324 partial symbol tables do not have dependencies. */
327 /* Header data from the line table, during full symbol processing. */
328 struct line_header
*line_header
;
330 /* Mark used when releasing cached dies. */
331 unsigned int mark
: 1;
333 /* This flag will be set if this compilation unit might include
334 inter-compilation-unit references. */
335 unsigned int has_form_ref_addr
: 1;
337 /* This flag will be set if this compilation unit includes any
338 DW_TAG_namespace DIEs. If we know that there are explicit
339 DIEs for namespaces, we don't need to try to infer them
340 from mangled names. */
341 unsigned int has_namespace_info
: 1;
344 /* Persistent data held for a compilation unit, even when not
345 processing it. We put a pointer to this structure in the
346 read_symtab_private field of the psymtab. If we encounter
347 inter-compilation-unit references, we also maintain a sorted
348 list of all compilation units. */
350 struct dwarf2_per_cu_data
352 /* The start offset and length of this compilation unit. 2**30-1
353 bytes should suffice to store the length of any compilation unit
354 - if it doesn't, GDB will fall over anyway. */
355 unsigned long offset
;
356 unsigned long length
: 30;
358 /* Flag indicating this compilation unit will be read in before
359 any of the current compilation units are processed. */
360 unsigned long queued
: 1;
362 /* This flag will be set if we need to load absolutely all DIEs
363 for this compilation unit, instead of just the ones we think
364 are interesting. It gets set if we look for a DIE in the
365 hash table and don't find it. */
366 unsigned int load_all_dies
: 1;
368 /* Set iff currently read in. */
369 struct dwarf2_cu
*cu
;
371 /* If full symbols for this CU have been read in, then this field
372 holds a map of DIE offsets to types. It isn't always possible
373 to reconstruct this information later, so we have to preserve
377 /* The partial symbol table associated with this compilation unit,
378 or NULL for partial units (which do not have an associated
380 struct partial_symtab
*psymtab
;
383 /* The line number information for a compilation unit (found in the
384 .debug_line section) begins with a "statement program header",
385 which contains the following information. */
388 unsigned int total_length
;
389 unsigned short version
;
390 unsigned int header_length
;
391 unsigned char minimum_instruction_length
;
392 unsigned char default_is_stmt
;
394 unsigned char line_range
;
395 unsigned char opcode_base
;
397 /* standard_opcode_lengths[i] is the number of operands for the
398 standard opcode whose value is i. This means that
399 standard_opcode_lengths[0] is unused, and the last meaningful
400 element is standard_opcode_lengths[opcode_base - 1]. */
401 unsigned char *standard_opcode_lengths
;
403 /* The include_directories table. NOTE! These strings are not
404 allocated with xmalloc; instead, they are pointers into
405 debug_line_buffer. If you try to free them, `free' will get
407 unsigned int num_include_dirs
, include_dirs_size
;
410 /* The file_names table. NOTE! These strings are not allocated
411 with xmalloc; instead, they are pointers into debug_line_buffer.
412 Don't try to free them directly. */
413 unsigned int num_file_names
, file_names_size
;
417 unsigned int dir_index
;
418 unsigned int mod_time
;
420 int included_p
; /* Non-zero if referenced by the Line Number Program. */
421 struct symtab
*symtab
; /* The associated symbol table, if any. */
424 /* The start and end of the statement program following this
425 header. These point into dwarf2_per_objfile->line_buffer. */
426 gdb_byte
*statement_program_start
, *statement_program_end
;
429 /* When we construct a partial symbol table entry we only
430 need this much information. */
431 struct partial_die_info
433 /* Offset of this DIE. */
436 /* DWARF-2 tag for this DIE. */
437 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
439 /* Language code associated with this DIE. This is only used
440 for the compilation unit DIE. */
441 unsigned int language
: 8;
443 /* Assorted flags describing the data found in this DIE. */
444 unsigned int has_children
: 1;
445 unsigned int is_external
: 1;
446 unsigned int is_declaration
: 1;
447 unsigned int has_type
: 1;
448 unsigned int has_specification
: 1;
449 unsigned int has_stmt_list
: 1;
450 unsigned int has_pc_info
: 1;
452 /* Flag set if the SCOPE field of this structure has been
454 unsigned int scope_set
: 1;
456 /* Flag set if the DIE has a byte_size attribute. */
457 unsigned int has_byte_size
: 1;
459 /* The name of this DIE. Normally the value of DW_AT_name, but
460 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
465 /* The scope to prepend to our children. This is generally
466 allocated on the comp_unit_obstack, so will disappear
467 when this compilation unit leaves the cache. */
470 /* The location description associated with this DIE, if any. */
471 struct dwarf_block
*locdesc
;
473 /* If HAS_PC_INFO, the PC range associated with this DIE. */
477 /* Pointer into the info_buffer pointing at the target of
478 DW_AT_sibling, if any. */
481 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
482 DW_AT_specification (or DW_AT_abstract_origin or
484 unsigned int spec_offset
;
486 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
487 unsigned int line_offset
;
489 /* Pointers to this DIE's parent, first child, and next sibling,
491 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
494 /* This data structure holds the information of an abbrev. */
497 unsigned int number
; /* number identifying abbrev */
498 enum dwarf_tag tag
; /* dwarf tag */
499 unsigned short has_children
; /* boolean */
500 unsigned short num_attrs
; /* number of attributes */
501 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
502 struct abbrev_info
*next
; /* next in chain */
507 enum dwarf_attribute name
;
508 enum dwarf_form form
;
511 /* This data structure holds a complete die structure. */
514 enum dwarf_tag tag
; /* Tag indicating type of die */
515 unsigned int abbrev
; /* Abbrev number */
516 unsigned int offset
; /* Offset in .debug_info section */
517 unsigned int num_attrs
; /* Number of attributes */
518 struct attribute
*attrs
; /* An array of attributes */
519 struct die_info
*next_ref
; /* Next die in ref hash table */
521 /* The dies in a compilation unit form an n-ary tree. PARENT
522 points to this die's parent; CHILD points to the first child of
523 this node; and all the children of a given node are chained
524 together via their SIBLING fields, terminated by a die whose
526 struct die_info
*child
; /* Its first child, if any. */
527 struct die_info
*sibling
; /* Its next sibling, if any. */
528 struct die_info
*parent
; /* Its parent, if any. */
530 struct type
*type
; /* Cached type information */
533 /* Attributes have a name and a value */
536 enum dwarf_attribute name
;
537 enum dwarf_form form
;
541 struct dwarf_block
*blk
;
549 struct function_range
552 CORE_ADDR lowpc
, highpc
;
554 struct function_range
*next
;
557 /* Get at parts of an attribute structure */
559 #define DW_STRING(attr) ((attr)->u.str)
560 #define DW_UNSND(attr) ((attr)->u.unsnd)
561 #define DW_BLOCK(attr) ((attr)->u.blk)
562 #define DW_SND(attr) ((attr)->u.snd)
563 #define DW_ADDR(attr) ((attr)->u.addr)
565 /* Blocks are a bunch of untyped bytes. */
572 #ifndef ATTR_ALLOC_CHUNK
573 #define ATTR_ALLOC_CHUNK 4
576 /* Allocate fields for structs, unions and enums in this size. */
577 #ifndef DW_FIELD_ALLOC_CHUNK
578 #define DW_FIELD_ALLOC_CHUNK 4
581 /* A zeroed version of a partial die for initialization purposes. */
582 static struct partial_die_info zeroed_partial_die
;
584 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
585 but this would require a corresponding change in unpack_field_as_long
587 static int bits_per_byte
= 8;
589 /* The routines that read and process dies for a C struct or C++ class
590 pass lists of data member fields and lists of member function fields
591 in an instance of a field_info structure, as defined below. */
594 /* List of data member and baseclasses fields. */
597 struct nextfield
*next
;
604 /* Number of fields. */
607 /* Number of baseclasses. */
610 /* Set if the accesibility of one of the fields is not public. */
611 int non_public_fields
;
613 /* Member function fields array, entries are allocated in the order they
614 are encountered in the object file. */
617 struct nextfnfield
*next
;
618 struct fn_field fnfield
;
622 /* Member function fieldlist array, contains name of possibly overloaded
623 member function, number of overloaded member functions and a pointer
624 to the head of the member function field chain. */
629 struct nextfnfield
*head
;
633 /* Number of entries in the fnfieldlists array. */
637 /* One item on the queue of compilation units to read in full symbols
639 struct dwarf2_queue_item
641 struct dwarf2_per_cu_data
*per_cu
;
642 struct dwarf2_queue_item
*next
;
645 /* The current queue. */
646 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
648 /* Loaded secondary compilation units are kept in memory until they
649 have not been referenced for the processing of this many
650 compilation units. Set this to zero to disable caching. Cache
651 sizes of up to at least twenty will improve startup time for
652 typical inter-CU-reference binaries, at an obvious memory cost. */
653 static int dwarf2_max_cache_age
= 5;
655 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
656 struct cmd_list_element
*c
, const char *value
)
658 fprintf_filtered (file
, _("\
659 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
664 /* Various complaints about symbol reading that don't abort the process */
667 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
669 complaint (&symfile_complaints
,
670 _("statement list doesn't fit in .debug_line section"));
674 dwarf2_debug_line_missing_file_complaint (void)
676 complaint (&symfile_complaints
,
677 _(".debug_line section has line data without a file"));
681 dwarf2_complex_location_expr_complaint (void)
683 complaint (&symfile_complaints
, _("location expression too complex"));
687 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
690 complaint (&symfile_complaints
,
691 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
696 dwarf2_macros_too_long_complaint (void)
698 complaint (&symfile_complaints
,
699 _("macro info runs off end of `.debug_macinfo' section"));
703 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
705 complaint (&symfile_complaints
,
706 _("macro debug info contains a malformed macro definition:\n`%s'"),
711 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
713 complaint (&symfile_complaints
,
714 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
717 /* local function prototypes */
719 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
722 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
725 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
728 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
729 struct partial_die_info
*,
730 struct partial_symtab
*);
732 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
734 static void scan_partial_symbols (struct partial_die_info
*,
735 CORE_ADDR
*, CORE_ADDR
*,
738 static void add_partial_symbol (struct partial_die_info
*,
741 static int pdi_needs_namespace (enum dwarf_tag tag
);
743 static void add_partial_namespace (struct partial_die_info
*pdi
,
744 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
745 struct dwarf2_cu
*cu
);
747 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
748 struct dwarf2_cu
*cu
);
750 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
753 struct dwarf2_cu
*cu
);
755 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
757 static void psymtab_to_symtab_1 (struct partial_symtab
*);
759 gdb_byte
*dwarf2_read_section (struct objfile
*, asection
*);
761 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
763 static void dwarf2_free_abbrev_table (void *);
765 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
768 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
771 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
774 static gdb_byte
*read_partial_die (struct partial_die_info
*,
775 struct abbrev_info
*abbrev
, unsigned int,
776 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
778 static struct partial_die_info
*find_partial_die (unsigned long,
781 static void fixup_partial_die (struct partial_die_info
*,
784 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
785 struct dwarf2_cu
*, int *);
787 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
788 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
790 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
791 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
793 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
795 static int read_1_signed_byte (bfd
*, gdb_byte
*);
797 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
799 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
801 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
803 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
806 static LONGEST
read_initial_length (bfd
*, gdb_byte
*,
807 struct comp_unit_head
*, unsigned int *);
809 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
812 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
814 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
816 static char *read_indirect_string (bfd
*, gdb_byte
*,
817 const struct comp_unit_head
*,
820 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
822 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
824 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
826 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
828 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
831 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
832 struct dwarf2_cu
*cu
);
834 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
836 static struct die_info
*die_specification (struct die_info
*die
,
839 static void free_line_header (struct line_header
*lh
);
841 static void add_file_name (struct line_header
*, char *, unsigned int,
842 unsigned int, unsigned int);
844 static struct line_header
*(dwarf_decode_line_header
845 (unsigned int offset
,
846 bfd
*abfd
, struct dwarf2_cu
*cu
));
848 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
849 struct dwarf2_cu
*, struct partial_symtab
*);
851 static void dwarf2_start_subfile (char *, char *, char *);
853 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
856 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
859 static void dwarf2_const_value_data (struct attribute
*attr
,
863 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
865 static struct type
*die_containing_type (struct die_info
*,
868 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
870 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
872 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
874 static char *typename_concat (struct obstack
*,
879 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
881 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
883 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
885 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
887 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
889 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
891 static int dwarf2_get_pc_bounds (struct die_info
*,
892 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
894 static void get_scope_pc_bounds (struct die_info
*,
895 CORE_ADDR
*, CORE_ADDR
*,
898 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
901 static void dwarf2_attach_fields_to_type (struct field_info
*,
902 struct type
*, struct dwarf2_cu
*);
904 static void dwarf2_add_member_fn (struct field_info
*,
905 struct die_info
*, struct type
*,
908 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
909 struct type
*, struct dwarf2_cu
*);
911 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
913 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
915 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
917 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
919 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
921 static const char *namespace_name (struct die_info
*die
,
922 int *is_anonymous
, struct dwarf2_cu
*);
924 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
926 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
928 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
930 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
932 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
935 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
937 static void read_tag_ptr_to_member_type (struct die_info
*,
940 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
942 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
944 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
946 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
948 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
950 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
952 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
954 gdb_byte
**new_info_ptr
,
955 struct die_info
*parent
);
957 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
959 gdb_byte
**new_info_ptr
,
960 struct die_info
*parent
);
962 static void free_die_list (struct die_info
*);
964 static void process_die (struct die_info
*, struct dwarf2_cu
*);
966 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
968 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
970 static struct die_info
*dwarf2_extension (struct die_info
*die
,
973 static char *dwarf_tag_name (unsigned int);
975 static char *dwarf_attr_name (unsigned int);
977 static char *dwarf_form_name (unsigned int);
979 static char *dwarf_stack_op_name (unsigned int);
981 static char *dwarf_bool_name (unsigned int);
983 static char *dwarf_type_encoding_name (unsigned int);
986 static char *dwarf_cfi_name (unsigned int);
988 struct die_info
*copy_die (struct die_info
*);
991 static struct die_info
*sibling_die (struct die_info
*);
993 static void dump_die (struct die_info
*);
995 static void dump_die_list (struct die_info
*);
997 static void store_in_ref_table (unsigned int, struct die_info
*,
1000 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
1001 struct dwarf2_cu
*);
1003 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
1005 static struct die_info
*follow_die_ref (struct die_info
*,
1007 struct dwarf2_cu
*);
1009 /* memory allocation interface */
1011 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1013 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1015 static struct die_info
*dwarf_alloc_die (void);
1017 static void initialize_cu_func_list (struct dwarf2_cu
*);
1019 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1020 struct dwarf2_cu
*);
1022 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1023 char *, bfd
*, struct dwarf2_cu
*);
1025 static int attr_form_is_block (struct attribute
*);
1027 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1029 struct dwarf2_cu
*cu
);
1031 static gdb_byte
*skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
1032 struct dwarf2_cu
*cu
);
1034 static void free_stack_comp_unit (void *);
1036 static hashval_t
partial_die_hash (const void *item
);
1038 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1040 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1041 (unsigned long offset
, struct objfile
*objfile
);
1043 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1044 (unsigned long offset
, struct objfile
*objfile
);
1046 static void free_one_comp_unit (void *);
1048 static void free_cached_comp_units (void *);
1050 static void age_cached_comp_units (void);
1052 static void free_one_cached_comp_unit (void *);
1054 static void set_die_type (struct die_info
*, struct type
*,
1055 struct dwarf2_cu
*);
1057 static void reset_die_and_siblings_types (struct die_info
*,
1058 struct dwarf2_cu
*);
1060 static void create_all_comp_units (struct objfile
*);
1062 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*,
1065 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1067 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1068 struct dwarf2_per_cu_data
*);
1070 static void dwarf2_mark (struct dwarf2_cu
*);
1072 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1074 static void read_set_type (struct die_info
*, struct dwarf2_cu
*);
1077 /* Try to locate the sections we need for DWARF 2 debugging
1078 information and return true if we have enough to do something. */
1081 dwarf2_has_info (struct objfile
*objfile
)
1083 struct dwarf2_per_objfile
*data
;
1085 /* Initialize per-objfile state. */
1086 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1087 memset (data
, 0, sizeof (*data
));
1088 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1089 dwarf2_per_objfile
= data
;
1091 dwarf_info_section
= 0;
1092 dwarf_abbrev_section
= 0;
1093 dwarf_line_section
= 0;
1094 dwarf_str_section
= 0;
1095 dwarf_macinfo_section
= 0;
1096 dwarf_frame_section
= 0;
1097 dwarf_eh_frame_section
= 0;
1098 dwarf_ranges_section
= 0;
1099 dwarf_loc_section
= 0;
1101 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1102 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1105 /* This function is mapped across the sections and remembers the
1106 offset and size of each of the debugging sections we are interested
1110 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1112 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1114 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1115 dwarf_info_section
= sectp
;
1117 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1119 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1120 dwarf_abbrev_section
= sectp
;
1122 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1124 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1125 dwarf_line_section
= sectp
;
1127 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1129 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1130 dwarf_pubnames_section
= sectp
;
1132 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1134 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1135 dwarf_aranges_section
= sectp
;
1137 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1139 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1140 dwarf_loc_section
= sectp
;
1142 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1144 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1145 dwarf_macinfo_section
= sectp
;
1147 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1149 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1150 dwarf_str_section
= sectp
;
1152 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1154 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1155 dwarf_frame_section
= sectp
;
1157 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1159 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1160 if (aflag
& SEC_HAS_CONTENTS
)
1162 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1163 dwarf_eh_frame_section
= sectp
;
1166 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1168 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1169 dwarf_ranges_section
= sectp
;
1172 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1173 && bfd_section_vma (abfd
, sectp
) == 0)
1174 dwarf2_per_objfile
->has_section_at_zero
= 1;
1177 /* Build a partial symbol table. */
1180 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1182 /* We definitely need the .debug_info and .debug_abbrev sections */
1184 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1185 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1187 if (dwarf_line_section
)
1188 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1190 dwarf2_per_objfile
->line_buffer
= NULL
;
1192 if (dwarf_str_section
)
1193 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1195 dwarf2_per_objfile
->str_buffer
= NULL
;
1197 if (dwarf_macinfo_section
)
1198 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1199 dwarf_macinfo_section
);
1201 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1203 if (dwarf_ranges_section
)
1204 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1206 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1208 if (dwarf_loc_section
)
1209 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1211 dwarf2_per_objfile
->loc_buffer
= NULL
;
1214 || (objfile
->global_psymbols
.size
== 0
1215 && objfile
->static_psymbols
.size
== 0))
1217 init_psymbol_list (objfile
, 1024);
1221 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1223 /* Things are significantly easier if we have .debug_aranges and
1224 .debug_pubnames sections */
1226 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1230 /* only test this case for now */
1232 /* In this case we have to work a bit harder */
1233 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1238 /* Build the partial symbol table from the information in the
1239 .debug_pubnames and .debug_aranges sections. */
1242 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1244 bfd
*abfd
= objfile
->obfd
;
1245 char *aranges_buffer
, *pubnames_buffer
;
1246 char *aranges_ptr
, *pubnames_ptr
;
1247 unsigned int entry_length
, version
, info_offset
, info_size
;
1249 pubnames_buffer
= dwarf2_read_section (objfile
,
1250 dwarf_pubnames_section
);
1251 pubnames_ptr
= pubnames_buffer
;
1252 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1254 struct comp_unit_head cu_header
;
1255 unsigned int bytes_read
;
1257 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1259 pubnames_ptr
+= bytes_read
;
1260 version
= read_1_byte (abfd
, pubnames_ptr
);
1262 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1264 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1268 aranges_buffer
= dwarf2_read_section (objfile
,
1269 dwarf_aranges_section
);
1274 /* Read in the comp unit header information from the debug_info at
1278 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1279 gdb_byte
*info_ptr
, bfd
*abfd
)
1282 unsigned int bytes_read
;
1283 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1285 info_ptr
+= bytes_read
;
1286 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1288 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1290 info_ptr
+= bytes_read
;
1291 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1293 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1294 if (signed_addr
< 0)
1295 internal_error (__FILE__
, __LINE__
,
1296 _("read_comp_unit_head: dwarf from non elf file"));
1297 cu_header
->signed_addr_p
= signed_addr
;
1302 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1305 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1307 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1309 if (header
->version
!= 2 && header
->version
!= 3)
1310 error (_("Dwarf Error: wrong version in compilation unit header "
1311 "(is %d, should be %d) [in module %s]"), header
->version
,
1312 2, bfd_get_filename (abfd
));
1314 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1315 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1316 "(offset 0x%lx + 6) [in module %s]"),
1317 (long) header
->abbrev_offset
,
1318 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1319 bfd_get_filename (abfd
));
1321 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1322 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1323 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1324 "(offset 0x%lx + 0) [in module %s]"),
1325 (long) header
->length
,
1326 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1327 bfd_get_filename (abfd
));
1332 /* Allocate a new partial symtab for file named NAME and mark this new
1333 partial symtab as being an include of PST. */
1336 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1337 struct objfile
*objfile
)
1339 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1341 subpst
->section_offsets
= pst
->section_offsets
;
1342 subpst
->textlow
= 0;
1343 subpst
->texthigh
= 0;
1345 subpst
->dependencies
= (struct partial_symtab
**)
1346 obstack_alloc (&objfile
->objfile_obstack
,
1347 sizeof (struct partial_symtab
*));
1348 subpst
->dependencies
[0] = pst
;
1349 subpst
->number_of_dependencies
= 1;
1351 subpst
->globals_offset
= 0;
1352 subpst
->n_global_syms
= 0;
1353 subpst
->statics_offset
= 0;
1354 subpst
->n_static_syms
= 0;
1355 subpst
->symtab
= NULL
;
1356 subpst
->read_symtab
= pst
->read_symtab
;
1359 /* No private part is necessary for include psymtabs. This property
1360 can be used to differentiate between such include psymtabs and
1361 the regular ones. */
1362 subpst
->read_symtab_private
= NULL
;
1365 /* Read the Line Number Program data and extract the list of files
1366 included by the source file represented by PST. Build an include
1367 partial symtab for each of these included files.
1369 This procedure assumes that there *is* a Line Number Program in
1370 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1371 before calling this procedure. */
1374 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1375 struct partial_die_info
*pdi
,
1376 struct partial_symtab
*pst
)
1378 struct objfile
*objfile
= cu
->objfile
;
1379 bfd
*abfd
= objfile
->obfd
;
1380 struct line_header
*lh
;
1382 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1384 return; /* No linetable, so no includes. */
1386 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1388 free_line_header (lh
);
1392 /* Build the partial symbol table by doing a quick pass through the
1393 .debug_info and .debug_abbrev sections. */
1396 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1398 /* Instead of reading this into a big buffer, we should probably use
1399 mmap() on architectures that support it. (FIXME) */
1400 bfd
*abfd
= objfile
->obfd
;
1402 gdb_byte
*beg_of_comp_unit
;
1403 struct partial_die_info comp_unit_die
;
1404 struct partial_symtab
*pst
;
1405 struct cleanup
*back_to
;
1406 CORE_ADDR lowpc
, highpc
, baseaddr
;
1408 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1410 /* Any cached compilation units will be linked by the per-objfile
1411 read_in_chain. Make sure to free them when we're done. */
1412 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1414 create_all_comp_units (objfile
);
1416 /* Since the objects we're extracting from .debug_info vary in
1417 length, only the individual functions to extract them (like
1418 read_comp_unit_head and load_partial_die) can really know whether
1419 the buffer is large enough to hold another complete object.
1421 At the moment, they don't actually check that. If .debug_info
1422 holds just one extra byte after the last compilation unit's dies,
1423 then read_comp_unit_head will happily read off the end of the
1424 buffer. read_partial_die is similarly casual. Those functions
1427 For this loop condition, simply checking whether there's any data
1428 left at all should be sufficient. */
1429 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1430 + dwarf2_per_objfile
->info_size
))
1432 struct cleanup
*back_to_inner
;
1433 struct dwarf2_cu cu
;
1434 struct abbrev_info
*abbrev
;
1435 unsigned int bytes_read
;
1436 struct dwarf2_per_cu_data
*this_cu
;
1438 beg_of_comp_unit
= info_ptr
;
1440 memset (&cu
, 0, sizeof (cu
));
1442 obstack_init (&cu
.comp_unit_obstack
);
1444 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1446 cu
.objfile
= objfile
;
1447 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1449 /* Complete the cu_header */
1450 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1451 cu
.header
.first_die_ptr
= info_ptr
;
1452 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1454 cu
.list_in_scope
= &file_symbols
;
1456 /* Read the abbrevs for this compilation unit into a table */
1457 dwarf2_read_abbrevs (abfd
, &cu
);
1458 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1460 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1462 /* Read the compilation unit die */
1463 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1464 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1465 abfd
, info_ptr
, &cu
);
1467 if (comp_unit_die
.tag
== DW_TAG_partial_unit
)
1469 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1470 + cu
.header
.initial_length_size
);
1471 do_cleanups (back_to_inner
);
1475 /* Set the language we're debugging */
1476 set_cu_language (comp_unit_die
.language
, &cu
);
1478 /* Allocate a new partial symbol table structure */
1479 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1480 comp_unit_die
.name
? comp_unit_die
.name
: "",
1481 comp_unit_die
.lowpc
,
1482 objfile
->global_psymbols
.next
,
1483 objfile
->static_psymbols
.next
);
1485 if (comp_unit_die
.dirname
)
1486 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1488 pst
->read_symtab_private
= (char *) this_cu
;
1490 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1492 /* Store the function that reads in the rest of the symbol table */
1493 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1495 /* If this compilation unit was already read in, free the
1496 cached copy in order to read it in again. This is
1497 necessary because we skipped some symbols when we first
1498 read in the compilation unit (see load_partial_dies).
1499 This problem could be avoided, but the benefit is
1501 if (this_cu
->cu
!= NULL
)
1502 free_one_cached_comp_unit (this_cu
->cu
);
1504 cu
.per_cu
= this_cu
;
1506 /* Note that this is a pointer to our stack frame, being
1507 added to a global data structure. It will be cleaned up
1508 in free_stack_comp_unit when we finish with this
1509 compilation unit. */
1512 this_cu
->psymtab
= pst
;
1514 /* Check if comp unit has_children.
1515 If so, read the rest of the partial symbols from this comp unit.
1516 If not, there's no more debug_info for this comp unit. */
1517 if (comp_unit_die
.has_children
)
1519 struct partial_die_info
*first_die
;
1521 lowpc
= ((CORE_ADDR
) -1);
1522 highpc
= ((CORE_ADDR
) 0);
1524 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1526 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1528 /* If we didn't find a lowpc, set it to highpc to avoid
1529 complaints from `maint check'. */
1530 if (lowpc
== ((CORE_ADDR
) -1))
1533 /* If the compilation unit didn't have an explicit address range,
1534 then use the information extracted from its child dies. */
1535 if (! comp_unit_die
.has_pc_info
)
1537 comp_unit_die
.lowpc
= lowpc
;
1538 comp_unit_die
.highpc
= highpc
;
1541 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1542 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1544 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1545 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1546 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1547 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1548 sort_pst_symbols (pst
);
1550 /* If there is already a psymtab or symtab for a file of this
1551 name, remove it. (If there is a symtab, more drastic things
1552 also happen.) This happens in VxWorks. */
1553 free_named_symtabs (pst
->filename
);
1555 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1556 + cu
.header
.initial_length_size
;
1558 if (comp_unit_die
.has_stmt_list
)
1560 /* Get the list of files included in the current compilation unit,
1561 and build a psymtab for each of them. */
1562 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1565 do_cleanups (back_to_inner
);
1567 do_cleanups (back_to
);
1570 /* Load the DIEs for a secondary CU into memory. */
1573 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1575 bfd
*abfd
= objfile
->obfd
;
1576 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1577 struct partial_die_info comp_unit_die
;
1578 struct dwarf2_cu
*cu
;
1579 struct abbrev_info
*abbrev
;
1580 unsigned int bytes_read
;
1581 struct cleanup
*back_to
;
1583 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1584 beg_of_comp_unit
= info_ptr
;
1586 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1587 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1589 obstack_init (&cu
->comp_unit_obstack
);
1591 cu
->objfile
= objfile
;
1592 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1594 /* Complete the cu_header. */
1595 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1596 cu
->header
.first_die_ptr
= info_ptr
;
1597 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1599 /* Read the abbrevs for this compilation unit into a table. */
1600 dwarf2_read_abbrevs (abfd
, cu
);
1601 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1603 /* Read the compilation unit die. */
1604 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1605 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1606 abfd
, info_ptr
, cu
);
1608 /* Set the language we're debugging. */
1609 set_cu_language (comp_unit_die
.language
, cu
);
1611 /* Link this compilation unit into the compilation unit tree. */
1613 cu
->per_cu
= this_cu
;
1615 /* Check if comp unit has_children.
1616 If so, read the rest of the partial symbols from this comp unit.
1617 If not, there's no more debug_info for this comp unit. */
1618 if (comp_unit_die
.has_children
)
1619 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1621 do_cleanups (back_to
);
1624 /* Create a list of all compilation units in OBJFILE. We do this only
1625 if an inter-comp-unit reference is found; presumably if there is one,
1626 there will be many, and one will occur early in the .debug_info section.
1627 So there's no point in building this list incrementally. */
1630 create_all_comp_units (struct objfile
*objfile
)
1634 struct dwarf2_per_cu_data
**all_comp_units
;
1635 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1639 all_comp_units
= xmalloc (n_allocated
1640 * sizeof (struct dwarf2_per_cu_data
*));
1642 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1644 struct comp_unit_head cu_header
;
1645 gdb_byte
*beg_of_comp_unit
;
1646 struct dwarf2_per_cu_data
*this_cu
;
1647 unsigned long offset
;
1648 unsigned int bytes_read
;
1650 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1652 /* Read just enough information to find out where the next
1653 compilation unit is. */
1654 cu_header
.initial_length_size
= 0;
1655 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1656 &cu_header
, &bytes_read
);
1658 /* Save the compilation unit for later lookup. */
1659 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1660 sizeof (struct dwarf2_per_cu_data
));
1661 memset (this_cu
, 0, sizeof (*this_cu
));
1662 this_cu
->offset
= offset
;
1663 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1665 if (n_comp_units
== n_allocated
)
1668 all_comp_units
= xrealloc (all_comp_units
,
1670 * sizeof (struct dwarf2_per_cu_data
*));
1672 all_comp_units
[n_comp_units
++] = this_cu
;
1674 info_ptr
= info_ptr
+ this_cu
->length
;
1677 dwarf2_per_objfile
->all_comp_units
1678 = obstack_alloc (&objfile
->objfile_obstack
,
1679 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1680 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1681 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1682 xfree (all_comp_units
);
1683 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1686 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1687 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1691 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1692 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1694 struct objfile
*objfile
= cu
->objfile
;
1695 bfd
*abfd
= objfile
->obfd
;
1696 struct partial_die_info
*pdi
;
1698 /* Now, march along the PDI's, descending into ones which have
1699 interesting children but skipping the children of the other ones,
1700 until we reach the end of the compilation unit. */
1706 fixup_partial_die (pdi
, cu
);
1708 /* Anonymous namespaces have no name but have interesting
1709 children, so we need to look at them. Ditto for anonymous
1712 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1713 || pdi
->tag
== DW_TAG_enumeration_type
)
1717 case DW_TAG_subprogram
:
1718 if (pdi
->has_pc_info
)
1720 if (pdi
->lowpc
< *lowpc
)
1722 *lowpc
= pdi
->lowpc
;
1724 if (pdi
->highpc
> *highpc
)
1726 *highpc
= pdi
->highpc
;
1728 if (!pdi
->is_declaration
)
1730 add_partial_symbol (pdi
, cu
);
1734 case DW_TAG_variable
:
1735 case DW_TAG_typedef
:
1736 case DW_TAG_union_type
:
1737 if (!pdi
->is_declaration
)
1739 add_partial_symbol (pdi
, cu
);
1742 case DW_TAG_class_type
:
1743 case DW_TAG_structure_type
:
1744 if (!pdi
->is_declaration
)
1746 add_partial_symbol (pdi
, cu
);
1749 case DW_TAG_enumeration_type
:
1750 if (!pdi
->is_declaration
)
1751 add_partial_enumeration (pdi
, cu
);
1753 case DW_TAG_base_type
:
1754 case DW_TAG_subrange_type
:
1755 /* File scope base type definitions are added to the partial
1757 add_partial_symbol (pdi
, cu
);
1759 case DW_TAG_namespace
:
1760 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1767 /* If the die has a sibling, skip to the sibling. */
1769 pdi
= pdi
->die_sibling
;
1773 /* Functions used to compute the fully scoped name of a partial DIE.
1775 Normally, this is simple. For C++, the parent DIE's fully scoped
1776 name is concatenated with "::" and the partial DIE's name. For
1777 Java, the same thing occurs except that "." is used instead of "::".
1778 Enumerators are an exception; they use the scope of their parent
1779 enumeration type, i.e. the name of the enumeration type is not
1780 prepended to the enumerator.
1782 There are two complexities. One is DW_AT_specification; in this
1783 case "parent" means the parent of the target of the specification,
1784 instead of the direct parent of the DIE. The other is compilers
1785 which do not emit DW_TAG_namespace; in this case we try to guess
1786 the fully qualified name of structure types from their members'
1787 linkage names. This must be done using the DIE's children rather
1788 than the children of any DW_AT_specification target. We only need
1789 to do this for structures at the top level, i.e. if the target of
1790 any DW_AT_specification (if any; otherwise the DIE itself) does not
1793 /* Compute the scope prefix associated with PDI's parent, in
1794 compilation unit CU. The result will be allocated on CU's
1795 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1796 field. NULL is returned if no prefix is necessary. */
1798 partial_die_parent_scope (struct partial_die_info
*pdi
,
1799 struct dwarf2_cu
*cu
)
1801 char *grandparent_scope
;
1802 struct partial_die_info
*parent
, *real_pdi
;
1804 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1805 then this means the parent of the specification DIE. */
1808 while (real_pdi
->has_specification
)
1809 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1811 parent
= real_pdi
->die_parent
;
1815 if (parent
->scope_set
)
1816 return parent
->scope
;
1818 fixup_partial_die (parent
, cu
);
1820 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1822 if (parent
->tag
== DW_TAG_namespace
1823 || parent
->tag
== DW_TAG_structure_type
1824 || parent
->tag
== DW_TAG_class_type
1825 || parent
->tag
== DW_TAG_union_type
)
1827 if (grandparent_scope
== NULL
)
1828 parent
->scope
= parent
->name
;
1830 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1833 else if (parent
->tag
== DW_TAG_enumeration_type
)
1834 /* Enumerators should not get the name of the enumeration as a prefix. */
1835 parent
->scope
= grandparent_scope
;
1838 /* FIXME drow/2004-04-01: What should we be doing with
1839 function-local names? For partial symbols, we should probably be
1841 complaint (&symfile_complaints
,
1842 _("unhandled containing DIE tag %d for DIE at %d"),
1843 parent
->tag
, pdi
->offset
);
1844 parent
->scope
= grandparent_scope
;
1847 parent
->scope_set
= 1;
1848 return parent
->scope
;
1851 /* Return the fully scoped name associated with PDI, from compilation unit
1852 CU. The result will be allocated with malloc. */
1854 partial_die_full_name (struct partial_die_info
*pdi
,
1855 struct dwarf2_cu
*cu
)
1859 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1860 if (parent_scope
== NULL
)
1863 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1867 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1869 struct objfile
*objfile
= cu
->objfile
;
1871 char *actual_name
= NULL
;
1872 const char *my_prefix
;
1873 const struct partial_symbol
*psym
= NULL
;
1875 int built_actual_name
= 0;
1877 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1879 if (pdi_needs_namespace (pdi
->tag
))
1881 actual_name
= partial_die_full_name (pdi
, cu
);
1883 built_actual_name
= 1;
1886 if (actual_name
== NULL
)
1887 actual_name
= pdi
->name
;
1891 case DW_TAG_subprogram
:
1892 if (pdi
->is_external
)
1894 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1895 mst_text, objfile); */
1896 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1897 VAR_DOMAIN
, LOC_BLOCK
,
1898 &objfile
->global_psymbols
,
1899 0, pdi
->lowpc
+ baseaddr
,
1900 cu
->language
, objfile
);
1904 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1905 mst_file_text, objfile); */
1906 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1907 VAR_DOMAIN
, LOC_BLOCK
,
1908 &objfile
->static_psymbols
,
1909 0, pdi
->lowpc
+ baseaddr
,
1910 cu
->language
, objfile
);
1913 case DW_TAG_variable
:
1914 if (pdi
->is_external
)
1917 Don't enter into the minimal symbol tables as there is
1918 a minimal symbol table entry from the ELF symbols already.
1919 Enter into partial symbol table if it has a location
1920 descriptor or a type.
1921 If the location descriptor is missing, new_symbol will create
1922 a LOC_UNRESOLVED symbol, the address of the variable will then
1923 be determined from the minimal symbol table whenever the variable
1925 The address for the partial symbol table entry is not
1926 used by GDB, but it comes in handy for debugging partial symbol
1930 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1931 if (pdi
->locdesc
|| pdi
->has_type
)
1932 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1933 VAR_DOMAIN
, LOC_STATIC
,
1934 &objfile
->global_psymbols
,
1936 cu
->language
, objfile
);
1940 /* Static Variable. Skip symbols without location descriptors. */
1941 if (pdi
->locdesc
== NULL
)
1943 if (built_actual_name
)
1944 xfree (actual_name
);
1947 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1948 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1949 mst_file_data, objfile); */
1950 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1951 VAR_DOMAIN
, LOC_STATIC
,
1952 &objfile
->static_psymbols
,
1954 cu
->language
, objfile
);
1957 case DW_TAG_typedef
:
1958 case DW_TAG_base_type
:
1959 case DW_TAG_subrange_type
:
1960 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1961 VAR_DOMAIN
, LOC_TYPEDEF
,
1962 &objfile
->static_psymbols
,
1963 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1965 case DW_TAG_namespace
:
1966 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1967 VAR_DOMAIN
, LOC_TYPEDEF
,
1968 &objfile
->global_psymbols
,
1969 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1971 case DW_TAG_class_type
:
1972 case DW_TAG_structure_type
:
1973 case DW_TAG_union_type
:
1974 case DW_TAG_enumeration_type
:
1975 /* Skip external references. The DWARF standard says in the section
1976 about "Structure, Union, and Class Type Entries": "An incomplete
1977 structure, union or class type is represented by a structure,
1978 union or class entry that does not have a byte size attribute
1979 and that has a DW_AT_declaration attribute." */
1980 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
1982 if (built_actual_name
)
1983 xfree (actual_name
);
1987 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1988 static vs. global. */
1989 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1990 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1991 (cu
->language
== language_cplus
1992 || cu
->language
== language_java
)
1993 ? &objfile
->global_psymbols
1994 : &objfile
->static_psymbols
,
1995 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1997 if (cu
->language
== language_cplus
1998 || cu
->language
== language_java
1999 || cu
->language
== language_ada
)
2001 /* For C++ and Java, these implicitly act as typedefs as well. */
2002 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2003 VAR_DOMAIN
, LOC_TYPEDEF
,
2004 &objfile
->global_psymbols
,
2005 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2008 case DW_TAG_enumerator
:
2009 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2010 VAR_DOMAIN
, LOC_CONST
,
2011 (cu
->language
== language_cplus
2012 || cu
->language
== language_java
)
2013 ? &objfile
->global_psymbols
2014 : &objfile
->static_psymbols
,
2015 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2021 /* Check to see if we should scan the name for possible namespace
2022 info. Only do this if this is C++, if we don't have namespace
2023 debugging info in the file, if the psym is of an appropriate type
2024 (otherwise we'll have psym == NULL), and if we actually had a
2025 mangled name to begin with. */
2027 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2028 cases which do not set PSYM above? */
2030 if (cu
->language
== language_cplus
2031 && cu
->has_namespace_info
== 0
2033 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2034 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2037 if (built_actual_name
)
2038 xfree (actual_name
);
2041 /* Determine whether a die of type TAG living in a C++ class or
2042 namespace needs to have the name of the scope prepended to the
2043 name listed in the die. */
2046 pdi_needs_namespace (enum dwarf_tag tag
)
2050 case DW_TAG_namespace
:
2051 case DW_TAG_typedef
:
2052 case DW_TAG_class_type
:
2053 case DW_TAG_structure_type
:
2054 case DW_TAG_union_type
:
2055 case DW_TAG_enumeration_type
:
2056 case DW_TAG_enumerator
:
2063 /* Read a partial die corresponding to a namespace; also, add a symbol
2064 corresponding to that namespace to the symbol table. NAMESPACE is
2065 the name of the enclosing namespace. */
2068 add_partial_namespace (struct partial_die_info
*pdi
,
2069 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2070 struct dwarf2_cu
*cu
)
2072 struct objfile
*objfile
= cu
->objfile
;
2074 /* Add a symbol for the namespace. */
2076 add_partial_symbol (pdi
, cu
);
2078 /* Now scan partial symbols in that namespace. */
2080 if (pdi
->has_children
)
2081 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2084 /* See if we can figure out if the class lives in a namespace. We do
2085 this by looking for a member function; its demangled name will
2086 contain namespace info, if there is any. */
2089 guess_structure_name (struct partial_die_info
*struct_pdi
,
2090 struct dwarf2_cu
*cu
)
2092 if ((cu
->language
== language_cplus
2093 || cu
->language
== language_java
)
2094 && cu
->has_namespace_info
== 0
2095 && struct_pdi
->has_children
)
2097 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2098 what template types look like, because the demangler
2099 frequently doesn't give the same name as the debug info. We
2100 could fix this by only using the demangled name to get the
2101 prefix (but see comment in read_structure_type). */
2103 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2104 struct partial_die_info
*real_pdi
;
2106 /* If this DIE (this DIE's specification, if any) has a parent, then
2107 we should not do this. We'll prepend the parent's fully qualified
2108 name when we create the partial symbol. */
2110 real_pdi
= struct_pdi
;
2111 while (real_pdi
->has_specification
)
2112 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2114 if (real_pdi
->die_parent
!= NULL
)
2117 while (child_pdi
!= NULL
)
2119 if (child_pdi
->tag
== DW_TAG_subprogram
)
2121 char *actual_class_name
2122 = language_class_name_from_physname (cu
->language_defn
,
2124 if (actual_class_name
!= NULL
)
2127 = obsavestring (actual_class_name
,
2128 strlen (actual_class_name
),
2129 &cu
->comp_unit_obstack
);
2130 xfree (actual_class_name
);
2135 child_pdi
= child_pdi
->die_sibling
;
2140 /* Read a partial die corresponding to an enumeration type. */
2143 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2144 struct dwarf2_cu
*cu
)
2146 struct objfile
*objfile
= cu
->objfile
;
2147 bfd
*abfd
= objfile
->obfd
;
2148 struct partial_die_info
*pdi
;
2150 if (enum_pdi
->name
!= NULL
)
2151 add_partial_symbol (enum_pdi
, cu
);
2153 pdi
= enum_pdi
->die_child
;
2156 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2157 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2159 add_partial_symbol (pdi
, cu
);
2160 pdi
= pdi
->die_sibling
;
2164 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2165 Return the corresponding abbrev, or NULL if the number is zero (indicating
2166 an empty DIE). In either case *BYTES_READ will be set to the length of
2167 the initial number. */
2169 static struct abbrev_info
*
2170 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2171 struct dwarf2_cu
*cu
)
2173 bfd
*abfd
= cu
->objfile
->obfd
;
2174 unsigned int abbrev_number
;
2175 struct abbrev_info
*abbrev
;
2177 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2179 if (abbrev_number
== 0)
2182 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2185 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2186 bfd_get_filename (abfd
));
2192 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2193 pointer to the end of a series of DIEs, terminated by an empty
2194 DIE. Any children of the skipped DIEs will also be skipped. */
2197 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2199 struct abbrev_info
*abbrev
;
2200 unsigned int bytes_read
;
2204 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2206 return info_ptr
+ bytes_read
;
2208 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2212 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2213 should point just after the initial uleb128 of a DIE, and the
2214 abbrev corresponding to that skipped uleb128 should be passed in
2215 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2219 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2220 struct dwarf2_cu
*cu
)
2222 unsigned int bytes_read
;
2223 struct attribute attr
;
2224 bfd
*abfd
= cu
->objfile
->obfd
;
2225 unsigned int form
, i
;
2227 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2229 /* The only abbrev we care about is DW_AT_sibling. */
2230 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2232 read_attribute (&attr
, &abbrev
->attrs
[i
],
2233 abfd
, info_ptr
, cu
);
2234 if (attr
.form
== DW_FORM_ref_addr
)
2235 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2237 return dwarf2_per_objfile
->info_buffer
2238 + dwarf2_get_ref_die_offset (&attr
, cu
);
2241 /* If it isn't DW_AT_sibling, skip this attribute. */
2242 form
= abbrev
->attrs
[i
].form
;
2247 case DW_FORM_ref_addr
:
2248 info_ptr
+= cu
->header
.addr_size
;
2267 case DW_FORM_string
:
2268 read_string (abfd
, info_ptr
, &bytes_read
);
2269 info_ptr
+= bytes_read
;
2272 info_ptr
+= cu
->header
.offset_size
;
2275 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2276 info_ptr
+= bytes_read
;
2278 case DW_FORM_block1
:
2279 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2281 case DW_FORM_block2
:
2282 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2284 case DW_FORM_block4
:
2285 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2289 case DW_FORM_ref_udata
:
2290 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2292 case DW_FORM_indirect
:
2293 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2294 info_ptr
+= bytes_read
;
2295 /* We need to continue parsing from here, so just go back to
2297 goto skip_attribute
;
2300 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2301 dwarf_form_name (form
),
2302 bfd_get_filename (abfd
));
2306 if (abbrev
->has_children
)
2307 return skip_children (info_ptr
, cu
);
2312 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2313 the next DIE after ORIG_PDI. */
2316 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2317 bfd
*abfd
, struct dwarf2_cu
*cu
)
2319 /* Do we know the sibling already? */
2321 if (orig_pdi
->sibling
)
2322 return orig_pdi
->sibling
;
2324 /* Are there any children to deal with? */
2326 if (!orig_pdi
->has_children
)
2329 /* Skip the children the long way. */
2331 return skip_children (info_ptr
, cu
);
2334 /* Expand this partial symbol table into a full symbol table. */
2337 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2339 /* FIXME: This is barely more than a stub. */
2344 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2350 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2351 gdb_flush (gdb_stdout
);
2354 /* Restore our global data. */
2355 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2356 dwarf2_objfile_data_key
);
2358 psymtab_to_symtab_1 (pst
);
2360 /* Finish up the debug error message. */
2362 printf_filtered (_("done.\n"));
2367 /* Add PER_CU to the queue. */
2370 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2372 struct dwarf2_queue_item
*item
;
2375 item
= xmalloc (sizeof (*item
));
2376 item
->per_cu
= per_cu
;
2379 if (dwarf2_queue
== NULL
)
2380 dwarf2_queue
= item
;
2382 dwarf2_queue_tail
->next
= item
;
2384 dwarf2_queue_tail
= item
;
2387 /* Process the queue. */
2390 process_queue (struct objfile
*objfile
)
2392 struct dwarf2_queue_item
*item
, *next_item
;
2394 /* Initially, there is just one item on the queue. Load its DIEs,
2395 and the DIEs of any other compilation units it requires,
2398 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2400 /* Read in this compilation unit. This may add new items to
2401 the end of the queue. */
2402 load_full_comp_unit (item
->per_cu
, objfile
);
2404 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2405 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2407 /* If this compilation unit has already had full symbols created,
2408 reset the TYPE fields in each DIE. */
2409 if (item
->per_cu
->type_hash
)
2410 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2414 /* Now everything left on the queue needs to be read in. Process
2415 them, one at a time, removing from the queue as we finish. */
2416 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2418 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2419 process_full_comp_unit (item
->per_cu
);
2421 item
->per_cu
->queued
= 0;
2422 next_item
= item
->next
;
2426 dwarf2_queue_tail
= NULL
;
2429 /* Free all allocated queue entries. This function only releases anything if
2430 an error was thrown; if the queue was processed then it would have been
2431 freed as we went along. */
2434 dwarf2_release_queue (void *dummy
)
2436 struct dwarf2_queue_item
*item
, *last
;
2438 item
= dwarf2_queue
;
2441 /* Anything still marked queued is likely to be in an
2442 inconsistent state, so discard it. */
2443 if (item
->per_cu
->queued
)
2445 if (item
->per_cu
->cu
!= NULL
)
2446 free_one_cached_comp_unit (item
->per_cu
->cu
);
2447 item
->per_cu
->queued
= 0;
2455 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2458 /* Read in full symbols for PST, and anything it depends on. */
2461 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2463 struct dwarf2_per_cu_data
*per_cu
;
2464 struct cleanup
*back_to
;
2467 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2468 if (!pst
->dependencies
[i
]->readin
)
2470 /* Inform about additional files that need to be read in. */
2473 /* FIXME: i18n: Need to make this a single string. */
2474 fputs_filtered (" ", gdb_stdout
);
2476 fputs_filtered ("and ", gdb_stdout
);
2478 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2479 wrap_here (""); /* Flush output */
2480 gdb_flush (gdb_stdout
);
2482 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2485 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2489 /* It's an include file, no symbols to read for it.
2490 Everything is in the parent symtab. */
2495 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2497 queue_comp_unit (per_cu
);
2499 process_queue (pst
->objfile
);
2501 /* Age the cache, releasing compilation units that have not
2502 been used recently. */
2503 age_cached_comp_units ();
2505 do_cleanups (back_to
);
2508 /* Load the DIEs associated with PST and PER_CU into memory. */
2510 static struct dwarf2_cu
*
2511 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2513 bfd
*abfd
= objfile
->obfd
;
2514 struct dwarf2_cu
*cu
;
2515 unsigned long offset
;
2517 struct cleanup
*back_to
, *free_cu_cleanup
;
2518 struct attribute
*attr
;
2521 /* Set local variables from the partial symbol table info. */
2522 offset
= per_cu
->offset
;
2524 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2526 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2527 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2529 /* If an error occurs while loading, release our storage. */
2530 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2532 cu
->objfile
= objfile
;
2534 /* read in the comp_unit header */
2535 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2537 /* Read the abbrevs for this compilation unit */
2538 dwarf2_read_abbrevs (abfd
, cu
);
2539 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2541 cu
->header
.offset
= offset
;
2543 cu
->per_cu
= per_cu
;
2546 /* We use this obstack for block values in dwarf_alloc_block. */
2547 obstack_init (&cu
->comp_unit_obstack
);
2549 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2551 /* We try not to read any attributes in this function, because not
2552 all objfiles needed for references have been loaded yet, and symbol
2553 table processing isn't initialized. But we have to set the CU language,
2554 or we won't be able to build types correctly. */
2555 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2557 set_cu_language (DW_UNSND (attr
), cu
);
2559 set_cu_language (language_minimal
, cu
);
2561 do_cleanups (back_to
);
2563 /* We've successfully allocated this compilation unit. Let our caller
2564 clean it up when finished with it. */
2565 discard_cleanups (free_cu_cleanup
);
2570 /* Generate full symbol information for PST and CU, whose DIEs have
2571 already been loaded into memory. */
2574 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2576 struct partial_symtab
*pst
= per_cu
->psymtab
;
2577 struct dwarf2_cu
*cu
= per_cu
->cu
;
2578 struct objfile
*objfile
= pst
->objfile
;
2579 bfd
*abfd
= objfile
->obfd
;
2580 CORE_ADDR lowpc
, highpc
;
2581 struct symtab
*symtab
;
2582 struct cleanup
*back_to
;
2583 struct attribute
*attr
;
2586 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2588 /* We're in the global namespace. */
2589 processing_current_prefix
= "";
2592 back_to
= make_cleanup (really_free_pendings
, NULL
);
2594 cu
->list_in_scope
= &file_symbols
;
2596 /* Find the base address of the compilation unit for range lists and
2597 location lists. It will normally be specified by DW_AT_low_pc.
2598 In DWARF-3 draft 4, the base address could be overridden by
2599 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2600 compilation units with discontinuous ranges. */
2602 cu
->header
.base_known
= 0;
2603 cu
->header
.base_address
= 0;
2605 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2608 cu
->header
.base_address
= DW_ADDR (attr
);
2609 cu
->header
.base_known
= 1;
2613 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2616 cu
->header
.base_address
= DW_ADDR (attr
);
2617 cu
->header
.base_known
= 1;
2621 /* Do line number decoding in read_file_scope () */
2622 process_die (cu
->dies
, cu
);
2624 /* Some compilers don't define a DW_AT_high_pc attribute for the
2625 compilation unit. If the DW_AT_high_pc is missing, synthesize
2626 it, by scanning the DIE's below the compilation unit. */
2627 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2629 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2631 /* Set symtab language to language from DW_AT_language.
2632 If the compilation is from a C file generated by language preprocessors,
2633 do not set the language if it was already deduced by start_subfile. */
2635 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2637 symtab
->language
= cu
->language
;
2639 pst
->symtab
= symtab
;
2642 do_cleanups (back_to
);
2645 /* Process a die and its children. */
2648 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2652 case DW_TAG_padding
:
2654 case DW_TAG_compile_unit
:
2655 read_file_scope (die
, cu
);
2657 case DW_TAG_subprogram
:
2658 read_subroutine_type (die
, cu
);
2659 read_func_scope (die
, cu
);
2661 case DW_TAG_inlined_subroutine
:
2662 /* FIXME: These are ignored for now.
2663 They could be used to set breakpoints on all inlined instances
2664 of a function and make GDB `next' properly over inlined functions. */
2666 case DW_TAG_lexical_block
:
2667 case DW_TAG_try_block
:
2668 case DW_TAG_catch_block
:
2669 read_lexical_block_scope (die
, cu
);
2671 case DW_TAG_class_type
:
2672 case DW_TAG_structure_type
:
2673 case DW_TAG_union_type
:
2674 read_structure_type (die
, cu
);
2675 process_structure_scope (die
, cu
);
2677 case DW_TAG_enumeration_type
:
2678 read_enumeration_type (die
, cu
);
2679 process_enumeration_scope (die
, cu
);
2682 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2683 a symbol or process any children. Therefore it doesn't do anything
2684 that won't be done on-demand by read_type_die. */
2685 case DW_TAG_subroutine_type
:
2686 read_subroutine_type (die
, cu
);
2688 case DW_TAG_set_type
:
2689 read_set_type (die
, cu
);
2691 case DW_TAG_array_type
:
2692 read_array_type (die
, cu
);
2694 case DW_TAG_pointer_type
:
2695 read_tag_pointer_type (die
, cu
);
2697 case DW_TAG_ptr_to_member_type
:
2698 read_tag_ptr_to_member_type (die
, cu
);
2700 case DW_TAG_reference_type
:
2701 read_tag_reference_type (die
, cu
);
2703 case DW_TAG_string_type
:
2704 read_tag_string_type (die
, cu
);
2708 case DW_TAG_base_type
:
2709 read_base_type (die
, cu
);
2710 /* Add a typedef symbol for the type definition, if it has a
2712 new_symbol (die
, die
->type
, cu
);
2714 case DW_TAG_subrange_type
:
2715 read_subrange_type (die
, cu
);
2716 /* Add a typedef symbol for the type definition, if it has a
2718 new_symbol (die
, die
->type
, cu
);
2720 case DW_TAG_common_block
:
2721 read_common_block (die
, cu
);
2723 case DW_TAG_common_inclusion
:
2725 case DW_TAG_namespace
:
2726 processing_has_namespace_info
= 1;
2727 read_namespace (die
, cu
);
2729 case DW_TAG_imported_declaration
:
2730 case DW_TAG_imported_module
:
2731 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2732 information contained in these. DW_TAG_imported_declaration
2733 dies shouldn't have children; DW_TAG_imported_module dies
2734 shouldn't in the C++ case, but conceivably could in the
2735 Fortran case, so we'll have to replace this gdb_assert if
2736 Fortran compilers start generating that info. */
2737 processing_has_namespace_info
= 1;
2738 gdb_assert (die
->child
== NULL
);
2741 new_symbol (die
, NULL
, cu
);
2747 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2749 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2753 free_cu_line_header (void *arg
)
2755 struct dwarf2_cu
*cu
= arg
;
2757 free_line_header (cu
->line_header
);
2758 cu
->line_header
= NULL
;
2762 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2764 struct objfile
*objfile
= cu
->objfile
;
2765 struct comp_unit_head
*cu_header
= &cu
->header
;
2766 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2767 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2768 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2769 struct attribute
*attr
;
2771 char *comp_dir
= NULL
;
2772 struct die_info
*child_die
;
2773 bfd
*abfd
= objfile
->obfd
;
2774 struct line_header
*line_header
= 0;
2777 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2779 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2781 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2782 from finish_block. */
2783 if (lowpc
== ((CORE_ADDR
) -1))
2788 /* Find the filename. Do not use dwarf2_name here, since the filename
2789 is not a source language identifier. */
2790 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2793 name
= DW_STRING (attr
);
2796 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2798 comp_dir
= DW_STRING (attr
);
2799 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
2801 comp_dir
= ldirname (name
);
2802 if (comp_dir
!= NULL
)
2803 make_cleanup (xfree
, comp_dir
);
2805 if (comp_dir
!= NULL
)
2807 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2808 directory, get rid of it. */
2809 char *cp
= strchr (comp_dir
, ':');
2811 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2818 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2821 set_cu_language (DW_UNSND (attr
), cu
);
2824 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2826 cu
->producer
= DW_STRING (attr
);
2828 /* We assume that we're processing GCC output. */
2829 processing_gcc_compilation
= 2;
2831 start_symtab (name
, comp_dir
, lowpc
);
2832 record_debugformat ("DWARF 2");
2833 record_producer (cu
->producer
);
2835 initialize_cu_func_list (cu
);
2837 /* Decode line number information if present. We do this before
2838 processing child DIEs, so that the line header table is available
2839 for DW_AT_decl_file. */
2840 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2843 unsigned int line_offset
= DW_UNSND (attr
);
2844 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2847 cu
->line_header
= line_header
;
2848 make_cleanup (free_cu_line_header
, cu
);
2849 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2853 /* Process all dies in compilation unit. */
2854 if (die
->child
!= NULL
)
2856 child_die
= die
->child
;
2857 while (child_die
&& child_die
->tag
)
2859 process_die (child_die
, cu
);
2860 child_die
= sibling_die (child_die
);
2864 /* Decode macro information, if present. Dwarf 2 macro information
2865 refers to information in the line number info statement program
2866 header, so we can only read it if we've read the header
2868 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2869 if (attr
&& line_header
)
2871 unsigned int macro_offset
= DW_UNSND (attr
);
2872 dwarf_decode_macros (line_header
, macro_offset
,
2873 comp_dir
, abfd
, cu
);
2875 do_cleanups (back_to
);
2879 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2880 struct dwarf2_cu
*cu
)
2882 struct function_range
*thisfn
;
2884 thisfn
= (struct function_range
*)
2885 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2886 thisfn
->name
= name
;
2887 thisfn
->lowpc
= lowpc
;
2888 thisfn
->highpc
= highpc
;
2889 thisfn
->seen_line
= 0;
2890 thisfn
->next
= NULL
;
2892 if (cu
->last_fn
== NULL
)
2893 cu
->first_fn
= thisfn
;
2895 cu
->last_fn
->next
= thisfn
;
2897 cu
->last_fn
= thisfn
;
2901 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2903 struct objfile
*objfile
= cu
->objfile
;
2904 struct context_stack
*new;
2907 struct die_info
*child_die
;
2908 struct attribute
*attr
;
2910 const char *previous_prefix
= processing_current_prefix
;
2911 struct cleanup
*back_to
= NULL
;
2914 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2916 name
= dwarf2_linkage_name (die
, cu
);
2918 /* Ignore functions with missing or empty names and functions with
2919 missing or invalid low and high pc attributes. */
2920 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2923 if (cu
->language
== language_cplus
2924 || cu
->language
== language_java
)
2926 struct die_info
*spec_die
= die_specification (die
, cu
);
2928 /* NOTE: carlton/2004-01-23: We have to be careful in the
2929 presence of DW_AT_specification. For example, with GCC 3.4,
2934 // Definition of N::foo.
2938 then we'll have a tree of DIEs like this:
2940 1: DW_TAG_compile_unit
2941 2: DW_TAG_namespace // N
2942 3: DW_TAG_subprogram // declaration of N::foo
2943 4: DW_TAG_subprogram // definition of N::foo
2944 DW_AT_specification // refers to die #3
2946 Thus, when processing die #4, we have to pretend that we're
2947 in the context of its DW_AT_specification, namely the contex
2950 if (spec_die
!= NULL
)
2952 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2953 processing_current_prefix
= specification_prefix
;
2954 back_to
= make_cleanup (xfree
, specification_prefix
);
2961 /* Record the function range for dwarf_decode_lines. */
2962 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2964 new = push_context (0, lowpc
);
2965 new->name
= new_symbol (die
, die
->type
, cu
);
2967 /* If there is a location expression for DW_AT_frame_base, record
2969 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2971 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2972 expression is being recorded directly in the function's symbol
2973 and not in a separate frame-base object. I guess this hack is
2974 to avoid adding some sort of frame-base adjunct/annex to the
2975 function's symbol :-(. The problem with doing this is that it
2976 results in a function symbol with a location expression that
2977 has nothing to do with the location of the function, ouch! The
2978 relationship should be: a function's symbol has-a frame base; a
2979 frame-base has-a location expression. */
2980 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2982 cu
->list_in_scope
= &local_symbols
;
2984 if (die
->child
!= NULL
)
2986 child_die
= die
->child
;
2987 while (child_die
&& child_die
->tag
)
2989 process_die (child_die
, cu
);
2990 child_die
= sibling_die (child_die
);
2994 new = pop_context ();
2995 /* Make a block for the local symbols within. */
2996 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2997 lowpc
, highpc
, objfile
);
2999 /* In C++, we can have functions nested inside functions (e.g., when
3000 a function declares a class that has methods). This means that
3001 when we finish processing a function scope, we may need to go
3002 back to building a containing block's symbol lists. */
3003 local_symbols
= new->locals
;
3004 param_symbols
= new->params
;
3006 /* If we've finished processing a top-level function, subsequent
3007 symbols go in the file symbol list. */
3008 if (outermost_context_p ())
3009 cu
->list_in_scope
= &file_symbols
;
3011 processing_current_prefix
= previous_prefix
;
3012 if (back_to
!= NULL
)
3013 do_cleanups (back_to
);
3016 /* Process all the DIES contained within a lexical block scope. Start
3017 a new scope, process the dies, and then close the scope. */
3020 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3022 struct objfile
*objfile
= cu
->objfile
;
3023 struct context_stack
*new;
3024 CORE_ADDR lowpc
, highpc
;
3025 struct die_info
*child_die
;
3028 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3030 /* Ignore blocks with missing or invalid low and high pc attributes. */
3031 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3032 as multiple lexical blocks? Handling children in a sane way would
3033 be nasty. Might be easier to properly extend generic blocks to
3035 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3040 push_context (0, lowpc
);
3041 if (die
->child
!= NULL
)
3043 child_die
= die
->child
;
3044 while (child_die
&& child_die
->tag
)
3046 process_die (child_die
, cu
);
3047 child_die
= sibling_die (child_die
);
3050 new = pop_context ();
3052 if (local_symbols
!= NULL
)
3054 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3057 local_symbols
= new->locals
;
3060 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
3061 Return 1 if the attributes are present and valid, otherwise, return 0. */
3064 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
3065 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
)
3067 struct objfile
*objfile
= cu
->objfile
;
3068 struct comp_unit_head
*cu_header
= &cu
->header
;
3069 bfd
*obfd
= objfile
->obfd
;
3070 unsigned int addr_size
= cu_header
->addr_size
;
3071 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3072 /* Base address selection entry. */
3082 found_base
= cu_header
->base_known
;
3083 base
= cu_header
->base_address
;
3085 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3087 complaint (&symfile_complaints
,
3088 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3092 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3094 /* Read in the largest possible address. */
3095 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3096 if ((marker
& mask
) == mask
)
3098 /* If we found the largest possible address, then
3099 read the base address. */
3100 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3101 buffer
+= 2 * addr_size
;
3102 offset
+= 2 * addr_size
;
3110 CORE_ADDR range_beginning
, range_end
;
3112 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3113 buffer
+= addr_size
;
3114 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3115 buffer
+= addr_size
;
3116 offset
+= 2 * addr_size
;
3118 /* An end of list marker is a pair of zero addresses. */
3119 if (range_beginning
== 0 && range_end
== 0)
3120 /* Found the end of list entry. */
3123 /* Each base address selection entry is a pair of 2 values.
3124 The first is the largest possible address, the second is
3125 the base address. Check for a base address here. */
3126 if ((range_beginning
& mask
) == mask
)
3128 /* If we found the largest possible address, then
3129 read the base address. */
3130 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3137 /* We have no valid base address for the ranges
3139 complaint (&symfile_complaints
,
3140 _("Invalid .debug_ranges data (no base address)"));
3144 range_beginning
+= base
;
3147 /* FIXME: This is recording everything as a low-high
3148 segment of consecutive addresses. We should have a
3149 data structure for discontiguous block ranges
3153 low
= range_beginning
;
3159 if (range_beginning
< low
)
3160 low
= range_beginning
;
3161 if (range_end
> high
)
3167 /* If the first entry is an end-of-list marker, the range
3168 describes an empty scope, i.e. no instructions. */
3174 *high_return
= high
;
3178 /* Get low and high pc attributes from a die. Return 1 if the attributes
3179 are present and valid, otherwise, return 0. Return -1 if the range is
3180 discontinuous, i.e. derived from DW_AT_ranges information. */
3182 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3183 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3185 struct attribute
*attr
;
3190 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3193 high
= DW_ADDR (attr
);
3194 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3196 low
= DW_ADDR (attr
);
3198 /* Found high w/o low attribute. */
3201 /* Found consecutive range of addresses. */
3206 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3209 /* Value of the DW_AT_ranges attribute is the offset in the
3210 .debug_ranges section. */
3211 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
))
3213 /* Found discontinuous range of addresses. */
3221 /* When using the GNU linker, .gnu.linkonce. sections are used to
3222 eliminate duplicate copies of functions and vtables and such.
3223 The linker will arbitrarily choose one and discard the others.
3224 The AT_*_pc values for such functions refer to local labels in
3225 these sections. If the section from that file was discarded, the
3226 labels are not in the output, so the relocs get a value of 0.
3227 If this is a discarded function, mark the pc bounds as invalid,
3228 so that GDB will ignore it. */
3229 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3237 /* Get the low and high pc's represented by the scope DIE, and store
3238 them in *LOWPC and *HIGHPC. If the correct values can't be
3239 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3242 get_scope_pc_bounds (struct die_info
*die
,
3243 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3244 struct dwarf2_cu
*cu
)
3246 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3247 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3248 CORE_ADDR current_low
, current_high
;
3250 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3252 best_low
= current_low
;
3253 best_high
= current_high
;
3257 struct die_info
*child
= die
->child
;
3259 while (child
&& child
->tag
)
3261 switch (child
->tag
) {
3262 case DW_TAG_subprogram
:
3263 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3265 best_low
= min (best_low
, current_low
);
3266 best_high
= max (best_high
, current_high
);
3269 case DW_TAG_namespace
:
3270 /* FIXME: carlton/2004-01-16: Should we do this for
3271 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3272 that current GCC's always emit the DIEs corresponding
3273 to definitions of methods of classes as children of a
3274 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3275 the DIEs giving the declarations, which could be
3276 anywhere). But I don't see any reason why the
3277 standards says that they have to be there. */
3278 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3280 if (current_low
!= ((CORE_ADDR
) -1))
3282 best_low
= min (best_low
, current_low
);
3283 best_high
= max (best_high
, current_high
);
3291 child
= sibling_die (child
);
3296 *highpc
= best_high
;
3299 /* Add an aggregate field to the field list. */
3302 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3303 struct dwarf2_cu
*cu
)
3305 struct objfile
*objfile
= cu
->objfile
;
3306 struct nextfield
*new_field
;
3307 struct attribute
*attr
;
3309 char *fieldname
= "";
3311 /* Allocate a new field list entry and link it in. */
3312 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3313 make_cleanup (xfree
, new_field
);
3314 memset (new_field
, 0, sizeof (struct nextfield
));
3315 new_field
->next
= fip
->fields
;
3316 fip
->fields
= new_field
;
3319 /* Handle accessibility and virtuality of field.
3320 The default accessibility for members is public, the default
3321 accessibility for inheritance is private. */
3322 if (die
->tag
!= DW_TAG_inheritance
)
3323 new_field
->accessibility
= DW_ACCESS_public
;
3325 new_field
->accessibility
= DW_ACCESS_private
;
3326 new_field
->virtuality
= DW_VIRTUALITY_none
;
3328 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3330 new_field
->accessibility
= DW_UNSND (attr
);
3331 if (new_field
->accessibility
!= DW_ACCESS_public
)
3332 fip
->non_public_fields
= 1;
3333 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3335 new_field
->virtuality
= DW_UNSND (attr
);
3337 fp
= &new_field
->field
;
3339 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3341 /* Data member other than a C++ static data member. */
3343 /* Get type of field. */
3344 fp
->type
= die_type (die
, cu
);
3346 FIELD_STATIC_KIND (*fp
) = 0;
3348 /* Get bit size of field (zero if none). */
3349 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3352 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3356 FIELD_BITSIZE (*fp
) = 0;
3359 /* Get bit offset of field. */
3360 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3363 FIELD_BITPOS (*fp
) =
3364 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3367 FIELD_BITPOS (*fp
) = 0;
3368 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3371 if (BITS_BIG_ENDIAN
)
3373 /* For big endian bits, the DW_AT_bit_offset gives the
3374 additional bit offset from the MSB of the containing
3375 anonymous object to the MSB of the field. We don't
3376 have to do anything special since we don't need to
3377 know the size of the anonymous object. */
3378 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3382 /* For little endian bits, compute the bit offset to the
3383 MSB of the anonymous object, subtract off the number of
3384 bits from the MSB of the field to the MSB of the
3385 object, and then subtract off the number of bits of
3386 the field itself. The result is the bit offset of
3387 the LSB of the field. */
3389 int bit_offset
= DW_UNSND (attr
);
3391 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3394 /* The size of the anonymous object containing
3395 the bit field is explicit, so use the
3396 indicated size (in bytes). */
3397 anonymous_size
= DW_UNSND (attr
);
3401 /* The size of the anonymous object containing
3402 the bit field must be inferred from the type
3403 attribute of the data member containing the
3405 anonymous_size
= TYPE_LENGTH (fp
->type
);
3407 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3408 - bit_offset
- FIELD_BITSIZE (*fp
);
3412 /* Get name of field. */
3413 fieldname
= dwarf2_name (die
, cu
);
3414 if (fieldname
== NULL
)
3417 /* The name is already allocated along with this objfile, so we don't
3418 need to duplicate it for the type. */
3419 fp
->name
= fieldname
;
3421 /* Change accessibility for artificial fields (e.g. virtual table
3422 pointer or virtual base class pointer) to private. */
3423 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3425 new_field
->accessibility
= DW_ACCESS_private
;
3426 fip
->non_public_fields
= 1;
3429 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3431 /* C++ static member. */
3433 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3434 is a declaration, but all versions of G++ as of this writing
3435 (so through at least 3.2.1) incorrectly generate
3436 DW_TAG_variable tags. */
3440 /* Get name of field. */
3441 fieldname
= dwarf2_name (die
, cu
);
3442 if (fieldname
== NULL
)
3445 /* Get physical name. */
3446 physname
= dwarf2_linkage_name (die
, cu
);
3448 /* The name is already allocated along with this objfile, so we don't
3449 need to duplicate it for the type. */
3450 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3451 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3452 FIELD_NAME (*fp
) = fieldname
;
3454 else if (die
->tag
== DW_TAG_inheritance
)
3456 /* C++ base class field. */
3457 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3459 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3461 FIELD_BITSIZE (*fp
) = 0;
3462 FIELD_STATIC_KIND (*fp
) = 0;
3463 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3464 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3465 fip
->nbaseclasses
++;
3469 /* Create the vector of fields, and attach it to the type. */
3472 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3473 struct dwarf2_cu
*cu
)
3475 int nfields
= fip
->nfields
;
3477 /* Record the field count, allocate space for the array of fields,
3478 and create blank accessibility bitfields if necessary. */
3479 TYPE_NFIELDS (type
) = nfields
;
3480 TYPE_FIELDS (type
) = (struct field
*)
3481 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3482 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3484 if (fip
->non_public_fields
)
3486 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3488 TYPE_FIELD_PRIVATE_BITS (type
) =
3489 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3490 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3492 TYPE_FIELD_PROTECTED_BITS (type
) =
3493 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3494 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3496 TYPE_FIELD_IGNORE_BITS (type
) =
3497 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3498 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3501 /* If the type has baseclasses, allocate and clear a bit vector for
3502 TYPE_FIELD_VIRTUAL_BITS. */
3503 if (fip
->nbaseclasses
)
3505 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3506 unsigned char *pointer
;
3508 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3509 pointer
= TYPE_ALLOC (type
, num_bytes
);
3510 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3511 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3512 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3515 /* Copy the saved-up fields into the field vector. Start from the head
3516 of the list, adding to the tail of the field array, so that they end
3517 up in the same order in the array in which they were added to the list. */
3518 while (nfields
-- > 0)
3520 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3521 switch (fip
->fields
->accessibility
)
3523 case DW_ACCESS_private
:
3524 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3527 case DW_ACCESS_protected
:
3528 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3531 case DW_ACCESS_public
:
3535 /* Unknown accessibility. Complain and treat it as public. */
3537 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3538 fip
->fields
->accessibility
);
3542 if (nfields
< fip
->nbaseclasses
)
3544 switch (fip
->fields
->virtuality
)
3546 case DW_VIRTUALITY_virtual
:
3547 case DW_VIRTUALITY_pure_virtual
:
3548 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3552 fip
->fields
= fip
->fields
->next
;
3556 /* Add a member function to the proper fieldlist. */
3559 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3560 struct type
*type
, struct dwarf2_cu
*cu
)
3562 struct objfile
*objfile
= cu
->objfile
;
3563 struct attribute
*attr
;
3564 struct fnfieldlist
*flp
;
3566 struct fn_field
*fnp
;
3569 struct nextfnfield
*new_fnfield
;
3571 /* Get name of member function. */
3572 fieldname
= dwarf2_name (die
, cu
);
3573 if (fieldname
== NULL
)
3576 /* Get the mangled name. */
3577 physname
= dwarf2_linkage_name (die
, cu
);
3579 /* Look up member function name in fieldlist. */
3580 for (i
= 0; i
< fip
->nfnfields
; i
++)
3582 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3586 /* Create new list element if necessary. */
3587 if (i
< fip
->nfnfields
)
3588 flp
= &fip
->fnfieldlists
[i
];
3591 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3593 fip
->fnfieldlists
= (struct fnfieldlist
*)
3594 xrealloc (fip
->fnfieldlists
,
3595 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3596 * sizeof (struct fnfieldlist
));
3597 if (fip
->nfnfields
== 0)
3598 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3600 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3601 flp
->name
= fieldname
;
3607 /* Create a new member function field and chain it to the field list
3609 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3610 make_cleanup (xfree
, new_fnfield
);
3611 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3612 new_fnfield
->next
= flp
->head
;
3613 flp
->head
= new_fnfield
;
3616 /* Fill in the member function field info. */
3617 fnp
= &new_fnfield
->fnfield
;
3618 /* The name is already allocated along with this objfile, so we don't
3619 need to duplicate it for the type. */
3620 fnp
->physname
= physname
? physname
: "";
3621 fnp
->type
= alloc_type (objfile
);
3622 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3624 int nparams
= TYPE_NFIELDS (die
->type
);
3626 /* TYPE is the domain of this method, and DIE->TYPE is the type
3627 of the method itself (TYPE_CODE_METHOD). */
3628 smash_to_method_type (fnp
->type
, type
,
3629 TYPE_TARGET_TYPE (die
->type
),
3630 TYPE_FIELDS (die
->type
),
3631 TYPE_NFIELDS (die
->type
),
3632 TYPE_VARARGS (die
->type
));
3634 /* Handle static member functions.
3635 Dwarf2 has no clean way to discern C++ static and non-static
3636 member functions. G++ helps GDB by marking the first
3637 parameter for non-static member functions (which is the
3638 this pointer) as artificial. We obtain this information
3639 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3640 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3641 fnp
->voffset
= VOFFSET_STATIC
;
3644 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3647 /* Get fcontext from DW_AT_containing_type if present. */
3648 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3649 fnp
->fcontext
= die_containing_type (die
, cu
);
3651 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3652 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3654 /* Get accessibility. */
3655 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3658 switch (DW_UNSND (attr
))
3660 case DW_ACCESS_private
:
3661 fnp
->is_private
= 1;
3663 case DW_ACCESS_protected
:
3664 fnp
->is_protected
= 1;
3669 /* Check for artificial methods. */
3670 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3671 if (attr
&& DW_UNSND (attr
) != 0)
3672 fnp
->is_artificial
= 1;
3674 /* Get index in virtual function table if it is a virtual member function. */
3675 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3678 /* Support the .debug_loc offsets */
3679 if (attr_form_is_block (attr
))
3681 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3683 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3685 dwarf2_complex_location_expr_complaint ();
3689 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3695 /* Create the vector of member function fields, and attach it to the type. */
3698 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3699 struct dwarf2_cu
*cu
)
3701 struct fnfieldlist
*flp
;
3702 int total_length
= 0;
3705 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3706 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3707 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3709 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3711 struct nextfnfield
*nfp
= flp
->head
;
3712 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3715 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3716 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3717 fn_flp
->fn_fields
= (struct fn_field
*)
3718 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3719 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3720 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3722 total_length
+= flp
->length
;
3725 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3726 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3729 /* Returns non-zero if NAME is the name of a vtable member in CU's
3730 language, zero otherwise. */
3732 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3734 static const char vptr
[] = "_vptr";
3735 static const char vtable
[] = "vtable";
3737 /* Look for the C++ and Java forms of the vtable. */
3738 if ((cu
->language
== language_java
3739 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3740 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3741 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3747 /* GCC outputs unnamed structures that are really pointers to member
3748 functions, with the ABI-specified layout. If DIE (from CU) describes
3749 such a structure, set its type, and return nonzero. Otherwise return
3752 GCC shouldn't do this; it should just output pointer to member DIEs.
3753 This is GCC PR debug/28767. */
3756 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
3758 struct objfile
*objfile
= cu
->objfile
;
3760 struct die_info
*pfn_die
, *delta_die
;
3761 struct attribute
*pfn_name
, *delta_name
;
3762 struct type
*pfn_type
, *domain_type
;
3764 /* Check for a structure with no name and two children. */
3765 if (die
->tag
!= DW_TAG_structure_type
3766 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
3767 || die
->child
== NULL
3768 || die
->child
->sibling
== NULL
3769 || (die
->child
->sibling
->sibling
!= NULL
3770 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
3773 /* Check for __pfn and __delta members. */
3774 pfn_die
= die
->child
;
3775 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
3776 if (pfn_die
->tag
!= DW_TAG_member
3778 || DW_STRING (pfn_name
) == NULL
3779 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
3782 delta_die
= pfn_die
->sibling
;
3783 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
3784 if (delta_die
->tag
!= DW_TAG_member
3785 || delta_name
== NULL
3786 || DW_STRING (delta_name
) == NULL
3787 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
3790 /* Find the type of the method. */
3791 pfn_type
= die_type (pfn_die
, cu
);
3792 if (pfn_type
== NULL
3793 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
3794 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
3797 /* Look for the "this" argument. */
3798 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
3799 if (TYPE_NFIELDS (pfn_type
) == 0
3800 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
3803 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
3804 type
= alloc_type (objfile
);
3805 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
3806 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
3807 TYPE_VARARGS (pfn_type
));
3808 type
= lookup_methodptr_type (type
);
3809 set_die_type (die
, type
, cu
);
3814 /* Called when we find the DIE that starts a structure or union scope
3815 (definition) to process all dies that define the members of the
3818 NOTE: we need to call struct_type regardless of whether or not the
3819 DIE has an at_name attribute, since it might be an anonymous
3820 structure or union. This gets the type entered into our set of
3823 However, if the structure is incomplete (an opaque struct/union)
3824 then suppress creating a symbol table entry for it since gdb only
3825 wants to find the one with the complete definition. Note that if
3826 it is complete, we just call new_symbol, which does it's own
3827 checking about whether the struct/union is anonymous or not (and
3828 suppresses creating a symbol table entry itself). */
3831 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3833 struct objfile
*objfile
= cu
->objfile
;
3835 struct attribute
*attr
;
3836 const char *previous_prefix
= processing_current_prefix
;
3837 struct cleanup
*back_to
= NULL
;
3843 if (quirk_gcc_member_function_pointer (die
, cu
))
3846 type
= alloc_type (objfile
);
3847 INIT_CPLUS_SPECIFIC (type
);
3848 name
= dwarf2_name (die
, cu
);
3851 if (cu
->language
== language_cplus
3852 || cu
->language
== language_java
)
3854 char *new_prefix
= determine_class_name (die
, cu
);
3855 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3856 strlen (new_prefix
),
3857 &objfile
->objfile_obstack
);
3858 back_to
= make_cleanup (xfree
, new_prefix
);
3859 processing_current_prefix
= new_prefix
;
3863 /* The name is already allocated along with this objfile, so
3864 we don't need to duplicate it for the type. */
3865 TYPE_TAG_NAME (type
) = name
;
3869 if (die
->tag
== DW_TAG_structure_type
)
3871 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3873 else if (die
->tag
== DW_TAG_union_type
)
3875 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3879 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3881 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3884 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3887 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3891 TYPE_LENGTH (type
) = 0;
3894 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB_SUPPORTED
;
3895 if (die_is_declaration (die
, cu
))
3896 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3898 /* We need to add the type field to the die immediately so we don't
3899 infinitely recurse when dealing with pointers to the structure
3900 type within the structure itself. */
3901 set_die_type (die
, type
, cu
);
3903 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3905 struct field_info fi
;
3906 struct die_info
*child_die
;
3907 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3909 memset (&fi
, 0, sizeof (struct field_info
));
3911 child_die
= die
->child
;
3913 while (child_die
&& child_die
->tag
)
3915 if (child_die
->tag
== DW_TAG_member
3916 || child_die
->tag
== DW_TAG_variable
)
3918 /* NOTE: carlton/2002-11-05: A C++ static data member
3919 should be a DW_TAG_member that is a declaration, but
3920 all versions of G++ as of this writing (so through at
3921 least 3.2.1) incorrectly generate DW_TAG_variable
3922 tags for them instead. */
3923 dwarf2_add_field (&fi
, child_die
, cu
);
3925 else if (child_die
->tag
== DW_TAG_subprogram
)
3927 /* C++ member function. */
3928 read_type_die (child_die
, cu
);
3929 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3931 else if (child_die
->tag
== DW_TAG_inheritance
)
3933 /* C++ base class field. */
3934 dwarf2_add_field (&fi
, child_die
, cu
);
3936 child_die
= sibling_die (child_die
);
3939 /* Attach fields and member functions to the type. */
3941 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3944 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3946 /* Get the type which refers to the base class (possibly this
3947 class itself) which contains the vtable pointer for the current
3948 class from the DW_AT_containing_type attribute. */
3950 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3952 struct type
*t
= die_containing_type (die
, cu
);
3954 TYPE_VPTR_BASETYPE (type
) = t
;
3959 /* Our own class provides vtbl ptr. */
3960 for (i
= TYPE_NFIELDS (t
) - 1;
3961 i
>= TYPE_N_BASECLASSES (t
);
3964 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3966 if (is_vtable_name (fieldname
, cu
))
3968 TYPE_VPTR_FIELDNO (type
) = i
;
3973 /* Complain if virtual function table field not found. */
3974 if (i
< TYPE_N_BASECLASSES (t
))
3975 complaint (&symfile_complaints
,
3976 _("virtual function table pointer not found when defining class '%s'"),
3977 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3982 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3985 else if (cu
->producer
3986 && strncmp (cu
->producer
,
3987 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3989 /* The IBM XLC compiler does not provide direct indication
3990 of the containing type, but the vtable pointer is
3991 always named __vfp. */
3995 for (i
= TYPE_NFIELDS (type
) - 1;
3996 i
>= TYPE_N_BASECLASSES (type
);
3999 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
4001 TYPE_VPTR_FIELDNO (type
) = i
;
4002 TYPE_VPTR_BASETYPE (type
) = type
;
4009 do_cleanups (back_to
);
4012 processing_current_prefix
= previous_prefix
;
4013 if (back_to
!= NULL
)
4014 do_cleanups (back_to
);
4018 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4020 struct objfile
*objfile
= cu
->objfile
;
4021 const char *previous_prefix
= processing_current_prefix
;
4022 struct die_info
*child_die
= die
->child
;
4024 if (TYPE_TAG_NAME (die
->type
) != NULL
)
4025 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
4027 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4028 snapshots) has been known to create a die giving a declaration
4029 for a class that has, as a child, a die giving a definition for a
4030 nested class. So we have to process our children even if the
4031 current die is a declaration. Normally, of course, a declaration
4032 won't have any children at all. */
4034 while (child_die
!= NULL
&& child_die
->tag
)
4036 if (child_die
->tag
== DW_TAG_member
4037 || child_die
->tag
== DW_TAG_variable
4038 || child_die
->tag
== DW_TAG_inheritance
)
4043 process_die (child_die
, cu
);
4045 child_die
= sibling_die (child_die
);
4048 /* Do not consider external references. According to the DWARF standard,
4049 these DIEs are identified by the fact that they have no byte_size
4050 attribute, and a declaration attribute. */
4051 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
4052 || !die_is_declaration (die
, cu
))
4053 new_symbol (die
, die
->type
, cu
);
4055 processing_current_prefix
= previous_prefix
;
4058 /* Given a DW_AT_enumeration_type die, set its type. We do not
4059 complete the type's fields yet, or create any symbols. */
4062 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4064 struct objfile
*objfile
= cu
->objfile
;
4066 struct attribute
*attr
;
4072 type
= alloc_type (objfile
);
4074 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4075 name
= dwarf2_name (die
, cu
);
4078 if (processing_has_namespace_info
)
4080 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
4081 processing_current_prefix
,
4086 /* The name is already allocated along with this objfile, so
4087 we don't need to duplicate it for the type. */
4088 TYPE_TAG_NAME (type
) = name
;
4092 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4095 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4099 TYPE_LENGTH (type
) = 0;
4102 set_die_type (die
, type
, cu
);
4105 /* Determine the name of the type represented by DIE, which should be
4106 a named C++ or Java compound type. Return the name in question; the caller
4107 is responsible for xfree()'ing it. */
4110 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4112 struct cleanup
*back_to
= NULL
;
4113 struct die_info
*spec_die
= die_specification (die
, cu
);
4114 char *new_prefix
= NULL
;
4116 /* If this is the definition of a class that is declared by another
4117 die, then processing_current_prefix may not be accurate; see
4118 read_func_scope for a similar example. */
4119 if (spec_die
!= NULL
)
4121 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4122 processing_current_prefix
= specification_prefix
;
4123 back_to
= make_cleanup (xfree
, specification_prefix
);
4126 /* If we don't have namespace debug info, guess the name by trying
4127 to demangle the names of members, just like we did in
4128 guess_structure_name. */
4129 if (!processing_has_namespace_info
)
4131 struct die_info
*child
;
4133 for (child
= die
->child
;
4134 child
!= NULL
&& child
->tag
!= 0;
4135 child
= sibling_die (child
))
4137 if (child
->tag
== DW_TAG_subprogram
)
4140 = language_class_name_from_physname (cu
->language_defn
,
4144 if (new_prefix
!= NULL
)
4150 if (new_prefix
== NULL
)
4152 const char *name
= dwarf2_name (die
, cu
);
4153 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4154 name
? name
: "<<anonymous>>",
4158 if (back_to
!= NULL
)
4159 do_cleanups (back_to
);
4164 /* Given a pointer to a die which begins an enumeration, process all
4165 the dies that define the members of the enumeration, and create the
4166 symbol for the enumeration type.
4168 NOTE: We reverse the order of the element list. */
4171 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4173 struct objfile
*objfile
= cu
->objfile
;
4174 struct die_info
*child_die
;
4175 struct field
*fields
;
4178 int unsigned_enum
= 1;
4183 if (die
->child
!= NULL
)
4185 child_die
= die
->child
;
4186 while (child_die
&& child_die
->tag
)
4188 if (child_die
->tag
!= DW_TAG_enumerator
)
4190 process_die (child_die
, cu
);
4194 name
= dwarf2_name (child_die
, cu
);
4197 sym
= new_symbol (child_die
, die
->type
, cu
);
4198 if (SYMBOL_VALUE (sym
) < 0)
4201 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4203 fields
= (struct field
*)
4205 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4206 * sizeof (struct field
));
4209 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4210 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4211 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4212 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4213 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4219 child_die
= sibling_die (child_die
);
4224 TYPE_NFIELDS (die
->type
) = num_fields
;
4225 TYPE_FIELDS (die
->type
) = (struct field
*)
4226 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4227 memcpy (TYPE_FIELDS (die
->type
), fields
,
4228 sizeof (struct field
) * num_fields
);
4232 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4235 new_symbol (die
, die
->type
, cu
);
4238 /* Extract all information from a DW_TAG_array_type DIE and put it in
4239 the DIE's type field. For now, this only handles one dimensional
4243 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4245 struct objfile
*objfile
= cu
->objfile
;
4246 struct die_info
*child_die
;
4247 struct type
*type
= NULL
;
4248 struct type
*element_type
, *range_type
, *index_type
;
4249 struct type
**range_types
= NULL
;
4250 struct attribute
*attr
;
4252 struct cleanup
*back_to
;
4255 /* Return if we've already decoded this type. */
4261 element_type
= die_type (die
, cu
);
4263 /* Irix 6.2 native cc creates array types without children for
4264 arrays with unspecified length. */
4265 if (die
->child
== NULL
)
4267 index_type
= builtin_type_int32
;
4268 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4269 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4274 back_to
= make_cleanup (null_cleanup
, NULL
);
4275 child_die
= die
->child
;
4276 while (child_die
&& child_die
->tag
)
4278 if (child_die
->tag
== DW_TAG_subrange_type
)
4280 read_subrange_type (child_die
, cu
);
4282 if (child_die
->type
!= NULL
)
4284 /* The range type was succesfully read. Save it for
4285 the array type creation. */
4286 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4288 range_types
= (struct type
**)
4289 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4290 * sizeof (struct type
*));
4292 make_cleanup (free_current_contents
, &range_types
);
4294 range_types
[ndim
++] = child_die
->type
;
4297 child_die
= sibling_die (child_die
);
4300 /* Dwarf2 dimensions are output from left to right, create the
4301 necessary array types in backwards order. */
4303 type
= element_type
;
4305 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4309 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4314 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4317 /* Understand Dwarf2 support for vector types (like they occur on
4318 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4319 array type. This is not part of the Dwarf2/3 standard yet, but a
4320 custom vendor extension. The main difference between a regular
4321 array and the vector variant is that vectors are passed by value
4323 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4325 make_vector_type (type
);
4327 name
= dwarf2_name (die
, cu
);
4329 TYPE_NAME (type
) = name
;
4331 do_cleanups (back_to
);
4333 /* Install the type in the die. */
4334 set_die_type (die
, type
, cu
);
4337 static enum dwarf_array_dim_ordering
4338 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4340 struct attribute
*attr
;
4342 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4344 if (attr
) return DW_SND (attr
);
4347 GNU F77 is a special case, as at 08/2004 array type info is the
4348 opposite order to the dwarf2 specification, but data is still
4349 laid out as per normal fortran.
4351 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4355 if (cu
->language
== language_fortran
&&
4356 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4358 return DW_ORD_row_major
;
4361 switch (cu
->language_defn
->la_array_ordering
)
4363 case array_column_major
:
4364 return DW_ORD_col_major
;
4365 case array_row_major
:
4367 return DW_ORD_row_major
;
4371 /* Extract all information from a DW_TAG_set_type DIE and put it in
4372 the DIE's type field. */
4375 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4377 if (die
->type
== NULL
)
4378 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4381 /* First cut: install each common block member as a global variable. */
4384 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4386 struct die_info
*child_die
;
4387 struct attribute
*attr
;
4389 CORE_ADDR base
= (CORE_ADDR
) 0;
4391 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4394 /* Support the .debug_loc offsets */
4395 if (attr_form_is_block (attr
))
4397 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4399 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4401 dwarf2_complex_location_expr_complaint ();
4405 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4406 "common block member");
4409 if (die
->child
!= NULL
)
4411 child_die
= die
->child
;
4412 while (child_die
&& child_die
->tag
)
4414 sym
= new_symbol (child_die
, NULL
, cu
);
4415 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4418 SYMBOL_VALUE_ADDRESS (sym
) =
4419 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4420 add_symbol_to_list (sym
, &global_symbols
);
4422 child_die
= sibling_die (child_die
);
4427 /* Read a C++ namespace. */
4430 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4432 struct objfile
*objfile
= cu
->objfile
;
4433 const char *previous_prefix
= processing_current_prefix
;
4436 struct die_info
*current_die
;
4437 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4439 name
= namespace_name (die
, &is_anonymous
, cu
);
4441 /* Now build the name of the current namespace. */
4443 if (previous_prefix
[0] == '\0')
4445 processing_current_prefix
= name
;
4449 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4450 make_cleanup (xfree
, temp_name
);
4451 processing_current_prefix
= temp_name
;
4454 /* Add a symbol associated to this if we haven't seen the namespace
4455 before. Also, add a using directive if it's an anonymous
4458 if (dwarf2_extension (die
, cu
) == NULL
)
4462 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4463 this cast will hopefully become unnecessary. */
4464 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4465 (char *) processing_current_prefix
,
4467 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4469 new_symbol (die
, type
, cu
);
4470 set_die_type (die
, type
, cu
);
4473 cp_add_using_directive (processing_current_prefix
,
4474 strlen (previous_prefix
),
4475 strlen (processing_current_prefix
));
4478 if (die
->child
!= NULL
)
4480 struct die_info
*child_die
= die
->child
;
4482 while (child_die
&& child_die
->tag
)
4484 process_die (child_die
, cu
);
4485 child_die
= sibling_die (child_die
);
4489 processing_current_prefix
= previous_prefix
;
4490 do_cleanups (back_to
);
4493 /* Return the name of the namespace represented by DIE. Set
4494 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4498 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4500 struct die_info
*current_die
;
4501 const char *name
= NULL
;
4503 /* Loop through the extensions until we find a name. */
4505 for (current_die
= die
;
4506 current_die
!= NULL
;
4507 current_die
= dwarf2_extension (die
, cu
))
4509 name
= dwarf2_name (current_die
, cu
);
4514 /* Is it an anonymous namespace? */
4516 *is_anonymous
= (name
== NULL
);
4518 name
= "(anonymous namespace)";
4523 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4524 the user defined type vector. */
4527 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4529 struct comp_unit_head
*cu_header
= &cu
->header
;
4531 struct attribute
*attr_byte_size
;
4532 struct attribute
*attr_address_class
;
4533 int byte_size
, addr_class
;
4540 type
= lookup_pointer_type (die_type (die
, cu
));
4542 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4544 byte_size
= DW_UNSND (attr_byte_size
);
4546 byte_size
= cu_header
->addr_size
;
4548 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4549 if (attr_address_class
)
4550 addr_class
= DW_UNSND (attr_address_class
);
4552 addr_class
= DW_ADDR_none
;
4554 /* If the pointer size or address class is different than the
4555 default, create a type variant marked as such and set the
4556 length accordingly. */
4557 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4559 if (gdbarch_address_class_type_flags_p (current_gdbarch
))
4563 type_flags
= gdbarch_address_class_type_flags
4564 (current_gdbarch
, byte_size
, addr_class
);
4565 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4566 type
= make_type_with_address_space (type
, type_flags
);
4568 else if (TYPE_LENGTH (type
) != byte_size
)
4570 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4573 /* Should we also complain about unhandled address classes? */
4577 TYPE_LENGTH (type
) = byte_size
;
4578 set_die_type (die
, type
, cu
);
4581 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4582 the user defined type vector. */
4585 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4587 struct objfile
*objfile
= cu
->objfile
;
4589 struct type
*to_type
;
4590 struct type
*domain
;
4597 to_type
= die_type (die
, cu
);
4598 domain
= die_containing_type (die
, cu
);
4600 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
4601 type
= lookup_methodptr_type (to_type
);
4603 type
= lookup_memberptr_type (to_type
, domain
);
4605 set_die_type (die
, type
, cu
);
4608 /* Extract all information from a DW_TAG_reference_type DIE and add to
4609 the user defined type vector. */
4612 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4614 struct comp_unit_head
*cu_header
= &cu
->header
;
4616 struct attribute
*attr
;
4623 type
= lookup_reference_type (die_type (die
, cu
));
4624 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4627 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4631 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4633 set_die_type (die
, type
, cu
);
4637 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4639 struct type
*base_type
;
4646 base_type
= die_type (die
, cu
);
4647 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4652 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4654 struct type
*base_type
;
4661 base_type
= die_type (die
, cu
);
4662 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4666 /* Extract all information from a DW_TAG_string_type DIE and add to
4667 the user defined type vector. It isn't really a user defined type,
4668 but it behaves like one, with other DIE's using an AT_user_def_type
4669 attribute to reference it. */
4672 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4674 struct objfile
*objfile
= cu
->objfile
;
4675 struct type
*type
, *range_type
, *index_type
, *char_type
;
4676 struct attribute
*attr
;
4677 unsigned int length
;
4684 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4687 length
= DW_UNSND (attr
);
4691 /* check for the DW_AT_byte_size attribute */
4692 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4695 length
= DW_UNSND (attr
);
4703 index_type
= builtin_type_int32
;
4704 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4705 type
= create_string_type (NULL
, range_type
);
4707 set_die_type (die
, type
, cu
);
4710 /* Handle DIES due to C code like:
4714 int (*funcp)(int a, long l);
4718 ('funcp' generates a DW_TAG_subroutine_type DIE)
4722 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4724 struct type
*type
; /* Type that this function returns */
4725 struct type
*ftype
; /* Function that returns above type */
4726 struct attribute
*attr
;
4728 /* Decode the type that this subroutine returns */
4733 type
= die_type (die
, cu
);
4734 ftype
= make_function_type (type
, (struct type
**) 0);
4736 /* All functions in C++, Pascal and Java have prototypes. */
4737 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4738 if ((attr
&& (DW_UNSND (attr
) != 0))
4739 || cu
->language
== language_cplus
4740 || cu
->language
== language_java
4741 || cu
->language
== language_pascal
)
4742 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4744 if (die
->child
!= NULL
)
4746 struct die_info
*child_die
;
4750 /* Count the number of parameters.
4751 FIXME: GDB currently ignores vararg functions, but knows about
4752 vararg member functions. */
4753 child_die
= die
->child
;
4754 while (child_die
&& child_die
->tag
)
4756 if (child_die
->tag
== DW_TAG_formal_parameter
)
4758 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4759 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4760 child_die
= sibling_die (child_die
);
4763 /* Allocate storage for parameters and fill them in. */
4764 TYPE_NFIELDS (ftype
) = nparams
;
4765 TYPE_FIELDS (ftype
) = (struct field
*)
4766 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4768 child_die
= die
->child
;
4769 while (child_die
&& child_die
->tag
)
4771 if (child_die
->tag
== DW_TAG_formal_parameter
)
4773 /* Dwarf2 has no clean way to discern C++ static and non-static
4774 member functions. G++ helps GDB by marking the first
4775 parameter for non-static member functions (which is the
4776 this pointer) as artificial. We pass this information
4777 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4778 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4780 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4782 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4783 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4786 child_die
= sibling_die (child_die
);
4790 set_die_type (die
, ftype
, cu
);
4794 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4796 struct objfile
*objfile
= cu
->objfile
;
4797 struct attribute
*attr
;
4802 name
= dwarf2_name (die
, cu
);
4803 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4804 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4806 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4810 /* Find a representation of a given base type and install
4811 it in the TYPE field of the die. */
4814 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4816 struct objfile
*objfile
= cu
->objfile
;
4818 struct attribute
*attr
;
4819 int encoding
= 0, size
= 0;
4821 enum type_code code
= TYPE_CODE_INT
;
4823 struct type
*target_type
= NULL
;
4825 /* If we've already decoded this die, this is a no-op. */
4831 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4834 encoding
= DW_UNSND (attr
);
4836 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4839 size
= DW_UNSND (attr
);
4841 name
= dwarf2_name (die
, cu
);
4844 complaint (&symfile_complaints
,
4845 _("DW_AT_name missing from DW_TAG_base_type"));
4850 case DW_ATE_address
:
4851 /* Turn DW_ATE_address into a void * pointer. */
4852 code
= TYPE_CODE_PTR
;
4853 type_flags
|= TYPE_FLAG_UNSIGNED
;
4854 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
4856 case DW_ATE_boolean
:
4857 code
= TYPE_CODE_BOOL
;
4858 type_flags
|= TYPE_FLAG_UNSIGNED
;
4860 case DW_ATE_complex_float
:
4861 code
= TYPE_CODE_COMPLEX
;
4862 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
4864 case DW_ATE_decimal_float
:
4865 code
= TYPE_CODE_DECFLOAT
;
4868 code
= TYPE_CODE_FLT
;
4872 case DW_ATE_unsigned
:
4873 type_flags
|= TYPE_FLAG_UNSIGNED
;
4875 case DW_ATE_signed_char
:
4876 if (cu
->language
== language_m2
)
4877 code
= TYPE_CODE_CHAR
;
4879 case DW_ATE_unsigned_char
:
4880 if (cu
->language
== language_m2
)
4881 code
= TYPE_CODE_CHAR
;
4882 type_flags
|= TYPE_FLAG_UNSIGNED
;
4885 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4886 dwarf_type_encoding_name (encoding
));
4890 type
= init_type (code
, size
, type_flags
, name
, objfile
);
4891 TYPE_TARGET_TYPE (type
) = target_type
;
4893 set_die_type (die
, type
, cu
);
4896 /* Read the given DW_AT_subrange DIE. */
4899 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4901 struct type
*base_type
;
4902 struct type
*range_type
;
4903 struct attribute
*attr
;
4908 /* If we have already decoded this die, then nothing more to do. */
4912 base_type
= die_type (die
, cu
);
4913 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4915 complaint (&symfile_complaints
,
4916 _("DW_AT_type missing from DW_TAG_subrange_type"));
4918 = init_type (TYPE_CODE_INT
, gdbarch_addr_bit (current_gdbarch
) / 8,
4919 0, NULL
, cu
->objfile
);
4922 if (cu
->language
== language_fortran
)
4924 /* FORTRAN implies a lower bound of 1, if not given. */
4928 /* FIXME: For variable sized arrays either of these could be
4929 a variable rather than a constant value. We'll allow it,
4930 but we don't know how to handle it. */
4931 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4933 low
= dwarf2_get_attr_constant_value (attr
, 0);
4935 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4938 if (attr
->form
== DW_FORM_block1
)
4940 /* GCC encodes arrays with unspecified or dynamic length
4941 with a DW_FORM_block1 attribute.
4942 FIXME: GDB does not yet know how to handle dynamic
4943 arrays properly, treat them as arrays with unspecified
4946 FIXME: jimb/2003-09-22: GDB does not really know
4947 how to handle arrays of unspecified length
4948 either; we just represent them as zero-length
4949 arrays. Choose an appropriate upper bound given
4950 the lower bound we've computed above. */
4954 high
= dwarf2_get_attr_constant_value (attr
, 1);
4957 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4959 name
= dwarf2_name (die
, cu
);
4961 TYPE_NAME (range_type
) = name
;
4963 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4965 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4967 set_die_type (die
, range_type
, cu
);
4971 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4978 /* For now, we only support the C meaning of an unspecified type: void. */
4980 type
= init_type (TYPE_CODE_VOID
, 0, 0, dwarf2_name (die
, cu
),
4983 set_die_type (die
, type
, cu
);
4986 /* Read a whole compilation unit into a linked list of dies. */
4988 static struct die_info
*
4989 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4991 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4994 /* Read a single die and all its descendents. Set the die's sibling
4995 field to NULL; set other fields in the die correctly, and set all
4996 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4997 location of the info_ptr after reading all of those dies. PARENT
4998 is the parent of the die in question. */
5000 static struct die_info
*
5001 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
5002 struct dwarf2_cu
*cu
,
5003 gdb_byte
**new_info_ptr
,
5004 struct die_info
*parent
)
5006 struct die_info
*die
;
5010 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
5011 store_in_ref_table (die
->offset
, die
, cu
);
5015 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
5021 *new_info_ptr
= cur_ptr
;
5024 die
->sibling
= NULL
;
5025 die
->parent
= parent
;
5029 /* Read a die, all of its descendents, and all of its siblings; set
5030 all of the fields of all of the dies correctly. Arguments are as
5031 in read_die_and_children. */
5033 static struct die_info
*
5034 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5035 struct dwarf2_cu
*cu
,
5036 gdb_byte
**new_info_ptr
,
5037 struct die_info
*parent
)
5039 struct die_info
*first_die
, *last_sibling
;
5043 first_die
= last_sibling
= NULL
;
5047 struct die_info
*die
5048 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5056 last_sibling
->sibling
= die
;
5061 *new_info_ptr
= cur_ptr
;
5071 /* Free a linked list of dies. */
5074 free_die_list (struct die_info
*dies
)
5076 struct die_info
*die
, *next
;
5081 if (die
->child
!= NULL
)
5082 free_die_list (die
->child
);
5083 next
= die
->sibling
;
5090 /* Read the contents of the section at OFFSET and of size SIZE from the
5091 object file specified by OBJFILE into the objfile_obstack and return it. */
5094 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
5096 bfd
*abfd
= objfile
->obfd
;
5097 gdb_byte
*buf
, *retbuf
;
5098 bfd_size_type size
= bfd_get_section_size (sectp
);
5103 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5104 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5108 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5109 || bfd_bread (buf
, size
, abfd
) != size
)
5110 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5111 bfd_get_filename (abfd
));
5116 /* In DWARF version 2, the description of the debugging information is
5117 stored in a separate .debug_abbrev section. Before we read any
5118 dies from a section we read in all abbreviations and install them
5119 in a hash table. This function also sets flags in CU describing
5120 the data found in the abbrev table. */
5123 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5125 struct comp_unit_head
*cu_header
= &cu
->header
;
5126 gdb_byte
*abbrev_ptr
;
5127 struct abbrev_info
*cur_abbrev
;
5128 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5129 unsigned int abbrev_form
, hash_number
;
5130 struct attr_abbrev
*cur_attrs
;
5131 unsigned int allocated_attrs
;
5133 /* Initialize dwarf2 abbrevs */
5134 obstack_init (&cu
->abbrev_obstack
);
5135 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5137 * sizeof (struct abbrev_info
*)));
5138 memset (cu
->dwarf2_abbrevs
, 0,
5139 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5141 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5142 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5143 abbrev_ptr
+= bytes_read
;
5145 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5146 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5148 /* loop until we reach an abbrev number of 0 */
5149 while (abbrev_number
)
5151 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5153 /* read in abbrev header */
5154 cur_abbrev
->number
= abbrev_number
;
5155 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5156 abbrev_ptr
+= bytes_read
;
5157 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5160 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5161 cu
->has_namespace_info
= 1;
5163 /* now read in declarations */
5164 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5165 abbrev_ptr
+= bytes_read
;
5166 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5167 abbrev_ptr
+= bytes_read
;
5170 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5172 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5174 = xrealloc (cur_attrs
, (allocated_attrs
5175 * sizeof (struct attr_abbrev
)));
5178 /* Record whether this compilation unit might have
5179 inter-compilation-unit references. If we don't know what form
5180 this attribute will have, then it might potentially be a
5181 DW_FORM_ref_addr, so we conservatively expect inter-CU
5184 if (abbrev_form
== DW_FORM_ref_addr
5185 || abbrev_form
== DW_FORM_indirect
)
5186 cu
->has_form_ref_addr
= 1;
5188 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5189 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5190 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5191 abbrev_ptr
+= bytes_read
;
5192 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5193 abbrev_ptr
+= bytes_read
;
5196 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5197 (cur_abbrev
->num_attrs
5198 * sizeof (struct attr_abbrev
)));
5199 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5200 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5202 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5203 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5204 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5206 /* Get next abbreviation.
5207 Under Irix6 the abbreviations for a compilation unit are not
5208 always properly terminated with an abbrev number of 0.
5209 Exit loop if we encounter an abbreviation which we have
5210 already read (which means we are about to read the abbreviations
5211 for the next compile unit) or if the end of the abbreviation
5212 table is reached. */
5213 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5214 >= dwarf2_per_objfile
->abbrev_size
)
5216 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5217 abbrev_ptr
+= bytes_read
;
5218 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5225 /* Release the memory used by the abbrev table for a compilation unit. */
5228 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5230 struct dwarf2_cu
*cu
= ptr_to_cu
;
5232 obstack_free (&cu
->abbrev_obstack
, NULL
);
5233 cu
->dwarf2_abbrevs
= NULL
;
5236 /* Lookup an abbrev_info structure in the abbrev hash table. */
5238 static struct abbrev_info
*
5239 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5241 unsigned int hash_number
;
5242 struct abbrev_info
*abbrev
;
5244 hash_number
= number
% ABBREV_HASH_SIZE
;
5245 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5249 if (abbrev
->number
== number
)
5252 abbrev
= abbrev
->next
;
5257 /* Returns nonzero if TAG represents a type that we might generate a partial
5261 is_type_tag_for_partial (int tag
)
5266 /* Some types that would be reasonable to generate partial symbols for,
5267 that we don't at present. */
5268 case DW_TAG_array_type
:
5269 case DW_TAG_file_type
:
5270 case DW_TAG_ptr_to_member_type
:
5271 case DW_TAG_set_type
:
5272 case DW_TAG_string_type
:
5273 case DW_TAG_subroutine_type
:
5275 case DW_TAG_base_type
:
5276 case DW_TAG_class_type
:
5277 case DW_TAG_enumeration_type
:
5278 case DW_TAG_structure_type
:
5279 case DW_TAG_subrange_type
:
5280 case DW_TAG_typedef
:
5281 case DW_TAG_union_type
:
5288 /* Load all DIEs that are interesting for partial symbols into memory. */
5290 static struct partial_die_info
*
5291 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5292 struct dwarf2_cu
*cu
)
5294 struct partial_die_info
*part_die
;
5295 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5296 struct abbrev_info
*abbrev
;
5297 unsigned int bytes_read
;
5298 unsigned int load_all
= 0;
5300 int nesting_level
= 1;
5305 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5309 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5313 &cu
->comp_unit_obstack
,
5314 hashtab_obstack_allocate
,
5315 dummy_obstack_deallocate
);
5317 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5318 sizeof (struct partial_die_info
));
5322 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5324 /* A NULL abbrev means the end of a series of children. */
5327 if (--nesting_level
== 0)
5329 /* PART_DIE was probably the last thing allocated on the
5330 comp_unit_obstack, so we could call obstack_free
5331 here. We don't do that because the waste is small,
5332 and will be cleaned up when we're done with this
5333 compilation unit. This way, we're also more robust
5334 against other users of the comp_unit_obstack. */
5337 info_ptr
+= bytes_read
;
5338 last_die
= parent_die
;
5339 parent_die
= parent_die
->die_parent
;
5343 /* Check whether this DIE is interesting enough to save. Normally
5344 we would not be interested in members here, but there may be
5345 later variables referencing them via DW_AT_specification (for
5348 && !is_type_tag_for_partial (abbrev
->tag
)
5349 && abbrev
->tag
!= DW_TAG_enumerator
5350 && abbrev
->tag
!= DW_TAG_subprogram
5351 && abbrev
->tag
!= DW_TAG_variable
5352 && abbrev
->tag
!= DW_TAG_namespace
5353 && abbrev
->tag
!= DW_TAG_member
)
5355 /* Otherwise we skip to the next sibling, if any. */
5356 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5360 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5361 abfd
, info_ptr
, cu
);
5363 /* This two-pass algorithm for processing partial symbols has a
5364 high cost in cache pressure. Thus, handle some simple cases
5365 here which cover the majority of C partial symbols. DIEs
5366 which neither have specification tags in them, nor could have
5367 specification tags elsewhere pointing at them, can simply be
5368 processed and discarded.
5370 This segment is also optional; scan_partial_symbols and
5371 add_partial_symbol will handle these DIEs if we chain
5372 them in normally. When compilers which do not emit large
5373 quantities of duplicate debug information are more common,
5374 this code can probably be removed. */
5376 /* Any complete simple types at the top level (pretty much all
5377 of them, for a language without namespaces), can be processed
5379 if (parent_die
== NULL
5380 && part_die
->has_specification
== 0
5381 && part_die
->is_declaration
== 0
5382 && (part_die
->tag
== DW_TAG_typedef
5383 || part_die
->tag
== DW_TAG_base_type
5384 || part_die
->tag
== DW_TAG_subrange_type
))
5386 if (building_psymtab
&& part_die
->name
!= NULL
)
5387 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5388 VAR_DOMAIN
, LOC_TYPEDEF
,
5389 &cu
->objfile
->static_psymbols
,
5390 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5391 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5395 /* If we're at the second level, and we're an enumerator, and
5396 our parent has no specification (meaning possibly lives in a
5397 namespace elsewhere), then we can add the partial symbol now
5398 instead of queueing it. */
5399 if (part_die
->tag
== DW_TAG_enumerator
5400 && parent_die
!= NULL
5401 && parent_die
->die_parent
== NULL
5402 && parent_die
->tag
== DW_TAG_enumeration_type
5403 && parent_die
->has_specification
== 0)
5405 if (part_die
->name
== NULL
)
5406 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5407 else if (building_psymtab
)
5408 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5409 VAR_DOMAIN
, LOC_CONST
,
5410 (cu
->language
== language_cplus
5411 || cu
->language
== language_java
)
5412 ? &cu
->objfile
->global_psymbols
5413 : &cu
->objfile
->static_psymbols
,
5414 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5416 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5420 /* We'll save this DIE so link it in. */
5421 part_die
->die_parent
= parent_die
;
5422 part_die
->die_sibling
= NULL
;
5423 part_die
->die_child
= NULL
;
5425 if (last_die
&& last_die
== parent_die
)
5426 last_die
->die_child
= part_die
;
5428 last_die
->die_sibling
= part_die
;
5430 last_die
= part_die
;
5432 if (first_die
== NULL
)
5433 first_die
= part_die
;
5435 /* Maybe add the DIE to the hash table. Not all DIEs that we
5436 find interesting need to be in the hash table, because we
5437 also have the parent/sibling/child chains; only those that we
5438 might refer to by offset later during partial symbol reading.
5440 For now this means things that might have be the target of a
5441 DW_AT_specification, DW_AT_abstract_origin, or
5442 DW_AT_extension. DW_AT_extension will refer only to
5443 namespaces; DW_AT_abstract_origin refers to functions (and
5444 many things under the function DIE, but we do not recurse
5445 into function DIEs during partial symbol reading) and
5446 possibly variables as well; DW_AT_specification refers to
5447 declarations. Declarations ought to have the DW_AT_declaration
5448 flag. It happens that GCC forgets to put it in sometimes, but
5449 only for functions, not for types.
5451 Adding more things than necessary to the hash table is harmless
5452 except for the performance cost. Adding too few will result in
5453 wasted time in find_partial_die, when we reread the compilation
5454 unit with load_all_dies set. */
5457 || abbrev
->tag
== DW_TAG_subprogram
5458 || abbrev
->tag
== DW_TAG_variable
5459 || abbrev
->tag
== DW_TAG_namespace
5460 || part_die
->is_declaration
)
5464 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5465 part_die
->offset
, INSERT
);
5469 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5470 sizeof (struct partial_die_info
));
5472 /* For some DIEs we want to follow their children (if any). For C
5473 we have no reason to follow the children of structures; for other
5474 languages we have to, both so that we can get at method physnames
5475 to infer fully qualified class names, and for DW_AT_specification. */
5476 if (last_die
->has_children
5478 || last_die
->tag
== DW_TAG_namespace
5479 || last_die
->tag
== DW_TAG_enumeration_type
5480 || (cu
->language
!= language_c
5481 && (last_die
->tag
== DW_TAG_class_type
5482 || last_die
->tag
== DW_TAG_structure_type
5483 || last_die
->tag
== DW_TAG_union_type
))))
5486 parent_die
= last_die
;
5490 /* Otherwise we skip to the next sibling, if any. */
5491 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5493 /* Back to the top, do it again. */
5497 /* Read a minimal amount of information into the minimal die structure. */
5500 read_partial_die (struct partial_die_info
*part_die
,
5501 struct abbrev_info
*abbrev
,
5502 unsigned int abbrev_len
, bfd
*abfd
,
5503 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5505 unsigned int bytes_read
, i
;
5506 struct attribute attr
;
5507 int has_low_pc_attr
= 0;
5508 int has_high_pc_attr
= 0;
5510 memset (part_die
, 0, sizeof (struct partial_die_info
));
5512 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5514 info_ptr
+= abbrev_len
;
5519 part_die
->tag
= abbrev
->tag
;
5520 part_die
->has_children
= abbrev
->has_children
;
5522 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5524 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5526 /* Store the data if it is of an attribute we want to keep in a
5527 partial symbol table. */
5532 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5533 if (part_die
->name
== NULL
)
5534 part_die
->name
= DW_STRING (&attr
);
5536 case DW_AT_comp_dir
:
5537 if (part_die
->dirname
== NULL
)
5538 part_die
->dirname
= DW_STRING (&attr
);
5540 case DW_AT_MIPS_linkage_name
:
5541 part_die
->name
= DW_STRING (&attr
);
5544 has_low_pc_attr
= 1;
5545 part_die
->lowpc
= DW_ADDR (&attr
);
5548 has_high_pc_attr
= 1;
5549 part_die
->highpc
= DW_ADDR (&attr
);
5552 if (dwarf2_ranges_read (DW_UNSND (&attr
), &part_die
->lowpc
,
5553 &part_die
->highpc
, cu
))
5554 has_low_pc_attr
= has_high_pc_attr
= 1;
5556 case DW_AT_location
:
5557 /* Support the .debug_loc offsets */
5558 if (attr_form_is_block (&attr
))
5560 part_die
->locdesc
= DW_BLOCK (&attr
);
5562 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5564 dwarf2_complex_location_expr_complaint ();
5568 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5569 "partial symbol information");
5572 case DW_AT_language
:
5573 part_die
->language
= DW_UNSND (&attr
);
5575 case DW_AT_external
:
5576 part_die
->is_external
= DW_UNSND (&attr
);
5578 case DW_AT_declaration
:
5579 part_die
->is_declaration
= DW_UNSND (&attr
);
5582 part_die
->has_type
= 1;
5584 case DW_AT_abstract_origin
:
5585 case DW_AT_specification
:
5586 case DW_AT_extension
:
5587 part_die
->has_specification
= 1;
5588 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5591 /* Ignore absolute siblings, they might point outside of
5592 the current compile unit. */
5593 if (attr
.form
== DW_FORM_ref_addr
)
5594 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5596 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5597 + dwarf2_get_ref_die_offset (&attr
, cu
);
5599 case DW_AT_stmt_list
:
5600 part_die
->has_stmt_list
= 1;
5601 part_die
->line_offset
= DW_UNSND (&attr
);
5603 case DW_AT_byte_size
:
5604 part_die
->has_byte_size
= 1;
5606 case DW_AT_calling_convention
:
5607 /* DWARF doesn't provide a way to identify a program's source-level
5608 entry point. DW_AT_calling_convention attributes are only meant
5609 to describe functions' calling conventions.
5611 However, because it's a necessary piece of information in
5612 Fortran, and because DW_CC_program is the only piece of debugging
5613 information whose definition refers to a 'main program' at all,
5614 several compilers have begun marking Fortran main programs with
5615 DW_CC_program --- even when those functions use the standard
5616 calling conventions.
5618 So until DWARF specifies a way to provide this information and
5619 compilers pick up the new representation, we'll support this
5621 if (DW_UNSND (&attr
) == DW_CC_program
5622 && cu
->language
== language_fortran
)
5623 set_main_name (part_die
->name
);
5630 /* When using the GNU linker, .gnu.linkonce. sections are used to
5631 eliminate duplicate copies of functions and vtables and such.
5632 The linker will arbitrarily choose one and discard the others.
5633 The AT_*_pc values for such functions refer to local labels in
5634 these sections. If the section from that file was discarded, the
5635 labels are not in the output, so the relocs get a value of 0.
5636 If this is a discarded function, mark the pc bounds as invalid,
5637 so that GDB will ignore it. */
5638 if (has_low_pc_attr
&& has_high_pc_attr
5639 && part_die
->lowpc
< part_die
->highpc
5640 && (part_die
->lowpc
!= 0
5641 || dwarf2_per_objfile
->has_section_at_zero
))
5642 part_die
->has_pc_info
= 1;
5646 /* Find a cached partial DIE at OFFSET in CU. */
5648 static struct partial_die_info
*
5649 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5651 struct partial_die_info
*lookup_die
= NULL
;
5652 struct partial_die_info part_die
;
5654 part_die
.offset
= offset
;
5655 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5660 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5662 static struct partial_die_info
*
5663 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5665 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5666 struct partial_die_info
*pd
= NULL
;
5668 if (offset
>= cu
->header
.offset
5669 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5671 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5676 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5678 if (per_cu
->cu
== NULL
)
5680 load_comp_unit (per_cu
, cu
->objfile
);
5681 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5682 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5685 per_cu
->cu
->last_used
= 0;
5686 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5688 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5690 struct cleanup
*back_to
;
5691 struct partial_die_info comp_unit_die
;
5692 struct abbrev_info
*abbrev
;
5693 unsigned int bytes_read
;
5696 per_cu
->load_all_dies
= 1;
5698 /* Re-read the DIEs. */
5699 back_to
= make_cleanup (null_cleanup
, 0);
5700 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5702 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5703 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5705 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5706 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5707 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5708 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5710 if (comp_unit_die
.has_children
)
5711 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5712 do_cleanups (back_to
);
5714 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5718 internal_error (__FILE__
, __LINE__
,
5719 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5720 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5724 /* Adjust PART_DIE before generating a symbol for it. This function
5725 may set the is_external flag or change the DIE's name. */
5728 fixup_partial_die (struct partial_die_info
*part_die
,
5729 struct dwarf2_cu
*cu
)
5731 /* If we found a reference attribute and the DIE has no name, try
5732 to find a name in the referred to DIE. */
5734 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5736 struct partial_die_info
*spec_die
;
5738 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5740 fixup_partial_die (spec_die
, cu
);
5744 part_die
->name
= spec_die
->name
;
5746 /* Copy DW_AT_external attribute if it is set. */
5747 if (spec_die
->is_external
)
5748 part_die
->is_external
= spec_die
->is_external
;
5752 /* Set default names for some unnamed DIEs. */
5753 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5754 || part_die
->tag
== DW_TAG_class_type
))
5755 part_die
->name
= "(anonymous class)";
5757 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5758 part_die
->name
= "(anonymous namespace)";
5760 if (part_die
->tag
== DW_TAG_structure_type
5761 || part_die
->tag
== DW_TAG_class_type
5762 || part_die
->tag
== DW_TAG_union_type
)
5763 guess_structure_name (part_die
, cu
);
5766 /* Read the die from the .debug_info section buffer. Set DIEP to
5767 point to a newly allocated die with its information, except for its
5768 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5769 whether the die has children or not. */
5772 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5773 struct dwarf2_cu
*cu
, int *has_children
)
5775 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5776 struct abbrev_info
*abbrev
;
5777 struct die_info
*die
;
5779 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5780 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5781 info_ptr
+= bytes_read
;
5784 die
= dwarf_alloc_die ();
5786 die
->abbrev
= abbrev_number
;
5793 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5796 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5798 bfd_get_filename (abfd
));
5800 die
= dwarf_alloc_die ();
5801 die
->offset
= offset
;
5802 die
->tag
= abbrev
->tag
;
5803 die
->abbrev
= abbrev_number
;
5806 die
->num_attrs
= abbrev
->num_attrs
;
5807 die
->attrs
= (struct attribute
*)
5808 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5810 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5812 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5813 abfd
, info_ptr
, cu
);
5815 /* If this attribute is an absolute reference to a different
5816 compilation unit, make sure that compilation unit is loaded
5818 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5819 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5820 || (DW_ADDR (&die
->attrs
[i
])
5821 >= cu
->header
.offset
+ cu
->header
.length
)))
5823 struct dwarf2_per_cu_data
*per_cu
;
5824 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5827 /* Mark the dependence relation so that we don't flush PER_CU
5829 dwarf2_add_dependence (cu
, per_cu
);
5831 /* If it's already on the queue, we have nothing to do. */
5835 /* If the compilation unit is already loaded, just mark it as
5837 if (per_cu
->cu
!= NULL
)
5839 per_cu
->cu
->last_used
= 0;
5843 /* Add it to the queue. */
5844 queue_comp_unit (per_cu
);
5849 *has_children
= abbrev
->has_children
;
5853 /* Read an attribute value described by an attribute form. */
5856 read_attribute_value (struct attribute
*attr
, unsigned form
,
5857 bfd
*abfd
, gdb_byte
*info_ptr
,
5858 struct dwarf2_cu
*cu
)
5860 struct comp_unit_head
*cu_header
= &cu
->header
;
5861 unsigned int bytes_read
;
5862 struct dwarf_block
*blk
;
5868 case DW_FORM_ref_addr
:
5869 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5870 info_ptr
+= bytes_read
;
5872 case DW_FORM_block2
:
5873 blk
= dwarf_alloc_block (cu
);
5874 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5876 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5877 info_ptr
+= blk
->size
;
5878 DW_BLOCK (attr
) = blk
;
5880 case DW_FORM_block4
:
5881 blk
= dwarf_alloc_block (cu
);
5882 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5884 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5885 info_ptr
+= blk
->size
;
5886 DW_BLOCK (attr
) = blk
;
5889 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5893 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5897 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5900 case DW_FORM_string
:
5901 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5902 info_ptr
+= bytes_read
;
5905 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5907 info_ptr
+= bytes_read
;
5910 blk
= dwarf_alloc_block (cu
);
5911 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5912 info_ptr
+= bytes_read
;
5913 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5914 info_ptr
+= blk
->size
;
5915 DW_BLOCK (attr
) = blk
;
5917 case DW_FORM_block1
:
5918 blk
= dwarf_alloc_block (cu
);
5919 blk
->size
= read_1_byte (abfd
, info_ptr
);
5921 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5922 info_ptr
+= blk
->size
;
5923 DW_BLOCK (attr
) = blk
;
5926 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5930 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5934 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5935 info_ptr
+= bytes_read
;
5938 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5939 info_ptr
+= bytes_read
;
5942 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5946 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5950 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5954 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5957 case DW_FORM_ref_udata
:
5958 DW_ADDR (attr
) = (cu
->header
.offset
5959 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5960 info_ptr
+= bytes_read
;
5962 case DW_FORM_indirect
:
5963 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5964 info_ptr
+= bytes_read
;
5965 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5968 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5969 dwarf_form_name (form
),
5970 bfd_get_filename (abfd
));
5975 /* Read an attribute described by an abbreviated attribute. */
5978 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5979 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5981 attr
->name
= abbrev
->name
;
5982 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5985 /* read dwarf information from a buffer */
5988 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5990 return bfd_get_8 (abfd
, buf
);
5994 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5996 return bfd_get_signed_8 (abfd
, buf
);
6000 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
6002 return bfd_get_16 (abfd
, buf
);
6006 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6008 return bfd_get_signed_16 (abfd
, buf
);
6012 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
6014 return bfd_get_32 (abfd
, buf
);
6018 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6020 return bfd_get_signed_32 (abfd
, buf
);
6023 static unsigned long
6024 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
6026 return bfd_get_64 (abfd
, buf
);
6030 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
6031 unsigned int *bytes_read
)
6033 struct comp_unit_head
*cu_header
= &cu
->header
;
6034 CORE_ADDR retval
= 0;
6036 if (cu_header
->signed_addr_p
)
6038 switch (cu_header
->addr_size
)
6041 retval
= bfd_get_signed_16 (abfd
, buf
);
6044 retval
= bfd_get_signed_32 (abfd
, buf
);
6047 retval
= bfd_get_signed_64 (abfd
, buf
);
6050 internal_error (__FILE__
, __LINE__
,
6051 _("read_address: bad switch, signed [in module %s]"),
6052 bfd_get_filename (abfd
));
6057 switch (cu_header
->addr_size
)
6060 retval
= bfd_get_16 (abfd
, buf
);
6063 retval
= bfd_get_32 (abfd
, buf
);
6066 retval
= bfd_get_64 (abfd
, buf
);
6069 internal_error (__FILE__
, __LINE__
,
6070 _("read_address: bad switch, unsigned [in module %s]"),
6071 bfd_get_filename (abfd
));
6075 *bytes_read
= cu_header
->addr_size
;
6079 /* Read the initial length from a section. The (draft) DWARF 3
6080 specification allows the initial length to take up either 4 bytes
6081 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6082 bytes describe the length and all offsets will be 8 bytes in length
6085 An older, non-standard 64-bit format is also handled by this
6086 function. The older format in question stores the initial length
6087 as an 8-byte quantity without an escape value. Lengths greater
6088 than 2^32 aren't very common which means that the initial 4 bytes
6089 is almost always zero. Since a length value of zero doesn't make
6090 sense for the 32-bit format, this initial zero can be considered to
6091 be an escape value which indicates the presence of the older 64-bit
6092 format. As written, the code can't detect (old format) lengths
6093 greater than 4GB. If it becomes necessary to handle lengths
6094 somewhat larger than 4GB, we could allow other small values (such
6095 as the non-sensical values of 1, 2, and 3) to also be used as
6096 escape values indicating the presence of the old format.
6098 The value returned via bytes_read should be used to increment the
6099 relevant pointer after calling read_initial_length().
6101 As a side effect, this function sets the fields initial_length_size
6102 and offset_size in cu_header to the values appropriate for the
6103 length field. (The format of the initial length field determines
6104 the width of file offsets to be fetched later with read_offset().)
6106 [ Note: read_initial_length() and read_offset() are based on the
6107 document entitled "DWARF Debugging Information Format", revision
6108 3, draft 8, dated November 19, 2001. This document was obtained
6111 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6113 This document is only a draft and is subject to change. (So beware.)
6115 Details regarding the older, non-standard 64-bit format were
6116 determined empirically by examining 64-bit ELF files produced by
6117 the SGI toolchain on an IRIX 6.5 machine.
6119 - Kevin, July 16, 2002
6123 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
6124 unsigned int *bytes_read
)
6126 LONGEST length
= bfd_get_32 (abfd
, buf
);
6128 if (length
== 0xffffffff)
6130 length
= bfd_get_64 (abfd
, buf
+ 4);
6133 else if (length
== 0)
6135 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6136 length
= bfd_get_64 (abfd
, buf
);
6146 gdb_assert (cu_header
->initial_length_size
== 0
6147 || cu_header
->initial_length_size
== 4
6148 || cu_header
->initial_length_size
== 8
6149 || cu_header
->initial_length_size
== 12);
6151 if (cu_header
->initial_length_size
!= 0
6152 && cu_header
->initial_length_size
!= *bytes_read
)
6153 complaint (&symfile_complaints
,
6154 _("intermixed 32-bit and 64-bit DWARF sections"));
6156 cu_header
->initial_length_size
= *bytes_read
;
6157 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6163 /* Read an offset from the data stream. The size of the offset is
6164 given by cu_header->offset_size. */
6167 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6168 unsigned int *bytes_read
)
6172 switch (cu_header
->offset_size
)
6175 retval
= bfd_get_32 (abfd
, buf
);
6179 retval
= bfd_get_64 (abfd
, buf
);
6183 internal_error (__FILE__
, __LINE__
,
6184 _("read_offset: bad switch [in module %s]"),
6185 bfd_get_filename (abfd
));
6192 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6194 /* If the size of a host char is 8 bits, we can return a pointer
6195 to the buffer, otherwise we have to copy the data to a buffer
6196 allocated on the temporary obstack. */
6197 gdb_assert (HOST_CHAR_BIT
== 8);
6202 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6204 /* If the size of a host char is 8 bits, we can return a pointer
6205 to the string, otherwise we have to copy the string to a buffer
6206 allocated on the temporary obstack. */
6207 gdb_assert (HOST_CHAR_BIT
== 8);
6210 *bytes_read_ptr
= 1;
6213 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6214 return (char *) buf
;
6218 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6219 const struct comp_unit_head
*cu_header
,
6220 unsigned int *bytes_read_ptr
)
6222 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6225 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6227 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6228 bfd_get_filename (abfd
));
6231 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6233 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6234 bfd_get_filename (abfd
));
6237 gdb_assert (HOST_CHAR_BIT
== 8);
6238 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6240 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6243 static unsigned long
6244 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6246 unsigned long result
;
6247 unsigned int num_read
;
6257 byte
= bfd_get_8 (abfd
, buf
);
6260 result
|= ((unsigned long)(byte
& 127) << shift
);
6261 if ((byte
& 128) == 0)
6267 *bytes_read_ptr
= num_read
;
6272 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6275 int i
, shift
, num_read
;
6284 byte
= bfd_get_8 (abfd
, buf
);
6287 result
|= ((long)(byte
& 127) << shift
);
6289 if ((byte
& 128) == 0)
6294 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6295 result
|= -(((long)1) << shift
);
6296 *bytes_read_ptr
= num_read
;
6300 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6303 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6309 byte
= bfd_get_8 (abfd
, buf
);
6311 if ((byte
& 128) == 0)
6317 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6323 cu
->language
= language_c
;
6325 case DW_LANG_C_plus_plus
:
6326 cu
->language
= language_cplus
;
6328 case DW_LANG_Fortran77
:
6329 case DW_LANG_Fortran90
:
6330 case DW_LANG_Fortran95
:
6331 cu
->language
= language_fortran
;
6333 case DW_LANG_Mips_Assembler
:
6334 cu
->language
= language_asm
;
6337 cu
->language
= language_java
;
6341 cu
->language
= language_ada
;
6343 case DW_LANG_Modula2
:
6344 cu
->language
= language_m2
;
6346 case DW_LANG_Pascal83
:
6347 cu
->language
= language_pascal
;
6349 case DW_LANG_Cobol74
:
6350 case DW_LANG_Cobol85
:
6352 cu
->language
= language_minimal
;
6355 cu
->language_defn
= language_def (cu
->language
);
6358 /* Return the named attribute or NULL if not there. */
6360 static struct attribute
*
6361 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6364 struct attribute
*spec
= NULL
;
6366 for (i
= 0; i
< die
->num_attrs
; ++i
)
6368 if (die
->attrs
[i
].name
== name
)
6369 return &die
->attrs
[i
];
6370 if (die
->attrs
[i
].name
== DW_AT_specification
6371 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6372 spec
= &die
->attrs
[i
];
6376 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6381 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6382 and holds a non-zero value. This function should only be used for
6383 DW_FORM_flag attributes. */
6386 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6388 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6390 return (attr
&& DW_UNSND (attr
));
6394 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6396 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6397 which value is non-zero. However, we have to be careful with
6398 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6399 (via dwarf2_flag_true_p) follows this attribute. So we may
6400 end up accidently finding a declaration attribute that belongs
6401 to a different DIE referenced by the specification attribute,
6402 even though the given DIE does not have a declaration attribute. */
6403 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6404 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6407 /* Return the die giving the specification for DIE, if there is
6410 static struct die_info
*
6411 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6413 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6415 if (spec_attr
== NULL
)
6418 return follow_die_ref (die
, spec_attr
, cu
);
6421 /* Free the line_header structure *LH, and any arrays and strings it
6424 free_line_header (struct line_header
*lh
)
6426 if (lh
->standard_opcode_lengths
)
6427 xfree (lh
->standard_opcode_lengths
);
6429 /* Remember that all the lh->file_names[i].name pointers are
6430 pointers into debug_line_buffer, and don't need to be freed. */
6432 xfree (lh
->file_names
);
6434 /* Similarly for the include directory names. */
6435 if (lh
->include_dirs
)
6436 xfree (lh
->include_dirs
);
6442 /* Add an entry to LH's include directory table. */
6444 add_include_dir (struct line_header
*lh
, char *include_dir
)
6446 /* Grow the array if necessary. */
6447 if (lh
->include_dirs_size
== 0)
6449 lh
->include_dirs_size
= 1; /* for testing */
6450 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6451 * sizeof (*lh
->include_dirs
));
6453 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6455 lh
->include_dirs_size
*= 2;
6456 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6457 (lh
->include_dirs_size
6458 * sizeof (*lh
->include_dirs
)));
6461 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6465 /* Add an entry to LH's file name table. */
6467 add_file_name (struct line_header
*lh
,
6469 unsigned int dir_index
,
6470 unsigned int mod_time
,
6471 unsigned int length
)
6473 struct file_entry
*fe
;
6475 /* Grow the array if necessary. */
6476 if (lh
->file_names_size
== 0)
6478 lh
->file_names_size
= 1; /* for testing */
6479 lh
->file_names
= xmalloc (lh
->file_names_size
6480 * sizeof (*lh
->file_names
));
6482 else if (lh
->num_file_names
>= lh
->file_names_size
)
6484 lh
->file_names_size
*= 2;
6485 lh
->file_names
= xrealloc (lh
->file_names
,
6486 (lh
->file_names_size
6487 * sizeof (*lh
->file_names
)));
6490 fe
= &lh
->file_names
[lh
->num_file_names
++];
6492 fe
->dir_index
= dir_index
;
6493 fe
->mod_time
= mod_time
;
6494 fe
->length
= length
;
6500 /* Read the statement program header starting at OFFSET in
6501 .debug_line, according to the endianness of ABFD. Return a pointer
6502 to a struct line_header, allocated using xmalloc.
6504 NOTE: the strings in the include directory and file name tables of
6505 the returned object point into debug_line_buffer, and must not be
6507 static struct line_header
*
6508 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6509 struct dwarf2_cu
*cu
)
6511 struct cleanup
*back_to
;
6512 struct line_header
*lh
;
6514 unsigned int bytes_read
;
6516 char *cur_dir
, *cur_file
;
6518 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6520 complaint (&symfile_complaints
, _("missing .debug_line section"));
6524 /* Make sure that at least there's room for the total_length field.
6525 That could be 12 bytes long, but we're just going to fudge that. */
6526 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6528 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6532 lh
= xmalloc (sizeof (*lh
));
6533 memset (lh
, 0, sizeof (*lh
));
6534 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6537 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6539 /* Read in the header. */
6541 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6542 line_ptr
+= bytes_read
;
6543 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6544 + dwarf2_per_objfile
->line_size
))
6546 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6549 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6550 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6552 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6553 line_ptr
+= bytes_read
;
6554 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6556 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6558 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6560 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6562 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6564 lh
->standard_opcode_lengths
6565 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6567 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6568 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6570 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6574 /* Read directory table. */
6575 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6577 line_ptr
+= bytes_read
;
6578 add_include_dir (lh
, cur_dir
);
6580 line_ptr
+= bytes_read
;
6582 /* Read file name table. */
6583 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6585 unsigned int dir_index
, mod_time
, length
;
6587 line_ptr
+= bytes_read
;
6588 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6589 line_ptr
+= bytes_read
;
6590 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6591 line_ptr
+= bytes_read
;
6592 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6593 line_ptr
+= bytes_read
;
6595 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6597 line_ptr
+= bytes_read
;
6598 lh
->statement_program_start
= line_ptr
;
6600 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6601 + dwarf2_per_objfile
->line_size
))
6602 complaint (&symfile_complaints
,
6603 _("line number info header doesn't fit in `.debug_line' section"));
6605 discard_cleanups (back_to
);
6609 /* This function exists to work around a bug in certain compilers
6610 (particularly GCC 2.95), in which the first line number marker of a
6611 function does not show up until after the prologue, right before
6612 the second line number marker. This function shifts ADDRESS down
6613 to the beginning of the function if necessary, and is called on
6614 addresses passed to record_line. */
6617 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6619 struct function_range
*fn
;
6621 /* Find the function_range containing address. */
6626 cu
->cached_fn
= cu
->first_fn
;
6630 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6636 while (fn
&& fn
!= cu
->cached_fn
)
6637 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6647 if (address
!= fn
->lowpc
)
6648 complaint (&symfile_complaints
,
6649 _("misplaced first line number at 0x%lx for '%s'"),
6650 (unsigned long) address
, fn
->name
);
6655 /* Decode the Line Number Program (LNP) for the given line_header
6656 structure and CU. The actual information extracted and the type
6657 of structures created from the LNP depends on the value of PST.
6659 1. If PST is NULL, then this procedure uses the data from the program
6660 to create all necessary symbol tables, and their linetables.
6661 The compilation directory of the file is passed in COMP_DIR,
6662 and must not be NULL.
6664 2. If PST is not NULL, this procedure reads the program to determine
6665 the list of files included by the unit represented by PST, and
6666 builds all the associated partial symbol tables. In this case,
6667 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6668 is not used to compute the full name of the symtab, and therefore
6669 omitting it when building the partial symtab does not introduce
6670 the potential for inconsistency - a partial symtab and its associated
6671 symbtab having a different fullname -). */
6674 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6675 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6677 gdb_byte
*line_ptr
, *extended_end
;
6679 unsigned int bytes_read
, extended_len
;
6680 unsigned char op_code
, extended_op
, adj_opcode
;
6682 struct objfile
*objfile
= cu
->objfile
;
6683 const int decode_for_pst_p
= (pst
!= NULL
);
6684 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
6686 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6688 line_ptr
= lh
->statement_program_start
;
6689 line_end
= lh
->statement_program_end
;
6691 /* Read the statement sequences until there's nothing left. */
6692 while (line_ptr
< line_end
)
6694 /* state machine registers */
6695 CORE_ADDR address
= 0;
6696 unsigned int file
= 1;
6697 unsigned int line
= 1;
6698 unsigned int column
= 0;
6699 int is_stmt
= lh
->default_is_stmt
;
6700 int basic_block
= 0;
6701 int end_sequence
= 0;
6703 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6705 /* Start a subfile for the current file of the state machine. */
6706 /* lh->include_dirs and lh->file_names are 0-based, but the
6707 directory and file name numbers in the statement program
6709 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6713 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6715 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6718 /* Decode the table. */
6719 while (!end_sequence
)
6721 op_code
= read_1_byte (abfd
, line_ptr
);
6724 if (op_code
>= lh
->opcode_base
)
6726 /* Special operand. */
6727 adj_opcode
= op_code
- lh
->opcode_base
;
6728 address
+= (adj_opcode
/ lh
->line_range
)
6729 * lh
->minimum_instruction_length
;
6730 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6731 if (lh
->num_file_names
< file
)
6732 dwarf2_debug_line_missing_file_complaint ();
6735 lh
->file_names
[file
- 1].included_p
= 1;
6736 if (!decode_for_pst_p
)
6738 if (last_subfile
!= current_subfile
)
6741 record_line (last_subfile
, 0, address
);
6742 last_subfile
= current_subfile
;
6744 /* Append row to matrix using current values. */
6745 record_line (current_subfile
, line
,
6746 check_cu_functions (address
, cu
));
6751 else switch (op_code
)
6753 case DW_LNS_extended_op
:
6754 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6755 line_ptr
+= bytes_read
;
6756 extended_end
= line_ptr
+ extended_len
;
6757 extended_op
= read_1_byte (abfd
, line_ptr
);
6759 switch (extended_op
)
6761 case DW_LNE_end_sequence
:
6764 if (lh
->num_file_names
< file
)
6765 dwarf2_debug_line_missing_file_complaint ();
6768 lh
->file_names
[file
- 1].included_p
= 1;
6769 if (!decode_for_pst_p
)
6770 record_line (current_subfile
, 0, address
);
6773 case DW_LNE_set_address
:
6774 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6775 line_ptr
+= bytes_read
;
6776 address
+= baseaddr
;
6778 case DW_LNE_define_file
:
6781 unsigned int dir_index
, mod_time
, length
;
6783 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6784 line_ptr
+= bytes_read
;
6786 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6787 line_ptr
+= bytes_read
;
6789 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6790 line_ptr
+= bytes_read
;
6792 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6793 line_ptr
+= bytes_read
;
6794 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6798 complaint (&symfile_complaints
,
6799 _("mangled .debug_line section"));
6802 /* Make sure that we parsed the extended op correctly. If e.g.
6803 we expected a different address size than the producer used,
6804 we may have read the wrong number of bytes. */
6805 if (line_ptr
!= extended_end
)
6807 complaint (&symfile_complaints
,
6808 _("mangled .debug_line section"));
6813 if (lh
->num_file_names
< file
)
6814 dwarf2_debug_line_missing_file_complaint ();
6817 lh
->file_names
[file
- 1].included_p
= 1;
6818 if (!decode_for_pst_p
)
6820 if (last_subfile
!= current_subfile
)
6823 record_line (last_subfile
, 0, address
);
6824 last_subfile
= current_subfile
;
6826 record_line (current_subfile
, line
,
6827 check_cu_functions (address
, cu
));
6832 case DW_LNS_advance_pc
:
6833 address
+= lh
->minimum_instruction_length
6834 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6835 line_ptr
+= bytes_read
;
6837 case DW_LNS_advance_line
:
6838 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6839 line_ptr
+= bytes_read
;
6841 case DW_LNS_set_file
:
6843 /* The arrays lh->include_dirs and lh->file_names are
6844 0-based, but the directory and file name numbers in
6845 the statement program are 1-based. */
6846 struct file_entry
*fe
;
6849 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6850 line_ptr
+= bytes_read
;
6851 if (lh
->num_file_names
< file
)
6852 dwarf2_debug_line_missing_file_complaint ();
6855 fe
= &lh
->file_names
[file
- 1];
6857 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6858 if (!decode_for_pst_p
)
6860 last_subfile
= current_subfile
;
6861 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6866 case DW_LNS_set_column
:
6867 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6868 line_ptr
+= bytes_read
;
6870 case DW_LNS_negate_stmt
:
6871 is_stmt
= (!is_stmt
);
6873 case DW_LNS_set_basic_block
:
6876 /* Add to the address register of the state machine the
6877 address increment value corresponding to special opcode
6878 255. I.e., this value is scaled by the minimum
6879 instruction length since special opcode 255 would have
6880 scaled the the increment. */
6881 case DW_LNS_const_add_pc
:
6882 address
+= (lh
->minimum_instruction_length
6883 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6885 case DW_LNS_fixed_advance_pc
:
6886 address
+= read_2_bytes (abfd
, line_ptr
);
6891 /* Unknown standard opcode, ignore it. */
6894 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6896 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6897 line_ptr
+= bytes_read
;
6904 if (decode_for_pst_p
)
6908 /* Now that we're done scanning the Line Header Program, we can
6909 create the psymtab of each included file. */
6910 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6911 if (lh
->file_names
[file_index
].included_p
== 1)
6913 const struct file_entry fe
= lh
->file_names
[file_index
];
6914 char *include_name
= fe
.name
;
6915 char *dir_name
= NULL
;
6916 char *pst_filename
= pst
->filename
;
6919 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6921 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6923 include_name
= concat (dir_name
, SLASH_STRING
,
6924 include_name
, (char *)NULL
);
6925 make_cleanup (xfree
, include_name
);
6928 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6930 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6931 pst_filename
, (char *)NULL
);
6932 make_cleanup (xfree
, pst_filename
);
6935 if (strcmp (include_name
, pst_filename
) != 0)
6936 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6941 /* Make sure a symtab is created for every file, even files
6942 which contain only variables (i.e. no code with associated
6946 struct file_entry
*fe
;
6948 for (i
= 0; i
< lh
->num_file_names
; i
++)
6951 fe
= &lh
->file_names
[i
];
6953 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6954 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6956 /* Skip the main file; we don't need it, and it must be
6957 allocated last, so that it will show up before the
6958 non-primary symtabs in the objfile's symtab list. */
6959 if (current_subfile
== first_subfile
)
6962 if (current_subfile
->symtab
== NULL
)
6963 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
6965 fe
->symtab
= current_subfile
->symtab
;
6970 /* Start a subfile for DWARF. FILENAME is the name of the file and
6971 DIRNAME the name of the source directory which contains FILENAME
6972 or NULL if not known. COMP_DIR is the compilation directory for the
6973 linetable's compilation unit or NULL if not known.
6974 This routine tries to keep line numbers from identical absolute and
6975 relative file names in a common subfile.
6977 Using the `list' example from the GDB testsuite, which resides in
6978 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6979 of /srcdir/list0.c yields the following debugging information for list0.c:
6981 DW_AT_name: /srcdir/list0.c
6982 DW_AT_comp_dir: /compdir
6983 files.files[0].name: list0.h
6984 files.files[0].dir: /srcdir
6985 files.files[1].name: list0.c
6986 files.files[1].dir: /srcdir
6988 The line number information for list0.c has to end up in a single
6989 subfile, so that `break /srcdir/list0.c:1' works as expected.
6990 start_subfile will ensure that this happens provided that we pass the
6991 concatenation of files.files[1].dir and files.files[1].name as the
6995 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
6999 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
7000 `start_symtab' will always pass the contents of DW_AT_comp_dir as
7001 second argument to start_subfile. To be consistent, we do the
7002 same here. In order not to lose the line information directory,
7003 we concatenate it to the filename when it makes sense.
7004 Note that the Dwarf3 standard says (speaking of filenames in line
7005 information): ``The directory index is ignored for file names
7006 that represent full path names''. Thus ignoring dirname in the
7007 `else' branch below isn't an issue. */
7009 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
7010 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
7012 fullname
= filename
;
7014 start_subfile (fullname
, comp_dir
);
7016 if (fullname
!= filename
)
7021 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
7022 struct dwarf2_cu
*cu
)
7024 struct objfile
*objfile
= cu
->objfile
;
7025 struct comp_unit_head
*cu_header
= &cu
->header
;
7027 /* NOTE drow/2003-01-30: There used to be a comment and some special
7028 code here to turn a symbol with DW_AT_external and a
7029 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
7030 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
7031 with some versions of binutils) where shared libraries could have
7032 relocations against symbols in their debug information - the
7033 minimal symbol would have the right address, but the debug info
7034 would not. It's no longer necessary, because we will explicitly
7035 apply relocations when we read in the debug information now. */
7037 /* A DW_AT_location attribute with no contents indicates that a
7038 variable has been optimized away. */
7039 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
7041 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7045 /* Handle one degenerate form of location expression specially, to
7046 preserve GDB's previous behavior when section offsets are
7047 specified. If this is just a DW_OP_addr then mark this symbol
7050 if (attr_form_is_block (attr
)
7051 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
7052 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
7056 SYMBOL_VALUE_ADDRESS (sym
) =
7057 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
7058 fixup_symbol_section (sym
, objfile
);
7059 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
7060 SYMBOL_SECTION (sym
));
7061 SYMBOL_CLASS (sym
) = LOC_STATIC
;
7065 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
7066 expression evaluator, and use LOC_COMPUTED only when necessary
7067 (i.e. when the value of a register or memory location is
7068 referenced, or a thread-local block, etc.). Then again, it might
7069 not be worthwhile. I'm assuming that it isn't unless performance
7070 or memory numbers show me otherwise. */
7072 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
7073 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
7076 /* Given a pointer to a DWARF information entry, figure out if we need
7077 to make a symbol table entry for it, and if so, create a new entry
7078 and return a pointer to it.
7079 If TYPE is NULL, determine symbol type from the die, otherwise
7080 used the passed type. */
7082 static struct symbol
*
7083 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
7085 struct objfile
*objfile
= cu
->objfile
;
7086 struct symbol
*sym
= NULL
;
7088 struct attribute
*attr
= NULL
;
7089 struct attribute
*attr2
= NULL
;
7092 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7094 if (die
->tag
!= DW_TAG_namespace
)
7095 name
= dwarf2_linkage_name (die
, cu
);
7097 name
= TYPE_NAME (type
);
7101 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
7102 sizeof (struct symbol
));
7103 OBJSTAT (objfile
, n_syms
++);
7104 memset (sym
, 0, sizeof (struct symbol
));
7106 /* Cache this symbol's name and the name's demangled form (if any). */
7107 SYMBOL_LANGUAGE (sym
) = cu
->language
;
7108 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
7110 /* Default assumptions.
7111 Use the passed type or decode it from the die. */
7112 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7113 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7115 SYMBOL_TYPE (sym
) = type
;
7117 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
7118 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
7121 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
7124 attr
= dwarf2_attr (die
, DW_AT_decl_file
, cu
);
7127 int file_index
= DW_UNSND (attr
);
7128 if (cu
->line_header
== NULL
7129 || file_index
> cu
->line_header
->num_file_names
)
7130 complaint (&symfile_complaints
,
7131 _("file index out of range"));
7132 else if (file_index
> 0)
7134 struct file_entry
*fe
;
7135 fe
= &cu
->line_header
->file_names
[file_index
- 1];
7136 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
7143 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7146 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
7148 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7150 case DW_TAG_subprogram
:
7151 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7153 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7154 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7155 if (attr2
&& (DW_UNSND (attr2
) != 0))
7157 add_symbol_to_list (sym
, &global_symbols
);
7161 add_symbol_to_list (sym
, cu
->list_in_scope
);
7164 case DW_TAG_variable
:
7165 /* Compilation with minimal debug info may result in variables
7166 with missing type entries. Change the misleading `void' type
7167 to something sensible. */
7168 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7170 = builtin_type (current_gdbarch
)->nodebug_data_symbol
;
7172 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7175 dwarf2_const_value (attr
, sym
, cu
);
7176 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7177 if (attr2
&& (DW_UNSND (attr2
) != 0))
7178 add_symbol_to_list (sym
, &global_symbols
);
7180 add_symbol_to_list (sym
, cu
->list_in_scope
);
7183 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7186 var_decode_location (attr
, sym
, cu
);
7187 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7188 if (attr2
&& (DW_UNSND (attr2
) != 0))
7189 add_symbol_to_list (sym
, &global_symbols
);
7191 add_symbol_to_list (sym
, cu
->list_in_scope
);
7195 /* We do not know the address of this symbol.
7196 If it is an external symbol and we have type information
7197 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7198 The address of the variable will then be determined from
7199 the minimal symbol table whenever the variable is
7201 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7202 if (attr2
&& (DW_UNSND (attr2
) != 0)
7203 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7205 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7206 add_symbol_to_list (sym
, &global_symbols
);
7210 case DW_TAG_formal_parameter
:
7211 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7214 var_decode_location (attr
, sym
, cu
);
7215 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7216 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
7217 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
7219 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7222 dwarf2_const_value (attr
, sym
, cu
);
7224 add_symbol_to_list (sym
, cu
->list_in_scope
);
7226 case DW_TAG_unspecified_parameters
:
7227 /* From varargs functions; gdb doesn't seem to have any
7228 interest in this information, so just ignore it for now.
7231 case DW_TAG_class_type
:
7232 case DW_TAG_structure_type
:
7233 case DW_TAG_union_type
:
7234 case DW_TAG_set_type
:
7235 case DW_TAG_enumeration_type
:
7236 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7237 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7239 /* Make sure that the symbol includes appropriate enclosing
7240 classes/namespaces in its name. These are calculated in
7241 read_structure_type, and the correct name is saved in
7244 if (cu
->language
== language_cplus
7245 || cu
->language
== language_java
)
7247 struct type
*type
= SYMBOL_TYPE (sym
);
7249 if (TYPE_TAG_NAME (type
) != NULL
)
7251 /* FIXME: carlton/2003-11-10: Should this use
7252 SYMBOL_SET_NAMES instead? (The same problem also
7253 arises further down in this function.) */
7254 /* The type's name is already allocated along with
7255 this objfile, so we don't need to duplicate it
7257 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7262 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7263 really ever be static objects: otherwise, if you try
7264 to, say, break of a class's method and you're in a file
7265 which doesn't mention that class, it won't work unless
7266 the check for all static symbols in lookup_symbol_aux
7267 saves you. See the OtherFileClass tests in
7268 gdb.c++/namespace.exp. */
7270 struct pending
**list_to_add
;
7272 list_to_add
= (cu
->list_in_scope
== &file_symbols
7273 && (cu
->language
== language_cplus
7274 || cu
->language
== language_java
)
7275 ? &global_symbols
: cu
->list_in_scope
);
7277 add_symbol_to_list (sym
, list_to_add
);
7279 /* The semantics of C++ state that "struct foo { ... }" also
7280 defines a typedef for "foo". A Java class declaration also
7281 defines a typedef for the class. Synthesize a typedef symbol
7282 so that "ptype foo" works as expected. */
7283 if (cu
->language
== language_cplus
7284 || cu
->language
== language_java
7285 || cu
->language
== language_ada
)
7287 struct symbol
*typedef_sym
= (struct symbol
*)
7288 obstack_alloc (&objfile
->objfile_obstack
,
7289 sizeof (struct symbol
));
7290 *typedef_sym
= *sym
;
7291 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7292 /* The symbol's name is already allocated along with
7293 this objfile, so we don't need to duplicate it for
7295 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7296 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7297 add_symbol_to_list (typedef_sym
, list_to_add
);
7301 case DW_TAG_typedef
:
7302 if (processing_has_namespace_info
7303 && processing_current_prefix
[0] != '\0')
7305 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7306 processing_current_prefix
,
7309 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7310 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7311 add_symbol_to_list (sym
, cu
->list_in_scope
);
7313 case DW_TAG_base_type
:
7314 case DW_TAG_subrange_type
:
7315 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7316 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7317 add_symbol_to_list (sym
, cu
->list_in_scope
);
7319 case DW_TAG_enumerator
:
7320 if (processing_has_namespace_info
7321 && processing_current_prefix
[0] != '\0')
7323 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7324 processing_current_prefix
,
7327 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7330 dwarf2_const_value (attr
, sym
, cu
);
7333 /* NOTE: carlton/2003-11-10: See comment above in the
7334 DW_TAG_class_type, etc. block. */
7336 struct pending
**list_to_add
;
7338 list_to_add
= (cu
->list_in_scope
== &file_symbols
7339 && (cu
->language
== language_cplus
7340 || cu
->language
== language_java
)
7341 ? &global_symbols
: cu
->list_in_scope
);
7343 add_symbol_to_list (sym
, list_to_add
);
7346 case DW_TAG_namespace
:
7347 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7348 add_symbol_to_list (sym
, &global_symbols
);
7351 /* Not a tag we recognize. Hopefully we aren't processing
7352 trash data, but since we must specifically ignore things
7353 we don't recognize, there is nothing else we should do at
7355 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7356 dwarf_tag_name (die
->tag
));
7363 /* Copy constant value from an attribute to a symbol. */
7366 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7367 struct dwarf2_cu
*cu
)
7369 struct objfile
*objfile
= cu
->objfile
;
7370 struct comp_unit_head
*cu_header
= &cu
->header
;
7371 struct dwarf_block
*blk
;
7376 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7377 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7378 cu_header
->addr_size
,
7379 TYPE_LENGTH (SYMBOL_TYPE
7381 SYMBOL_VALUE_BYTES (sym
) =
7382 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7383 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7384 it's body - store_unsigned_integer. */
7385 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7387 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7389 case DW_FORM_block1
:
7390 case DW_FORM_block2
:
7391 case DW_FORM_block4
:
7393 blk
= DW_BLOCK (attr
);
7394 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7395 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7397 TYPE_LENGTH (SYMBOL_TYPE
7399 SYMBOL_VALUE_BYTES (sym
) =
7400 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7401 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7402 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7405 /* The DW_AT_const_value attributes are supposed to carry the
7406 symbol's value "represented as it would be on the target
7407 architecture." By the time we get here, it's already been
7408 converted to host endianness, so we just need to sign- or
7409 zero-extend it as appropriate. */
7411 dwarf2_const_value_data (attr
, sym
, 8);
7414 dwarf2_const_value_data (attr
, sym
, 16);
7417 dwarf2_const_value_data (attr
, sym
, 32);
7420 dwarf2_const_value_data (attr
, sym
, 64);
7424 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7425 SYMBOL_CLASS (sym
) = LOC_CONST
;
7429 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7430 SYMBOL_CLASS (sym
) = LOC_CONST
;
7434 complaint (&symfile_complaints
,
7435 _("unsupported const value attribute form: '%s'"),
7436 dwarf_form_name (attr
->form
));
7437 SYMBOL_VALUE (sym
) = 0;
7438 SYMBOL_CLASS (sym
) = LOC_CONST
;
7444 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7445 or zero-extend it as appropriate for the symbol's type. */
7447 dwarf2_const_value_data (struct attribute
*attr
,
7451 LONGEST l
= DW_UNSND (attr
);
7453 if (bits
< sizeof (l
) * 8)
7455 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7456 l
&= ((LONGEST
) 1 << bits
) - 1;
7458 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7461 SYMBOL_VALUE (sym
) = l
;
7462 SYMBOL_CLASS (sym
) = LOC_CONST
;
7466 /* Return the type of the die in question using its DW_AT_type attribute. */
7468 static struct type
*
7469 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7472 struct attribute
*type_attr
;
7473 struct die_info
*type_die
;
7475 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7478 /* A missing DW_AT_type represents a void type. */
7479 return builtin_type (current_gdbarch
)->builtin_void
;
7482 type_die
= follow_die_ref (die
, type_attr
, cu
);
7484 type
= tag_type_to_type (type_die
, cu
);
7487 dump_die (type_die
);
7488 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7494 /* Return the containing type of the die in question using its
7495 DW_AT_containing_type attribute. */
7497 static struct type
*
7498 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7500 struct type
*type
= NULL
;
7501 struct attribute
*type_attr
;
7502 struct die_info
*type_die
= NULL
;
7504 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7507 type_die
= follow_die_ref (die
, type_attr
, cu
);
7508 type
= tag_type_to_type (type_die
, cu
);
7513 dump_die (type_die
);
7514 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7520 static struct type
*
7521 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7529 read_type_die (die
, cu
);
7533 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7541 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7543 char *prefix
= determine_prefix (die
, cu
);
7544 const char *old_prefix
= processing_current_prefix
;
7545 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7546 processing_current_prefix
= prefix
;
7550 case DW_TAG_class_type
:
7551 case DW_TAG_structure_type
:
7552 case DW_TAG_union_type
:
7553 read_structure_type (die
, cu
);
7555 case DW_TAG_enumeration_type
:
7556 read_enumeration_type (die
, cu
);
7558 case DW_TAG_subprogram
:
7559 case DW_TAG_subroutine_type
:
7560 read_subroutine_type (die
, cu
);
7562 case DW_TAG_array_type
:
7563 read_array_type (die
, cu
);
7565 case DW_TAG_set_type
:
7566 read_set_type (die
, cu
);
7568 case DW_TAG_pointer_type
:
7569 read_tag_pointer_type (die
, cu
);
7571 case DW_TAG_ptr_to_member_type
:
7572 read_tag_ptr_to_member_type (die
, cu
);
7574 case DW_TAG_reference_type
:
7575 read_tag_reference_type (die
, cu
);
7577 case DW_TAG_const_type
:
7578 read_tag_const_type (die
, cu
);
7580 case DW_TAG_volatile_type
:
7581 read_tag_volatile_type (die
, cu
);
7583 case DW_TAG_string_type
:
7584 read_tag_string_type (die
, cu
);
7586 case DW_TAG_typedef
:
7587 read_typedef (die
, cu
);
7589 case DW_TAG_subrange_type
:
7590 read_subrange_type (die
, cu
);
7592 case DW_TAG_base_type
:
7593 read_base_type (die
, cu
);
7595 case DW_TAG_unspecified_type
:
7596 read_unspecified_type (die
, cu
);
7599 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7600 dwarf_tag_name (die
->tag
));
7604 processing_current_prefix
= old_prefix
;
7605 do_cleanups (back_to
);
7608 /* Return the name of the namespace/class that DIE is defined within,
7609 or "" if we can't tell. The caller should xfree the result. */
7611 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7612 therein) for an example of how to use this function to deal with
7613 DW_AT_specification. */
7616 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7618 struct die_info
*parent
;
7620 if (cu
->language
!= language_cplus
7621 && cu
->language
!= language_java
)
7624 parent
= die
->parent
;
7628 return xstrdup ("");
7632 switch (parent
->tag
) {
7633 case DW_TAG_namespace
:
7635 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7636 before doing this check? */
7637 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7639 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7644 char *parent_prefix
= determine_prefix (parent
, cu
);
7645 char *retval
= typename_concat (NULL
, parent_prefix
,
7646 namespace_name (parent
, &dummy
,
7649 xfree (parent_prefix
);
7654 case DW_TAG_class_type
:
7655 case DW_TAG_structure_type
:
7657 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7659 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7663 const char *old_prefix
= processing_current_prefix
;
7664 char *new_prefix
= determine_prefix (parent
, cu
);
7667 processing_current_prefix
= new_prefix
;
7668 retval
= determine_class_name (parent
, cu
);
7669 processing_current_prefix
= old_prefix
;
7676 return determine_prefix (parent
, cu
);
7681 /* Return a newly-allocated string formed by concatenating PREFIX and
7682 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7683 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7684 perform an obconcat, otherwise allocate storage for the result. The CU argument
7685 is used to determine the language and hence, the appropriate separator. */
7687 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7690 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7691 struct dwarf2_cu
*cu
)
7695 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7697 else if (cu
->language
== language_java
)
7704 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7709 strcpy (retval
, prefix
);
7710 strcat (retval
, sep
);
7713 strcat (retval
, suffix
);
7719 /* We have an obstack. */
7720 return obconcat (obs
, prefix
, sep
, suffix
);
7726 copy_die (struct die_info
*old_die
)
7728 struct die_info
*new_die
;
7731 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7732 memset (new_die
, 0, sizeof (struct die_info
));
7734 new_die
->tag
= old_die
->tag
;
7735 new_die
->has_children
= old_die
->has_children
;
7736 new_die
->abbrev
= old_die
->abbrev
;
7737 new_die
->offset
= old_die
->offset
;
7738 new_die
->type
= NULL
;
7740 num_attrs
= old_die
->num_attrs
;
7741 new_die
->num_attrs
= num_attrs
;
7742 new_die
->attrs
= (struct attribute
*)
7743 xmalloc (num_attrs
* sizeof (struct attribute
));
7745 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7747 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7748 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7749 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7752 new_die
->next
= NULL
;
7757 /* Return sibling of die, NULL if no sibling. */
7759 static struct die_info
*
7760 sibling_die (struct die_info
*die
)
7762 return die
->sibling
;
7765 /* Get linkage name of a die, return NULL if not found. */
7768 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7770 struct attribute
*attr
;
7772 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7773 if (attr
&& DW_STRING (attr
))
7774 return DW_STRING (attr
);
7775 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7776 if (attr
&& DW_STRING (attr
))
7777 return DW_STRING (attr
);
7781 /* Get name of a die, return NULL if not found. */
7784 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7786 struct attribute
*attr
;
7788 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7789 if (attr
&& DW_STRING (attr
))
7790 return DW_STRING (attr
);
7794 /* Return the die that this die in an extension of, or NULL if there
7797 static struct die_info
*
7798 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7800 struct attribute
*attr
;
7802 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7806 return follow_die_ref (die
, attr
, cu
);
7809 /* Convert a DIE tag into its string name. */
7812 dwarf_tag_name (unsigned tag
)
7816 case DW_TAG_padding
:
7817 return "DW_TAG_padding";
7818 case DW_TAG_array_type
:
7819 return "DW_TAG_array_type";
7820 case DW_TAG_class_type
:
7821 return "DW_TAG_class_type";
7822 case DW_TAG_entry_point
:
7823 return "DW_TAG_entry_point";
7824 case DW_TAG_enumeration_type
:
7825 return "DW_TAG_enumeration_type";
7826 case DW_TAG_formal_parameter
:
7827 return "DW_TAG_formal_parameter";
7828 case DW_TAG_imported_declaration
:
7829 return "DW_TAG_imported_declaration";
7831 return "DW_TAG_label";
7832 case DW_TAG_lexical_block
:
7833 return "DW_TAG_lexical_block";
7835 return "DW_TAG_member";
7836 case DW_TAG_pointer_type
:
7837 return "DW_TAG_pointer_type";
7838 case DW_TAG_reference_type
:
7839 return "DW_TAG_reference_type";
7840 case DW_TAG_compile_unit
:
7841 return "DW_TAG_compile_unit";
7842 case DW_TAG_string_type
:
7843 return "DW_TAG_string_type";
7844 case DW_TAG_structure_type
:
7845 return "DW_TAG_structure_type";
7846 case DW_TAG_subroutine_type
:
7847 return "DW_TAG_subroutine_type";
7848 case DW_TAG_typedef
:
7849 return "DW_TAG_typedef";
7850 case DW_TAG_union_type
:
7851 return "DW_TAG_union_type";
7852 case DW_TAG_unspecified_parameters
:
7853 return "DW_TAG_unspecified_parameters";
7854 case DW_TAG_variant
:
7855 return "DW_TAG_variant";
7856 case DW_TAG_common_block
:
7857 return "DW_TAG_common_block";
7858 case DW_TAG_common_inclusion
:
7859 return "DW_TAG_common_inclusion";
7860 case DW_TAG_inheritance
:
7861 return "DW_TAG_inheritance";
7862 case DW_TAG_inlined_subroutine
:
7863 return "DW_TAG_inlined_subroutine";
7865 return "DW_TAG_module";
7866 case DW_TAG_ptr_to_member_type
:
7867 return "DW_TAG_ptr_to_member_type";
7868 case DW_TAG_set_type
:
7869 return "DW_TAG_set_type";
7870 case DW_TAG_subrange_type
:
7871 return "DW_TAG_subrange_type";
7872 case DW_TAG_with_stmt
:
7873 return "DW_TAG_with_stmt";
7874 case DW_TAG_access_declaration
:
7875 return "DW_TAG_access_declaration";
7876 case DW_TAG_base_type
:
7877 return "DW_TAG_base_type";
7878 case DW_TAG_catch_block
:
7879 return "DW_TAG_catch_block";
7880 case DW_TAG_const_type
:
7881 return "DW_TAG_const_type";
7882 case DW_TAG_constant
:
7883 return "DW_TAG_constant";
7884 case DW_TAG_enumerator
:
7885 return "DW_TAG_enumerator";
7886 case DW_TAG_file_type
:
7887 return "DW_TAG_file_type";
7889 return "DW_TAG_friend";
7890 case DW_TAG_namelist
:
7891 return "DW_TAG_namelist";
7892 case DW_TAG_namelist_item
:
7893 return "DW_TAG_namelist_item";
7894 case DW_TAG_packed_type
:
7895 return "DW_TAG_packed_type";
7896 case DW_TAG_subprogram
:
7897 return "DW_TAG_subprogram";
7898 case DW_TAG_template_type_param
:
7899 return "DW_TAG_template_type_param";
7900 case DW_TAG_template_value_param
:
7901 return "DW_TAG_template_value_param";
7902 case DW_TAG_thrown_type
:
7903 return "DW_TAG_thrown_type";
7904 case DW_TAG_try_block
:
7905 return "DW_TAG_try_block";
7906 case DW_TAG_variant_part
:
7907 return "DW_TAG_variant_part";
7908 case DW_TAG_variable
:
7909 return "DW_TAG_variable";
7910 case DW_TAG_volatile_type
:
7911 return "DW_TAG_volatile_type";
7912 case DW_TAG_dwarf_procedure
:
7913 return "DW_TAG_dwarf_procedure";
7914 case DW_TAG_restrict_type
:
7915 return "DW_TAG_restrict_type";
7916 case DW_TAG_interface_type
:
7917 return "DW_TAG_interface_type";
7918 case DW_TAG_namespace
:
7919 return "DW_TAG_namespace";
7920 case DW_TAG_imported_module
:
7921 return "DW_TAG_imported_module";
7922 case DW_TAG_unspecified_type
:
7923 return "DW_TAG_unspecified_type";
7924 case DW_TAG_partial_unit
:
7925 return "DW_TAG_partial_unit";
7926 case DW_TAG_imported_unit
:
7927 return "DW_TAG_imported_unit";
7928 case DW_TAG_condition
:
7929 return "DW_TAG_condition";
7930 case DW_TAG_shared_type
:
7931 return "DW_TAG_shared_type";
7932 case DW_TAG_MIPS_loop
:
7933 return "DW_TAG_MIPS_loop";
7934 case DW_TAG_HP_array_descriptor
:
7935 return "DW_TAG_HP_array_descriptor";
7936 case DW_TAG_format_label
:
7937 return "DW_TAG_format_label";
7938 case DW_TAG_function_template
:
7939 return "DW_TAG_function_template";
7940 case DW_TAG_class_template
:
7941 return "DW_TAG_class_template";
7942 case DW_TAG_GNU_BINCL
:
7943 return "DW_TAG_GNU_BINCL";
7944 case DW_TAG_GNU_EINCL
:
7945 return "DW_TAG_GNU_EINCL";
7946 case DW_TAG_upc_shared_type
:
7947 return "DW_TAG_upc_shared_type";
7948 case DW_TAG_upc_strict_type
:
7949 return "DW_TAG_upc_strict_type";
7950 case DW_TAG_upc_relaxed_type
:
7951 return "DW_TAG_upc_relaxed_type";
7952 case DW_TAG_PGI_kanji_type
:
7953 return "DW_TAG_PGI_kanji_type";
7954 case DW_TAG_PGI_interface_block
:
7955 return "DW_TAG_PGI_interface_block";
7957 return "DW_TAG_<unknown>";
7961 /* Convert a DWARF attribute code into its string name. */
7964 dwarf_attr_name (unsigned attr
)
7969 return "DW_AT_sibling";
7970 case DW_AT_location
:
7971 return "DW_AT_location";
7973 return "DW_AT_name";
7974 case DW_AT_ordering
:
7975 return "DW_AT_ordering";
7976 case DW_AT_subscr_data
:
7977 return "DW_AT_subscr_data";
7978 case DW_AT_byte_size
:
7979 return "DW_AT_byte_size";
7980 case DW_AT_bit_offset
:
7981 return "DW_AT_bit_offset";
7982 case DW_AT_bit_size
:
7983 return "DW_AT_bit_size";
7984 case DW_AT_element_list
:
7985 return "DW_AT_element_list";
7986 case DW_AT_stmt_list
:
7987 return "DW_AT_stmt_list";
7989 return "DW_AT_low_pc";
7991 return "DW_AT_high_pc";
7992 case DW_AT_language
:
7993 return "DW_AT_language";
7995 return "DW_AT_member";
7997 return "DW_AT_discr";
7998 case DW_AT_discr_value
:
7999 return "DW_AT_discr_value";
8000 case DW_AT_visibility
:
8001 return "DW_AT_visibility";
8003 return "DW_AT_import";
8004 case DW_AT_string_length
:
8005 return "DW_AT_string_length";
8006 case DW_AT_common_reference
:
8007 return "DW_AT_common_reference";
8008 case DW_AT_comp_dir
:
8009 return "DW_AT_comp_dir";
8010 case DW_AT_const_value
:
8011 return "DW_AT_const_value";
8012 case DW_AT_containing_type
:
8013 return "DW_AT_containing_type";
8014 case DW_AT_default_value
:
8015 return "DW_AT_default_value";
8017 return "DW_AT_inline";
8018 case DW_AT_is_optional
:
8019 return "DW_AT_is_optional";
8020 case DW_AT_lower_bound
:
8021 return "DW_AT_lower_bound";
8022 case DW_AT_producer
:
8023 return "DW_AT_producer";
8024 case DW_AT_prototyped
:
8025 return "DW_AT_prototyped";
8026 case DW_AT_return_addr
:
8027 return "DW_AT_return_addr";
8028 case DW_AT_start_scope
:
8029 return "DW_AT_start_scope";
8030 case DW_AT_stride_size
:
8031 return "DW_AT_stride_size";
8032 case DW_AT_upper_bound
:
8033 return "DW_AT_upper_bound";
8034 case DW_AT_abstract_origin
:
8035 return "DW_AT_abstract_origin";
8036 case DW_AT_accessibility
:
8037 return "DW_AT_accessibility";
8038 case DW_AT_address_class
:
8039 return "DW_AT_address_class";
8040 case DW_AT_artificial
:
8041 return "DW_AT_artificial";
8042 case DW_AT_base_types
:
8043 return "DW_AT_base_types";
8044 case DW_AT_calling_convention
:
8045 return "DW_AT_calling_convention";
8047 return "DW_AT_count";
8048 case DW_AT_data_member_location
:
8049 return "DW_AT_data_member_location";
8050 case DW_AT_decl_column
:
8051 return "DW_AT_decl_column";
8052 case DW_AT_decl_file
:
8053 return "DW_AT_decl_file";
8054 case DW_AT_decl_line
:
8055 return "DW_AT_decl_line";
8056 case DW_AT_declaration
:
8057 return "DW_AT_declaration";
8058 case DW_AT_discr_list
:
8059 return "DW_AT_discr_list";
8060 case DW_AT_encoding
:
8061 return "DW_AT_encoding";
8062 case DW_AT_external
:
8063 return "DW_AT_external";
8064 case DW_AT_frame_base
:
8065 return "DW_AT_frame_base";
8067 return "DW_AT_friend";
8068 case DW_AT_identifier_case
:
8069 return "DW_AT_identifier_case";
8070 case DW_AT_macro_info
:
8071 return "DW_AT_macro_info";
8072 case DW_AT_namelist_items
:
8073 return "DW_AT_namelist_items";
8074 case DW_AT_priority
:
8075 return "DW_AT_priority";
8077 return "DW_AT_segment";
8078 case DW_AT_specification
:
8079 return "DW_AT_specification";
8080 case DW_AT_static_link
:
8081 return "DW_AT_static_link";
8083 return "DW_AT_type";
8084 case DW_AT_use_location
:
8085 return "DW_AT_use_location";
8086 case DW_AT_variable_parameter
:
8087 return "DW_AT_variable_parameter";
8088 case DW_AT_virtuality
:
8089 return "DW_AT_virtuality";
8090 case DW_AT_vtable_elem_location
:
8091 return "DW_AT_vtable_elem_location";
8092 /* DWARF 3 values. */
8093 case DW_AT_allocated
:
8094 return "DW_AT_allocated";
8095 case DW_AT_associated
:
8096 return "DW_AT_associated";
8097 case DW_AT_data_location
:
8098 return "DW_AT_data_location";
8100 return "DW_AT_stride";
8101 case DW_AT_entry_pc
:
8102 return "DW_AT_entry_pc";
8103 case DW_AT_use_UTF8
:
8104 return "DW_AT_use_UTF8";
8105 case DW_AT_extension
:
8106 return "DW_AT_extension";
8108 return "DW_AT_ranges";
8109 case DW_AT_trampoline
:
8110 return "DW_AT_trampoline";
8111 case DW_AT_call_column
:
8112 return "DW_AT_call_column";
8113 case DW_AT_call_file
:
8114 return "DW_AT_call_file";
8115 case DW_AT_call_line
:
8116 return "DW_AT_call_line";
8117 case DW_AT_description
:
8118 return "DW_AT_description";
8119 case DW_AT_binary_scale
:
8120 return "DW_AT_binary_scale";
8121 case DW_AT_decimal_scale
:
8122 return "DW_AT_decimal_scale";
8124 return "DW_AT_small";
8125 case DW_AT_decimal_sign
:
8126 return "DW_AT_decimal_sign";
8127 case DW_AT_digit_count
:
8128 return "DW_AT_digit_count";
8129 case DW_AT_picture_string
:
8130 return "DW_AT_picture_string";
8132 return "DW_AT_mutable";
8133 case DW_AT_threads_scaled
:
8134 return "DW_AT_threads_scaled";
8135 case DW_AT_explicit
:
8136 return "DW_AT_explicit";
8137 case DW_AT_object_pointer
:
8138 return "DW_AT_object_pointer";
8139 case DW_AT_endianity
:
8140 return "DW_AT_endianity";
8141 case DW_AT_elemental
:
8142 return "DW_AT_elemental";
8144 return "DW_AT_pure";
8145 case DW_AT_recursive
:
8146 return "DW_AT_recursive";
8148 /* SGI/MIPS extensions. */
8149 case DW_AT_MIPS_fde
:
8150 return "DW_AT_MIPS_fde";
8151 case DW_AT_MIPS_loop_begin
:
8152 return "DW_AT_MIPS_loop_begin";
8153 case DW_AT_MIPS_tail_loop_begin
:
8154 return "DW_AT_MIPS_tail_loop_begin";
8155 case DW_AT_MIPS_epilog_begin
:
8156 return "DW_AT_MIPS_epilog_begin";
8157 case DW_AT_MIPS_loop_unroll_factor
:
8158 return "DW_AT_MIPS_loop_unroll_factor";
8159 case DW_AT_MIPS_software_pipeline_depth
:
8160 return "DW_AT_MIPS_software_pipeline_depth";
8161 case DW_AT_MIPS_linkage_name
:
8162 return "DW_AT_MIPS_linkage_name";
8163 case DW_AT_MIPS_stride
:
8164 return "DW_AT_MIPS_stride";
8165 case DW_AT_MIPS_abstract_name
:
8166 return "DW_AT_MIPS_abstract_name";
8167 case DW_AT_MIPS_clone_origin
:
8168 return "DW_AT_MIPS_clone_origin";
8169 case DW_AT_MIPS_has_inlines
:
8170 return "DW_AT_MIPS_has_inlines";
8172 /* HP extensions. */
8173 case DW_AT_HP_block_index
:
8174 return "DW_AT_HP_block_index";
8175 case DW_AT_HP_unmodifiable
:
8176 return "DW_AT_HP_unmodifiable";
8177 case DW_AT_HP_actuals_stmt_list
:
8178 return "DW_AT_HP_actuals_stmt_list";
8179 case DW_AT_HP_proc_per_section
:
8180 return "DW_AT_HP_proc_per_section";
8181 case DW_AT_HP_raw_data_ptr
:
8182 return "DW_AT_HP_raw_data_ptr";
8183 case DW_AT_HP_pass_by_reference
:
8184 return "DW_AT_HP_pass_by_reference";
8185 case DW_AT_HP_opt_level
:
8186 return "DW_AT_HP_opt_level";
8187 case DW_AT_HP_prof_version_id
:
8188 return "DW_AT_HP_prof_version_id";
8189 case DW_AT_HP_opt_flags
:
8190 return "DW_AT_HP_opt_flags";
8191 case DW_AT_HP_cold_region_low_pc
:
8192 return "DW_AT_HP_cold_region_low_pc";
8193 case DW_AT_HP_cold_region_high_pc
:
8194 return "DW_AT_HP_cold_region_high_pc";
8195 case DW_AT_HP_all_variables_modifiable
:
8196 return "DW_AT_HP_all_variables_modifiable";
8197 case DW_AT_HP_linkage_name
:
8198 return "DW_AT_HP_linkage_name";
8199 case DW_AT_HP_prof_flags
:
8200 return "DW_AT_HP_prof_flags";
8201 /* GNU extensions. */
8202 case DW_AT_sf_names
:
8203 return "DW_AT_sf_names";
8204 case DW_AT_src_info
:
8205 return "DW_AT_src_info";
8206 case DW_AT_mac_info
:
8207 return "DW_AT_mac_info";
8208 case DW_AT_src_coords
:
8209 return "DW_AT_src_coords";
8210 case DW_AT_body_begin
:
8211 return "DW_AT_body_begin";
8212 case DW_AT_body_end
:
8213 return "DW_AT_body_end";
8214 case DW_AT_GNU_vector
:
8215 return "DW_AT_GNU_vector";
8216 /* VMS extensions. */
8217 case DW_AT_VMS_rtnbeg_pd_address
:
8218 return "DW_AT_VMS_rtnbeg_pd_address";
8219 /* UPC extension. */
8220 case DW_AT_upc_threads_scaled
:
8221 return "DW_AT_upc_threads_scaled";
8222 /* PGI (STMicroelectronics) extensions. */
8223 case DW_AT_PGI_lbase
:
8224 return "DW_AT_PGI_lbase";
8225 case DW_AT_PGI_soffset
:
8226 return "DW_AT_PGI_soffset";
8227 case DW_AT_PGI_lstride
:
8228 return "DW_AT_PGI_lstride";
8230 return "DW_AT_<unknown>";
8234 /* Convert a DWARF value form code into its string name. */
8237 dwarf_form_name (unsigned form
)
8242 return "DW_FORM_addr";
8243 case DW_FORM_block2
:
8244 return "DW_FORM_block2";
8245 case DW_FORM_block4
:
8246 return "DW_FORM_block4";
8248 return "DW_FORM_data2";
8250 return "DW_FORM_data4";
8252 return "DW_FORM_data8";
8253 case DW_FORM_string
:
8254 return "DW_FORM_string";
8256 return "DW_FORM_block";
8257 case DW_FORM_block1
:
8258 return "DW_FORM_block1";
8260 return "DW_FORM_data1";
8262 return "DW_FORM_flag";
8264 return "DW_FORM_sdata";
8266 return "DW_FORM_strp";
8268 return "DW_FORM_udata";
8269 case DW_FORM_ref_addr
:
8270 return "DW_FORM_ref_addr";
8272 return "DW_FORM_ref1";
8274 return "DW_FORM_ref2";
8276 return "DW_FORM_ref4";
8278 return "DW_FORM_ref8";
8279 case DW_FORM_ref_udata
:
8280 return "DW_FORM_ref_udata";
8281 case DW_FORM_indirect
:
8282 return "DW_FORM_indirect";
8284 return "DW_FORM_<unknown>";
8288 /* Convert a DWARF stack opcode into its string name. */
8291 dwarf_stack_op_name (unsigned op
)
8296 return "DW_OP_addr";
8298 return "DW_OP_deref";
8300 return "DW_OP_const1u";
8302 return "DW_OP_const1s";
8304 return "DW_OP_const2u";
8306 return "DW_OP_const2s";
8308 return "DW_OP_const4u";
8310 return "DW_OP_const4s";
8312 return "DW_OP_const8u";
8314 return "DW_OP_const8s";
8316 return "DW_OP_constu";
8318 return "DW_OP_consts";
8322 return "DW_OP_drop";
8324 return "DW_OP_over";
8326 return "DW_OP_pick";
8328 return "DW_OP_swap";
8332 return "DW_OP_xderef";
8340 return "DW_OP_minus";
8352 return "DW_OP_plus";
8353 case DW_OP_plus_uconst
:
8354 return "DW_OP_plus_uconst";
8360 return "DW_OP_shra";
8378 return "DW_OP_skip";
8380 return "DW_OP_lit0";
8382 return "DW_OP_lit1";
8384 return "DW_OP_lit2";
8386 return "DW_OP_lit3";
8388 return "DW_OP_lit4";
8390 return "DW_OP_lit5";
8392 return "DW_OP_lit6";
8394 return "DW_OP_lit7";
8396 return "DW_OP_lit8";
8398 return "DW_OP_lit9";
8400 return "DW_OP_lit10";
8402 return "DW_OP_lit11";
8404 return "DW_OP_lit12";
8406 return "DW_OP_lit13";
8408 return "DW_OP_lit14";
8410 return "DW_OP_lit15";
8412 return "DW_OP_lit16";
8414 return "DW_OP_lit17";
8416 return "DW_OP_lit18";
8418 return "DW_OP_lit19";
8420 return "DW_OP_lit20";
8422 return "DW_OP_lit21";
8424 return "DW_OP_lit22";
8426 return "DW_OP_lit23";
8428 return "DW_OP_lit24";
8430 return "DW_OP_lit25";
8432 return "DW_OP_lit26";
8434 return "DW_OP_lit27";
8436 return "DW_OP_lit28";
8438 return "DW_OP_lit29";
8440 return "DW_OP_lit30";
8442 return "DW_OP_lit31";
8444 return "DW_OP_reg0";
8446 return "DW_OP_reg1";
8448 return "DW_OP_reg2";
8450 return "DW_OP_reg3";
8452 return "DW_OP_reg4";
8454 return "DW_OP_reg5";
8456 return "DW_OP_reg6";
8458 return "DW_OP_reg7";
8460 return "DW_OP_reg8";
8462 return "DW_OP_reg9";
8464 return "DW_OP_reg10";
8466 return "DW_OP_reg11";
8468 return "DW_OP_reg12";
8470 return "DW_OP_reg13";
8472 return "DW_OP_reg14";
8474 return "DW_OP_reg15";
8476 return "DW_OP_reg16";
8478 return "DW_OP_reg17";
8480 return "DW_OP_reg18";
8482 return "DW_OP_reg19";
8484 return "DW_OP_reg20";
8486 return "DW_OP_reg21";
8488 return "DW_OP_reg22";
8490 return "DW_OP_reg23";
8492 return "DW_OP_reg24";
8494 return "DW_OP_reg25";
8496 return "DW_OP_reg26";
8498 return "DW_OP_reg27";
8500 return "DW_OP_reg28";
8502 return "DW_OP_reg29";
8504 return "DW_OP_reg30";
8506 return "DW_OP_reg31";
8508 return "DW_OP_breg0";
8510 return "DW_OP_breg1";
8512 return "DW_OP_breg2";
8514 return "DW_OP_breg3";
8516 return "DW_OP_breg4";
8518 return "DW_OP_breg5";
8520 return "DW_OP_breg6";
8522 return "DW_OP_breg7";
8524 return "DW_OP_breg8";
8526 return "DW_OP_breg9";
8528 return "DW_OP_breg10";
8530 return "DW_OP_breg11";
8532 return "DW_OP_breg12";
8534 return "DW_OP_breg13";
8536 return "DW_OP_breg14";
8538 return "DW_OP_breg15";
8540 return "DW_OP_breg16";
8542 return "DW_OP_breg17";
8544 return "DW_OP_breg18";
8546 return "DW_OP_breg19";
8548 return "DW_OP_breg20";
8550 return "DW_OP_breg21";
8552 return "DW_OP_breg22";
8554 return "DW_OP_breg23";
8556 return "DW_OP_breg24";
8558 return "DW_OP_breg25";
8560 return "DW_OP_breg26";
8562 return "DW_OP_breg27";
8564 return "DW_OP_breg28";
8566 return "DW_OP_breg29";
8568 return "DW_OP_breg30";
8570 return "DW_OP_breg31";
8572 return "DW_OP_regx";
8574 return "DW_OP_fbreg";
8576 return "DW_OP_bregx";
8578 return "DW_OP_piece";
8579 case DW_OP_deref_size
:
8580 return "DW_OP_deref_size";
8581 case DW_OP_xderef_size
:
8582 return "DW_OP_xderef_size";
8585 /* DWARF 3 extensions. */
8586 case DW_OP_push_object_address
:
8587 return "DW_OP_push_object_address";
8589 return "DW_OP_call2";
8591 return "DW_OP_call4";
8592 case DW_OP_call_ref
:
8593 return "DW_OP_call_ref";
8594 /* GNU extensions. */
8595 case DW_OP_form_tls_address
:
8596 return "DW_OP_form_tls_address";
8597 case DW_OP_call_frame_cfa
:
8598 return "DW_OP_call_frame_cfa";
8599 case DW_OP_bit_piece
:
8600 return "DW_OP_bit_piece";
8601 case DW_OP_GNU_push_tls_address
:
8602 return "DW_OP_GNU_push_tls_address";
8603 case DW_OP_GNU_uninit
:
8604 return "DW_OP_GNU_uninit";
8605 /* HP extensions. */
8606 case DW_OP_HP_is_value
:
8607 return "DW_OP_HP_is_value";
8608 case DW_OP_HP_fltconst4
:
8609 return "DW_OP_HP_fltconst4";
8610 case DW_OP_HP_fltconst8
:
8611 return "DW_OP_HP_fltconst8";
8612 case DW_OP_HP_mod_range
:
8613 return "DW_OP_HP_mod_range";
8614 case DW_OP_HP_unmod_range
:
8615 return "DW_OP_HP_unmod_range";
8617 return "DW_OP_HP_tls";
8619 return "OP_<unknown>";
8624 dwarf_bool_name (unsigned mybool
)
8632 /* Convert a DWARF type code into its string name. */
8635 dwarf_type_encoding_name (unsigned enc
)
8640 return "DW_ATE_void";
8641 case DW_ATE_address
:
8642 return "DW_ATE_address";
8643 case DW_ATE_boolean
:
8644 return "DW_ATE_boolean";
8645 case DW_ATE_complex_float
:
8646 return "DW_ATE_complex_float";
8648 return "DW_ATE_float";
8650 return "DW_ATE_signed";
8651 case DW_ATE_signed_char
:
8652 return "DW_ATE_signed_char";
8653 case DW_ATE_unsigned
:
8654 return "DW_ATE_unsigned";
8655 case DW_ATE_unsigned_char
:
8656 return "DW_ATE_unsigned_char";
8658 case DW_ATE_imaginary_float
:
8659 return "DW_ATE_imaginary_float";
8660 case DW_ATE_packed_decimal
:
8661 return "DW_ATE_packed_decimal";
8662 case DW_ATE_numeric_string
:
8663 return "DW_ATE_numeric_string";
8665 return "DW_ATE_edited";
8666 case DW_ATE_signed_fixed
:
8667 return "DW_ATE_signed_fixed";
8668 case DW_ATE_unsigned_fixed
:
8669 return "DW_ATE_unsigned_fixed";
8670 case DW_ATE_decimal_float
:
8671 return "DW_ATE_decimal_float";
8672 /* HP extensions. */
8673 case DW_ATE_HP_float80
:
8674 return "DW_ATE_HP_float80";
8675 case DW_ATE_HP_complex_float80
:
8676 return "DW_ATE_HP_complex_float80";
8677 case DW_ATE_HP_float128
:
8678 return "DW_ATE_HP_float128";
8679 case DW_ATE_HP_complex_float128
:
8680 return "DW_ATE_HP_complex_float128";
8681 case DW_ATE_HP_floathpintel
:
8682 return "DW_ATE_HP_floathpintel";
8683 case DW_ATE_HP_imaginary_float80
:
8684 return "DW_ATE_HP_imaginary_float80";
8685 case DW_ATE_HP_imaginary_float128
:
8686 return "DW_ATE_HP_imaginary_float128";
8688 return "DW_ATE_<unknown>";
8692 /* Convert a DWARF call frame info operation to its string name. */
8696 dwarf_cfi_name (unsigned cfi_opc
)
8700 case DW_CFA_advance_loc
:
8701 return "DW_CFA_advance_loc";
8703 return "DW_CFA_offset";
8704 case DW_CFA_restore
:
8705 return "DW_CFA_restore";
8707 return "DW_CFA_nop";
8708 case DW_CFA_set_loc
:
8709 return "DW_CFA_set_loc";
8710 case DW_CFA_advance_loc1
:
8711 return "DW_CFA_advance_loc1";
8712 case DW_CFA_advance_loc2
:
8713 return "DW_CFA_advance_loc2";
8714 case DW_CFA_advance_loc4
:
8715 return "DW_CFA_advance_loc4";
8716 case DW_CFA_offset_extended
:
8717 return "DW_CFA_offset_extended";
8718 case DW_CFA_restore_extended
:
8719 return "DW_CFA_restore_extended";
8720 case DW_CFA_undefined
:
8721 return "DW_CFA_undefined";
8722 case DW_CFA_same_value
:
8723 return "DW_CFA_same_value";
8724 case DW_CFA_register
:
8725 return "DW_CFA_register";
8726 case DW_CFA_remember_state
:
8727 return "DW_CFA_remember_state";
8728 case DW_CFA_restore_state
:
8729 return "DW_CFA_restore_state";
8730 case DW_CFA_def_cfa
:
8731 return "DW_CFA_def_cfa";
8732 case DW_CFA_def_cfa_register
:
8733 return "DW_CFA_def_cfa_register";
8734 case DW_CFA_def_cfa_offset
:
8735 return "DW_CFA_def_cfa_offset";
8737 case DW_CFA_def_cfa_expression
:
8738 return "DW_CFA_def_cfa_expression";
8739 case DW_CFA_expression
:
8740 return "DW_CFA_expression";
8741 case DW_CFA_offset_extended_sf
:
8742 return "DW_CFA_offset_extended_sf";
8743 case DW_CFA_def_cfa_sf
:
8744 return "DW_CFA_def_cfa_sf";
8745 case DW_CFA_def_cfa_offset_sf
:
8746 return "DW_CFA_def_cfa_offset_sf";
8747 case DW_CFA_val_offset
:
8748 return "DW_CFA_val_offset";
8749 case DW_CFA_val_offset_sf
:
8750 return "DW_CFA_val_offset_sf";
8751 case DW_CFA_val_expression
:
8752 return "DW_CFA_val_expression";
8753 /* SGI/MIPS specific. */
8754 case DW_CFA_MIPS_advance_loc8
:
8755 return "DW_CFA_MIPS_advance_loc8";
8756 /* GNU extensions. */
8757 case DW_CFA_GNU_window_save
:
8758 return "DW_CFA_GNU_window_save";
8759 case DW_CFA_GNU_args_size
:
8760 return "DW_CFA_GNU_args_size";
8761 case DW_CFA_GNU_negative_offset_extended
:
8762 return "DW_CFA_GNU_negative_offset_extended";
8764 return "DW_CFA_<unknown>";
8770 dump_die (struct die_info
*die
)
8774 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8775 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8776 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8777 dwarf_bool_name (die
->child
!= NULL
));
8779 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8780 for (i
= 0; i
< die
->num_attrs
; ++i
)
8782 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8783 dwarf_attr_name (die
->attrs
[i
].name
),
8784 dwarf_form_name (die
->attrs
[i
].form
));
8785 switch (die
->attrs
[i
].form
)
8787 case DW_FORM_ref_addr
:
8789 fprintf_unfiltered (gdb_stderr
, "address: ");
8790 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8792 case DW_FORM_block2
:
8793 case DW_FORM_block4
:
8795 case DW_FORM_block1
:
8796 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8801 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8802 (long) (DW_ADDR (&die
->attrs
[i
])));
8810 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8812 case DW_FORM_string
:
8814 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8815 DW_STRING (&die
->attrs
[i
])
8816 ? DW_STRING (&die
->attrs
[i
]) : "");
8819 if (DW_UNSND (&die
->attrs
[i
]))
8820 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8822 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8824 case DW_FORM_indirect
:
8825 /* the reader will have reduced the indirect form to
8826 the "base form" so this form should not occur */
8827 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8830 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8831 die
->attrs
[i
].form
);
8833 fprintf_unfiltered (gdb_stderr
, "\n");
8838 dump_die_list (struct die_info
*die
)
8843 if (die
->child
!= NULL
)
8844 dump_die_list (die
->child
);
8845 if (die
->sibling
!= NULL
)
8846 dump_die_list (die
->sibling
);
8851 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8852 struct dwarf2_cu
*cu
)
8855 struct die_info
*old
;
8857 h
= (offset
% REF_HASH_SIZE
);
8858 old
= cu
->die_ref_table
[h
];
8859 die
->next_ref
= old
;
8860 cu
->die_ref_table
[h
] = die
;
8864 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8866 unsigned int result
= 0;
8870 case DW_FORM_ref_addr
:
8875 case DW_FORM_ref_udata
:
8876 result
= DW_ADDR (attr
);
8879 complaint (&symfile_complaints
,
8880 _("unsupported die ref attribute form: '%s'"),
8881 dwarf_form_name (attr
->form
));
8886 /* Return the constant value held by the given attribute. Return -1
8887 if the value held by the attribute is not constant. */
8890 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8892 if (attr
->form
== DW_FORM_sdata
)
8893 return DW_SND (attr
);
8894 else if (attr
->form
== DW_FORM_udata
8895 || attr
->form
== DW_FORM_data1
8896 || attr
->form
== DW_FORM_data2
8897 || attr
->form
== DW_FORM_data4
8898 || attr
->form
== DW_FORM_data8
)
8899 return DW_UNSND (attr
);
8902 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8903 dwarf_form_name (attr
->form
));
8904 return default_value
;
8908 static struct die_info
*
8909 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8910 struct dwarf2_cu
*cu
)
8912 struct die_info
*die
;
8913 unsigned int offset
;
8915 struct die_info temp_die
;
8916 struct dwarf2_cu
*target_cu
;
8918 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8920 if (DW_ADDR (attr
) < cu
->header
.offset
8921 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8923 struct dwarf2_per_cu_data
*per_cu
;
8924 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8926 target_cu
= per_cu
->cu
;
8931 h
= (offset
% REF_HASH_SIZE
);
8932 die
= target_cu
->die_ref_table
[h
];
8935 if (die
->offset
== offset
)
8937 die
= die
->next_ref
;
8940 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8941 "at 0x%lx [in module %s]"),
8942 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8947 /* Decode simple location descriptions.
8948 Given a pointer to a dwarf block that defines a location, compute
8949 the location and return the value.
8951 NOTE drow/2003-11-18: This function is called in two situations
8952 now: for the address of static or global variables (partial symbols
8953 only) and for offsets into structures which are expected to be
8954 (more or less) constant. The partial symbol case should go away,
8955 and only the constant case should remain. That will let this
8956 function complain more accurately. A few special modes are allowed
8957 without complaint for global variables (for instance, global
8958 register values and thread-local values).
8960 A location description containing no operations indicates that the
8961 object is optimized out. The return value is 0 for that case.
8962 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8963 callers will only want a very basic result and this can become a
8966 Note that stack[0] is unused except as a default error return.
8967 Note that stack overflow is not yet handled. */
8970 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8972 struct objfile
*objfile
= cu
->objfile
;
8973 struct comp_unit_head
*cu_header
= &cu
->header
;
8975 int size
= blk
->size
;
8976 gdb_byte
*data
= blk
->data
;
8977 CORE_ADDR stack
[64];
8979 unsigned int bytes_read
, unsnd
;
9023 stack
[++stacki
] = op
- DW_OP_lit0
;
9058 stack
[++stacki
] = op
- DW_OP_reg0
;
9060 dwarf2_complex_location_expr_complaint ();
9064 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9066 stack
[++stacki
] = unsnd
;
9068 dwarf2_complex_location_expr_complaint ();
9072 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
9078 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
9083 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
9088 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
9093 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
9098 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
9103 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
9108 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
9114 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
9119 stack
[stacki
+ 1] = stack
[stacki
];
9124 stack
[stacki
- 1] += stack
[stacki
];
9128 case DW_OP_plus_uconst
:
9129 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9134 stack
[stacki
- 1] -= stack
[stacki
];
9139 /* If we're not the last op, then we definitely can't encode
9140 this using GDB's address_class enum. This is valid for partial
9141 global symbols, although the variable's address will be bogus
9144 dwarf2_complex_location_expr_complaint ();
9147 case DW_OP_GNU_push_tls_address
:
9148 /* The top of the stack has the offset from the beginning
9149 of the thread control block at which the variable is located. */
9150 /* Nothing should follow this operator, so the top of stack would
9152 /* This is valid for partial global symbols, but the variable's
9153 address will be bogus in the psymtab. */
9155 dwarf2_complex_location_expr_complaint ();
9158 case DW_OP_GNU_uninit
:
9162 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
9163 dwarf_stack_op_name (op
));
9164 return (stack
[stacki
]);
9167 return (stack
[stacki
]);
9170 /* memory allocation interface */
9172 static struct dwarf_block
*
9173 dwarf_alloc_block (struct dwarf2_cu
*cu
)
9175 struct dwarf_block
*blk
;
9177 blk
= (struct dwarf_block
*)
9178 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
9182 static struct abbrev_info
*
9183 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
9185 struct abbrev_info
*abbrev
;
9187 abbrev
= (struct abbrev_info
*)
9188 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
9189 memset (abbrev
, 0, sizeof (struct abbrev_info
));
9193 static struct die_info
*
9194 dwarf_alloc_die (void)
9196 struct die_info
*die
;
9198 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
9199 memset (die
, 0, sizeof (struct die_info
));
9204 /* Macro support. */
9207 /* Return the full name of file number I in *LH's file name table.
9208 Use COMP_DIR as the name of the current directory of the
9209 compilation. The result is allocated using xmalloc; the caller is
9210 responsible for freeing it. */
9212 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
9214 /* Is the file number a valid index into the line header's file name
9215 table? Remember that file numbers start with one, not zero. */
9216 if (1 <= file
&& file
<= lh
->num_file_names
)
9218 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9220 if (IS_ABSOLUTE_PATH (fe
->name
))
9221 return xstrdup (fe
->name
);
9229 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9235 dir_len
= strlen (dir
);
9236 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
9237 strcpy (full_name
, dir
);
9238 full_name
[dir_len
] = '/';
9239 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
9243 return xstrdup (fe
->name
);
9248 /* The compiler produced a bogus file number. We can at least
9249 record the macro definitions made in the file, even if we
9250 won't be able to find the file by name. */
9252 sprintf (fake_name
, "<bad macro file number %d>", file
);
9254 complaint (&symfile_complaints
,
9255 _("bad file number in macro information (%d)"),
9258 return xstrdup (fake_name
);
9263 static struct macro_source_file
*
9264 macro_start_file (int file
, int line
,
9265 struct macro_source_file
*current_file
,
9266 const char *comp_dir
,
9267 struct line_header
*lh
, struct objfile
*objfile
)
9269 /* The full name of this source file. */
9270 char *full_name
= file_full_name (file
, lh
, comp_dir
);
9272 /* We don't create a macro table for this compilation unit
9273 at all until we actually get a filename. */
9274 if (! pending_macros
)
9275 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
9276 objfile
->macro_cache
);
9279 /* If we have no current file, then this must be the start_file
9280 directive for the compilation unit's main source file. */
9281 current_file
= macro_set_main (pending_macros
, full_name
);
9283 current_file
= macro_include (current_file
, line
, full_name
);
9287 return current_file
;
9291 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9292 followed by a null byte. */
9294 copy_string (const char *buf
, int len
)
9296 char *s
= xmalloc (len
+ 1);
9297 memcpy (s
, buf
, len
);
9305 consume_improper_spaces (const char *p
, const char *body
)
9309 complaint (&symfile_complaints
,
9310 _("macro definition contains spaces in formal argument list:\n`%s'"),
9322 parse_macro_definition (struct macro_source_file
*file
, int line
,
9327 /* The body string takes one of two forms. For object-like macro
9328 definitions, it should be:
9330 <macro name> " " <definition>
9332 For function-like macro definitions, it should be:
9334 <macro name> "() " <definition>
9336 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9338 Spaces may appear only where explicitly indicated, and in the
9341 The Dwarf 2 spec says that an object-like macro's name is always
9342 followed by a space, but versions of GCC around March 2002 omit
9343 the space when the macro's definition is the empty string.
9345 The Dwarf 2 spec says that there should be no spaces between the
9346 formal arguments in a function-like macro's formal argument list,
9347 but versions of GCC around March 2002 include spaces after the
9351 /* Find the extent of the macro name. The macro name is terminated
9352 by either a space or null character (for an object-like macro) or
9353 an opening paren (for a function-like macro). */
9354 for (p
= body
; *p
; p
++)
9355 if (*p
== ' ' || *p
== '(')
9358 if (*p
== ' ' || *p
== '\0')
9360 /* It's an object-like macro. */
9361 int name_len
= p
- body
;
9362 char *name
= copy_string (body
, name_len
);
9363 const char *replacement
;
9366 replacement
= body
+ name_len
+ 1;
9369 dwarf2_macro_malformed_definition_complaint (body
);
9370 replacement
= body
+ name_len
;
9373 macro_define_object (file
, line
, name
, replacement
);
9379 /* It's a function-like macro. */
9380 char *name
= copy_string (body
, p
- body
);
9383 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9387 p
= consume_improper_spaces (p
, body
);
9389 /* Parse the formal argument list. */
9390 while (*p
&& *p
!= ')')
9392 /* Find the extent of the current argument name. */
9393 const char *arg_start
= p
;
9395 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9398 if (! *p
|| p
== arg_start
)
9399 dwarf2_macro_malformed_definition_complaint (body
);
9402 /* Make sure argv has room for the new argument. */
9403 if (argc
>= argv_size
)
9406 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9409 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9412 p
= consume_improper_spaces (p
, body
);
9414 /* Consume the comma, if present. */
9419 p
= consume_improper_spaces (p
, body
);
9428 /* Perfectly formed definition, no complaints. */
9429 macro_define_function (file
, line
, name
,
9430 argc
, (const char **) argv
,
9432 else if (*p
== '\0')
9434 /* Complain, but do define it. */
9435 dwarf2_macro_malformed_definition_complaint (body
);
9436 macro_define_function (file
, line
, name
,
9437 argc
, (const char **) argv
,
9441 /* Just complain. */
9442 dwarf2_macro_malformed_definition_complaint (body
);
9445 /* Just complain. */
9446 dwarf2_macro_malformed_definition_complaint (body
);
9452 for (i
= 0; i
< argc
; i
++)
9458 dwarf2_macro_malformed_definition_complaint (body
);
9463 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9464 char *comp_dir
, bfd
*abfd
,
9465 struct dwarf2_cu
*cu
)
9467 gdb_byte
*mac_ptr
, *mac_end
;
9468 struct macro_source_file
*current_file
= 0;
9470 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9472 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9476 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9477 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9478 + dwarf2_per_objfile
->macinfo_size
;
9482 enum dwarf_macinfo_record_type macinfo_type
;
9484 /* Do we at least have room for a macinfo type byte? */
9485 if (mac_ptr
>= mac_end
)
9487 dwarf2_macros_too_long_complaint ();
9491 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9494 switch (macinfo_type
)
9496 /* A zero macinfo type indicates the end of the macro
9501 case DW_MACINFO_define
:
9502 case DW_MACINFO_undef
:
9504 unsigned int bytes_read
;
9508 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9509 mac_ptr
+= bytes_read
;
9510 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9511 mac_ptr
+= bytes_read
;
9514 complaint (&symfile_complaints
,
9515 _("debug info gives macro %s outside of any file: %s"),
9517 DW_MACINFO_define
? "definition" : macinfo_type
==
9518 DW_MACINFO_undef
? "undefinition" :
9519 "something-or-other", body
);
9522 if (macinfo_type
== DW_MACINFO_define
)
9523 parse_macro_definition (current_file
, line
, body
);
9524 else if (macinfo_type
== DW_MACINFO_undef
)
9525 macro_undef (current_file
, line
, body
);
9530 case DW_MACINFO_start_file
:
9532 unsigned int bytes_read
;
9535 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9536 mac_ptr
+= bytes_read
;
9537 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9538 mac_ptr
+= bytes_read
;
9540 current_file
= macro_start_file (file
, line
,
9541 current_file
, comp_dir
,
9546 case DW_MACINFO_end_file
:
9548 complaint (&symfile_complaints
,
9549 _("macro debug info has an unmatched `close_file' directive"));
9552 current_file
= current_file
->included_by
;
9555 enum dwarf_macinfo_record_type next_type
;
9557 /* GCC circa March 2002 doesn't produce the zero
9558 type byte marking the end of the compilation
9559 unit. Complain if it's not there, but exit no
9562 /* Do we at least have room for a macinfo type byte? */
9563 if (mac_ptr
>= mac_end
)
9565 dwarf2_macros_too_long_complaint ();
9569 /* We don't increment mac_ptr here, so this is just
9571 next_type
= read_1_byte (abfd
, mac_ptr
);
9573 complaint (&symfile_complaints
,
9574 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9581 case DW_MACINFO_vendor_ext
:
9583 unsigned int bytes_read
;
9587 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9588 mac_ptr
+= bytes_read
;
9589 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9590 mac_ptr
+= bytes_read
;
9592 /* We don't recognize any vendor extensions. */
9599 /* Check if the attribute's form is a DW_FORM_block*
9600 if so return true else false. */
9602 attr_form_is_block (struct attribute
*attr
)
9604 return (attr
== NULL
? 0 :
9605 attr
->form
== DW_FORM_block1
9606 || attr
->form
== DW_FORM_block2
9607 || attr
->form
== DW_FORM_block4
9608 || attr
->form
== DW_FORM_block
);
9612 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9613 struct dwarf2_cu
*cu
)
9615 struct objfile
*objfile
= cu
->objfile
;
9617 /* Save the master objfile, so that we can report and look up the
9618 correct file containing this variable. */
9619 if (objfile
->separate_debug_objfile_backlink
)
9620 objfile
= objfile
->separate_debug_objfile_backlink
;
9622 if ((attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9623 /* ".debug_loc" may not exist at all, or the offset may be outside
9624 the section. If so, fall through to the complaint in the
9626 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9628 struct dwarf2_loclist_baton
*baton
;
9630 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9631 sizeof (struct dwarf2_loclist_baton
));
9632 baton
->objfile
= objfile
;
9634 /* We don't know how long the location list is, but make sure we
9635 don't run off the edge of the section. */
9636 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9637 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9638 baton
->base_address
= cu
->header
.base_address
;
9639 if (cu
->header
.base_known
== 0)
9640 complaint (&symfile_complaints
,
9641 _("Location list used without specifying the CU base address."));
9643 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9644 SYMBOL_LOCATION_BATON (sym
) = baton
;
9648 struct dwarf2_locexpr_baton
*baton
;
9650 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9651 sizeof (struct dwarf2_locexpr_baton
));
9652 baton
->objfile
= objfile
;
9654 if (attr_form_is_block (attr
))
9656 /* Note that we're just copying the block's data pointer
9657 here, not the actual data. We're still pointing into the
9658 info_buffer for SYM's objfile; right now we never release
9659 that buffer, but when we do clean up properly this may
9661 baton
->size
= DW_BLOCK (attr
)->size
;
9662 baton
->data
= DW_BLOCK (attr
)->data
;
9666 dwarf2_invalid_attrib_class_complaint ("location description",
9667 SYMBOL_NATURAL_NAME (sym
));
9672 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9673 SYMBOL_LOCATION_BATON (sym
) = baton
;
9677 /* Locate the compilation unit from CU's objfile which contains the
9678 DIE at OFFSET. Raises an error on failure. */
9680 static struct dwarf2_per_cu_data
*
9681 dwarf2_find_containing_comp_unit (unsigned long offset
,
9682 struct objfile
*objfile
)
9684 struct dwarf2_per_cu_data
*this_cu
;
9688 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9691 int mid
= low
+ (high
- low
) / 2;
9692 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9697 gdb_assert (low
== high
);
9698 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9701 error (_("Dwarf Error: could not find partial DIE containing "
9702 "offset 0x%lx [in module %s]"),
9703 (long) offset
, bfd_get_filename (objfile
->obfd
));
9705 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9706 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9710 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9711 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9712 && offset
>= this_cu
->offset
+ this_cu
->length
)
9713 error (_("invalid dwarf2 offset %ld"), offset
);
9714 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9719 /* Locate the compilation unit from OBJFILE which is located at exactly
9720 OFFSET. Raises an error on failure. */
9722 static struct dwarf2_per_cu_data
*
9723 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9725 struct dwarf2_per_cu_data
*this_cu
;
9726 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9727 if (this_cu
->offset
!= offset
)
9728 error (_("no compilation unit with offset %ld."), offset
);
9732 /* Release one cached compilation unit, CU. We unlink it from the tree
9733 of compilation units, but we don't remove it from the read_in_chain;
9734 the caller is responsible for that. */
9737 free_one_comp_unit (void *data
)
9739 struct dwarf2_cu
*cu
= data
;
9741 if (cu
->per_cu
!= NULL
)
9742 cu
->per_cu
->cu
= NULL
;
9745 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9747 free_die_list (cu
->dies
);
9752 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9753 when we're finished with it. We can't free the pointer itself, but be
9754 sure to unlink it from the cache. Also release any associated storage
9755 and perform cache maintenance.
9757 Only used during partial symbol parsing. */
9760 free_stack_comp_unit (void *data
)
9762 struct dwarf2_cu
*cu
= data
;
9764 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9765 cu
->partial_dies
= NULL
;
9767 if (cu
->per_cu
!= NULL
)
9769 /* This compilation unit is on the stack in our caller, so we
9770 should not xfree it. Just unlink it. */
9771 cu
->per_cu
->cu
= NULL
;
9774 /* If we had a per-cu pointer, then we may have other compilation
9775 units loaded, so age them now. */
9776 age_cached_comp_units ();
9780 /* Free all cached compilation units. */
9783 free_cached_comp_units (void *data
)
9785 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9787 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9788 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9789 while (per_cu
!= NULL
)
9791 struct dwarf2_per_cu_data
*next_cu
;
9793 next_cu
= per_cu
->cu
->read_in_chain
;
9795 free_one_comp_unit (per_cu
->cu
);
9796 *last_chain
= next_cu
;
9802 /* Increase the age counter on each cached compilation unit, and free
9803 any that are too old. */
9806 age_cached_comp_units (void)
9808 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9810 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9811 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9812 while (per_cu
!= NULL
)
9814 per_cu
->cu
->last_used
++;
9815 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9816 dwarf2_mark (per_cu
->cu
);
9817 per_cu
= per_cu
->cu
->read_in_chain
;
9820 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9821 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9822 while (per_cu
!= NULL
)
9824 struct dwarf2_per_cu_data
*next_cu
;
9826 next_cu
= per_cu
->cu
->read_in_chain
;
9828 if (!per_cu
->cu
->mark
)
9830 free_one_comp_unit (per_cu
->cu
);
9831 *last_chain
= next_cu
;
9834 last_chain
= &per_cu
->cu
->read_in_chain
;
9840 /* Remove a single compilation unit from the cache. */
9843 free_one_cached_comp_unit (void *target_cu
)
9845 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9847 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9848 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9849 while (per_cu
!= NULL
)
9851 struct dwarf2_per_cu_data
*next_cu
;
9853 next_cu
= per_cu
->cu
->read_in_chain
;
9855 if (per_cu
->cu
== target_cu
)
9857 free_one_comp_unit (per_cu
->cu
);
9858 *last_chain
= next_cu
;
9862 last_chain
= &per_cu
->cu
->read_in_chain
;
9868 /* Release all extra memory associated with OBJFILE. */
9871 dwarf2_free_objfile (struct objfile
*objfile
)
9873 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
9875 if (dwarf2_per_objfile
== NULL
)
9878 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
9879 free_cached_comp_units (NULL
);
9881 /* Everything else should be on the objfile obstack. */
9884 /* A pair of DIE offset and GDB type pointer. We store these
9885 in a hash table separate from the DIEs, and preserve them
9886 when the DIEs are flushed out of cache. */
9888 struct dwarf2_offset_and_type
9890 unsigned int offset
;
9894 /* Hash function for a dwarf2_offset_and_type. */
9897 offset_and_type_hash (const void *item
)
9899 const struct dwarf2_offset_and_type
*ofs
= item
;
9903 /* Equality function for a dwarf2_offset_and_type. */
9906 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9908 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9909 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9910 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9913 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9914 table if necessary. */
9917 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9919 struct dwarf2_offset_and_type
**slot
, ofs
;
9923 if (cu
->per_cu
== NULL
)
9926 if (cu
->per_cu
->type_hash
== NULL
)
9927 cu
->per_cu
->type_hash
9928 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9929 offset_and_type_hash
,
9932 &cu
->objfile
->objfile_obstack
,
9933 hashtab_obstack_allocate
,
9934 dummy_obstack_deallocate
);
9936 ofs
.offset
= die
->offset
;
9938 slot
= (struct dwarf2_offset_and_type
**)
9939 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9940 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9944 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9945 have a saved type. */
9947 static struct type
*
9948 get_die_type (struct die_info
*die
, htab_t type_hash
)
9950 struct dwarf2_offset_and_type
*slot
, ofs
;
9952 ofs
.offset
= die
->offset
;
9953 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9960 /* Restore the types of the DIE tree starting at START_DIE from the hash
9961 table saved in CU. */
9964 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9966 struct die_info
*die
;
9968 if (cu
->per_cu
->type_hash
== NULL
)
9971 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9973 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9974 if (die
->child
!= NULL
)
9975 reset_die_and_siblings_types (die
->child
, cu
);
9979 /* Set the mark field in CU and in every other compilation unit in the
9980 cache that we must keep because we are keeping CU. */
9982 /* Add a dependence relationship from CU to REF_PER_CU. */
9985 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9986 struct dwarf2_per_cu_data
*ref_per_cu
)
9990 if (cu
->dependencies
== NULL
)
9992 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9993 NULL
, &cu
->comp_unit_obstack
,
9994 hashtab_obstack_allocate
,
9995 dummy_obstack_deallocate
);
9997 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
10002 /* Set the mark field in CU and in every other compilation unit in the
10003 cache that we must keep because we are keeping CU. */
10006 dwarf2_mark_helper (void **slot
, void *data
)
10008 struct dwarf2_per_cu_data
*per_cu
;
10010 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
10011 if (per_cu
->cu
->mark
)
10013 per_cu
->cu
->mark
= 1;
10015 if (per_cu
->cu
->dependencies
!= NULL
)
10016 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10022 dwarf2_mark (struct dwarf2_cu
*cu
)
10027 if (cu
->dependencies
!= NULL
)
10028 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10032 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
10036 per_cu
->cu
->mark
= 0;
10037 per_cu
= per_cu
->cu
->read_in_chain
;
10041 /* Trivial hash function for partial_die_info: the hash value of a DIE
10042 is its offset in .debug_info for this objfile. */
10045 partial_die_hash (const void *item
)
10047 const struct partial_die_info
*part_die
= item
;
10048 return part_die
->offset
;
10051 /* Trivial comparison function for partial_die_info structures: two DIEs
10052 are equal if they have the same offset. */
10055 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
10057 const struct partial_die_info
*part_die_lhs
= item_lhs
;
10058 const struct partial_die_info
*part_die_rhs
= item_rhs
;
10059 return part_die_lhs
->offset
== part_die_rhs
->offset
;
10062 static struct cmd_list_element
*set_dwarf2_cmdlist
;
10063 static struct cmd_list_element
*show_dwarf2_cmdlist
;
10066 set_dwarf2_cmd (char *args
, int from_tty
)
10068 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
10072 show_dwarf2_cmd (char *args
, int from_tty
)
10074 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
10077 void _initialize_dwarf2_read (void);
10080 _initialize_dwarf2_read (void)
10082 dwarf2_objfile_data_key
= register_objfile_data ();
10084 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
10085 Set DWARF 2 specific variables.\n\
10086 Configure DWARF 2 variables such as the cache size"),
10087 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
10088 0/*allow-unknown*/, &maintenance_set_cmdlist
);
10090 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
10091 Show DWARF 2 specific variables\n\
10092 Show DWARF 2 variables such as the cache size"),
10093 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
10094 0/*allow-unknown*/, &maintenance_show_cmdlist
);
10096 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
10097 &dwarf2_max_cache_age
, _("\
10098 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
10099 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
10100 A higher limit means that cached compilation units will be stored\n\
10101 in memory longer, and more total memory will be used. Zero disables\n\
10102 caching, which can slow down startup."),
10104 show_dwarf2_max_cache_age
,
10105 &set_dwarf2_cmdlist
,
10106 &show_dwarf2_cmdlist
);