1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 support in dwarfread.c
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 2 of the License, or (at
19 your option) any later version.
21 This program is distributed in the hope that it will be useful, but
22 WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street, Fifth Floor,
29 Boston, MA 02110-1301, USA. */
36 #include "elf/dwarf2.h"
39 #include "expression.h"
40 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
45 #include "dwarf2expr.h"
46 #include "dwarf2loc.h"
47 #include "cp-support.h"
53 #include "gdb_string.h"
54 #include "gdb_assert.h"
55 #include <sys/types.h>
57 /* A note on memory usage for this file.
59 At the present time, this code reads the debug info sections into
60 the objfile's objfile_obstack. A definite improvement for startup
61 time, on platforms which do not emit relocations for debug
62 sections, would be to use mmap instead. The object's complete
63 debug information is loaded into memory, partly to simplify
64 absolute DIE references.
66 Whether using obstacks or mmap, the sections should remain loaded
67 until the objfile is released, and pointers into the section data
68 can be used for any other data associated to the objfile (symbol
69 names, type names, location expressions to name a few). */
71 #ifndef DWARF2_REG_TO_REGNUM
72 #define DWARF2_REG_TO_REGNUM(REG) (REG)
76 /* .debug_info header for a compilation unit
77 Because of alignment constraints, this structure has padding and cannot
78 be mapped directly onto the beginning of the .debug_info section. */
79 typedef struct comp_unit_header
81 unsigned int length
; /* length of the .debug_info
83 unsigned short version
; /* version number -- 2 for DWARF
85 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
86 unsigned char addr_size
; /* byte size of an address -- 4 */
89 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
92 /* .debug_pubnames header
93 Because of alignment constraints, this structure has padding and cannot
94 be mapped directly onto the beginning of the .debug_info section. */
95 typedef struct pubnames_header
97 unsigned int length
; /* length of the .debug_pubnames
99 unsigned char version
; /* version number -- 2 for DWARF
101 unsigned int info_offset
; /* offset into .debug_info section */
102 unsigned int info_size
; /* byte size of .debug_info section
106 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
108 /* .debug_pubnames header
109 Because of alignment constraints, this structure has padding and cannot
110 be mapped directly onto the beginning of the .debug_info section. */
111 typedef struct aranges_header
113 unsigned int length
; /* byte len of the .debug_aranges
115 unsigned short version
; /* version number -- 2 for DWARF
117 unsigned int info_offset
; /* offset into .debug_info section */
118 unsigned char addr_size
; /* byte size of an address */
119 unsigned char seg_size
; /* byte size of segment descriptor */
122 #define _ACTUAL_ARANGES_HEADER_SIZE 12
124 /* .debug_line statement program prologue
125 Because of alignment constraints, this structure has padding and cannot
126 be mapped directly onto the beginning of the .debug_info section. */
127 typedef struct statement_prologue
129 unsigned int total_length
; /* byte length of the statement
131 unsigned short version
; /* version number -- 2 for DWARF
133 unsigned int prologue_length
; /* # bytes between prologue &
135 unsigned char minimum_instruction_length
; /* byte size of
137 unsigned char default_is_stmt
; /* initial value of is_stmt
140 unsigned char line_range
;
141 unsigned char opcode_base
; /* number assigned to first special
143 unsigned char *standard_opcode_lengths
;
147 static const struct objfile_data
*dwarf2_objfile_data_key
;
149 struct dwarf2_per_objfile
151 /* Sizes of debugging sections. */
152 unsigned int info_size
;
153 unsigned int abbrev_size
;
154 unsigned int line_size
;
155 unsigned int pubnames_size
;
156 unsigned int aranges_size
;
157 unsigned int loc_size
;
158 unsigned int macinfo_size
;
159 unsigned int str_size
;
160 unsigned int ranges_size
;
161 unsigned int frame_size
;
162 unsigned int eh_frame_size
;
164 /* Loaded data from the sections. */
165 gdb_byte
*info_buffer
;
166 gdb_byte
*abbrev_buffer
;
167 gdb_byte
*line_buffer
;
168 gdb_byte
*str_buffer
;
169 gdb_byte
*macinfo_buffer
;
170 gdb_byte
*ranges_buffer
;
171 gdb_byte
*loc_buffer
;
173 /* A list of all the compilation units. This is used to locate
174 the target compilation unit of a particular reference. */
175 struct dwarf2_per_cu_data
**all_comp_units
;
177 /* The number of compilation units in ALL_COMP_UNITS. */
180 /* A chain of compilation units that are currently read in, so that
181 they can be freed later. */
182 struct dwarf2_per_cu_data
*read_in_chain
;
185 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
187 static asection
*dwarf_info_section
;
188 static asection
*dwarf_abbrev_section
;
189 static asection
*dwarf_line_section
;
190 static asection
*dwarf_pubnames_section
;
191 static asection
*dwarf_aranges_section
;
192 static asection
*dwarf_loc_section
;
193 static asection
*dwarf_macinfo_section
;
194 static asection
*dwarf_str_section
;
195 static asection
*dwarf_ranges_section
;
196 asection
*dwarf_frame_section
;
197 asection
*dwarf_eh_frame_section
;
199 /* names of the debugging sections */
201 #define INFO_SECTION ".debug_info"
202 #define ABBREV_SECTION ".debug_abbrev"
203 #define LINE_SECTION ".debug_line"
204 #define PUBNAMES_SECTION ".debug_pubnames"
205 #define ARANGES_SECTION ".debug_aranges"
206 #define LOC_SECTION ".debug_loc"
207 #define MACINFO_SECTION ".debug_macinfo"
208 #define STR_SECTION ".debug_str"
209 #define RANGES_SECTION ".debug_ranges"
210 #define FRAME_SECTION ".debug_frame"
211 #define EH_FRAME_SECTION ".eh_frame"
213 /* local data types */
215 /* We hold several abbreviation tables in memory at the same time. */
216 #ifndef ABBREV_HASH_SIZE
217 #define ABBREV_HASH_SIZE 121
220 /* The data in a compilation unit header, after target2host
221 translation, looks like this. */
222 struct comp_unit_head
224 unsigned long length
;
226 unsigned int abbrev_offset
;
227 unsigned char addr_size
;
228 unsigned char signed_addr_p
;
230 /* Size of file offsets; either 4 or 8. */
231 unsigned int offset_size
;
233 /* Size of the length field; either 4 or 12. */
234 unsigned int initial_length_size
;
236 /* Offset to the first byte of this compilation unit header in the
237 .debug_info section, for resolving relative reference dies. */
240 /* Pointer to this compilation unit header in the .debug_info
242 gdb_byte
*cu_head_ptr
;
244 /* Pointer to the first die of this compilation unit. This will be
245 the first byte following the compilation unit header. */
246 gdb_byte
*first_die_ptr
;
248 /* Pointer to the next compilation unit header in the program. */
249 struct comp_unit_head
*next
;
251 /* Base address of this compilation unit. */
252 CORE_ADDR base_address
;
254 /* Non-zero if base_address has been set. */
258 /* Fixed size for the DIE hash table. */
259 #ifndef REF_HASH_SIZE
260 #define REF_HASH_SIZE 1021
263 /* Internal state when decoding a particular compilation unit. */
266 /* The objfile containing this compilation unit. */
267 struct objfile
*objfile
;
269 /* The header of the compilation unit.
271 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
272 should logically be moved to the dwarf2_cu structure. */
273 struct comp_unit_head header
;
275 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
277 /* The language we are debugging. */
278 enum language language
;
279 const struct language_defn
*language_defn
;
281 const char *producer
;
283 /* The generic symbol table building routines have separate lists for
284 file scope symbols and all all other scopes (local scopes). So
285 we need to select the right one to pass to add_symbol_to_list().
286 We do it by keeping a pointer to the correct list in list_in_scope.
288 FIXME: The original dwarf code just treated the file scope as the
289 first local scope, and all other local scopes as nested local
290 scopes, and worked fine. Check to see if we really need to
291 distinguish these in buildsym.c. */
292 struct pending
**list_in_scope
;
294 /* Maintain an array of referenced fundamental types for the current
295 compilation unit being read. For DWARF version 1, we have to construct
296 the fundamental types on the fly, since no information about the
297 fundamental types is supplied. Each such fundamental type is created by
298 calling a language dependent routine to create the type, and then a
299 pointer to that type is then placed in the array at the index specified
300 by it's FT_<TYPENAME> value. The array has a fixed size set by the
301 FT_NUM_MEMBERS compile time constant, which is the number of predefined
302 fundamental types gdb knows how to construct. */
303 struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
305 /* DWARF abbreviation table associated with this compilation unit. */
306 struct abbrev_info
**dwarf2_abbrevs
;
308 /* Storage for the abbrev table. */
309 struct obstack abbrev_obstack
;
311 /* Hash table holding all the loaded partial DIEs. */
314 /* Storage for things with the same lifetime as this read-in compilation
315 unit, including partial DIEs. */
316 struct obstack comp_unit_obstack
;
318 /* When multiple dwarf2_cu structures are living in memory, this field
319 chains them all together, so that they can be released efficiently.
320 We will probably also want a generation counter so that most-recently-used
321 compilation units are cached... */
322 struct dwarf2_per_cu_data
*read_in_chain
;
324 /* Backchain to our per_cu entry if the tree has been built. */
325 struct dwarf2_per_cu_data
*per_cu
;
327 /* How many compilation units ago was this CU last referenced? */
330 /* A hash table of die offsets for following references. */
331 struct die_info
*die_ref_table
[REF_HASH_SIZE
];
333 /* Full DIEs if read in. */
334 struct die_info
*dies
;
336 /* A set of pointers to dwarf2_per_cu_data objects for compilation
337 units referenced by this one. Only set during full symbol processing;
338 partial symbol tables do not have dependencies. */
341 /* Mark used when releasing cached dies. */
342 unsigned int mark
: 1;
344 /* This flag will be set if this compilation unit might include
345 inter-compilation-unit references. */
346 unsigned int has_form_ref_addr
: 1;
348 /* This flag will be set if this compilation unit includes any
349 DW_TAG_namespace DIEs. If we know that there are explicit
350 DIEs for namespaces, we don't need to try to infer them
351 from mangled names. */
352 unsigned int has_namespace_info
: 1;
355 /* Persistent data held for a compilation unit, even when not
356 processing it. We put a pointer to this structure in the
357 read_symtab_private field of the psymtab. If we encounter
358 inter-compilation-unit references, we also maintain a sorted
359 list of all compilation units. */
361 struct dwarf2_per_cu_data
363 /* The start offset and length of this compilation unit. 2**31-1
364 bytes should suffice to store the length of any compilation unit
365 - if it doesn't, GDB will fall over anyway. */
366 unsigned long offset
;
367 unsigned long length
: 31;
369 /* Flag indicating this compilation unit will be read in before
370 any of the current compilation units are processed. */
371 unsigned long queued
: 1;
373 /* Set iff currently read in. */
374 struct dwarf2_cu
*cu
;
376 /* If full symbols for this CU have been read in, then this field
377 holds a map of DIE offsets to types. It isn't always possible
378 to reconstruct this information later, so we have to preserve
382 /* The partial symbol table associated with this compilation unit. */
383 struct partial_symtab
*psymtab
;
386 /* The line number information for a compilation unit (found in the
387 .debug_line section) begins with a "statement program header",
388 which contains the following information. */
391 unsigned int total_length
;
392 unsigned short version
;
393 unsigned int header_length
;
394 unsigned char minimum_instruction_length
;
395 unsigned char default_is_stmt
;
397 unsigned char line_range
;
398 unsigned char opcode_base
;
400 /* standard_opcode_lengths[i] is the number of operands for the
401 standard opcode whose value is i. This means that
402 standard_opcode_lengths[0] is unused, and the last meaningful
403 element is standard_opcode_lengths[opcode_base - 1]. */
404 unsigned char *standard_opcode_lengths
;
406 /* The include_directories table. NOTE! These strings are not
407 allocated with xmalloc; instead, they are pointers into
408 debug_line_buffer. If you try to free them, `free' will get
410 unsigned int num_include_dirs
, include_dirs_size
;
413 /* The file_names table. NOTE! These strings are not allocated
414 with xmalloc; instead, they are pointers into debug_line_buffer.
415 Don't try to free them directly. */
416 unsigned int num_file_names
, file_names_size
;
420 unsigned int dir_index
;
421 unsigned int mod_time
;
423 int included_p
; /* Non-zero if referenced by the Line Number Program. */
426 /* The start and end of the statement program following this
427 header. These point into dwarf2_per_objfile->line_buffer. */
428 gdb_byte
*statement_program_start
, *statement_program_end
;
431 /* When we construct a partial symbol table entry we only
432 need this much information. */
433 struct partial_die_info
435 /* Offset of this DIE. */
438 /* DWARF-2 tag for this DIE. */
439 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
441 /* Language code associated with this DIE. This is only used
442 for the compilation unit DIE. */
443 unsigned int language
: 8;
445 /* Assorted flags describing the data found in this DIE. */
446 unsigned int has_children
: 1;
447 unsigned int is_external
: 1;
448 unsigned int is_declaration
: 1;
449 unsigned int has_type
: 1;
450 unsigned int has_specification
: 1;
451 unsigned int has_stmt_list
: 1;
452 unsigned int has_pc_info
: 1;
454 /* Flag set if the SCOPE field of this structure has been
456 unsigned int scope_set
: 1;
458 /* The name of this DIE. Normally the value of DW_AT_name, but
459 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
464 /* The scope to prepend to our children. This is generally
465 allocated on the comp_unit_obstack, so will disappear
466 when this compilation unit leaves the cache. */
469 /* The location description associated with this DIE, if any. */
470 struct dwarf_block
*locdesc
;
472 /* If HAS_PC_INFO, the PC range associated with this DIE. */
476 /* Pointer into the info_buffer pointing at the target of
477 DW_AT_sibling, if any. */
480 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
481 DW_AT_specification (or DW_AT_abstract_origin or
483 unsigned int spec_offset
;
485 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
486 unsigned int line_offset
;
488 /* Pointers to this DIE's parent, first child, and next sibling,
490 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
493 /* This data structure holds the information of an abbrev. */
496 unsigned int number
; /* number identifying abbrev */
497 enum dwarf_tag tag
; /* dwarf tag */
498 unsigned short has_children
; /* boolean */
499 unsigned short num_attrs
; /* number of attributes */
500 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
501 struct abbrev_info
*next
; /* next in chain */
506 enum dwarf_attribute name
;
507 enum dwarf_form form
;
510 /* This data structure holds a complete die structure. */
513 enum dwarf_tag tag
; /* Tag indicating type of die */
514 unsigned int abbrev
; /* Abbrev number */
515 unsigned int offset
; /* Offset in .debug_info section */
516 unsigned int num_attrs
; /* Number of attributes */
517 struct attribute
*attrs
; /* An array of attributes */
518 struct die_info
*next_ref
; /* Next die in ref hash table */
520 /* The dies in a compilation unit form an n-ary tree. PARENT
521 points to this die's parent; CHILD points to the first child of
522 this node; and all the children of a given node are chained
523 together via their SIBLING fields, terminated by a die whose
525 struct die_info
*child
; /* Its first child, if any. */
526 struct die_info
*sibling
; /* Its next sibling, if any. */
527 struct die_info
*parent
; /* Its parent, if any. */
529 struct type
*type
; /* Cached type information */
532 /* Attributes have a name and a value */
535 enum dwarf_attribute name
;
536 enum dwarf_form form
;
540 struct dwarf_block
*blk
;
548 struct function_range
551 CORE_ADDR lowpc
, highpc
;
553 struct function_range
*next
;
556 /* Get at parts of an attribute structure */
558 #define DW_STRING(attr) ((attr)->u.str)
559 #define DW_UNSND(attr) ((attr)->u.unsnd)
560 #define DW_BLOCK(attr) ((attr)->u.blk)
561 #define DW_SND(attr) ((attr)->u.snd)
562 #define DW_ADDR(attr) ((attr)->u.addr)
564 /* Blocks are a bunch of untyped bytes. */
571 #ifndef ATTR_ALLOC_CHUNK
572 #define ATTR_ALLOC_CHUNK 4
575 /* Allocate fields for structs, unions and enums in this size. */
576 #ifndef DW_FIELD_ALLOC_CHUNK
577 #define DW_FIELD_ALLOC_CHUNK 4
580 /* A zeroed version of a partial die for initialization purposes. */
581 static struct partial_die_info zeroed_partial_die
;
583 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
584 but this would require a corresponding change in unpack_field_as_long
586 static int bits_per_byte
= 8;
588 /* The routines that read and process dies for a C struct or C++ class
589 pass lists of data member fields and lists of member function fields
590 in an instance of a field_info structure, as defined below. */
593 /* List of data member and baseclasses fields. */
596 struct nextfield
*next
;
603 /* Number of fields. */
606 /* Number of baseclasses. */
609 /* Set if the accesibility of one of the fields is not public. */
610 int non_public_fields
;
612 /* Member function fields array, entries are allocated in the order they
613 are encountered in the object file. */
616 struct nextfnfield
*next
;
617 struct fn_field fnfield
;
621 /* Member function fieldlist array, contains name of possibly overloaded
622 member function, number of overloaded member functions and a pointer
623 to the head of the member function field chain. */
628 struct nextfnfield
*head
;
632 /* Number of entries in the fnfieldlists array. */
636 /* One item on the queue of compilation units to read in full symbols
638 struct dwarf2_queue_item
640 struct dwarf2_per_cu_data
*per_cu
;
641 struct dwarf2_queue_item
*next
;
644 /* The current queue. */
645 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
647 /* Loaded secondary compilation units are kept in memory until they
648 have not been referenced for the processing of this many
649 compilation units. Set this to zero to disable caching. Cache
650 sizes of up to at least twenty will improve startup time for
651 typical inter-CU-reference binaries, at an obvious memory cost. */
652 static int dwarf2_max_cache_age
= 5;
654 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
655 struct cmd_list_element
*c
, const char *value
)
657 fprintf_filtered (file
, _("\
658 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
663 /* Various complaints about symbol reading that don't abort the process */
666 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
668 complaint (&symfile_complaints
,
669 _("statement list doesn't fit in .debug_line section"));
673 dwarf2_complex_location_expr_complaint (void)
675 complaint (&symfile_complaints
, _("location expression too complex"));
679 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
682 complaint (&symfile_complaints
,
683 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
688 dwarf2_macros_too_long_complaint (void)
690 complaint (&symfile_complaints
,
691 _("macro info runs off end of `.debug_macinfo' section"));
695 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
697 complaint (&symfile_complaints
,
698 _("macro debug info contains a malformed macro definition:\n`%s'"),
703 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
705 complaint (&symfile_complaints
,
706 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
709 /* local function prototypes */
711 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
714 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
717 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
720 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
721 struct partial_die_info
*,
722 struct partial_symtab
*);
724 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
726 static void scan_partial_symbols (struct partial_die_info
*,
727 CORE_ADDR
*, CORE_ADDR
*,
730 static void add_partial_symbol (struct partial_die_info
*,
733 static int pdi_needs_namespace (enum dwarf_tag tag
);
735 static void add_partial_namespace (struct partial_die_info
*pdi
,
736 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
737 struct dwarf2_cu
*cu
);
739 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
740 struct dwarf2_cu
*cu
);
742 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
745 struct dwarf2_cu
*cu
);
747 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
749 static void psymtab_to_symtab_1 (struct partial_symtab
*);
751 gdb_byte
*dwarf2_read_section (struct objfile
*, asection
*);
753 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
755 static void dwarf2_free_abbrev_table (void *);
757 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
760 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
763 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
766 static gdb_byte
*read_partial_die (struct partial_die_info
*,
767 struct abbrev_info
*abbrev
, unsigned int,
768 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
770 static struct partial_die_info
*find_partial_die (unsigned long,
773 static void fixup_partial_die (struct partial_die_info
*,
776 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
777 struct dwarf2_cu
*, int *);
779 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
780 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
782 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
783 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
785 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
787 static int read_1_signed_byte (bfd
*, gdb_byte
*);
789 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
791 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
793 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
795 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
798 static LONGEST
read_initial_length (bfd
*, gdb_byte
*,
799 struct comp_unit_head
*, unsigned int *);
801 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
804 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
806 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
808 static char *read_indirect_string (bfd
*, gdb_byte
*,
809 const struct comp_unit_head
*,
812 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
814 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
816 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
818 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
820 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
823 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
824 struct dwarf2_cu
*cu
);
826 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
828 static struct die_info
*die_specification (struct die_info
*die
,
831 static void free_line_header (struct line_header
*lh
);
833 static void add_file_name (struct line_header
*, char *, unsigned int,
834 unsigned int, unsigned int);
836 static struct line_header
*(dwarf_decode_line_header
837 (unsigned int offset
,
838 bfd
*abfd
, struct dwarf2_cu
*cu
));
840 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
841 struct dwarf2_cu
*, struct partial_symtab
*);
843 static void dwarf2_start_subfile (char *, char *);
845 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
848 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
851 static void dwarf2_const_value_data (struct attribute
*attr
,
855 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
857 static struct type
*die_containing_type (struct die_info
*,
860 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
862 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
864 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
866 static char *typename_concat (struct obstack
*,
871 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
873 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
875 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
877 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
879 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
881 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
883 static int dwarf2_get_pc_bounds (struct die_info
*,
884 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
886 static void get_scope_pc_bounds (struct die_info
*,
887 CORE_ADDR
*, CORE_ADDR
*,
890 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
893 static void dwarf2_attach_fields_to_type (struct field_info
*,
894 struct type
*, struct dwarf2_cu
*);
896 static void dwarf2_add_member_fn (struct field_info
*,
897 struct die_info
*, struct type
*,
900 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
901 struct type
*, struct dwarf2_cu
*);
903 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
905 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
907 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
909 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
911 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
913 static const char *namespace_name (struct die_info
*die
,
914 int *is_anonymous
, struct dwarf2_cu
*);
916 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
918 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
920 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
922 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
924 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
926 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
929 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
931 static void read_tag_ptr_to_member_type (struct die_info
*,
934 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
936 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
938 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
940 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
942 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
944 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
946 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
948 gdb_byte
**new_info_ptr
,
949 struct die_info
*parent
);
951 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
953 gdb_byte
**new_info_ptr
,
954 struct die_info
*parent
);
956 static void free_die_list (struct die_info
*);
958 static void process_die (struct die_info
*, struct dwarf2_cu
*);
960 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
962 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
964 static struct die_info
*dwarf2_extension (struct die_info
*die
,
967 static char *dwarf_tag_name (unsigned int);
969 static char *dwarf_attr_name (unsigned int);
971 static char *dwarf_form_name (unsigned int);
973 static char *dwarf_stack_op_name (unsigned int);
975 static char *dwarf_bool_name (unsigned int);
977 static char *dwarf_type_encoding_name (unsigned int);
980 static char *dwarf_cfi_name (unsigned int);
982 struct die_info
*copy_die (struct die_info
*);
985 static struct die_info
*sibling_die (struct die_info
*);
987 static void dump_die (struct die_info
*);
989 static void dump_die_list (struct die_info
*);
991 static void store_in_ref_table (unsigned int, struct die_info
*,
994 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
997 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
999 static struct die_info
*follow_die_ref (struct die_info
*,
1001 struct dwarf2_cu
*);
1003 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
1004 struct dwarf2_cu
*);
1006 /* memory allocation interface */
1008 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1010 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1012 static struct die_info
*dwarf_alloc_die (void);
1014 static void initialize_cu_func_list (struct dwarf2_cu
*);
1016 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1017 struct dwarf2_cu
*);
1019 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1020 char *, bfd
*, struct dwarf2_cu
*);
1022 static int attr_form_is_block (struct attribute
*);
1025 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
1026 struct dwarf2_cu
*cu
);
1028 static gdb_byte
*skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
1029 struct dwarf2_cu
*cu
);
1031 static void free_stack_comp_unit (void *);
1033 static void *hashtab_obstack_allocate (void *data
, size_t size
, size_t count
);
1035 static void dummy_obstack_deallocate (void *object
, void *data
);
1037 static hashval_t
partial_die_hash (const void *item
);
1039 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1041 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1042 (unsigned long offset
, struct objfile
*objfile
);
1044 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1045 (unsigned long offset
, struct objfile
*objfile
);
1047 static void free_one_comp_unit (void *);
1049 static void free_cached_comp_units (void *);
1051 static void age_cached_comp_units (void);
1053 static void free_one_cached_comp_unit (void *);
1055 static void set_die_type (struct die_info
*, struct type
*,
1056 struct dwarf2_cu
*);
1058 static void reset_die_and_siblings_types (struct die_info
*,
1059 struct dwarf2_cu
*);
1061 static void create_all_comp_units (struct objfile
*);
1063 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 /* Try to locate the sections we need for DWARF 2 debugging
1075 information and return true if we have enough to do something. */
1078 dwarf2_has_info (struct objfile
*objfile
)
1080 struct dwarf2_per_objfile
*data
;
1082 /* Initialize per-objfile state. */
1083 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1084 memset (data
, 0, sizeof (*data
));
1085 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1086 dwarf2_per_objfile
= data
;
1088 dwarf_info_section
= 0;
1089 dwarf_abbrev_section
= 0;
1090 dwarf_line_section
= 0;
1091 dwarf_str_section
= 0;
1092 dwarf_macinfo_section
= 0;
1093 dwarf_frame_section
= 0;
1094 dwarf_eh_frame_section
= 0;
1095 dwarf_ranges_section
= 0;
1096 dwarf_loc_section
= 0;
1098 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1099 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1102 /* This function is mapped across the sections and remembers the
1103 offset and size of each of the debugging sections we are interested
1107 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
1109 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1111 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1112 dwarf_info_section
= sectp
;
1114 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1116 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1117 dwarf_abbrev_section
= sectp
;
1119 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1121 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1122 dwarf_line_section
= sectp
;
1124 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1126 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1127 dwarf_pubnames_section
= sectp
;
1129 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1131 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1132 dwarf_aranges_section
= sectp
;
1134 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1136 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1137 dwarf_loc_section
= sectp
;
1139 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1141 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1142 dwarf_macinfo_section
= sectp
;
1144 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1146 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1147 dwarf_str_section
= sectp
;
1149 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1151 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1152 dwarf_frame_section
= sectp
;
1154 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1156 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1157 if (aflag
& SEC_HAS_CONTENTS
)
1159 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1160 dwarf_eh_frame_section
= sectp
;
1163 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1165 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1166 dwarf_ranges_section
= sectp
;
1170 /* Build a partial symbol table. */
1173 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1175 /* We definitely need the .debug_info and .debug_abbrev sections */
1177 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1178 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1180 if (dwarf_line_section
)
1181 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1183 dwarf2_per_objfile
->line_buffer
= NULL
;
1185 if (dwarf_str_section
)
1186 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1188 dwarf2_per_objfile
->str_buffer
= NULL
;
1190 if (dwarf_macinfo_section
)
1191 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1192 dwarf_macinfo_section
);
1194 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1196 if (dwarf_ranges_section
)
1197 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1199 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1201 if (dwarf_loc_section
)
1202 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1204 dwarf2_per_objfile
->loc_buffer
= NULL
;
1207 || (objfile
->global_psymbols
.size
== 0
1208 && objfile
->static_psymbols
.size
== 0))
1210 init_psymbol_list (objfile
, 1024);
1214 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1216 /* Things are significantly easier if we have .debug_aranges and
1217 .debug_pubnames sections */
1219 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1223 /* only test this case for now */
1225 /* In this case we have to work a bit harder */
1226 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1231 /* Build the partial symbol table from the information in the
1232 .debug_pubnames and .debug_aranges sections. */
1235 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1237 bfd
*abfd
= objfile
->obfd
;
1238 char *aranges_buffer
, *pubnames_buffer
;
1239 char *aranges_ptr
, *pubnames_ptr
;
1240 unsigned int entry_length
, version
, info_offset
, info_size
;
1242 pubnames_buffer
= dwarf2_read_section (objfile
,
1243 dwarf_pubnames_section
);
1244 pubnames_ptr
= pubnames_buffer
;
1245 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1247 struct comp_unit_head cu_header
;
1248 unsigned int bytes_read
;
1250 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1252 pubnames_ptr
+= bytes_read
;
1253 version
= read_1_byte (abfd
, pubnames_ptr
);
1255 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1257 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1261 aranges_buffer
= dwarf2_read_section (objfile
,
1262 dwarf_aranges_section
);
1267 /* Read in the comp unit header information from the debug_info at
1271 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1272 gdb_byte
*info_ptr
, bfd
*abfd
)
1275 unsigned int bytes_read
;
1276 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1278 info_ptr
+= bytes_read
;
1279 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1281 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1283 info_ptr
+= bytes_read
;
1284 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1286 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1287 if (signed_addr
< 0)
1288 internal_error (__FILE__
, __LINE__
,
1289 _("read_comp_unit_head: dwarf from non elf file"));
1290 cu_header
->signed_addr_p
= signed_addr
;
1295 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1298 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1300 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1302 if (header
->version
!= 2)
1303 error (_("Dwarf Error: wrong version in compilation unit header "
1304 "(is %d, should be %d) [in module %s]"), header
->version
,
1305 2, bfd_get_filename (abfd
));
1307 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1308 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1309 "(offset 0x%lx + 6) [in module %s]"),
1310 (long) header
->abbrev_offset
,
1311 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1312 bfd_get_filename (abfd
));
1314 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1315 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1316 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1317 "(offset 0x%lx + 0) [in module %s]"),
1318 (long) header
->length
,
1319 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1320 bfd_get_filename (abfd
));
1325 /* Allocate a new partial symtab for file named NAME and mark this new
1326 partial symtab as being an include of PST. */
1329 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1330 struct objfile
*objfile
)
1332 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1334 subpst
->section_offsets
= pst
->section_offsets
;
1335 subpst
->textlow
= 0;
1336 subpst
->texthigh
= 0;
1338 subpst
->dependencies
= (struct partial_symtab
**)
1339 obstack_alloc (&objfile
->objfile_obstack
,
1340 sizeof (struct partial_symtab
*));
1341 subpst
->dependencies
[0] = pst
;
1342 subpst
->number_of_dependencies
= 1;
1344 subpst
->globals_offset
= 0;
1345 subpst
->n_global_syms
= 0;
1346 subpst
->statics_offset
= 0;
1347 subpst
->n_static_syms
= 0;
1348 subpst
->symtab
= NULL
;
1349 subpst
->read_symtab
= pst
->read_symtab
;
1352 /* No private part is necessary for include psymtabs. This property
1353 can be used to differentiate between such include psymtabs and
1354 the regular ones. */
1355 subpst
->read_symtab_private
= NULL
;
1358 /* Read the Line Number Program data and extract the list of files
1359 included by the source file represented by PST. Build an include
1360 partial symtab for each of these included files.
1362 This procedure assumes that there *is* a Line Number Program in
1363 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1364 before calling this procedure. */
1367 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1368 struct partial_die_info
*pdi
,
1369 struct partial_symtab
*pst
)
1371 struct objfile
*objfile
= cu
->objfile
;
1372 bfd
*abfd
= objfile
->obfd
;
1373 struct line_header
*lh
;
1375 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1377 return; /* No linetable, so no includes. */
1379 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1381 free_line_header (lh
);
1385 /* Build the partial symbol table by doing a quick pass through the
1386 .debug_info and .debug_abbrev sections. */
1389 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1391 /* Instead of reading this into a big buffer, we should probably use
1392 mmap() on architectures that support it. (FIXME) */
1393 bfd
*abfd
= objfile
->obfd
;
1395 gdb_byte
*beg_of_comp_unit
;
1396 struct partial_die_info comp_unit_die
;
1397 struct partial_symtab
*pst
;
1398 struct cleanup
*back_to
;
1399 CORE_ADDR lowpc
, highpc
, baseaddr
;
1401 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1403 /* Any cached compilation units will be linked by the per-objfile
1404 read_in_chain. Make sure to free them when we're done. */
1405 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1407 create_all_comp_units (objfile
);
1409 /* Since the objects we're extracting from .debug_info vary in
1410 length, only the individual functions to extract them (like
1411 read_comp_unit_head and load_partial_die) can really know whether
1412 the buffer is large enough to hold another complete object.
1414 At the moment, they don't actually check that. If .debug_info
1415 holds just one extra byte after the last compilation unit's dies,
1416 then read_comp_unit_head will happily read off the end of the
1417 buffer. read_partial_die is similarly casual. Those functions
1420 For this loop condition, simply checking whether there's any data
1421 left at all should be sufficient. */
1422 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1423 + dwarf2_per_objfile
->info_size
))
1425 struct cleanup
*back_to_inner
;
1426 struct dwarf2_cu cu
;
1427 struct abbrev_info
*abbrev
;
1428 unsigned int bytes_read
;
1429 struct dwarf2_per_cu_data
*this_cu
;
1431 beg_of_comp_unit
= info_ptr
;
1433 memset (&cu
, 0, sizeof (cu
));
1435 obstack_init (&cu
.comp_unit_obstack
);
1437 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1439 cu
.objfile
= objfile
;
1440 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1442 /* Complete the cu_header */
1443 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1444 cu
.header
.first_die_ptr
= info_ptr
;
1445 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1447 cu
.list_in_scope
= &file_symbols
;
1449 /* Read the abbrevs for this compilation unit into a table */
1450 dwarf2_read_abbrevs (abfd
, &cu
);
1451 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1453 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1455 /* Read the compilation unit die */
1456 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1457 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1458 abfd
, info_ptr
, &cu
);
1460 /* Set the language we're debugging */
1461 set_cu_language (comp_unit_die
.language
, &cu
);
1463 /* Allocate a new partial symbol table structure */
1464 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1465 comp_unit_die
.name
? comp_unit_die
.name
: "",
1466 comp_unit_die
.lowpc
,
1467 objfile
->global_psymbols
.next
,
1468 objfile
->static_psymbols
.next
);
1470 if (comp_unit_die
.dirname
)
1471 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1473 pst
->read_symtab_private
= (char *) this_cu
;
1475 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1477 /* Store the function that reads in the rest of the symbol table */
1478 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1480 /* If this compilation unit was already read in, free the
1481 cached copy in order to read it in again. This is
1482 necessary because we skipped some symbols when we first
1483 read in the compilation unit (see load_partial_dies).
1484 This problem could be avoided, but the benefit is
1486 if (this_cu
->cu
!= NULL
)
1487 free_one_cached_comp_unit (this_cu
->cu
);
1489 cu
.per_cu
= this_cu
;
1491 /* Note that this is a pointer to our stack frame, being
1492 added to a global data structure. It will be cleaned up
1493 in free_stack_comp_unit when we finish with this
1494 compilation unit. */
1497 this_cu
->psymtab
= pst
;
1499 /* Check if comp unit has_children.
1500 If so, read the rest of the partial symbols from this comp unit.
1501 If not, there's no more debug_info for this comp unit. */
1502 if (comp_unit_die
.has_children
)
1504 struct partial_die_info
*first_die
;
1506 lowpc
= ((CORE_ADDR
) -1);
1507 highpc
= ((CORE_ADDR
) 0);
1509 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1511 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1513 /* If we didn't find a lowpc, set it to highpc to avoid
1514 complaints from `maint check'. */
1515 if (lowpc
== ((CORE_ADDR
) -1))
1518 /* If the compilation unit didn't have an explicit address range,
1519 then use the information extracted from its child dies. */
1520 if (! comp_unit_die
.has_pc_info
)
1522 comp_unit_die
.lowpc
= lowpc
;
1523 comp_unit_die
.highpc
= highpc
;
1526 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1527 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1529 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1530 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1531 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1532 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1533 sort_pst_symbols (pst
);
1535 /* If there is already a psymtab or symtab for a file of this
1536 name, remove it. (If there is a symtab, more drastic things
1537 also happen.) This happens in VxWorks. */
1538 free_named_symtabs (pst
->filename
);
1540 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1541 + cu
.header
.initial_length_size
;
1543 if (comp_unit_die
.has_stmt_list
)
1545 /* Get the list of files included in the current compilation unit,
1546 and build a psymtab for each of them. */
1547 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1550 do_cleanups (back_to_inner
);
1552 do_cleanups (back_to
);
1555 /* Load the DIEs for a secondary CU into memory. */
1558 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1560 bfd
*abfd
= objfile
->obfd
;
1561 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1562 struct partial_die_info comp_unit_die
;
1563 struct dwarf2_cu
*cu
;
1564 struct abbrev_info
*abbrev
;
1565 unsigned int bytes_read
;
1566 struct cleanup
*back_to
;
1568 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1569 beg_of_comp_unit
= info_ptr
;
1571 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1572 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1574 obstack_init (&cu
->comp_unit_obstack
);
1576 cu
->objfile
= objfile
;
1577 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1579 /* Complete the cu_header. */
1580 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1581 cu
->header
.first_die_ptr
= info_ptr
;
1582 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1584 /* Read the abbrevs for this compilation unit into a table. */
1585 dwarf2_read_abbrevs (abfd
, cu
);
1586 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1588 /* Read the compilation unit die. */
1589 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1590 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1591 abfd
, info_ptr
, cu
);
1593 /* Set the language we're debugging. */
1594 set_cu_language (comp_unit_die
.language
, cu
);
1596 /* Link this compilation unit into the compilation unit tree. */
1598 cu
->per_cu
= this_cu
;
1600 /* Check if comp unit has_children.
1601 If so, read the rest of the partial symbols from this comp unit.
1602 If not, there's no more debug_info for this comp unit. */
1603 if (comp_unit_die
.has_children
)
1604 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1606 do_cleanups (back_to
);
1609 /* Create a list of all compilation units in OBJFILE. We do this only
1610 if an inter-comp-unit reference is found; presumably if there is one,
1611 there will be many, and one will occur early in the .debug_info section.
1612 So there's no point in building this list incrementally. */
1615 create_all_comp_units (struct objfile
*objfile
)
1619 struct dwarf2_per_cu_data
**all_comp_units
;
1620 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1624 all_comp_units
= xmalloc (n_allocated
1625 * sizeof (struct dwarf2_per_cu_data
*));
1627 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1629 struct comp_unit_head cu_header
;
1630 gdb_byte
*beg_of_comp_unit
;
1631 struct dwarf2_per_cu_data
*this_cu
;
1632 unsigned long offset
;
1633 unsigned int bytes_read
;
1635 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1637 /* Read just enough information to find out where the next
1638 compilation unit is. */
1639 cu_header
.initial_length_size
= 0;
1640 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1641 &cu_header
, &bytes_read
);
1643 /* Save the compilation unit for later lookup. */
1644 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1645 sizeof (struct dwarf2_per_cu_data
));
1646 memset (this_cu
, 0, sizeof (*this_cu
));
1647 this_cu
->offset
= offset
;
1648 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1650 if (n_comp_units
== n_allocated
)
1653 all_comp_units
= xrealloc (all_comp_units
,
1655 * sizeof (struct dwarf2_per_cu_data
*));
1657 all_comp_units
[n_comp_units
++] = this_cu
;
1659 info_ptr
= info_ptr
+ this_cu
->length
;
1662 dwarf2_per_objfile
->all_comp_units
1663 = obstack_alloc (&objfile
->objfile_obstack
,
1664 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1665 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1666 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1667 xfree (all_comp_units
);
1668 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1671 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1672 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1676 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1677 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1679 struct objfile
*objfile
= cu
->objfile
;
1680 bfd
*abfd
= objfile
->obfd
;
1681 struct partial_die_info
*pdi
;
1683 /* Now, march along the PDI's, descending into ones which have
1684 interesting children but skipping the children of the other ones,
1685 until we reach the end of the compilation unit. */
1691 fixup_partial_die (pdi
, cu
);
1693 /* Anonymous namespaces have no name but have interesting
1694 children, so we need to look at them. Ditto for anonymous
1697 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1698 || pdi
->tag
== DW_TAG_enumeration_type
)
1702 case DW_TAG_subprogram
:
1703 if (pdi
->has_pc_info
)
1705 if (pdi
->lowpc
< *lowpc
)
1707 *lowpc
= pdi
->lowpc
;
1709 if (pdi
->highpc
> *highpc
)
1711 *highpc
= pdi
->highpc
;
1713 if (!pdi
->is_declaration
)
1715 add_partial_symbol (pdi
, cu
);
1719 case DW_TAG_variable
:
1720 case DW_TAG_typedef
:
1721 case DW_TAG_union_type
:
1722 if (!pdi
->is_declaration
)
1724 add_partial_symbol (pdi
, cu
);
1727 case DW_TAG_class_type
:
1728 case DW_TAG_structure_type
:
1729 if (!pdi
->is_declaration
)
1731 add_partial_symbol (pdi
, cu
);
1734 case DW_TAG_enumeration_type
:
1735 if (!pdi
->is_declaration
)
1736 add_partial_enumeration (pdi
, cu
);
1738 case DW_TAG_base_type
:
1739 case DW_TAG_subrange_type
:
1740 /* File scope base type definitions are added to the partial
1742 add_partial_symbol (pdi
, cu
);
1744 case DW_TAG_namespace
:
1745 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1752 /* If the die has a sibling, skip to the sibling. */
1754 pdi
= pdi
->die_sibling
;
1758 /* Functions used to compute the fully scoped name of a partial DIE.
1760 Normally, this is simple. For C++, the parent DIE's fully scoped
1761 name is concatenated with "::" and the partial DIE's name. For
1762 Java, the same thing occurs except that "." is used instead of "::".
1763 Enumerators are an exception; they use the scope of their parent
1764 enumeration type, i.e. the name of the enumeration type is not
1765 prepended to the enumerator.
1767 There are two complexities. One is DW_AT_specification; in this
1768 case "parent" means the parent of the target of the specification,
1769 instead of the direct parent of the DIE. The other is compilers
1770 which do not emit DW_TAG_namespace; in this case we try to guess
1771 the fully qualified name of structure types from their members'
1772 linkage names. This must be done using the DIE's children rather
1773 than the children of any DW_AT_specification target. We only need
1774 to do this for structures at the top level, i.e. if the target of
1775 any DW_AT_specification (if any; otherwise the DIE itself) does not
1778 /* Compute the scope prefix associated with PDI's parent, in
1779 compilation unit CU. The result will be allocated on CU's
1780 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1781 field. NULL is returned if no prefix is necessary. */
1783 partial_die_parent_scope (struct partial_die_info
*pdi
,
1784 struct dwarf2_cu
*cu
)
1786 char *grandparent_scope
;
1787 struct partial_die_info
*parent
, *real_pdi
;
1789 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1790 then this means the parent of the specification DIE. */
1793 while (real_pdi
->has_specification
)
1794 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1796 parent
= real_pdi
->die_parent
;
1800 if (parent
->scope_set
)
1801 return parent
->scope
;
1803 fixup_partial_die (parent
, cu
);
1805 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1807 if (parent
->tag
== DW_TAG_namespace
1808 || parent
->tag
== DW_TAG_structure_type
1809 || parent
->tag
== DW_TAG_class_type
1810 || parent
->tag
== DW_TAG_union_type
)
1812 if (grandparent_scope
== NULL
)
1813 parent
->scope
= parent
->name
;
1815 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1818 else if (parent
->tag
== DW_TAG_enumeration_type
)
1819 /* Enumerators should not get the name of the enumeration as a prefix. */
1820 parent
->scope
= grandparent_scope
;
1823 /* FIXME drow/2004-04-01: What should we be doing with
1824 function-local names? For partial symbols, we should probably be
1826 complaint (&symfile_complaints
,
1827 _("unhandled containing DIE tag %d for DIE at %d"),
1828 parent
->tag
, pdi
->offset
);
1829 parent
->scope
= grandparent_scope
;
1832 parent
->scope_set
= 1;
1833 return parent
->scope
;
1836 /* Return the fully scoped name associated with PDI, from compilation unit
1837 CU. The result will be allocated with malloc. */
1839 partial_die_full_name (struct partial_die_info
*pdi
,
1840 struct dwarf2_cu
*cu
)
1844 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1845 if (parent_scope
== NULL
)
1848 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1852 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1854 struct objfile
*objfile
= cu
->objfile
;
1857 const char *my_prefix
;
1858 const struct partial_symbol
*psym
= NULL
;
1860 int built_actual_name
= 0;
1862 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1866 if (pdi_needs_namespace (pdi
->tag
))
1868 actual_name
= partial_die_full_name (pdi
, cu
);
1870 built_actual_name
= 1;
1873 if (actual_name
== NULL
)
1874 actual_name
= pdi
->name
;
1878 case DW_TAG_subprogram
:
1879 if (pdi
->is_external
)
1881 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1882 mst_text, objfile); */
1883 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1884 VAR_DOMAIN
, LOC_BLOCK
,
1885 &objfile
->global_psymbols
,
1886 0, pdi
->lowpc
+ baseaddr
,
1887 cu
->language
, objfile
);
1891 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1892 mst_file_text, objfile); */
1893 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1894 VAR_DOMAIN
, LOC_BLOCK
,
1895 &objfile
->static_psymbols
,
1896 0, pdi
->lowpc
+ baseaddr
,
1897 cu
->language
, objfile
);
1900 case DW_TAG_variable
:
1901 if (pdi
->is_external
)
1904 Don't enter into the minimal symbol tables as there is
1905 a minimal symbol table entry from the ELF symbols already.
1906 Enter into partial symbol table if it has a location
1907 descriptor or a type.
1908 If the location descriptor is missing, new_symbol will create
1909 a LOC_UNRESOLVED symbol, the address of the variable will then
1910 be determined from the minimal symbol table whenever the variable
1912 The address for the partial symbol table entry is not
1913 used by GDB, but it comes in handy for debugging partial symbol
1917 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1918 if (pdi
->locdesc
|| pdi
->has_type
)
1919 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1920 VAR_DOMAIN
, LOC_STATIC
,
1921 &objfile
->global_psymbols
,
1923 cu
->language
, objfile
);
1927 /* Static Variable. Skip symbols without location descriptors. */
1928 if (pdi
->locdesc
== NULL
)
1930 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1931 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1932 mst_file_data, objfile); */
1933 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1934 VAR_DOMAIN
, LOC_STATIC
,
1935 &objfile
->static_psymbols
,
1937 cu
->language
, objfile
);
1940 case DW_TAG_typedef
:
1941 case DW_TAG_base_type
:
1942 case DW_TAG_subrange_type
:
1943 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1944 VAR_DOMAIN
, LOC_TYPEDEF
,
1945 &objfile
->static_psymbols
,
1946 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1948 case DW_TAG_namespace
:
1949 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1950 VAR_DOMAIN
, LOC_TYPEDEF
,
1951 &objfile
->global_psymbols
,
1952 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1954 case DW_TAG_class_type
:
1955 case DW_TAG_structure_type
:
1956 case DW_TAG_union_type
:
1957 case DW_TAG_enumeration_type
:
1958 /* Skip aggregate types without children, these are external
1960 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1961 static vs. global. */
1962 if (pdi
->has_children
== 0)
1964 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1965 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1966 (cu
->language
== language_cplus
1967 || cu
->language
== language_java
)
1968 ? &objfile
->global_psymbols
1969 : &objfile
->static_psymbols
,
1970 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1972 if (cu
->language
== language_cplus
1973 || cu
->language
== language_java
)
1975 /* For C++ and Java, these implicitly act as typedefs as well. */
1976 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1977 VAR_DOMAIN
, LOC_TYPEDEF
,
1978 &objfile
->global_psymbols
,
1979 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1982 case DW_TAG_enumerator
:
1983 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1984 VAR_DOMAIN
, LOC_CONST
,
1985 (cu
->language
== language_cplus
1986 || cu
->language
== language_java
)
1987 ? &objfile
->global_psymbols
1988 : &objfile
->static_psymbols
,
1989 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1995 /* Check to see if we should scan the name for possible namespace
1996 info. Only do this if this is C++, if we don't have namespace
1997 debugging info in the file, if the psym is of an appropriate type
1998 (otherwise we'll have psym == NULL), and if we actually had a
1999 mangled name to begin with. */
2001 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2002 cases which do not set PSYM above? */
2004 if (cu
->language
== language_cplus
2005 && cu
->has_namespace_info
== 0
2007 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2008 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2011 if (built_actual_name
)
2012 xfree (actual_name
);
2015 /* Determine whether a die of type TAG living in a C++ class or
2016 namespace needs to have the name of the scope prepended to the
2017 name listed in the die. */
2020 pdi_needs_namespace (enum dwarf_tag tag
)
2024 case DW_TAG_namespace
:
2025 case DW_TAG_typedef
:
2026 case DW_TAG_class_type
:
2027 case DW_TAG_structure_type
:
2028 case DW_TAG_union_type
:
2029 case DW_TAG_enumeration_type
:
2030 case DW_TAG_enumerator
:
2037 /* Read a partial die corresponding to a namespace; also, add a symbol
2038 corresponding to that namespace to the symbol table. NAMESPACE is
2039 the name of the enclosing namespace. */
2042 add_partial_namespace (struct partial_die_info
*pdi
,
2043 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2044 struct dwarf2_cu
*cu
)
2046 struct objfile
*objfile
= cu
->objfile
;
2048 /* Add a symbol for the namespace. */
2050 add_partial_symbol (pdi
, cu
);
2052 /* Now scan partial symbols in that namespace. */
2054 if (pdi
->has_children
)
2055 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2058 /* See if we can figure out if the class lives in a namespace. We do
2059 this by looking for a member function; its demangled name will
2060 contain namespace info, if there is any. */
2063 guess_structure_name (struct partial_die_info
*struct_pdi
,
2064 struct dwarf2_cu
*cu
)
2066 if ((cu
->language
== language_cplus
2067 || cu
->language
== language_java
)
2068 && cu
->has_namespace_info
== 0
2069 && struct_pdi
->has_children
)
2071 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2072 what template types look like, because the demangler
2073 frequently doesn't give the same name as the debug info. We
2074 could fix this by only using the demangled name to get the
2075 prefix (but see comment in read_structure_type). */
2077 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2078 struct partial_die_info
*real_pdi
;
2080 /* If this DIE (this DIE's specification, if any) has a parent, then
2081 we should not do this. We'll prepend the parent's fully qualified
2082 name when we create the partial symbol. */
2084 real_pdi
= struct_pdi
;
2085 while (real_pdi
->has_specification
)
2086 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2088 if (real_pdi
->die_parent
!= NULL
)
2091 while (child_pdi
!= NULL
)
2093 if (child_pdi
->tag
== DW_TAG_subprogram
)
2095 char *actual_class_name
2096 = language_class_name_from_physname (cu
->language_defn
,
2098 if (actual_class_name
!= NULL
)
2101 = obsavestring (actual_class_name
,
2102 strlen (actual_class_name
),
2103 &cu
->comp_unit_obstack
);
2104 xfree (actual_class_name
);
2109 child_pdi
= child_pdi
->die_sibling
;
2114 /* Read a partial die corresponding to an enumeration type. */
2117 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2118 struct dwarf2_cu
*cu
)
2120 struct objfile
*objfile
= cu
->objfile
;
2121 bfd
*abfd
= objfile
->obfd
;
2122 struct partial_die_info
*pdi
;
2124 if (enum_pdi
->name
!= NULL
)
2125 add_partial_symbol (enum_pdi
, cu
);
2127 pdi
= enum_pdi
->die_child
;
2130 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2131 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2133 add_partial_symbol (pdi
, cu
);
2134 pdi
= pdi
->die_sibling
;
2138 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2139 Return the corresponding abbrev, or NULL if the number is zero (indicating
2140 an empty DIE). In either case *BYTES_READ will be set to the length of
2141 the initial number. */
2143 static struct abbrev_info
*
2144 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2145 struct dwarf2_cu
*cu
)
2147 bfd
*abfd
= cu
->objfile
->obfd
;
2148 unsigned int abbrev_number
;
2149 struct abbrev_info
*abbrev
;
2151 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2153 if (abbrev_number
== 0)
2156 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2159 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2160 bfd_get_filename (abfd
));
2166 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2167 pointer to the end of a series of DIEs, terminated by an empty
2168 DIE. Any children of the skipped DIEs will also be skipped. */
2171 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2173 struct abbrev_info
*abbrev
;
2174 unsigned int bytes_read
;
2178 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2180 return info_ptr
+ bytes_read
;
2182 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2186 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2187 should point just after the initial uleb128 of a DIE, and the
2188 abbrev corresponding to that skipped uleb128 should be passed in
2189 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2193 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2194 struct dwarf2_cu
*cu
)
2196 unsigned int bytes_read
;
2197 struct attribute attr
;
2198 bfd
*abfd
= cu
->objfile
->obfd
;
2199 unsigned int form
, i
;
2201 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2203 /* The only abbrev we care about is DW_AT_sibling. */
2204 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2206 read_attribute (&attr
, &abbrev
->attrs
[i
],
2207 abfd
, info_ptr
, cu
);
2208 if (attr
.form
== DW_FORM_ref_addr
)
2209 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2211 return dwarf2_per_objfile
->info_buffer
2212 + dwarf2_get_ref_die_offset (&attr
, cu
);
2215 /* If it isn't DW_AT_sibling, skip this attribute. */
2216 form
= abbrev
->attrs
[i
].form
;
2221 case DW_FORM_ref_addr
:
2222 info_ptr
+= cu
->header
.addr_size
;
2241 case DW_FORM_string
:
2242 read_string (abfd
, info_ptr
, &bytes_read
);
2243 info_ptr
+= bytes_read
;
2246 info_ptr
+= cu
->header
.offset_size
;
2249 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2250 info_ptr
+= bytes_read
;
2252 case DW_FORM_block1
:
2253 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2255 case DW_FORM_block2
:
2256 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2258 case DW_FORM_block4
:
2259 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2263 case DW_FORM_ref_udata
:
2264 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2266 case DW_FORM_indirect
:
2267 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2268 info_ptr
+= bytes_read
;
2269 /* We need to continue parsing from here, so just go back to
2271 goto skip_attribute
;
2274 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2275 dwarf_form_name (form
),
2276 bfd_get_filename (abfd
));
2280 if (abbrev
->has_children
)
2281 return skip_children (info_ptr
, cu
);
2286 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2287 the next DIE after ORIG_PDI. */
2290 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2291 bfd
*abfd
, struct dwarf2_cu
*cu
)
2293 /* Do we know the sibling already? */
2295 if (orig_pdi
->sibling
)
2296 return orig_pdi
->sibling
;
2298 /* Are there any children to deal with? */
2300 if (!orig_pdi
->has_children
)
2303 /* Skip the children the long way. */
2305 return skip_children (info_ptr
, cu
);
2308 /* Expand this partial symbol table into a full symbol table. */
2311 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2313 /* FIXME: This is barely more than a stub. */
2318 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2324 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2325 gdb_flush (gdb_stdout
);
2328 /* Restore our global data. */
2329 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2330 dwarf2_objfile_data_key
);
2332 psymtab_to_symtab_1 (pst
);
2334 /* Finish up the debug error message. */
2336 printf_filtered (_("done.\n"));
2341 /* Add PER_CU to the queue. */
2344 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2346 struct dwarf2_queue_item
*item
;
2349 item
= xmalloc (sizeof (*item
));
2350 item
->per_cu
= per_cu
;
2353 if (dwarf2_queue
== NULL
)
2354 dwarf2_queue
= item
;
2356 dwarf2_queue_tail
->next
= item
;
2358 dwarf2_queue_tail
= item
;
2361 /* Process the queue. */
2364 process_queue (struct objfile
*objfile
)
2366 struct dwarf2_queue_item
*item
, *next_item
;
2368 /* Initially, there is just one item on the queue. Load its DIEs,
2369 and the DIEs of any other compilation units it requires,
2372 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2374 /* Read in this compilation unit. This may add new items to
2375 the end of the queue. */
2376 load_full_comp_unit (item
->per_cu
);
2378 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2379 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2381 /* If this compilation unit has already had full symbols created,
2382 reset the TYPE fields in each DIE. */
2383 if (item
->per_cu
->psymtab
->readin
)
2384 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2388 /* Now everything left on the queue needs to be read in. Process
2389 them, one at a time, removing from the queue as we finish. */
2390 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2392 if (!item
->per_cu
->psymtab
->readin
)
2393 process_full_comp_unit (item
->per_cu
);
2395 item
->per_cu
->queued
= 0;
2396 next_item
= item
->next
;
2400 dwarf2_queue_tail
= NULL
;
2403 /* Free all allocated queue entries. This function only releases anything if
2404 an error was thrown; if the queue was processed then it would have been
2405 freed as we went along. */
2408 dwarf2_release_queue (void *dummy
)
2410 struct dwarf2_queue_item
*item
, *last
;
2412 item
= dwarf2_queue
;
2415 /* Anything still marked queued is likely to be in an
2416 inconsistent state, so discard it. */
2417 if (item
->per_cu
->queued
)
2419 if (item
->per_cu
->cu
!= NULL
)
2420 free_one_cached_comp_unit (item
->per_cu
->cu
);
2421 item
->per_cu
->queued
= 0;
2429 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2432 /* Read in full symbols for PST, and anything it depends on. */
2435 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2437 struct dwarf2_per_cu_data
*per_cu
;
2438 struct cleanup
*back_to
;
2441 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2442 if (!pst
->dependencies
[i
]->readin
)
2444 /* Inform about additional files that need to be read in. */
2447 /* FIXME: i18n: Need to make this a single string. */
2448 fputs_filtered (" ", gdb_stdout
);
2450 fputs_filtered ("and ", gdb_stdout
);
2452 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2453 wrap_here (""); /* Flush output */
2454 gdb_flush (gdb_stdout
);
2456 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2459 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2463 /* It's an include file, no symbols to read for it.
2464 Everything is in the parent symtab. */
2469 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2471 queue_comp_unit (per_cu
);
2473 process_queue (pst
->objfile
);
2475 /* Age the cache, releasing compilation units that have not
2476 been used recently. */
2477 age_cached_comp_units ();
2479 do_cleanups (back_to
);
2482 /* Load the DIEs associated with PST and PER_CU into memory. */
2484 static struct dwarf2_cu
*
2485 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2487 struct partial_symtab
*pst
= per_cu
->psymtab
;
2488 bfd
*abfd
= pst
->objfile
->obfd
;
2489 struct dwarf2_cu
*cu
;
2490 unsigned long offset
;
2492 struct cleanup
*back_to
, *free_cu_cleanup
;
2493 struct attribute
*attr
;
2496 /* Set local variables from the partial symbol table info. */
2497 offset
= per_cu
->offset
;
2499 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2501 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2502 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2504 /* If an error occurs while loading, release our storage. */
2505 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2507 cu
->objfile
= pst
->objfile
;
2509 /* read in the comp_unit header */
2510 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2512 /* Read the abbrevs for this compilation unit */
2513 dwarf2_read_abbrevs (abfd
, cu
);
2514 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2516 cu
->header
.offset
= offset
;
2518 cu
->per_cu
= per_cu
;
2521 /* We use this obstack for block values in dwarf_alloc_block. */
2522 obstack_init (&cu
->comp_unit_obstack
);
2524 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2526 /* We try not to read any attributes in this function, because not
2527 all objfiles needed for references have been loaded yet, and symbol
2528 table processing isn't initialized. But we have to set the CU language,
2529 or we won't be able to build types correctly. */
2530 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2532 set_cu_language (DW_UNSND (attr
), cu
);
2534 set_cu_language (language_minimal
, cu
);
2536 do_cleanups (back_to
);
2538 /* We've successfully allocated this compilation unit. Let our caller
2539 clean it up when finished with it. */
2540 discard_cleanups (free_cu_cleanup
);
2545 /* Generate full symbol information for PST and CU, whose DIEs have
2546 already been loaded into memory. */
2549 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2551 struct partial_symtab
*pst
= per_cu
->psymtab
;
2552 struct dwarf2_cu
*cu
= per_cu
->cu
;
2553 struct objfile
*objfile
= pst
->objfile
;
2554 bfd
*abfd
= objfile
->obfd
;
2555 CORE_ADDR lowpc
, highpc
;
2556 struct symtab
*symtab
;
2557 struct cleanup
*back_to
;
2558 struct attribute
*attr
;
2561 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2563 /* We're in the global namespace. */
2564 processing_current_prefix
= "";
2567 back_to
= make_cleanup (really_free_pendings
, NULL
);
2569 cu
->list_in_scope
= &file_symbols
;
2571 /* Find the base address of the compilation unit for range lists and
2572 location lists. It will normally be specified by DW_AT_low_pc.
2573 In DWARF-3 draft 4, the base address could be overridden by
2574 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2575 compilation units with discontinuous ranges. */
2577 cu
->header
.base_known
= 0;
2578 cu
->header
.base_address
= 0;
2580 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2583 cu
->header
.base_address
= DW_ADDR (attr
);
2584 cu
->header
.base_known
= 1;
2588 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2591 cu
->header
.base_address
= DW_ADDR (attr
);
2592 cu
->header
.base_known
= 1;
2596 /* Do line number decoding in read_file_scope () */
2597 process_die (cu
->dies
, cu
);
2599 /* Some compilers don't define a DW_AT_high_pc attribute for the
2600 compilation unit. If the DW_AT_high_pc is missing, synthesize
2601 it, by scanning the DIE's below the compilation unit. */
2602 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2604 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2606 /* Set symtab language to language from DW_AT_language.
2607 If the compilation is from a C file generated by language preprocessors,
2608 do not set the language if it was already deduced by start_subfile. */
2610 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2612 symtab
->language
= cu
->language
;
2614 pst
->symtab
= symtab
;
2617 do_cleanups (back_to
);
2620 /* Process a die and its children. */
2623 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2627 case DW_TAG_padding
:
2629 case DW_TAG_compile_unit
:
2630 read_file_scope (die
, cu
);
2632 case DW_TAG_subprogram
:
2633 read_subroutine_type (die
, cu
);
2634 read_func_scope (die
, cu
);
2636 case DW_TAG_inlined_subroutine
:
2637 /* FIXME: These are ignored for now.
2638 They could be used to set breakpoints on all inlined instances
2639 of a function and make GDB `next' properly over inlined functions. */
2641 case DW_TAG_lexical_block
:
2642 case DW_TAG_try_block
:
2643 case DW_TAG_catch_block
:
2644 read_lexical_block_scope (die
, cu
);
2646 case DW_TAG_class_type
:
2647 case DW_TAG_structure_type
:
2648 case DW_TAG_union_type
:
2649 read_structure_type (die
, cu
);
2650 process_structure_scope (die
, cu
);
2652 case DW_TAG_enumeration_type
:
2653 read_enumeration_type (die
, cu
);
2654 process_enumeration_scope (die
, cu
);
2657 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2658 a symbol or process any children. Therefore it doesn't do anything
2659 that won't be done on-demand by read_type_die. */
2660 case DW_TAG_subroutine_type
:
2661 read_subroutine_type (die
, cu
);
2663 case DW_TAG_array_type
:
2664 read_array_type (die
, cu
);
2666 case DW_TAG_pointer_type
:
2667 read_tag_pointer_type (die
, cu
);
2669 case DW_TAG_ptr_to_member_type
:
2670 read_tag_ptr_to_member_type (die
, cu
);
2672 case DW_TAG_reference_type
:
2673 read_tag_reference_type (die
, cu
);
2675 case DW_TAG_string_type
:
2676 read_tag_string_type (die
, cu
);
2680 case DW_TAG_base_type
:
2681 read_base_type (die
, cu
);
2682 /* Add a typedef symbol for the type definition, if it has a
2684 new_symbol (die
, die
->type
, cu
);
2686 case DW_TAG_subrange_type
:
2687 read_subrange_type (die
, cu
);
2688 /* Add a typedef symbol for the type definition, if it has a
2690 new_symbol (die
, die
->type
, cu
);
2692 case DW_TAG_common_block
:
2693 read_common_block (die
, cu
);
2695 case DW_TAG_common_inclusion
:
2697 case DW_TAG_namespace
:
2698 processing_has_namespace_info
= 1;
2699 read_namespace (die
, cu
);
2701 case DW_TAG_imported_declaration
:
2702 case DW_TAG_imported_module
:
2703 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2704 information contained in these. DW_TAG_imported_declaration
2705 dies shouldn't have children; DW_TAG_imported_module dies
2706 shouldn't in the C++ case, but conceivably could in the
2707 Fortran case, so we'll have to replace this gdb_assert if
2708 Fortran compilers start generating that info. */
2709 processing_has_namespace_info
= 1;
2710 gdb_assert (die
->child
== NULL
);
2713 new_symbol (die
, NULL
, cu
);
2719 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2721 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2725 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2727 struct objfile
*objfile
= cu
->objfile
;
2728 struct comp_unit_head
*cu_header
= &cu
->header
;
2729 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2730 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2731 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2732 struct attribute
*attr
;
2733 char *name
= "<unknown>";
2734 char *comp_dir
= NULL
;
2735 struct die_info
*child_die
;
2736 bfd
*abfd
= objfile
->obfd
;
2737 struct line_header
*line_header
= 0;
2740 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2742 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2744 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2745 from finish_block. */
2746 if (lowpc
== ((CORE_ADDR
) -1))
2751 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2754 name
= DW_STRING (attr
);
2756 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2759 comp_dir
= DW_STRING (attr
);
2762 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2763 directory, get rid of it. */
2764 char *cp
= strchr (comp_dir
, ':');
2766 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2771 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2774 set_cu_language (DW_UNSND (attr
), cu
);
2777 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2779 cu
->producer
= DW_STRING (attr
);
2781 /* We assume that we're processing GCC output. */
2782 processing_gcc_compilation
= 2;
2784 /* FIXME:Do something here. */
2785 if (dip
->at_producer
!= NULL
)
2787 handle_producer (dip
->at_producer
);
2791 /* The compilation unit may be in a different language or objfile,
2792 zero out all remembered fundamental types. */
2793 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2795 start_symtab (name
, comp_dir
, lowpc
);
2796 record_debugformat ("DWARF 2");
2798 initialize_cu_func_list (cu
);
2800 /* Process all dies in compilation unit. */
2801 if (die
->child
!= NULL
)
2803 child_die
= die
->child
;
2804 while (child_die
&& child_die
->tag
)
2806 process_die (child_die
, cu
);
2807 child_die
= sibling_die (child_die
);
2811 /* Decode line number information if present. */
2812 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2815 unsigned int line_offset
= DW_UNSND (attr
);
2816 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2819 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2820 (void *) line_header
);
2821 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2825 /* Decode macro information, if present. Dwarf 2 macro information
2826 refers to information in the line number info statement program
2827 header, so we can only read it if we've read the header
2829 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2830 if (attr
&& line_header
)
2832 unsigned int macro_offset
= DW_UNSND (attr
);
2833 dwarf_decode_macros (line_header
, macro_offset
,
2834 comp_dir
, abfd
, cu
);
2836 do_cleanups (back_to
);
2840 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2841 struct dwarf2_cu
*cu
)
2843 struct function_range
*thisfn
;
2845 thisfn
= (struct function_range
*)
2846 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2847 thisfn
->name
= name
;
2848 thisfn
->lowpc
= lowpc
;
2849 thisfn
->highpc
= highpc
;
2850 thisfn
->seen_line
= 0;
2851 thisfn
->next
= NULL
;
2853 if (cu
->last_fn
== NULL
)
2854 cu
->first_fn
= thisfn
;
2856 cu
->last_fn
->next
= thisfn
;
2858 cu
->last_fn
= thisfn
;
2862 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2864 struct objfile
*objfile
= cu
->objfile
;
2865 struct context_stack
*new;
2868 struct die_info
*child_die
;
2869 struct attribute
*attr
;
2871 const char *previous_prefix
= processing_current_prefix
;
2872 struct cleanup
*back_to
= NULL
;
2875 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2877 name
= dwarf2_linkage_name (die
, cu
);
2879 /* Ignore functions with missing or empty names and functions with
2880 missing or invalid low and high pc attributes. */
2881 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2884 if (cu
->language
== language_cplus
2885 || cu
->language
== language_java
)
2887 struct die_info
*spec_die
= die_specification (die
, cu
);
2889 /* NOTE: carlton/2004-01-23: We have to be careful in the
2890 presence of DW_AT_specification. For example, with GCC 3.4,
2895 // Definition of N::foo.
2899 then we'll have a tree of DIEs like this:
2901 1: DW_TAG_compile_unit
2902 2: DW_TAG_namespace // N
2903 3: DW_TAG_subprogram // declaration of N::foo
2904 4: DW_TAG_subprogram // definition of N::foo
2905 DW_AT_specification // refers to die #3
2907 Thus, when processing die #4, we have to pretend that we're
2908 in the context of its DW_AT_specification, namely the contex
2911 if (spec_die
!= NULL
)
2913 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2914 processing_current_prefix
= specification_prefix
;
2915 back_to
= make_cleanup (xfree
, specification_prefix
);
2922 /* Record the function range for dwarf_decode_lines. */
2923 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2925 new = push_context (0, lowpc
);
2926 new->name
= new_symbol (die
, die
->type
, cu
);
2928 /* If there is a location expression for DW_AT_frame_base, record
2930 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2932 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2933 expression is being recorded directly in the function's symbol
2934 and not in a separate frame-base object. I guess this hack is
2935 to avoid adding some sort of frame-base adjunct/annex to the
2936 function's symbol :-(. The problem with doing this is that it
2937 results in a function symbol with a location expression that
2938 has nothing to do with the location of the function, ouch! The
2939 relationship should be: a function's symbol has-a frame base; a
2940 frame-base has-a location expression. */
2941 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2943 cu
->list_in_scope
= &local_symbols
;
2945 if (die
->child
!= NULL
)
2947 child_die
= die
->child
;
2948 while (child_die
&& child_die
->tag
)
2950 process_die (child_die
, cu
);
2951 child_die
= sibling_die (child_die
);
2955 new = pop_context ();
2956 /* Make a block for the local symbols within. */
2957 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2958 lowpc
, highpc
, objfile
);
2960 /* In C++, we can have functions nested inside functions (e.g., when
2961 a function declares a class that has methods). This means that
2962 when we finish processing a function scope, we may need to go
2963 back to building a containing block's symbol lists. */
2964 local_symbols
= new->locals
;
2965 param_symbols
= new->params
;
2967 /* If we've finished processing a top-level function, subsequent
2968 symbols go in the file symbol list. */
2969 if (outermost_context_p ())
2970 cu
->list_in_scope
= &file_symbols
;
2972 processing_current_prefix
= previous_prefix
;
2973 if (back_to
!= NULL
)
2974 do_cleanups (back_to
);
2977 /* Process all the DIES contained within a lexical block scope. Start
2978 a new scope, process the dies, and then close the scope. */
2981 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2983 struct objfile
*objfile
= cu
->objfile
;
2984 struct context_stack
*new;
2985 CORE_ADDR lowpc
, highpc
;
2986 struct die_info
*child_die
;
2989 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2991 /* Ignore blocks with missing or invalid low and high pc attributes. */
2992 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2993 as multiple lexical blocks? Handling children in a sane way would
2994 be nasty. Might be easier to properly extend generic blocks to
2996 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3001 push_context (0, lowpc
);
3002 if (die
->child
!= NULL
)
3004 child_die
= die
->child
;
3005 while (child_die
&& child_die
->tag
)
3007 process_die (child_die
, cu
);
3008 child_die
= sibling_die (child_die
);
3011 new = pop_context ();
3013 if (local_symbols
!= NULL
)
3015 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3018 local_symbols
= new->locals
;
3021 /* Get low and high pc attributes from a die. Return 1 if the attributes
3022 are present and valid, otherwise, return 0. Return -1 if the range is
3023 discontinuous, i.e. derived from DW_AT_ranges information. */
3025 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3026 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3028 struct objfile
*objfile
= cu
->objfile
;
3029 struct comp_unit_head
*cu_header
= &cu
->header
;
3030 struct attribute
*attr
;
3031 bfd
*obfd
= objfile
->obfd
;
3036 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3039 high
= DW_ADDR (attr
);
3040 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3042 low
= DW_ADDR (attr
);
3044 /* Found high w/o low attribute. */
3047 /* Found consecutive range of addresses. */
3052 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3055 unsigned int addr_size
= cu_header
->addr_size
;
3056 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3057 /* Value of the DW_AT_ranges attribute is the offset in the
3058 .debug_ranges section. */
3059 unsigned int offset
= DW_UNSND (attr
);
3060 /* Base address selection entry. */
3068 found_base
= cu_header
->base_known
;
3069 base
= cu_header
->base_address
;
3071 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3073 complaint (&symfile_complaints
,
3074 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3078 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3080 /* Read in the largest possible address. */
3081 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3082 if ((marker
& mask
) == mask
)
3084 /* If we found the largest possible address, then
3085 read the base address. */
3086 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3087 buffer
+= 2 * addr_size
;
3088 offset
+= 2 * addr_size
;
3096 CORE_ADDR range_beginning
, range_end
;
3098 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3099 buffer
+= addr_size
;
3100 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3101 buffer
+= addr_size
;
3102 offset
+= 2 * addr_size
;
3104 /* An end of list marker is a pair of zero addresses. */
3105 if (range_beginning
== 0 && range_end
== 0)
3106 /* Found the end of list entry. */
3109 /* Each base address selection entry is a pair of 2 values.
3110 The first is the largest possible address, the second is
3111 the base address. Check for a base address here. */
3112 if ((range_beginning
& mask
) == mask
)
3114 /* If we found the largest possible address, then
3115 read the base address. */
3116 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3123 /* We have no valid base address for the ranges
3125 complaint (&symfile_complaints
,
3126 _("Invalid .debug_ranges data (no base address)"));
3130 range_beginning
+= base
;
3133 /* FIXME: This is recording everything as a low-high
3134 segment of consecutive addresses. We should have a
3135 data structure for discontiguous block ranges
3139 low
= range_beginning
;
3145 if (range_beginning
< low
)
3146 low
= range_beginning
;
3147 if (range_end
> high
)
3153 /* If the first entry is an end-of-list marker, the range
3154 describes an empty scope, i.e. no instructions. */
3164 /* When using the GNU linker, .gnu.linkonce. sections are used to
3165 eliminate duplicate copies of functions and vtables and such.
3166 The linker will arbitrarily choose one and discard the others.
3167 The AT_*_pc values for such functions refer to local labels in
3168 these sections. If the section from that file was discarded, the
3169 labels are not in the output, so the relocs get a value of 0.
3170 If this is a discarded function, mark the pc bounds as invalid,
3171 so that GDB will ignore it. */
3172 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
3180 /* Get the low and high pc's represented by the scope DIE, and store
3181 them in *LOWPC and *HIGHPC. If the correct values can't be
3182 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3185 get_scope_pc_bounds (struct die_info
*die
,
3186 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3187 struct dwarf2_cu
*cu
)
3189 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3190 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3191 CORE_ADDR current_low
, current_high
;
3193 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3195 best_low
= current_low
;
3196 best_high
= current_high
;
3200 struct die_info
*child
= die
->child
;
3202 while (child
&& child
->tag
)
3204 switch (child
->tag
) {
3205 case DW_TAG_subprogram
:
3206 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3208 best_low
= min (best_low
, current_low
);
3209 best_high
= max (best_high
, current_high
);
3212 case DW_TAG_namespace
:
3213 /* FIXME: carlton/2004-01-16: Should we do this for
3214 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3215 that current GCC's always emit the DIEs corresponding
3216 to definitions of methods of classes as children of a
3217 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3218 the DIEs giving the declarations, which could be
3219 anywhere). But I don't see any reason why the
3220 standards says that they have to be there. */
3221 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3223 if (current_low
!= ((CORE_ADDR
) -1))
3225 best_low
= min (best_low
, current_low
);
3226 best_high
= max (best_high
, current_high
);
3234 child
= sibling_die (child
);
3239 *highpc
= best_high
;
3242 /* Add an aggregate field to the field list. */
3245 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3246 struct dwarf2_cu
*cu
)
3248 struct objfile
*objfile
= cu
->objfile
;
3249 struct nextfield
*new_field
;
3250 struct attribute
*attr
;
3252 char *fieldname
= "";
3254 /* Allocate a new field list entry and link it in. */
3255 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3256 make_cleanup (xfree
, new_field
);
3257 memset (new_field
, 0, sizeof (struct nextfield
));
3258 new_field
->next
= fip
->fields
;
3259 fip
->fields
= new_field
;
3262 /* Handle accessibility and virtuality of field.
3263 The default accessibility for members is public, the default
3264 accessibility for inheritance is private. */
3265 if (die
->tag
!= DW_TAG_inheritance
)
3266 new_field
->accessibility
= DW_ACCESS_public
;
3268 new_field
->accessibility
= DW_ACCESS_private
;
3269 new_field
->virtuality
= DW_VIRTUALITY_none
;
3271 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3273 new_field
->accessibility
= DW_UNSND (attr
);
3274 if (new_field
->accessibility
!= DW_ACCESS_public
)
3275 fip
->non_public_fields
= 1;
3276 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3278 new_field
->virtuality
= DW_UNSND (attr
);
3280 fp
= &new_field
->field
;
3282 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3284 /* Data member other than a C++ static data member. */
3286 /* Get type of field. */
3287 fp
->type
= die_type (die
, cu
);
3289 FIELD_STATIC_KIND (*fp
) = 0;
3291 /* Get bit size of field (zero if none). */
3292 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3295 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3299 FIELD_BITSIZE (*fp
) = 0;
3302 /* Get bit offset of field. */
3303 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3306 FIELD_BITPOS (*fp
) =
3307 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3310 FIELD_BITPOS (*fp
) = 0;
3311 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3314 if (BITS_BIG_ENDIAN
)
3316 /* For big endian bits, the DW_AT_bit_offset gives the
3317 additional bit offset from the MSB of the containing
3318 anonymous object to the MSB of the field. We don't
3319 have to do anything special since we don't need to
3320 know the size of the anonymous object. */
3321 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3325 /* For little endian bits, compute the bit offset to the
3326 MSB of the anonymous object, subtract off the number of
3327 bits from the MSB of the field to the MSB of the
3328 object, and then subtract off the number of bits of
3329 the field itself. The result is the bit offset of
3330 the LSB of the field. */
3332 int bit_offset
= DW_UNSND (attr
);
3334 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3337 /* The size of the anonymous object containing
3338 the bit field is explicit, so use the
3339 indicated size (in bytes). */
3340 anonymous_size
= DW_UNSND (attr
);
3344 /* The size of the anonymous object containing
3345 the bit field must be inferred from the type
3346 attribute of the data member containing the
3348 anonymous_size
= TYPE_LENGTH (fp
->type
);
3350 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3351 - bit_offset
- FIELD_BITSIZE (*fp
);
3355 /* Get name of field. */
3356 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3357 if (attr
&& DW_STRING (attr
))
3358 fieldname
= DW_STRING (attr
);
3360 /* The name is already allocated along with this objfile, so we don't
3361 need to duplicate it for the type. */
3362 fp
->name
= fieldname
;
3364 /* Change accessibility for artificial fields (e.g. virtual table
3365 pointer or virtual base class pointer) to private. */
3366 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3368 new_field
->accessibility
= DW_ACCESS_private
;
3369 fip
->non_public_fields
= 1;
3372 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3374 /* C++ static member. */
3376 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3377 is a declaration, but all versions of G++ as of this writing
3378 (so through at least 3.2.1) incorrectly generate
3379 DW_TAG_variable tags. */
3383 /* Get name of field. */
3384 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3385 if (attr
&& DW_STRING (attr
))
3386 fieldname
= DW_STRING (attr
);
3390 /* Get physical name. */
3391 physname
= dwarf2_linkage_name (die
, cu
);
3393 /* The name is already allocated along with this objfile, so we don't
3394 need to duplicate it for the type. */
3395 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3396 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3397 FIELD_NAME (*fp
) = fieldname
;
3399 else if (die
->tag
== DW_TAG_inheritance
)
3401 /* C++ base class field. */
3402 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3404 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3406 FIELD_BITSIZE (*fp
) = 0;
3407 FIELD_STATIC_KIND (*fp
) = 0;
3408 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3409 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3410 fip
->nbaseclasses
++;
3414 /* Create the vector of fields, and attach it to the type. */
3417 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3418 struct dwarf2_cu
*cu
)
3420 int nfields
= fip
->nfields
;
3422 /* Record the field count, allocate space for the array of fields,
3423 and create blank accessibility bitfields if necessary. */
3424 TYPE_NFIELDS (type
) = nfields
;
3425 TYPE_FIELDS (type
) = (struct field
*)
3426 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3427 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3429 if (fip
->non_public_fields
)
3431 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3433 TYPE_FIELD_PRIVATE_BITS (type
) =
3434 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3435 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3437 TYPE_FIELD_PROTECTED_BITS (type
) =
3438 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3439 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3441 TYPE_FIELD_IGNORE_BITS (type
) =
3442 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3443 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3446 /* If the type has baseclasses, allocate and clear a bit vector for
3447 TYPE_FIELD_VIRTUAL_BITS. */
3448 if (fip
->nbaseclasses
)
3450 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3451 unsigned char *pointer
;
3453 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3454 pointer
= TYPE_ALLOC (type
, num_bytes
);
3455 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3456 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3457 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3460 /* Copy the saved-up fields into the field vector. Start from the head
3461 of the list, adding to the tail of the field array, so that they end
3462 up in the same order in the array in which they were added to the list. */
3463 while (nfields
-- > 0)
3465 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3466 switch (fip
->fields
->accessibility
)
3468 case DW_ACCESS_private
:
3469 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3472 case DW_ACCESS_protected
:
3473 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3476 case DW_ACCESS_public
:
3480 /* Unknown accessibility. Complain and treat it as public. */
3482 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3483 fip
->fields
->accessibility
);
3487 if (nfields
< fip
->nbaseclasses
)
3489 switch (fip
->fields
->virtuality
)
3491 case DW_VIRTUALITY_virtual
:
3492 case DW_VIRTUALITY_pure_virtual
:
3493 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3497 fip
->fields
= fip
->fields
->next
;
3501 /* Add a member function to the proper fieldlist. */
3504 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3505 struct type
*type
, struct dwarf2_cu
*cu
)
3507 struct objfile
*objfile
= cu
->objfile
;
3508 struct attribute
*attr
;
3509 struct fnfieldlist
*flp
;
3511 struct fn_field
*fnp
;
3514 struct nextfnfield
*new_fnfield
;
3516 /* Get name of member function. */
3517 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3518 if (attr
&& DW_STRING (attr
))
3519 fieldname
= DW_STRING (attr
);
3523 /* Get the mangled name. */
3524 physname
= dwarf2_linkage_name (die
, cu
);
3526 /* Look up member function name in fieldlist. */
3527 for (i
= 0; i
< fip
->nfnfields
; i
++)
3529 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3533 /* Create new list element if necessary. */
3534 if (i
< fip
->nfnfields
)
3535 flp
= &fip
->fnfieldlists
[i
];
3538 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3540 fip
->fnfieldlists
= (struct fnfieldlist
*)
3541 xrealloc (fip
->fnfieldlists
,
3542 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3543 * sizeof (struct fnfieldlist
));
3544 if (fip
->nfnfields
== 0)
3545 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3547 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3548 flp
->name
= fieldname
;
3554 /* Create a new member function field and chain it to the field list
3556 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3557 make_cleanup (xfree
, new_fnfield
);
3558 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3559 new_fnfield
->next
= flp
->head
;
3560 flp
->head
= new_fnfield
;
3563 /* Fill in the member function field info. */
3564 fnp
= &new_fnfield
->fnfield
;
3565 /* The name is already allocated along with this objfile, so we don't
3566 need to duplicate it for the type. */
3567 fnp
->physname
= physname
? physname
: "";
3568 fnp
->type
= alloc_type (objfile
);
3569 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3571 int nparams
= TYPE_NFIELDS (die
->type
);
3573 /* TYPE is the domain of this method, and DIE->TYPE is the type
3574 of the method itself (TYPE_CODE_METHOD). */
3575 smash_to_method_type (fnp
->type
, type
,
3576 TYPE_TARGET_TYPE (die
->type
),
3577 TYPE_FIELDS (die
->type
),
3578 TYPE_NFIELDS (die
->type
),
3579 TYPE_VARARGS (die
->type
));
3581 /* Handle static member functions.
3582 Dwarf2 has no clean way to discern C++ static and non-static
3583 member functions. G++ helps GDB by marking the first
3584 parameter for non-static member functions (which is the
3585 this pointer) as artificial. We obtain this information
3586 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3587 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3588 fnp
->voffset
= VOFFSET_STATIC
;
3591 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3594 /* Get fcontext from DW_AT_containing_type if present. */
3595 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3596 fnp
->fcontext
= die_containing_type (die
, cu
);
3598 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3599 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3601 /* Get accessibility. */
3602 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3605 switch (DW_UNSND (attr
))
3607 case DW_ACCESS_private
:
3608 fnp
->is_private
= 1;
3610 case DW_ACCESS_protected
:
3611 fnp
->is_protected
= 1;
3616 /* Check for artificial methods. */
3617 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3618 if (attr
&& DW_UNSND (attr
) != 0)
3619 fnp
->is_artificial
= 1;
3621 /* Get index in virtual function table if it is a virtual member function. */
3622 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3625 /* Support the .debug_loc offsets */
3626 if (attr_form_is_block (attr
))
3628 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3630 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3632 dwarf2_complex_location_expr_complaint ();
3636 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3642 /* Create the vector of member function fields, and attach it to the type. */
3645 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3646 struct dwarf2_cu
*cu
)
3648 struct fnfieldlist
*flp
;
3649 int total_length
= 0;
3652 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3653 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3654 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3656 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3658 struct nextfnfield
*nfp
= flp
->head
;
3659 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3662 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3663 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3664 fn_flp
->fn_fields
= (struct fn_field
*)
3665 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3666 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3667 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3669 total_length
+= flp
->length
;
3672 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3673 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3677 /* Returns non-zero if NAME is the name of a vtable member in CU's
3678 language, zero otherwise. */
3680 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3682 static const char vptr
[] = "_vptr";
3683 static const char vtable
[] = "vtable";
3685 /* Look for the C++ and Java forms of the vtable. */
3686 if ((cu
->language
== language_java
3687 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3688 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3689 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3696 /* Called when we find the DIE that starts a structure or union scope
3697 (definition) to process all dies that define the members of the
3700 NOTE: we need to call struct_type regardless of whether or not the
3701 DIE has an at_name attribute, since it might be an anonymous
3702 structure or union. This gets the type entered into our set of
3705 However, if the structure is incomplete (an opaque struct/union)
3706 then suppress creating a symbol table entry for it since gdb only
3707 wants to find the one with the complete definition. Note that if
3708 it is complete, we just call new_symbol, which does it's own
3709 checking about whether the struct/union is anonymous or not (and
3710 suppresses creating a symbol table entry itself). */
3713 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3715 struct objfile
*objfile
= cu
->objfile
;
3717 struct attribute
*attr
;
3718 const char *previous_prefix
= processing_current_prefix
;
3719 struct cleanup
*back_to
= NULL
;
3724 type
= alloc_type (objfile
);
3726 INIT_CPLUS_SPECIFIC (type
);
3727 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3728 if (attr
&& DW_STRING (attr
))
3730 if (cu
->language
== language_cplus
3731 || cu
->language
== language_java
)
3733 char *new_prefix
= determine_class_name (die
, cu
);
3734 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3735 strlen (new_prefix
),
3736 &objfile
->objfile_obstack
);
3737 back_to
= make_cleanup (xfree
, new_prefix
);
3738 processing_current_prefix
= new_prefix
;
3742 /* The name is already allocated along with this objfile, so
3743 we don't need to duplicate it for the type. */
3744 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3748 if (die
->tag
== DW_TAG_structure_type
)
3750 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3752 else if (die
->tag
== DW_TAG_union_type
)
3754 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3758 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3760 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3763 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3766 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3770 TYPE_LENGTH (type
) = 0;
3773 if (die_is_declaration (die
, cu
))
3774 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3776 /* We need to add the type field to the die immediately so we don't
3777 infinitely recurse when dealing with pointers to the structure
3778 type within the structure itself. */
3779 set_die_type (die
, type
, cu
);
3781 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3783 struct field_info fi
;
3784 struct die_info
*child_die
;
3785 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3787 memset (&fi
, 0, sizeof (struct field_info
));
3789 child_die
= die
->child
;
3791 while (child_die
&& child_die
->tag
)
3793 if (child_die
->tag
== DW_TAG_member
3794 || child_die
->tag
== DW_TAG_variable
)
3796 /* NOTE: carlton/2002-11-05: A C++ static data member
3797 should be a DW_TAG_member that is a declaration, but
3798 all versions of G++ as of this writing (so through at
3799 least 3.2.1) incorrectly generate DW_TAG_variable
3800 tags for them instead. */
3801 dwarf2_add_field (&fi
, child_die
, cu
);
3803 else if (child_die
->tag
== DW_TAG_subprogram
)
3805 /* C++ member function. */
3806 read_type_die (child_die
, cu
);
3807 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3809 else if (child_die
->tag
== DW_TAG_inheritance
)
3811 /* C++ base class field. */
3812 dwarf2_add_field (&fi
, child_die
, cu
);
3814 child_die
= sibling_die (child_die
);
3817 /* Attach fields and member functions to the type. */
3819 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3822 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3824 /* Get the type which refers to the base class (possibly this
3825 class itself) which contains the vtable pointer for the current
3826 class from the DW_AT_containing_type attribute. */
3828 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3830 struct type
*t
= die_containing_type (die
, cu
);
3832 TYPE_VPTR_BASETYPE (type
) = t
;
3837 /* Our own class provides vtbl ptr. */
3838 for (i
= TYPE_NFIELDS (t
) - 1;
3839 i
>= TYPE_N_BASECLASSES (t
);
3842 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3844 if (is_vtable_name (fieldname
, cu
))
3846 TYPE_VPTR_FIELDNO (type
) = i
;
3851 /* Complain if virtual function table field not found. */
3852 if (i
< TYPE_N_BASECLASSES (t
))
3853 complaint (&symfile_complaints
,
3854 _("virtual function table pointer not found when defining class '%s'"),
3855 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3860 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3863 else if (cu
->producer
3864 && strncmp (cu
->producer
,
3865 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3867 /* The IBM XLC compiler does not provide direct indication
3868 of the containing type, but the vtable pointer is
3869 always named __vfp. */
3873 for (i
= TYPE_NFIELDS (type
) - 1;
3874 i
>= TYPE_N_BASECLASSES (type
);
3877 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3879 TYPE_VPTR_FIELDNO (type
) = i
;
3880 TYPE_VPTR_BASETYPE (type
) = type
;
3887 do_cleanups (back_to
);
3890 processing_current_prefix
= previous_prefix
;
3891 if (back_to
!= NULL
)
3892 do_cleanups (back_to
);
3896 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3898 struct objfile
*objfile
= cu
->objfile
;
3899 const char *previous_prefix
= processing_current_prefix
;
3900 struct die_info
*child_die
= die
->child
;
3902 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3903 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3905 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3906 snapshots) has been known to create a die giving a declaration
3907 for a class that has, as a child, a die giving a definition for a
3908 nested class. So we have to process our children even if the
3909 current die is a declaration. Normally, of course, a declaration
3910 won't have any children at all. */
3912 while (child_die
!= NULL
&& child_die
->tag
)
3914 if (child_die
->tag
== DW_TAG_member
3915 || child_die
->tag
== DW_TAG_variable
3916 || child_die
->tag
== DW_TAG_inheritance
)
3921 process_die (child_die
, cu
);
3923 child_die
= sibling_die (child_die
);
3926 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3927 new_symbol (die
, die
->type
, cu
);
3929 processing_current_prefix
= previous_prefix
;
3932 /* Given a DW_AT_enumeration_type die, set its type. We do not
3933 complete the type's fields yet, or create any symbols. */
3936 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3938 struct objfile
*objfile
= cu
->objfile
;
3940 struct attribute
*attr
;
3945 type
= alloc_type (objfile
);
3947 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3948 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3949 if (attr
&& DW_STRING (attr
))
3951 char *name
= DW_STRING (attr
);
3953 if (processing_has_namespace_info
)
3955 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
3956 processing_current_prefix
,
3961 /* The name is already allocated along with this objfile, so
3962 we don't need to duplicate it for the type. */
3963 TYPE_TAG_NAME (type
) = name
;
3967 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3970 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3974 TYPE_LENGTH (type
) = 0;
3977 set_die_type (die
, type
, cu
);
3980 /* Determine the name of the type represented by DIE, which should be
3981 a named C++ or Java compound type. Return the name in question; the caller
3982 is responsible for xfree()'ing it. */
3985 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3987 struct cleanup
*back_to
= NULL
;
3988 struct die_info
*spec_die
= die_specification (die
, cu
);
3989 char *new_prefix
= NULL
;
3991 /* If this is the definition of a class that is declared by another
3992 die, then processing_current_prefix may not be accurate; see
3993 read_func_scope for a similar example. */
3994 if (spec_die
!= NULL
)
3996 char *specification_prefix
= determine_prefix (spec_die
, cu
);
3997 processing_current_prefix
= specification_prefix
;
3998 back_to
= make_cleanup (xfree
, specification_prefix
);
4001 /* If we don't have namespace debug info, guess the name by trying
4002 to demangle the names of members, just like we did in
4003 guess_structure_name. */
4004 if (!processing_has_namespace_info
)
4006 struct die_info
*child
;
4008 for (child
= die
->child
;
4009 child
!= NULL
&& child
->tag
!= 0;
4010 child
= sibling_die (child
))
4012 if (child
->tag
== DW_TAG_subprogram
)
4015 = language_class_name_from_physname (cu
->language_defn
,
4019 if (new_prefix
!= NULL
)
4025 if (new_prefix
== NULL
)
4027 const char *name
= dwarf2_name (die
, cu
);
4028 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4029 name
? name
: "<<anonymous>>",
4033 if (back_to
!= NULL
)
4034 do_cleanups (back_to
);
4039 /* Given a pointer to a die which begins an enumeration, process all
4040 the dies that define the members of the enumeration, and create the
4041 symbol for the enumeration type.
4043 NOTE: We reverse the order of the element list. */
4046 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4048 struct objfile
*objfile
= cu
->objfile
;
4049 struct die_info
*child_die
;
4050 struct field
*fields
;
4051 struct attribute
*attr
;
4054 int unsigned_enum
= 1;
4058 if (die
->child
!= NULL
)
4060 child_die
= die
->child
;
4061 while (child_die
&& child_die
->tag
)
4063 if (child_die
->tag
!= DW_TAG_enumerator
)
4065 process_die (child_die
, cu
);
4069 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4072 sym
= new_symbol (child_die
, die
->type
, cu
);
4073 if (SYMBOL_VALUE (sym
) < 0)
4076 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4078 fields
= (struct field
*)
4080 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4081 * sizeof (struct field
));
4084 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4085 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4086 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4087 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4088 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4094 child_die
= sibling_die (child_die
);
4099 TYPE_NFIELDS (die
->type
) = num_fields
;
4100 TYPE_FIELDS (die
->type
) = (struct field
*)
4101 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4102 memcpy (TYPE_FIELDS (die
->type
), fields
,
4103 sizeof (struct field
) * num_fields
);
4107 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4110 new_symbol (die
, die
->type
, cu
);
4113 /* Extract all information from a DW_TAG_array_type DIE and put it in
4114 the DIE's type field. For now, this only handles one dimensional
4118 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4120 struct objfile
*objfile
= cu
->objfile
;
4121 struct die_info
*child_die
;
4122 struct type
*type
= NULL
;
4123 struct type
*element_type
, *range_type
, *index_type
;
4124 struct type
**range_types
= NULL
;
4125 struct attribute
*attr
;
4127 struct cleanup
*back_to
;
4129 /* Return if we've already decoded this type. */
4135 element_type
= die_type (die
, cu
);
4137 /* Irix 6.2 native cc creates array types without children for
4138 arrays with unspecified length. */
4139 if (die
->child
== NULL
)
4141 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4142 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4143 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4148 back_to
= make_cleanup (null_cleanup
, NULL
);
4149 child_die
= die
->child
;
4150 while (child_die
&& child_die
->tag
)
4152 if (child_die
->tag
== DW_TAG_subrange_type
)
4154 read_subrange_type (child_die
, cu
);
4156 if (child_die
->type
!= NULL
)
4158 /* The range type was succesfully read. Save it for
4159 the array type creation. */
4160 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4162 range_types
= (struct type
**)
4163 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4164 * sizeof (struct type
*));
4166 make_cleanup (free_current_contents
, &range_types
);
4168 range_types
[ndim
++] = child_die
->type
;
4171 child_die
= sibling_die (child_die
);
4174 /* Dwarf2 dimensions are output from left to right, create the
4175 necessary array types in backwards order. */
4177 type
= element_type
;
4179 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4183 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4188 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4191 /* Understand Dwarf2 support for vector types (like they occur on
4192 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4193 array type. This is not part of the Dwarf2/3 standard yet, but a
4194 custom vendor extension. The main difference between a regular
4195 array and the vector variant is that vectors are passed by value
4197 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4199 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4201 do_cleanups (back_to
);
4203 /* Install the type in the die. */
4204 set_die_type (die
, type
, cu
);
4207 static enum dwarf_array_dim_ordering
4208 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4210 struct attribute
*attr
;
4212 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4214 if (attr
) return DW_SND (attr
);
4217 GNU F77 is a special case, as at 08/2004 array type info is the
4218 opposite order to the dwarf2 specification, but data is still
4219 laid out as per normal fortran.
4221 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4225 if (cu
->language
== language_fortran
&&
4226 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4228 return DW_ORD_row_major
;
4231 switch (cu
->language_defn
->la_array_ordering
)
4233 case array_column_major
:
4234 return DW_ORD_col_major
;
4235 case array_row_major
:
4237 return DW_ORD_row_major
;
4242 /* First cut: install each common block member as a global variable. */
4245 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4247 struct die_info
*child_die
;
4248 struct attribute
*attr
;
4250 CORE_ADDR base
= (CORE_ADDR
) 0;
4252 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4255 /* Support the .debug_loc offsets */
4256 if (attr_form_is_block (attr
))
4258 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4260 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4262 dwarf2_complex_location_expr_complaint ();
4266 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4267 "common block member");
4270 if (die
->child
!= NULL
)
4272 child_die
= die
->child
;
4273 while (child_die
&& child_die
->tag
)
4275 sym
= new_symbol (child_die
, NULL
, cu
);
4276 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4279 SYMBOL_VALUE_ADDRESS (sym
) =
4280 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4281 add_symbol_to_list (sym
, &global_symbols
);
4283 child_die
= sibling_die (child_die
);
4288 /* Read a C++ namespace. */
4291 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4293 struct objfile
*objfile
= cu
->objfile
;
4294 const char *previous_prefix
= processing_current_prefix
;
4297 struct die_info
*current_die
;
4298 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4300 name
= namespace_name (die
, &is_anonymous
, cu
);
4302 /* Now build the name of the current namespace. */
4304 if (previous_prefix
[0] == '\0')
4306 processing_current_prefix
= name
;
4310 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4311 make_cleanup (xfree
, temp_name
);
4312 processing_current_prefix
= temp_name
;
4315 /* Add a symbol associated to this if we haven't seen the namespace
4316 before. Also, add a using directive if it's an anonymous
4319 if (dwarf2_extension (die
, cu
) == NULL
)
4323 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4324 this cast will hopefully become unnecessary. */
4325 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4326 (char *) processing_current_prefix
,
4328 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4330 new_symbol (die
, type
, cu
);
4331 set_die_type (die
, type
, cu
);
4334 cp_add_using_directive (processing_current_prefix
,
4335 strlen (previous_prefix
),
4336 strlen (processing_current_prefix
));
4339 if (die
->child
!= NULL
)
4341 struct die_info
*child_die
= die
->child
;
4343 while (child_die
&& child_die
->tag
)
4345 process_die (child_die
, cu
);
4346 child_die
= sibling_die (child_die
);
4350 processing_current_prefix
= previous_prefix
;
4351 do_cleanups (back_to
);
4354 /* Return the name of the namespace represented by DIE. Set
4355 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4359 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4361 struct die_info
*current_die
;
4362 const char *name
= NULL
;
4364 /* Loop through the extensions until we find a name. */
4366 for (current_die
= die
;
4367 current_die
!= NULL
;
4368 current_die
= dwarf2_extension (die
, cu
))
4370 name
= dwarf2_name (current_die
, cu
);
4375 /* Is it an anonymous namespace? */
4377 *is_anonymous
= (name
== NULL
);
4379 name
= "(anonymous namespace)";
4384 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4385 the user defined type vector. */
4388 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4390 struct comp_unit_head
*cu_header
= &cu
->header
;
4392 struct attribute
*attr_byte_size
;
4393 struct attribute
*attr_address_class
;
4394 int byte_size
, addr_class
;
4401 type
= lookup_pointer_type (die_type (die
, cu
));
4403 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4405 byte_size
= DW_UNSND (attr_byte_size
);
4407 byte_size
= cu_header
->addr_size
;
4409 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4410 if (attr_address_class
)
4411 addr_class
= DW_UNSND (attr_address_class
);
4413 addr_class
= DW_ADDR_none
;
4415 /* If the pointer size or address class is different than the
4416 default, create a type variant marked as such and set the
4417 length accordingly. */
4418 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4420 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4424 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4425 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4426 type
= make_type_with_address_space (type
, type_flags
);
4428 else if (TYPE_LENGTH (type
) != byte_size
)
4430 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4433 /* Should we also complain about unhandled address classes? */
4437 TYPE_LENGTH (type
) = byte_size
;
4438 set_die_type (die
, type
, cu
);
4441 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4442 the user defined type vector. */
4445 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4447 struct objfile
*objfile
= cu
->objfile
;
4449 struct type
*to_type
;
4450 struct type
*domain
;
4457 type
= alloc_type (objfile
);
4458 to_type
= die_type (die
, cu
);
4459 domain
= die_containing_type (die
, cu
);
4460 smash_to_member_type (type
, domain
, to_type
);
4462 set_die_type (die
, type
, cu
);
4465 /* Extract all information from a DW_TAG_reference_type DIE and add to
4466 the user defined type vector. */
4469 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4471 struct comp_unit_head
*cu_header
= &cu
->header
;
4473 struct attribute
*attr
;
4480 type
= lookup_reference_type (die_type (die
, cu
));
4481 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4484 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4488 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4490 set_die_type (die
, type
, cu
);
4494 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4496 struct type
*base_type
;
4503 base_type
= die_type (die
, cu
);
4504 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4509 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4511 struct type
*base_type
;
4518 base_type
= die_type (die
, cu
);
4519 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4523 /* Extract all information from a DW_TAG_string_type DIE and add to
4524 the user defined type vector. It isn't really a user defined type,
4525 but it behaves like one, with other DIE's using an AT_user_def_type
4526 attribute to reference it. */
4529 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4531 struct objfile
*objfile
= cu
->objfile
;
4532 struct type
*type
, *range_type
, *index_type
, *char_type
;
4533 struct attribute
*attr
;
4534 unsigned int length
;
4541 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4544 length
= DW_UNSND (attr
);
4548 /* check for the DW_AT_byte_size attribute */
4549 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4552 length
= DW_UNSND (attr
);
4559 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4560 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4561 if (cu
->language
== language_fortran
)
4563 /* Need to create a unique string type for bounds
4565 type
= create_string_type (0, range_type
);
4569 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4570 type
= create_string_type (char_type
, range_type
);
4572 set_die_type (die
, type
, cu
);
4575 /* Handle DIES due to C code like:
4579 int (*funcp)(int a, long l);
4583 ('funcp' generates a DW_TAG_subroutine_type DIE)
4587 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4589 struct type
*type
; /* Type that this function returns */
4590 struct type
*ftype
; /* Function that returns above type */
4591 struct attribute
*attr
;
4593 /* Decode the type that this subroutine returns */
4598 type
= die_type (die
, cu
);
4599 ftype
= make_function_type (type
, (struct type
**) 0);
4601 /* All functions in C++ and Java have prototypes. */
4602 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4603 if ((attr
&& (DW_UNSND (attr
) != 0))
4604 || cu
->language
== language_cplus
4605 || cu
->language
== language_java
)
4606 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4608 if (die
->child
!= NULL
)
4610 struct die_info
*child_die
;
4614 /* Count the number of parameters.
4615 FIXME: GDB currently ignores vararg functions, but knows about
4616 vararg member functions. */
4617 child_die
= die
->child
;
4618 while (child_die
&& child_die
->tag
)
4620 if (child_die
->tag
== DW_TAG_formal_parameter
)
4622 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4623 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4624 child_die
= sibling_die (child_die
);
4627 /* Allocate storage for parameters and fill them in. */
4628 TYPE_NFIELDS (ftype
) = nparams
;
4629 TYPE_FIELDS (ftype
) = (struct field
*)
4630 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
4632 child_die
= die
->child
;
4633 while (child_die
&& child_die
->tag
)
4635 if (child_die
->tag
== DW_TAG_formal_parameter
)
4637 /* Dwarf2 has no clean way to discern C++ static and non-static
4638 member functions. G++ helps GDB by marking the first
4639 parameter for non-static member functions (which is the
4640 this pointer) as artificial. We pass this information
4641 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4642 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4644 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4646 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4647 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4650 child_die
= sibling_die (child_die
);
4654 set_die_type (die
, ftype
, cu
);
4658 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4660 struct objfile
*objfile
= cu
->objfile
;
4661 struct attribute
*attr
;
4666 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4667 if (attr
&& DW_STRING (attr
))
4669 name
= DW_STRING (attr
);
4671 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4672 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4674 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4678 /* Find a representation of a given base type and install
4679 it in the TYPE field of the die. */
4682 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4684 struct objfile
*objfile
= cu
->objfile
;
4686 struct attribute
*attr
;
4687 int encoding
= 0, size
= 0;
4689 /* If we've already decoded this die, this is a no-op. */
4695 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4698 encoding
= DW_UNSND (attr
);
4700 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4703 size
= DW_UNSND (attr
);
4705 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4706 if (attr
&& DW_STRING (attr
))
4708 enum type_code code
= TYPE_CODE_INT
;
4713 case DW_ATE_address
:
4714 /* Turn DW_ATE_address into a void * pointer. */
4715 code
= TYPE_CODE_PTR
;
4716 type_flags
|= TYPE_FLAG_UNSIGNED
;
4718 case DW_ATE_boolean
:
4719 code
= TYPE_CODE_BOOL
;
4720 type_flags
|= TYPE_FLAG_UNSIGNED
;
4722 case DW_ATE_complex_float
:
4723 code
= TYPE_CODE_COMPLEX
;
4726 code
= TYPE_CODE_FLT
;
4729 case DW_ATE_signed_char
:
4731 case DW_ATE_unsigned
:
4732 case DW_ATE_unsigned_char
:
4733 type_flags
|= TYPE_FLAG_UNSIGNED
;
4736 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4737 dwarf_type_encoding_name (encoding
));
4740 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4741 if (encoding
== DW_ATE_address
)
4742 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4744 else if (encoding
== DW_ATE_complex_float
)
4747 TYPE_TARGET_TYPE (type
)
4748 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4749 else if (size
== 16)
4750 TYPE_TARGET_TYPE (type
)
4751 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4753 TYPE_TARGET_TYPE (type
)
4754 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4759 type
= dwarf_base_type (encoding
, size
, cu
);
4761 set_die_type (die
, type
, cu
);
4764 /* Read the given DW_AT_subrange DIE. */
4767 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4769 struct type
*base_type
;
4770 struct type
*range_type
;
4771 struct attribute
*attr
;
4775 /* If we have already decoded this die, then nothing more to do. */
4779 base_type
= die_type (die
, cu
);
4780 if (base_type
== NULL
)
4782 complaint (&symfile_complaints
,
4783 _("DW_AT_type missing from DW_TAG_subrange_type"));
4787 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4788 base_type
= alloc_type (NULL
);
4790 if (cu
->language
== language_fortran
)
4792 /* FORTRAN implies a lower bound of 1, if not given. */
4796 /* FIXME: For variable sized arrays either of these could be
4797 a variable rather than a constant value. We'll allow it,
4798 but we don't know how to handle it. */
4799 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4801 low
= dwarf2_get_attr_constant_value (attr
, 0);
4803 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4806 if (attr
->form
== DW_FORM_block1
)
4808 /* GCC encodes arrays with unspecified or dynamic length
4809 with a DW_FORM_block1 attribute.
4810 FIXME: GDB does not yet know how to handle dynamic
4811 arrays properly, treat them as arrays with unspecified
4814 FIXME: jimb/2003-09-22: GDB does not really know
4815 how to handle arrays of unspecified length
4816 either; we just represent them as zero-length
4817 arrays. Choose an appropriate upper bound given
4818 the lower bound we've computed above. */
4822 high
= dwarf2_get_attr_constant_value (attr
, 1);
4825 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4827 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4828 if (attr
&& DW_STRING (attr
))
4829 TYPE_NAME (range_type
) = DW_STRING (attr
);
4831 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4833 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4835 set_die_type (die
, range_type
, cu
);
4839 /* Read a whole compilation unit into a linked list of dies. */
4841 static struct die_info
*
4842 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4844 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4847 /* Read a single die and all its descendents. Set the die's sibling
4848 field to NULL; set other fields in the die correctly, and set all
4849 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4850 location of the info_ptr after reading all of those dies. PARENT
4851 is the parent of the die in question. */
4853 static struct die_info
*
4854 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
4855 struct dwarf2_cu
*cu
,
4856 gdb_byte
**new_info_ptr
,
4857 struct die_info
*parent
)
4859 struct die_info
*die
;
4863 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4864 store_in_ref_table (die
->offset
, die
, cu
);
4868 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4874 *new_info_ptr
= cur_ptr
;
4877 die
->sibling
= NULL
;
4878 die
->parent
= parent
;
4882 /* Read a die, all of its descendents, and all of its siblings; set
4883 all of the fields of all of the dies correctly. Arguments are as
4884 in read_die_and_children. */
4886 static struct die_info
*
4887 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
4888 struct dwarf2_cu
*cu
,
4889 gdb_byte
**new_info_ptr
,
4890 struct die_info
*parent
)
4892 struct die_info
*first_die
, *last_sibling
;
4896 first_die
= last_sibling
= NULL
;
4900 struct die_info
*die
4901 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4909 last_sibling
->sibling
= die
;
4914 *new_info_ptr
= cur_ptr
;
4924 /* Free a linked list of dies. */
4927 free_die_list (struct die_info
*dies
)
4929 struct die_info
*die
, *next
;
4934 if (die
->child
!= NULL
)
4935 free_die_list (die
->child
);
4936 next
= die
->sibling
;
4943 /* Read the contents of the section at OFFSET and of size SIZE from the
4944 object file specified by OBJFILE into the objfile_obstack and return it. */
4947 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4949 bfd
*abfd
= objfile
->obfd
;
4950 gdb_byte
*buf
, *retbuf
;
4951 bfd_size_type size
= bfd_get_section_size (sectp
);
4956 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
4957 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
4961 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4962 || bfd_bread (buf
, size
, abfd
) != size
)
4963 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
4964 bfd_get_filename (abfd
));
4969 /* In DWARF version 2, the description of the debugging information is
4970 stored in a separate .debug_abbrev section. Before we read any
4971 dies from a section we read in all abbreviations and install them
4972 in a hash table. This function also sets flags in CU describing
4973 the data found in the abbrev table. */
4976 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4978 struct comp_unit_head
*cu_header
= &cu
->header
;
4979 gdb_byte
*abbrev_ptr
;
4980 struct abbrev_info
*cur_abbrev
;
4981 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4982 unsigned int abbrev_form
, hash_number
;
4983 struct attr_abbrev
*cur_attrs
;
4984 unsigned int allocated_attrs
;
4986 /* Initialize dwarf2 abbrevs */
4987 obstack_init (&cu
->abbrev_obstack
);
4988 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
4990 * sizeof (struct abbrev_info
*)));
4991 memset (cu
->dwarf2_abbrevs
, 0,
4992 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
4994 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
4995 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4996 abbrev_ptr
+= bytes_read
;
4998 allocated_attrs
= ATTR_ALLOC_CHUNK
;
4999 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5001 /* loop until we reach an abbrev number of 0 */
5002 while (abbrev_number
)
5004 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5006 /* read in abbrev header */
5007 cur_abbrev
->number
= abbrev_number
;
5008 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5009 abbrev_ptr
+= bytes_read
;
5010 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5013 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5014 cu
->has_namespace_info
= 1;
5016 /* now read in declarations */
5017 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5018 abbrev_ptr
+= bytes_read
;
5019 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5020 abbrev_ptr
+= bytes_read
;
5023 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5025 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5027 = xrealloc (cur_attrs
, (allocated_attrs
5028 * sizeof (struct attr_abbrev
)));
5031 /* Record whether this compilation unit might have
5032 inter-compilation-unit references. If we don't know what form
5033 this attribute will have, then it might potentially be a
5034 DW_FORM_ref_addr, so we conservatively expect inter-CU
5037 if (abbrev_form
== DW_FORM_ref_addr
5038 || abbrev_form
== DW_FORM_indirect
)
5039 cu
->has_form_ref_addr
= 1;
5041 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5042 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5043 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5044 abbrev_ptr
+= bytes_read
;
5045 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5046 abbrev_ptr
+= bytes_read
;
5049 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5050 (cur_abbrev
->num_attrs
5051 * sizeof (struct attr_abbrev
)));
5052 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5053 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5055 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5056 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5057 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5059 /* Get next abbreviation.
5060 Under Irix6 the abbreviations for a compilation unit are not
5061 always properly terminated with an abbrev number of 0.
5062 Exit loop if we encounter an abbreviation which we have
5063 already read (which means we are about to read the abbreviations
5064 for the next compile unit) or if the end of the abbreviation
5065 table is reached. */
5066 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5067 >= dwarf2_per_objfile
->abbrev_size
)
5069 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5070 abbrev_ptr
+= bytes_read
;
5071 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5078 /* Release the memory used by the abbrev table for a compilation unit. */
5081 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5083 struct dwarf2_cu
*cu
= ptr_to_cu
;
5085 obstack_free (&cu
->abbrev_obstack
, NULL
);
5086 cu
->dwarf2_abbrevs
= NULL
;
5089 /* Lookup an abbrev_info structure in the abbrev hash table. */
5091 static struct abbrev_info
*
5092 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5094 unsigned int hash_number
;
5095 struct abbrev_info
*abbrev
;
5097 hash_number
= number
% ABBREV_HASH_SIZE
;
5098 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5102 if (abbrev
->number
== number
)
5105 abbrev
= abbrev
->next
;
5110 /* Returns nonzero if TAG represents a type that we might generate a partial
5114 is_type_tag_for_partial (int tag
)
5119 /* Some types that would be reasonable to generate partial symbols for,
5120 that we don't at present. */
5121 case DW_TAG_array_type
:
5122 case DW_TAG_file_type
:
5123 case DW_TAG_ptr_to_member_type
:
5124 case DW_TAG_set_type
:
5125 case DW_TAG_string_type
:
5126 case DW_TAG_subroutine_type
:
5128 case DW_TAG_base_type
:
5129 case DW_TAG_class_type
:
5130 case DW_TAG_enumeration_type
:
5131 case DW_TAG_structure_type
:
5132 case DW_TAG_subrange_type
:
5133 case DW_TAG_typedef
:
5134 case DW_TAG_union_type
:
5141 /* Load all DIEs that are interesting for partial symbols into memory. */
5143 static struct partial_die_info
*
5144 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5145 struct dwarf2_cu
*cu
)
5147 struct partial_die_info
*part_die
;
5148 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5149 struct abbrev_info
*abbrev
;
5150 unsigned int bytes_read
;
5152 int nesting_level
= 1;
5158 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5162 &cu
->comp_unit_obstack
,
5163 hashtab_obstack_allocate
,
5164 dummy_obstack_deallocate
);
5166 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5167 sizeof (struct partial_die_info
));
5171 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5173 /* A NULL abbrev means the end of a series of children. */
5176 if (--nesting_level
== 0)
5178 /* PART_DIE was probably the last thing allocated on the
5179 comp_unit_obstack, so we could call obstack_free
5180 here. We don't do that because the waste is small,
5181 and will be cleaned up when we're done with this
5182 compilation unit. This way, we're also more robust
5183 against other users of the comp_unit_obstack. */
5186 info_ptr
+= bytes_read
;
5187 last_die
= parent_die
;
5188 parent_die
= parent_die
->die_parent
;
5192 /* Check whether this DIE is interesting enough to save. */
5193 if (!is_type_tag_for_partial (abbrev
->tag
)
5194 && abbrev
->tag
!= DW_TAG_enumerator
5195 && abbrev
->tag
!= DW_TAG_subprogram
5196 && abbrev
->tag
!= DW_TAG_variable
5197 && abbrev
->tag
!= DW_TAG_namespace
)
5199 /* Otherwise we skip to the next sibling, if any. */
5200 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5204 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5205 abfd
, info_ptr
, cu
);
5207 /* This two-pass algorithm for processing partial symbols has a
5208 high cost in cache pressure. Thus, handle some simple cases
5209 here which cover the majority of C partial symbols. DIEs
5210 which neither have specification tags in them, nor could have
5211 specification tags elsewhere pointing at them, can simply be
5212 processed and discarded.
5214 This segment is also optional; scan_partial_symbols and
5215 add_partial_symbol will handle these DIEs if we chain
5216 them in normally. When compilers which do not emit large
5217 quantities of duplicate debug information are more common,
5218 this code can probably be removed. */
5220 /* Any complete simple types at the top level (pretty much all
5221 of them, for a language without namespaces), can be processed
5223 if (parent_die
== NULL
5224 && part_die
->has_specification
== 0
5225 && part_die
->is_declaration
== 0
5226 && (part_die
->tag
== DW_TAG_typedef
5227 || part_die
->tag
== DW_TAG_base_type
5228 || part_die
->tag
== DW_TAG_subrange_type
))
5230 if (building_psymtab
&& part_die
->name
!= NULL
)
5231 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5232 VAR_DOMAIN
, LOC_TYPEDEF
,
5233 &cu
->objfile
->static_psymbols
,
5234 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5235 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5239 /* If we're at the second level, and we're an enumerator, and
5240 our parent has no specification (meaning possibly lives in a
5241 namespace elsewhere), then we can add the partial symbol now
5242 instead of queueing it. */
5243 if (part_die
->tag
== DW_TAG_enumerator
5244 && parent_die
!= NULL
5245 && parent_die
->die_parent
== NULL
5246 && parent_die
->tag
== DW_TAG_enumeration_type
5247 && parent_die
->has_specification
== 0)
5249 if (part_die
->name
== NULL
)
5250 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5251 else if (building_psymtab
)
5252 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5253 VAR_DOMAIN
, LOC_CONST
,
5254 (cu
->language
== language_cplus
5255 || cu
->language
== language_java
)
5256 ? &cu
->objfile
->global_psymbols
5257 : &cu
->objfile
->static_psymbols
,
5258 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5260 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5264 /* We'll save this DIE so link it in. */
5265 part_die
->die_parent
= parent_die
;
5266 part_die
->die_sibling
= NULL
;
5267 part_die
->die_child
= NULL
;
5269 if (last_die
&& last_die
== parent_die
)
5270 last_die
->die_child
= part_die
;
5272 last_die
->die_sibling
= part_die
;
5274 last_die
= part_die
;
5276 if (first_die
== NULL
)
5277 first_die
= part_die
;
5279 /* Maybe add the DIE to the hash table. Not all DIEs that we
5280 find interesting need to be in the hash table, because we
5281 also have the parent/sibling/child chains; only those that we
5282 might refer to by offset later during partial symbol reading.
5284 For now this means things that might have be the target of a
5285 DW_AT_specification, DW_AT_abstract_origin, or
5286 DW_AT_extension. DW_AT_extension will refer only to
5287 namespaces; DW_AT_abstract_origin refers to functions (and
5288 many things under the function DIE, but we do not recurse
5289 into function DIEs during partial symbol reading) and
5290 possibly variables as well; DW_AT_specification refers to
5291 declarations. Declarations ought to have the DW_AT_declaration
5292 flag. It happens that GCC forgets to put it in sometimes, but
5293 only for functions, not for types.
5295 Adding more things than necessary to the hash table is harmless
5296 except for the performance cost. Adding too few will result in
5297 internal errors in find_partial_die. */
5299 if (abbrev
->tag
== DW_TAG_subprogram
5300 || abbrev
->tag
== DW_TAG_variable
5301 || abbrev
->tag
== DW_TAG_namespace
5302 || part_die
->is_declaration
)
5306 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5307 part_die
->offset
, INSERT
);
5311 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5312 sizeof (struct partial_die_info
));
5314 /* For some DIEs we want to follow their children (if any). For C
5315 we have no reason to follow the children of structures; for other
5316 languages we have to, both so that we can get at method physnames
5317 to infer fully qualified class names, and for DW_AT_specification. */
5318 if (last_die
->has_children
5319 && (last_die
->tag
== DW_TAG_namespace
5320 || last_die
->tag
== DW_TAG_enumeration_type
5321 || (cu
->language
!= language_c
5322 && (last_die
->tag
== DW_TAG_class_type
5323 || last_die
->tag
== DW_TAG_structure_type
5324 || last_die
->tag
== DW_TAG_union_type
))))
5327 parent_die
= last_die
;
5331 /* Otherwise we skip to the next sibling, if any. */
5332 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5334 /* Back to the top, do it again. */
5338 /* Read a minimal amount of information into the minimal die structure. */
5341 read_partial_die (struct partial_die_info
*part_die
,
5342 struct abbrev_info
*abbrev
,
5343 unsigned int abbrev_len
, bfd
*abfd
,
5344 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5346 unsigned int bytes_read
, i
;
5347 struct attribute attr
;
5348 int has_low_pc_attr
= 0;
5349 int has_high_pc_attr
= 0;
5351 memset (part_die
, 0, sizeof (struct partial_die_info
));
5353 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5355 info_ptr
+= abbrev_len
;
5360 part_die
->tag
= abbrev
->tag
;
5361 part_die
->has_children
= abbrev
->has_children
;
5363 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5365 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5367 /* Store the data if it is of an attribute we want to keep in a
5368 partial symbol table. */
5373 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5374 if (part_die
->name
== NULL
)
5375 part_die
->name
= DW_STRING (&attr
);
5377 case DW_AT_comp_dir
:
5378 if (part_die
->dirname
== NULL
)
5379 part_die
->dirname
= DW_STRING (&attr
);
5381 case DW_AT_MIPS_linkage_name
:
5382 part_die
->name
= DW_STRING (&attr
);
5385 has_low_pc_attr
= 1;
5386 part_die
->lowpc
= DW_ADDR (&attr
);
5389 has_high_pc_attr
= 1;
5390 part_die
->highpc
= DW_ADDR (&attr
);
5392 case DW_AT_location
:
5393 /* Support the .debug_loc offsets */
5394 if (attr_form_is_block (&attr
))
5396 part_die
->locdesc
= DW_BLOCK (&attr
);
5398 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5400 dwarf2_complex_location_expr_complaint ();
5404 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5405 "partial symbol information");
5408 case DW_AT_language
:
5409 part_die
->language
= DW_UNSND (&attr
);
5411 case DW_AT_external
:
5412 part_die
->is_external
= DW_UNSND (&attr
);
5414 case DW_AT_declaration
:
5415 part_die
->is_declaration
= DW_UNSND (&attr
);
5418 part_die
->has_type
= 1;
5420 case DW_AT_abstract_origin
:
5421 case DW_AT_specification
:
5422 case DW_AT_extension
:
5423 part_die
->has_specification
= 1;
5424 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5427 /* Ignore absolute siblings, they might point outside of
5428 the current compile unit. */
5429 if (attr
.form
== DW_FORM_ref_addr
)
5430 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5432 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5433 + dwarf2_get_ref_die_offset (&attr
, cu
);
5435 case DW_AT_stmt_list
:
5436 part_die
->has_stmt_list
= 1;
5437 part_die
->line_offset
= DW_UNSND (&attr
);
5444 /* When using the GNU linker, .gnu.linkonce. sections are used to
5445 eliminate duplicate copies of functions and vtables and such.
5446 The linker will arbitrarily choose one and discard the others.
5447 The AT_*_pc values for such functions refer to local labels in
5448 these sections. If the section from that file was discarded, the
5449 labels are not in the output, so the relocs get a value of 0.
5450 If this is a discarded function, mark the pc bounds as invalid,
5451 so that GDB will ignore it. */
5452 if (has_low_pc_attr
&& has_high_pc_attr
5453 && part_die
->lowpc
< part_die
->highpc
5454 && (part_die
->lowpc
!= 0
5455 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5456 part_die
->has_pc_info
= 1;
5460 /* Find a cached partial DIE at OFFSET in CU. */
5462 static struct partial_die_info
*
5463 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5465 struct partial_die_info
*lookup_die
= NULL
;
5466 struct partial_die_info part_die
;
5468 part_die
.offset
= offset
;
5469 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5471 if (lookup_die
== NULL
)
5472 internal_error (__FILE__
, __LINE__
,
5473 _("could not find partial DIE in cache\n"));
5478 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5480 static struct partial_die_info
*
5481 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5483 struct dwarf2_per_cu_data
*per_cu
;
5485 if (offset
>= cu
->header
.offset
5486 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5487 return find_partial_die_in_comp_unit (offset
, cu
);
5489 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5491 if (per_cu
->cu
== NULL
)
5493 load_comp_unit (per_cu
, cu
->objfile
);
5494 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5495 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5498 per_cu
->cu
->last_used
= 0;
5499 return find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5502 /* Adjust PART_DIE before generating a symbol for it. This function
5503 may set the is_external flag or change the DIE's name. */
5506 fixup_partial_die (struct partial_die_info
*part_die
,
5507 struct dwarf2_cu
*cu
)
5509 /* If we found a reference attribute and the DIE has no name, try
5510 to find a name in the referred to DIE. */
5512 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5514 struct partial_die_info
*spec_die
;
5516 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5518 fixup_partial_die (spec_die
, cu
);
5522 part_die
->name
= spec_die
->name
;
5524 /* Copy DW_AT_external attribute if it is set. */
5525 if (spec_die
->is_external
)
5526 part_die
->is_external
= spec_die
->is_external
;
5530 /* Set default names for some unnamed DIEs. */
5531 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5532 || part_die
->tag
== DW_TAG_class_type
))
5533 part_die
->name
= "(anonymous class)";
5535 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5536 part_die
->name
= "(anonymous namespace)";
5538 if (part_die
->tag
== DW_TAG_structure_type
5539 || part_die
->tag
== DW_TAG_class_type
5540 || part_die
->tag
== DW_TAG_union_type
)
5541 guess_structure_name (part_die
, cu
);
5544 /* Read the die from the .debug_info section buffer. Set DIEP to
5545 point to a newly allocated die with its information, except for its
5546 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5547 whether the die has children or not. */
5550 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5551 struct dwarf2_cu
*cu
, int *has_children
)
5553 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5554 struct abbrev_info
*abbrev
;
5555 struct die_info
*die
;
5557 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5558 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5559 info_ptr
+= bytes_read
;
5562 die
= dwarf_alloc_die ();
5564 die
->abbrev
= abbrev_number
;
5571 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5574 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5576 bfd_get_filename (abfd
));
5578 die
= dwarf_alloc_die ();
5579 die
->offset
= offset
;
5580 die
->tag
= abbrev
->tag
;
5581 die
->abbrev
= abbrev_number
;
5584 die
->num_attrs
= abbrev
->num_attrs
;
5585 die
->attrs
= (struct attribute
*)
5586 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5588 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5590 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5591 abfd
, info_ptr
, cu
);
5593 /* If this attribute is an absolute reference to a different
5594 compilation unit, make sure that compilation unit is loaded
5596 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5597 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5598 || (DW_ADDR (&die
->attrs
[i
])
5599 >= cu
->header
.offset
+ cu
->header
.length
)))
5601 struct dwarf2_per_cu_data
*per_cu
;
5602 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5605 /* Mark the dependence relation so that we don't flush PER_CU
5607 dwarf2_add_dependence (cu
, per_cu
);
5609 /* If it's already on the queue, we have nothing to do. */
5613 /* If the compilation unit is already loaded, just mark it as
5615 if (per_cu
->cu
!= NULL
)
5617 per_cu
->cu
->last_used
= 0;
5621 /* Add it to the queue. */
5622 queue_comp_unit (per_cu
);
5627 *has_children
= abbrev
->has_children
;
5631 /* Read an attribute value described by an attribute form. */
5634 read_attribute_value (struct attribute
*attr
, unsigned form
,
5635 bfd
*abfd
, gdb_byte
*info_ptr
,
5636 struct dwarf2_cu
*cu
)
5638 struct comp_unit_head
*cu_header
= &cu
->header
;
5639 unsigned int bytes_read
;
5640 struct dwarf_block
*blk
;
5646 case DW_FORM_ref_addr
:
5647 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5648 info_ptr
+= bytes_read
;
5650 case DW_FORM_block2
:
5651 blk
= dwarf_alloc_block (cu
);
5652 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5654 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5655 info_ptr
+= blk
->size
;
5656 DW_BLOCK (attr
) = blk
;
5658 case DW_FORM_block4
:
5659 blk
= dwarf_alloc_block (cu
);
5660 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5662 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5663 info_ptr
+= blk
->size
;
5664 DW_BLOCK (attr
) = blk
;
5667 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5671 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5675 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5678 case DW_FORM_string
:
5679 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5680 info_ptr
+= bytes_read
;
5683 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5685 info_ptr
+= bytes_read
;
5688 blk
= dwarf_alloc_block (cu
);
5689 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5690 info_ptr
+= bytes_read
;
5691 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5692 info_ptr
+= blk
->size
;
5693 DW_BLOCK (attr
) = blk
;
5695 case DW_FORM_block1
:
5696 blk
= dwarf_alloc_block (cu
);
5697 blk
->size
= read_1_byte (abfd
, info_ptr
);
5699 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5700 info_ptr
+= blk
->size
;
5701 DW_BLOCK (attr
) = blk
;
5704 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5708 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5712 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5713 info_ptr
+= bytes_read
;
5716 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5717 info_ptr
+= bytes_read
;
5720 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5724 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5728 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5732 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5735 case DW_FORM_ref_udata
:
5736 DW_ADDR (attr
) = (cu
->header
.offset
5737 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5738 info_ptr
+= bytes_read
;
5740 case DW_FORM_indirect
:
5741 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5742 info_ptr
+= bytes_read
;
5743 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5746 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5747 dwarf_form_name (form
),
5748 bfd_get_filename (abfd
));
5753 /* Read an attribute described by an abbreviated attribute. */
5756 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5757 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5759 attr
->name
= abbrev
->name
;
5760 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5763 /* read dwarf information from a buffer */
5766 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5768 return bfd_get_8 (abfd
, buf
);
5772 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5774 return bfd_get_signed_8 (abfd
, buf
);
5778 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5780 return bfd_get_16 (abfd
, buf
);
5784 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5786 return bfd_get_signed_16 (abfd
, buf
);
5790 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5792 return bfd_get_32 (abfd
, buf
);
5796 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5798 return bfd_get_signed_32 (abfd
, buf
);
5801 static unsigned long
5802 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
5804 return bfd_get_64 (abfd
, buf
);
5808 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
5809 unsigned int *bytes_read
)
5811 struct comp_unit_head
*cu_header
= &cu
->header
;
5812 CORE_ADDR retval
= 0;
5814 if (cu_header
->signed_addr_p
)
5816 switch (cu_header
->addr_size
)
5819 retval
= bfd_get_signed_16 (abfd
, buf
);
5822 retval
= bfd_get_signed_32 (abfd
, buf
);
5825 retval
= bfd_get_signed_64 (abfd
, buf
);
5828 internal_error (__FILE__
, __LINE__
,
5829 _("read_address: bad switch, signed [in module %s]"),
5830 bfd_get_filename (abfd
));
5835 switch (cu_header
->addr_size
)
5838 retval
= bfd_get_16 (abfd
, buf
);
5841 retval
= bfd_get_32 (abfd
, buf
);
5844 retval
= bfd_get_64 (abfd
, buf
);
5847 internal_error (__FILE__
, __LINE__
,
5848 _("read_address: bad switch, unsigned [in module %s]"),
5849 bfd_get_filename (abfd
));
5853 *bytes_read
= cu_header
->addr_size
;
5857 /* Read the initial length from a section. The (draft) DWARF 3
5858 specification allows the initial length to take up either 4 bytes
5859 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5860 bytes describe the length and all offsets will be 8 bytes in length
5863 An older, non-standard 64-bit format is also handled by this
5864 function. The older format in question stores the initial length
5865 as an 8-byte quantity without an escape value. Lengths greater
5866 than 2^32 aren't very common which means that the initial 4 bytes
5867 is almost always zero. Since a length value of zero doesn't make
5868 sense for the 32-bit format, this initial zero can be considered to
5869 be an escape value which indicates the presence of the older 64-bit
5870 format. As written, the code can't detect (old format) lengths
5871 greater than 4GB. If it becomes necessary to handle lengths
5872 somewhat larger than 4GB, we could allow other small values (such
5873 as the non-sensical values of 1, 2, and 3) to also be used as
5874 escape values indicating the presence of the old format.
5876 The value returned via bytes_read should be used to increment the
5877 relevant pointer after calling read_initial_length().
5879 As a side effect, this function sets the fields initial_length_size
5880 and offset_size in cu_header to the values appropriate for the
5881 length field. (The format of the initial length field determines
5882 the width of file offsets to be fetched later with read_offset().)
5884 [ Note: read_initial_length() and read_offset() are based on the
5885 document entitled "DWARF Debugging Information Format", revision
5886 3, draft 8, dated November 19, 2001. This document was obtained
5889 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5891 This document is only a draft and is subject to change. (So beware.)
5893 Details regarding the older, non-standard 64-bit format were
5894 determined empirically by examining 64-bit ELF files produced by
5895 the SGI toolchain on an IRIX 6.5 machine.
5897 - Kevin, July 16, 2002
5901 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
5902 unsigned int *bytes_read
)
5904 LONGEST length
= bfd_get_32 (abfd
, buf
);
5906 if (length
== 0xffffffff)
5908 length
= bfd_get_64 (abfd
, buf
+ 4);
5911 else if (length
== 0)
5913 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
5914 length
= bfd_get_64 (abfd
, buf
);
5924 gdb_assert (cu_header
->initial_length_size
== 0
5925 || cu_header
->initial_length_size
== 4
5926 || cu_header
->initial_length_size
== 8
5927 || cu_header
->initial_length_size
== 12);
5929 if (cu_header
->initial_length_size
!= 0
5930 && cu_header
->initial_length_size
!= *bytes_read
)
5931 complaint (&symfile_complaints
,
5932 _("intermixed 32-bit and 64-bit DWARF sections"));
5934 cu_header
->initial_length_size
= *bytes_read
;
5935 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
5941 /* Read an offset from the data stream. The size of the offset is
5942 given by cu_header->offset_size. */
5945 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
5946 unsigned int *bytes_read
)
5950 switch (cu_header
->offset_size
)
5953 retval
= bfd_get_32 (abfd
, buf
);
5957 retval
= bfd_get_64 (abfd
, buf
);
5961 internal_error (__FILE__
, __LINE__
,
5962 _("read_offset: bad switch [in module %s]"),
5963 bfd_get_filename (abfd
));
5970 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
5972 /* If the size of a host char is 8 bits, we can return a pointer
5973 to the buffer, otherwise we have to copy the data to a buffer
5974 allocated on the temporary obstack. */
5975 gdb_assert (HOST_CHAR_BIT
== 8);
5980 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
5982 /* If the size of a host char is 8 bits, we can return a pointer
5983 to the string, otherwise we have to copy the string to a buffer
5984 allocated on the temporary obstack. */
5985 gdb_assert (HOST_CHAR_BIT
== 8);
5988 *bytes_read_ptr
= 1;
5991 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
5992 return (char *) buf
;
5996 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
5997 const struct comp_unit_head
*cu_header
,
5998 unsigned int *bytes_read_ptr
)
6000 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6003 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6005 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6006 bfd_get_filename (abfd
));
6009 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6011 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6012 bfd_get_filename (abfd
));
6015 gdb_assert (HOST_CHAR_BIT
== 8);
6016 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6018 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6021 static unsigned long
6022 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6024 unsigned long result
;
6025 unsigned int num_read
;
6035 byte
= bfd_get_8 (abfd
, buf
);
6038 result
|= ((unsigned long)(byte
& 127) << shift
);
6039 if ((byte
& 128) == 0)
6045 *bytes_read_ptr
= num_read
;
6050 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6053 int i
, shift
, num_read
;
6062 byte
= bfd_get_8 (abfd
, buf
);
6065 result
|= ((long)(byte
& 127) << shift
);
6067 if ((byte
& 128) == 0)
6072 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6073 result
|= -(((long)1) << shift
);
6074 *bytes_read_ptr
= num_read
;
6078 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6081 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6087 byte
= bfd_get_8 (abfd
, buf
);
6089 if ((byte
& 128) == 0)
6095 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6101 cu
->language
= language_c
;
6103 case DW_LANG_C_plus_plus
:
6104 cu
->language
= language_cplus
;
6106 case DW_LANG_Fortran77
:
6107 case DW_LANG_Fortran90
:
6108 case DW_LANG_Fortran95
:
6109 cu
->language
= language_fortran
;
6111 case DW_LANG_Mips_Assembler
:
6112 cu
->language
= language_asm
;
6115 cu
->language
= language_java
;
6119 cu
->language
= language_ada
;
6121 case DW_LANG_Cobol74
:
6122 case DW_LANG_Cobol85
:
6123 case DW_LANG_Pascal83
:
6124 case DW_LANG_Modula2
:
6126 cu
->language
= language_minimal
;
6129 cu
->language_defn
= language_def (cu
->language
);
6132 /* Return the named attribute or NULL if not there. */
6134 static struct attribute
*
6135 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6138 struct attribute
*spec
= NULL
;
6140 for (i
= 0; i
< die
->num_attrs
; ++i
)
6142 if (die
->attrs
[i
].name
== name
)
6143 return &die
->attrs
[i
];
6144 if (die
->attrs
[i
].name
== DW_AT_specification
6145 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6146 spec
= &die
->attrs
[i
];
6150 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6155 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6156 and holds a non-zero value. This function should only be used for
6157 DW_FORM_flag attributes. */
6160 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6162 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6164 return (attr
&& DW_UNSND (attr
));
6168 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6170 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6171 which value is non-zero. However, we have to be careful with
6172 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6173 (via dwarf2_flag_true_p) follows this attribute. So we may
6174 end up accidently finding a declaration attribute that belongs
6175 to a different DIE referenced by the specification attribute,
6176 even though the given DIE does not have a declaration attribute. */
6177 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6178 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6181 /* Return the die giving the specification for DIE, if there is
6184 static struct die_info
*
6185 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6187 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6189 if (spec_attr
== NULL
)
6192 return follow_die_ref (die
, spec_attr
, cu
);
6195 /* Free the line_header structure *LH, and any arrays and strings it
6198 free_line_header (struct line_header
*lh
)
6200 if (lh
->standard_opcode_lengths
)
6201 xfree (lh
->standard_opcode_lengths
);
6203 /* Remember that all the lh->file_names[i].name pointers are
6204 pointers into debug_line_buffer, and don't need to be freed. */
6206 xfree (lh
->file_names
);
6208 /* Similarly for the include directory names. */
6209 if (lh
->include_dirs
)
6210 xfree (lh
->include_dirs
);
6216 /* Add an entry to LH's include directory table. */
6218 add_include_dir (struct line_header
*lh
, char *include_dir
)
6220 /* Grow the array if necessary. */
6221 if (lh
->include_dirs_size
== 0)
6223 lh
->include_dirs_size
= 1; /* for testing */
6224 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6225 * sizeof (*lh
->include_dirs
));
6227 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6229 lh
->include_dirs_size
*= 2;
6230 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6231 (lh
->include_dirs_size
6232 * sizeof (*lh
->include_dirs
)));
6235 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6239 /* Add an entry to LH's file name table. */
6241 add_file_name (struct line_header
*lh
,
6243 unsigned int dir_index
,
6244 unsigned int mod_time
,
6245 unsigned int length
)
6247 struct file_entry
*fe
;
6249 /* Grow the array if necessary. */
6250 if (lh
->file_names_size
== 0)
6252 lh
->file_names_size
= 1; /* for testing */
6253 lh
->file_names
= xmalloc (lh
->file_names_size
6254 * sizeof (*lh
->file_names
));
6256 else if (lh
->num_file_names
>= lh
->file_names_size
)
6258 lh
->file_names_size
*= 2;
6259 lh
->file_names
= xrealloc (lh
->file_names
,
6260 (lh
->file_names_size
6261 * sizeof (*lh
->file_names
)));
6264 fe
= &lh
->file_names
[lh
->num_file_names
++];
6266 fe
->dir_index
= dir_index
;
6267 fe
->mod_time
= mod_time
;
6268 fe
->length
= length
;
6273 /* Read the statement program header starting at OFFSET in
6274 .debug_line, according to the endianness of ABFD. Return a pointer
6275 to a struct line_header, allocated using xmalloc.
6277 NOTE: the strings in the include directory and file name tables of
6278 the returned object point into debug_line_buffer, and must not be
6280 static struct line_header
*
6281 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6282 struct dwarf2_cu
*cu
)
6284 struct cleanup
*back_to
;
6285 struct line_header
*lh
;
6287 unsigned int bytes_read
;
6289 char *cur_dir
, *cur_file
;
6291 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6293 complaint (&symfile_complaints
, _("missing .debug_line section"));
6297 /* Make sure that at least there's room for the total_length field.
6298 That could be 12 bytes long, but we're just going to fudge that. */
6299 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6301 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6305 lh
= xmalloc (sizeof (*lh
));
6306 memset (lh
, 0, sizeof (*lh
));
6307 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6310 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6312 /* Read in the header. */
6314 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6315 line_ptr
+= bytes_read
;
6316 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6317 + dwarf2_per_objfile
->line_size
))
6319 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6322 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6323 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6325 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6326 line_ptr
+= bytes_read
;
6327 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6329 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6331 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6333 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6335 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6337 lh
->standard_opcode_lengths
6338 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6340 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6341 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6343 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6347 /* Read directory table. */
6348 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6350 line_ptr
+= bytes_read
;
6351 add_include_dir (lh
, cur_dir
);
6353 line_ptr
+= bytes_read
;
6355 /* Read file name table. */
6356 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6358 unsigned int dir_index
, mod_time
, length
;
6360 line_ptr
+= bytes_read
;
6361 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6362 line_ptr
+= bytes_read
;
6363 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6364 line_ptr
+= bytes_read
;
6365 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6366 line_ptr
+= bytes_read
;
6368 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6370 line_ptr
+= bytes_read
;
6371 lh
->statement_program_start
= line_ptr
;
6373 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6374 + dwarf2_per_objfile
->line_size
))
6375 complaint (&symfile_complaints
,
6376 _("line number info header doesn't fit in `.debug_line' section"));
6378 discard_cleanups (back_to
);
6382 /* This function exists to work around a bug in certain compilers
6383 (particularly GCC 2.95), in which the first line number marker of a
6384 function does not show up until after the prologue, right before
6385 the second line number marker. This function shifts ADDRESS down
6386 to the beginning of the function if necessary, and is called on
6387 addresses passed to record_line. */
6390 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6392 struct function_range
*fn
;
6394 /* Find the function_range containing address. */
6399 cu
->cached_fn
= cu
->first_fn
;
6403 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6409 while (fn
&& fn
!= cu
->cached_fn
)
6410 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6420 if (address
!= fn
->lowpc
)
6421 complaint (&symfile_complaints
,
6422 _("misplaced first line number at 0x%lx for '%s'"),
6423 (unsigned long) address
, fn
->name
);
6428 /* Decode the Line Number Program (LNP) for the given line_header
6429 structure and CU. The actual information extracted and the type
6430 of structures created from the LNP depends on the value of PST.
6432 1. If PST is NULL, then this procedure uses the data from the program
6433 to create all necessary symbol tables, and their linetables.
6434 The compilation directory of the file is passed in COMP_DIR,
6435 and must not be NULL.
6437 2. If PST is not NULL, this procedure reads the program to determine
6438 the list of files included by the unit represented by PST, and
6439 builds all the associated partial symbol tables. In this case,
6440 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6441 is not used to compute the full name of the symtab, and therefore
6442 omitting it when building the partial symtab does not introduce
6443 the potential for inconsistency - a partial symtab and its associated
6444 symbtab having a different fullname -). */
6447 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6448 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6452 unsigned int bytes_read
;
6453 unsigned char op_code
, extended_op
, adj_opcode
;
6455 struct objfile
*objfile
= cu
->objfile
;
6456 const int decode_for_pst_p
= (pst
!= NULL
);
6458 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6460 line_ptr
= lh
->statement_program_start
;
6461 line_end
= lh
->statement_program_end
;
6463 /* Read the statement sequences until there's nothing left. */
6464 while (line_ptr
< line_end
)
6466 /* state machine registers */
6467 CORE_ADDR address
= 0;
6468 unsigned int file
= 1;
6469 unsigned int line
= 1;
6470 unsigned int column
= 0;
6471 int is_stmt
= lh
->default_is_stmt
;
6472 int basic_block
= 0;
6473 int end_sequence
= 0;
6475 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6477 /* Start a subfile for the current file of the state machine. */
6478 /* lh->include_dirs and lh->file_names are 0-based, but the
6479 directory and file name numbers in the statement program
6481 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6485 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6488 dwarf2_start_subfile (fe
->name
, dir
);
6491 /* Decode the table. */
6492 while (!end_sequence
)
6494 op_code
= read_1_byte (abfd
, line_ptr
);
6497 if (op_code
>= lh
->opcode_base
)
6499 /* Special operand. */
6500 adj_opcode
= op_code
- lh
->opcode_base
;
6501 address
+= (adj_opcode
/ lh
->line_range
)
6502 * lh
->minimum_instruction_length
;
6503 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6504 lh
->file_names
[file
- 1].included_p
= 1;
6505 if (!decode_for_pst_p
)
6507 /* Append row to matrix using current values. */
6508 record_line (current_subfile
, line
,
6509 check_cu_functions (address
, cu
));
6513 else switch (op_code
)
6515 case DW_LNS_extended_op
:
6516 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6517 line_ptr
+= bytes_read
;
6518 extended_op
= read_1_byte (abfd
, line_ptr
);
6520 switch (extended_op
)
6522 case DW_LNE_end_sequence
:
6524 lh
->file_names
[file
- 1].included_p
= 1;
6525 if (!decode_for_pst_p
)
6526 record_line (current_subfile
, 0, address
);
6528 case DW_LNE_set_address
:
6529 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6530 line_ptr
+= bytes_read
;
6531 address
+= baseaddr
;
6533 case DW_LNE_define_file
:
6536 unsigned int dir_index
, mod_time
, length
;
6538 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6539 line_ptr
+= bytes_read
;
6541 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6542 line_ptr
+= bytes_read
;
6544 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6545 line_ptr
+= bytes_read
;
6547 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6548 line_ptr
+= bytes_read
;
6549 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6553 complaint (&symfile_complaints
,
6554 _("mangled .debug_line section"));
6559 lh
->file_names
[file
- 1].included_p
= 1;
6560 if (!decode_for_pst_p
)
6561 record_line (current_subfile
, line
,
6562 check_cu_functions (address
, cu
));
6565 case DW_LNS_advance_pc
:
6566 address
+= lh
->minimum_instruction_length
6567 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6568 line_ptr
+= bytes_read
;
6570 case DW_LNS_advance_line
:
6571 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6572 line_ptr
+= bytes_read
;
6574 case DW_LNS_set_file
:
6576 /* The arrays lh->include_dirs and lh->file_names are
6577 0-based, but the directory and file name numbers in
6578 the statement program are 1-based. */
6579 struct file_entry
*fe
;
6582 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6583 line_ptr
+= bytes_read
;
6584 fe
= &lh
->file_names
[file
- 1];
6586 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6589 if (!decode_for_pst_p
)
6590 dwarf2_start_subfile (fe
->name
, dir
);
6593 case DW_LNS_set_column
:
6594 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6595 line_ptr
+= bytes_read
;
6597 case DW_LNS_negate_stmt
:
6598 is_stmt
= (!is_stmt
);
6600 case DW_LNS_set_basic_block
:
6603 /* Add to the address register of the state machine the
6604 address increment value corresponding to special opcode
6605 255. I.e., this value is scaled by the minimum
6606 instruction length since special opcode 255 would have
6607 scaled the the increment. */
6608 case DW_LNS_const_add_pc
:
6609 address
+= (lh
->minimum_instruction_length
6610 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6612 case DW_LNS_fixed_advance_pc
:
6613 address
+= read_2_bytes (abfd
, line_ptr
);
6618 /* Unknown standard opcode, ignore it. */
6621 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6623 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6624 line_ptr
+= bytes_read
;
6631 if (decode_for_pst_p
)
6635 /* Now that we're done scanning the Line Header Program, we can
6636 create the psymtab of each included file. */
6637 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6638 if (lh
->file_names
[file_index
].included_p
== 1)
6640 const struct file_entry fe
= lh
->file_names
[file_index
];
6641 char *include_name
= fe
.name
;
6642 char *dir_name
= NULL
;
6643 char *pst_filename
= pst
->filename
;
6646 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6648 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6650 include_name
= concat (dir_name
, SLASH_STRING
,
6651 include_name
, (char *)NULL
);
6652 make_cleanup (xfree
, include_name
);
6655 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6657 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6658 pst_filename
, (char *)NULL
);
6659 make_cleanup (xfree
, pst_filename
);
6662 if (strcmp (include_name
, pst_filename
) != 0)
6663 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6668 /* Start a subfile for DWARF. FILENAME is the name of the file and
6669 DIRNAME the name of the source directory which contains FILENAME
6670 or NULL if not known.
6671 This routine tries to keep line numbers from identical absolute and
6672 relative file names in a common subfile.
6674 Using the `list' example from the GDB testsuite, which resides in
6675 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6676 of /srcdir/list0.c yields the following debugging information for list0.c:
6678 DW_AT_name: /srcdir/list0.c
6679 DW_AT_comp_dir: /compdir
6680 files.files[0].name: list0.h
6681 files.files[0].dir: /srcdir
6682 files.files[1].name: list0.c
6683 files.files[1].dir: /srcdir
6685 The line number information for list0.c has to end up in a single
6686 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6689 dwarf2_start_subfile (char *filename
, char *dirname
)
6691 /* If the filename isn't absolute, try to match an existing subfile
6692 with the full pathname. */
6694 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6696 struct subfile
*subfile
;
6697 char *fullname
= concat (dirname
, "/", filename
, (char *)NULL
);
6699 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
6701 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
6703 current_subfile
= subfile
;
6710 start_subfile (filename
, dirname
);
6714 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6715 struct dwarf2_cu
*cu
)
6717 struct objfile
*objfile
= cu
->objfile
;
6718 struct comp_unit_head
*cu_header
= &cu
->header
;
6720 /* NOTE drow/2003-01-30: There used to be a comment and some special
6721 code here to turn a symbol with DW_AT_external and a
6722 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6723 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6724 with some versions of binutils) where shared libraries could have
6725 relocations against symbols in their debug information - the
6726 minimal symbol would have the right address, but the debug info
6727 would not. It's no longer necessary, because we will explicitly
6728 apply relocations when we read in the debug information now. */
6730 /* A DW_AT_location attribute with no contents indicates that a
6731 variable has been optimized away. */
6732 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6734 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6738 /* Handle one degenerate form of location expression specially, to
6739 preserve GDB's previous behavior when section offsets are
6740 specified. If this is just a DW_OP_addr then mark this symbol
6743 if (attr_form_is_block (attr
)
6744 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6745 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6749 SYMBOL_VALUE_ADDRESS (sym
) =
6750 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6751 fixup_symbol_section (sym
, objfile
);
6752 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6753 SYMBOL_SECTION (sym
));
6754 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6758 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6759 expression evaluator, and use LOC_COMPUTED only when necessary
6760 (i.e. when the value of a register or memory location is
6761 referenced, or a thread-local block, etc.). Then again, it might
6762 not be worthwhile. I'm assuming that it isn't unless performance
6763 or memory numbers show me otherwise. */
6765 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6766 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6769 /* Given a pointer to a DWARF information entry, figure out if we need
6770 to make a symbol table entry for it, and if so, create a new entry
6771 and return a pointer to it.
6772 If TYPE is NULL, determine symbol type from the die, otherwise
6773 used the passed type. */
6775 static struct symbol
*
6776 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6778 struct objfile
*objfile
= cu
->objfile
;
6779 struct symbol
*sym
= NULL
;
6781 struct attribute
*attr
= NULL
;
6782 struct attribute
*attr2
= NULL
;
6785 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6787 if (die
->tag
!= DW_TAG_namespace
)
6788 name
= dwarf2_linkage_name (die
, cu
);
6790 name
= TYPE_NAME (type
);
6794 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6795 sizeof (struct symbol
));
6796 OBJSTAT (objfile
, n_syms
++);
6797 memset (sym
, 0, sizeof (struct symbol
));
6799 /* Cache this symbol's name and the name's demangled form (if any). */
6800 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6801 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6803 /* Default assumptions.
6804 Use the passed type or decode it from the die. */
6805 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6806 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6808 SYMBOL_TYPE (sym
) = type
;
6810 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6811 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6814 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6819 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6822 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6824 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6826 case DW_TAG_subprogram
:
6827 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6829 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6830 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6831 if (attr2
&& (DW_UNSND (attr2
) != 0))
6833 add_symbol_to_list (sym
, &global_symbols
);
6837 add_symbol_to_list (sym
, cu
->list_in_scope
);
6840 case DW_TAG_variable
:
6841 /* Compilation with minimal debug info may result in variables
6842 with missing type entries. Change the misleading `void' type
6843 to something sensible. */
6844 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6845 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6846 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6847 "<variable, no debug info>",
6849 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6852 dwarf2_const_value (attr
, sym
, cu
);
6853 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6854 if (attr2
&& (DW_UNSND (attr2
) != 0))
6855 add_symbol_to_list (sym
, &global_symbols
);
6857 add_symbol_to_list (sym
, cu
->list_in_scope
);
6860 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6863 var_decode_location (attr
, sym
, cu
);
6864 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6865 if (attr2
&& (DW_UNSND (attr2
) != 0))
6866 add_symbol_to_list (sym
, &global_symbols
);
6868 add_symbol_to_list (sym
, cu
->list_in_scope
);
6872 /* We do not know the address of this symbol.
6873 If it is an external symbol and we have type information
6874 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6875 The address of the variable will then be determined from
6876 the minimal symbol table whenever the variable is
6878 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6879 if (attr2
&& (DW_UNSND (attr2
) != 0)
6880 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6882 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6883 add_symbol_to_list (sym
, &global_symbols
);
6887 case DW_TAG_formal_parameter
:
6888 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6891 var_decode_location (attr
, sym
, cu
);
6892 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6893 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6894 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6896 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6899 dwarf2_const_value (attr
, sym
, cu
);
6901 add_symbol_to_list (sym
, cu
->list_in_scope
);
6903 case DW_TAG_unspecified_parameters
:
6904 /* From varargs functions; gdb doesn't seem to have any
6905 interest in this information, so just ignore it for now.
6908 case DW_TAG_class_type
:
6909 case DW_TAG_structure_type
:
6910 case DW_TAG_union_type
:
6911 case DW_TAG_enumeration_type
:
6912 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6913 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6915 /* Make sure that the symbol includes appropriate enclosing
6916 classes/namespaces in its name. These are calculated in
6917 read_structure_type, and the correct name is saved in
6920 if (cu
->language
== language_cplus
6921 || cu
->language
== language_java
)
6923 struct type
*type
= SYMBOL_TYPE (sym
);
6925 if (TYPE_TAG_NAME (type
) != NULL
)
6927 /* FIXME: carlton/2003-11-10: Should this use
6928 SYMBOL_SET_NAMES instead? (The same problem also
6929 arises further down in this function.) */
6930 /* The type's name is already allocated along with
6931 this objfile, so we don't need to duplicate it
6933 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
6938 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6939 really ever be static objects: otherwise, if you try
6940 to, say, break of a class's method and you're in a file
6941 which doesn't mention that class, it won't work unless
6942 the check for all static symbols in lookup_symbol_aux
6943 saves you. See the OtherFileClass tests in
6944 gdb.c++/namespace.exp. */
6946 struct pending
**list_to_add
;
6948 list_to_add
= (cu
->list_in_scope
== &file_symbols
6949 && (cu
->language
== language_cplus
6950 || cu
->language
== language_java
)
6951 ? &global_symbols
: cu
->list_in_scope
);
6953 add_symbol_to_list (sym
, list_to_add
);
6955 /* The semantics of C++ state that "struct foo { ... }" also
6956 defines a typedef for "foo". A Java class declaration also
6957 defines a typedef for the class. Synthesize a typedef symbol
6958 so that "ptype foo" works as expected. */
6959 if (cu
->language
== language_cplus
6960 || cu
->language
== language_java
)
6962 struct symbol
*typedef_sym
= (struct symbol
*)
6963 obstack_alloc (&objfile
->objfile_obstack
,
6964 sizeof (struct symbol
));
6965 *typedef_sym
= *sym
;
6966 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
6967 /* The symbol's name is already allocated along with
6968 this objfile, so we don't need to duplicate it for
6970 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
6971 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
6972 add_symbol_to_list (typedef_sym
, list_to_add
);
6976 case DW_TAG_typedef
:
6977 if (processing_has_namespace_info
6978 && processing_current_prefix
[0] != '\0')
6980 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6981 processing_current_prefix
,
6984 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6985 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6986 add_symbol_to_list (sym
, cu
->list_in_scope
);
6988 case DW_TAG_base_type
:
6989 case DW_TAG_subrange_type
:
6990 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6991 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6992 add_symbol_to_list (sym
, cu
->list_in_scope
);
6994 case DW_TAG_enumerator
:
6995 if (processing_has_namespace_info
6996 && processing_current_prefix
[0] != '\0')
6998 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6999 processing_current_prefix
,
7002 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7005 dwarf2_const_value (attr
, sym
, cu
);
7008 /* NOTE: carlton/2003-11-10: See comment above in the
7009 DW_TAG_class_type, etc. block. */
7011 struct pending
**list_to_add
;
7013 list_to_add
= (cu
->list_in_scope
== &file_symbols
7014 && (cu
->language
== language_cplus
7015 || cu
->language
== language_java
)
7016 ? &global_symbols
: cu
->list_in_scope
);
7018 add_symbol_to_list (sym
, list_to_add
);
7021 case DW_TAG_namespace
:
7022 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7023 add_symbol_to_list (sym
, &global_symbols
);
7026 /* Not a tag we recognize. Hopefully we aren't processing
7027 trash data, but since we must specifically ignore things
7028 we don't recognize, there is nothing else we should do at
7030 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7031 dwarf_tag_name (die
->tag
));
7038 /* Copy constant value from an attribute to a symbol. */
7041 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7042 struct dwarf2_cu
*cu
)
7044 struct objfile
*objfile
= cu
->objfile
;
7045 struct comp_unit_head
*cu_header
= &cu
->header
;
7046 struct dwarf_block
*blk
;
7051 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7052 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7053 cu_header
->addr_size
,
7054 TYPE_LENGTH (SYMBOL_TYPE
7056 SYMBOL_VALUE_BYTES (sym
) =
7057 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7058 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7059 it's body - store_unsigned_integer. */
7060 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7062 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7064 case DW_FORM_block1
:
7065 case DW_FORM_block2
:
7066 case DW_FORM_block4
:
7068 blk
= DW_BLOCK (attr
);
7069 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7070 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7072 TYPE_LENGTH (SYMBOL_TYPE
7074 SYMBOL_VALUE_BYTES (sym
) =
7075 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7076 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7077 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7080 /* The DW_AT_const_value attributes are supposed to carry the
7081 symbol's value "represented as it would be on the target
7082 architecture." By the time we get here, it's already been
7083 converted to host endianness, so we just need to sign- or
7084 zero-extend it as appropriate. */
7086 dwarf2_const_value_data (attr
, sym
, 8);
7089 dwarf2_const_value_data (attr
, sym
, 16);
7092 dwarf2_const_value_data (attr
, sym
, 32);
7095 dwarf2_const_value_data (attr
, sym
, 64);
7099 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7100 SYMBOL_CLASS (sym
) = LOC_CONST
;
7104 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7105 SYMBOL_CLASS (sym
) = LOC_CONST
;
7109 complaint (&symfile_complaints
,
7110 _("unsupported const value attribute form: '%s'"),
7111 dwarf_form_name (attr
->form
));
7112 SYMBOL_VALUE (sym
) = 0;
7113 SYMBOL_CLASS (sym
) = LOC_CONST
;
7119 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7120 or zero-extend it as appropriate for the symbol's type. */
7122 dwarf2_const_value_data (struct attribute
*attr
,
7126 LONGEST l
= DW_UNSND (attr
);
7128 if (bits
< sizeof (l
) * 8)
7130 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7131 l
&= ((LONGEST
) 1 << bits
) - 1;
7133 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7136 SYMBOL_VALUE (sym
) = l
;
7137 SYMBOL_CLASS (sym
) = LOC_CONST
;
7141 /* Return the type of the die in question using its DW_AT_type attribute. */
7143 static struct type
*
7144 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7147 struct attribute
*type_attr
;
7148 struct die_info
*type_die
;
7150 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7153 /* A missing DW_AT_type represents a void type. */
7154 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7157 type_die
= follow_die_ref (die
, type_attr
, cu
);
7159 type
= tag_type_to_type (type_die
, cu
);
7162 dump_die (type_die
);
7163 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7169 /* Return the containing type of the die in question using its
7170 DW_AT_containing_type attribute. */
7172 static struct type
*
7173 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7175 struct type
*type
= NULL
;
7176 struct attribute
*type_attr
;
7177 struct die_info
*type_die
= NULL
;
7179 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7182 type_die
= follow_die_ref (die
, type_attr
, cu
);
7183 type
= tag_type_to_type (type_die
, cu
);
7188 dump_die (type_die
);
7189 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7195 static struct type
*
7196 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7204 read_type_die (die
, cu
);
7208 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7216 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7218 char *prefix
= determine_prefix (die
, cu
);
7219 const char *old_prefix
= processing_current_prefix
;
7220 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7221 processing_current_prefix
= prefix
;
7225 case DW_TAG_class_type
:
7226 case DW_TAG_structure_type
:
7227 case DW_TAG_union_type
:
7228 read_structure_type (die
, cu
);
7230 case DW_TAG_enumeration_type
:
7231 read_enumeration_type (die
, cu
);
7233 case DW_TAG_subprogram
:
7234 case DW_TAG_subroutine_type
:
7235 read_subroutine_type (die
, cu
);
7237 case DW_TAG_array_type
:
7238 read_array_type (die
, cu
);
7240 case DW_TAG_pointer_type
:
7241 read_tag_pointer_type (die
, cu
);
7243 case DW_TAG_ptr_to_member_type
:
7244 read_tag_ptr_to_member_type (die
, cu
);
7246 case DW_TAG_reference_type
:
7247 read_tag_reference_type (die
, cu
);
7249 case DW_TAG_const_type
:
7250 read_tag_const_type (die
, cu
);
7252 case DW_TAG_volatile_type
:
7253 read_tag_volatile_type (die
, cu
);
7255 case DW_TAG_string_type
:
7256 read_tag_string_type (die
, cu
);
7258 case DW_TAG_typedef
:
7259 read_typedef (die
, cu
);
7261 case DW_TAG_subrange_type
:
7262 read_subrange_type (die
, cu
);
7264 case DW_TAG_base_type
:
7265 read_base_type (die
, cu
);
7268 complaint (&symfile_complaints
, _("unexepected tag in read_type_die: '%s'"),
7269 dwarf_tag_name (die
->tag
));
7273 processing_current_prefix
= old_prefix
;
7274 do_cleanups (back_to
);
7277 /* Return the name of the namespace/class that DIE is defined within,
7278 or "" if we can't tell. The caller should xfree the result. */
7280 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7281 therein) for an example of how to use this function to deal with
7282 DW_AT_specification. */
7285 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7287 struct die_info
*parent
;
7289 if (cu
->language
!= language_cplus
7290 && cu
->language
!= language_java
)
7293 parent
= die
->parent
;
7297 return xstrdup ("");
7301 switch (parent
->tag
) {
7302 case DW_TAG_namespace
:
7304 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7305 before doing this check? */
7306 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7308 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7313 char *parent_prefix
= determine_prefix (parent
, cu
);
7314 char *retval
= typename_concat (NULL
, parent_prefix
,
7315 namespace_name (parent
, &dummy
,
7318 xfree (parent_prefix
);
7323 case DW_TAG_class_type
:
7324 case DW_TAG_structure_type
:
7326 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7328 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7332 const char *old_prefix
= processing_current_prefix
;
7333 char *new_prefix
= determine_prefix (parent
, cu
);
7336 processing_current_prefix
= new_prefix
;
7337 retval
= determine_class_name (parent
, cu
);
7338 processing_current_prefix
= old_prefix
;
7345 return determine_prefix (parent
, cu
);
7350 /* Return a newly-allocated string formed by concatenating PREFIX and
7351 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7352 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7353 perform an obconcat, otherwise allocate storage for the result. The CU argument
7354 is used to determine the language and hence, the appropriate separator. */
7356 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7359 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7360 struct dwarf2_cu
*cu
)
7364 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7366 else if (cu
->language
== language_java
)
7373 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7378 strcpy (retval
, prefix
);
7379 strcat (retval
, sep
);
7382 strcat (retval
, suffix
);
7388 /* We have an obstack. */
7389 return obconcat (obs
, prefix
, sep
, suffix
);
7393 static struct type
*
7394 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7396 struct objfile
*objfile
= cu
->objfile
;
7398 /* FIXME - this should not produce a new (struct type *)
7399 every time. It should cache base types. */
7403 case DW_ATE_address
:
7404 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7406 case DW_ATE_boolean
:
7407 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7409 case DW_ATE_complex_float
:
7412 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7416 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7422 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7426 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7433 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7436 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7440 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7444 case DW_ATE_signed_char
:
7445 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7447 case DW_ATE_unsigned
:
7451 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7454 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7458 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7462 case DW_ATE_unsigned_char
:
7463 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7466 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7473 copy_die (struct die_info
*old_die
)
7475 struct die_info
*new_die
;
7478 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7479 memset (new_die
, 0, sizeof (struct die_info
));
7481 new_die
->tag
= old_die
->tag
;
7482 new_die
->has_children
= old_die
->has_children
;
7483 new_die
->abbrev
= old_die
->abbrev
;
7484 new_die
->offset
= old_die
->offset
;
7485 new_die
->type
= NULL
;
7487 num_attrs
= old_die
->num_attrs
;
7488 new_die
->num_attrs
= num_attrs
;
7489 new_die
->attrs
= (struct attribute
*)
7490 xmalloc (num_attrs
* sizeof (struct attribute
));
7492 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7494 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7495 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7496 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7499 new_die
->next
= NULL
;
7504 /* Return sibling of die, NULL if no sibling. */
7506 static struct die_info
*
7507 sibling_die (struct die_info
*die
)
7509 return die
->sibling
;
7512 /* Get linkage name of a die, return NULL if not found. */
7515 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7517 struct attribute
*attr
;
7519 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7520 if (attr
&& DW_STRING (attr
))
7521 return DW_STRING (attr
);
7522 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7523 if (attr
&& DW_STRING (attr
))
7524 return DW_STRING (attr
);
7528 /* Get name of a die, return NULL if not found. */
7531 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7533 struct attribute
*attr
;
7535 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7536 if (attr
&& DW_STRING (attr
))
7537 return DW_STRING (attr
);
7541 /* Return the die that this die in an extension of, or NULL if there
7544 static struct die_info
*
7545 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7547 struct attribute
*attr
;
7549 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7553 return follow_die_ref (die
, attr
, cu
);
7556 /* Convert a DIE tag into its string name. */
7559 dwarf_tag_name (unsigned tag
)
7563 case DW_TAG_padding
:
7564 return "DW_TAG_padding";
7565 case DW_TAG_array_type
:
7566 return "DW_TAG_array_type";
7567 case DW_TAG_class_type
:
7568 return "DW_TAG_class_type";
7569 case DW_TAG_entry_point
:
7570 return "DW_TAG_entry_point";
7571 case DW_TAG_enumeration_type
:
7572 return "DW_TAG_enumeration_type";
7573 case DW_TAG_formal_parameter
:
7574 return "DW_TAG_formal_parameter";
7575 case DW_TAG_imported_declaration
:
7576 return "DW_TAG_imported_declaration";
7578 return "DW_TAG_label";
7579 case DW_TAG_lexical_block
:
7580 return "DW_TAG_lexical_block";
7582 return "DW_TAG_member";
7583 case DW_TAG_pointer_type
:
7584 return "DW_TAG_pointer_type";
7585 case DW_TAG_reference_type
:
7586 return "DW_TAG_reference_type";
7587 case DW_TAG_compile_unit
:
7588 return "DW_TAG_compile_unit";
7589 case DW_TAG_string_type
:
7590 return "DW_TAG_string_type";
7591 case DW_TAG_structure_type
:
7592 return "DW_TAG_structure_type";
7593 case DW_TAG_subroutine_type
:
7594 return "DW_TAG_subroutine_type";
7595 case DW_TAG_typedef
:
7596 return "DW_TAG_typedef";
7597 case DW_TAG_union_type
:
7598 return "DW_TAG_union_type";
7599 case DW_TAG_unspecified_parameters
:
7600 return "DW_TAG_unspecified_parameters";
7601 case DW_TAG_variant
:
7602 return "DW_TAG_variant";
7603 case DW_TAG_common_block
:
7604 return "DW_TAG_common_block";
7605 case DW_TAG_common_inclusion
:
7606 return "DW_TAG_common_inclusion";
7607 case DW_TAG_inheritance
:
7608 return "DW_TAG_inheritance";
7609 case DW_TAG_inlined_subroutine
:
7610 return "DW_TAG_inlined_subroutine";
7612 return "DW_TAG_module";
7613 case DW_TAG_ptr_to_member_type
:
7614 return "DW_TAG_ptr_to_member_type";
7615 case DW_TAG_set_type
:
7616 return "DW_TAG_set_type";
7617 case DW_TAG_subrange_type
:
7618 return "DW_TAG_subrange_type";
7619 case DW_TAG_with_stmt
:
7620 return "DW_TAG_with_stmt";
7621 case DW_TAG_access_declaration
:
7622 return "DW_TAG_access_declaration";
7623 case DW_TAG_base_type
:
7624 return "DW_TAG_base_type";
7625 case DW_TAG_catch_block
:
7626 return "DW_TAG_catch_block";
7627 case DW_TAG_const_type
:
7628 return "DW_TAG_const_type";
7629 case DW_TAG_constant
:
7630 return "DW_TAG_constant";
7631 case DW_TAG_enumerator
:
7632 return "DW_TAG_enumerator";
7633 case DW_TAG_file_type
:
7634 return "DW_TAG_file_type";
7636 return "DW_TAG_friend";
7637 case DW_TAG_namelist
:
7638 return "DW_TAG_namelist";
7639 case DW_TAG_namelist_item
:
7640 return "DW_TAG_namelist_item";
7641 case DW_TAG_packed_type
:
7642 return "DW_TAG_packed_type";
7643 case DW_TAG_subprogram
:
7644 return "DW_TAG_subprogram";
7645 case DW_TAG_template_type_param
:
7646 return "DW_TAG_template_type_param";
7647 case DW_TAG_template_value_param
:
7648 return "DW_TAG_template_value_param";
7649 case DW_TAG_thrown_type
:
7650 return "DW_TAG_thrown_type";
7651 case DW_TAG_try_block
:
7652 return "DW_TAG_try_block";
7653 case DW_TAG_variant_part
:
7654 return "DW_TAG_variant_part";
7655 case DW_TAG_variable
:
7656 return "DW_TAG_variable";
7657 case DW_TAG_volatile_type
:
7658 return "DW_TAG_volatile_type";
7659 case DW_TAG_dwarf_procedure
:
7660 return "DW_TAG_dwarf_procedure";
7661 case DW_TAG_restrict_type
:
7662 return "DW_TAG_restrict_type";
7663 case DW_TAG_interface_type
:
7664 return "DW_TAG_interface_type";
7665 case DW_TAG_namespace
:
7666 return "DW_TAG_namespace";
7667 case DW_TAG_imported_module
:
7668 return "DW_TAG_imported_module";
7669 case DW_TAG_unspecified_type
:
7670 return "DW_TAG_unspecified_type";
7671 case DW_TAG_partial_unit
:
7672 return "DW_TAG_partial_unit";
7673 case DW_TAG_imported_unit
:
7674 return "DW_TAG_imported_unit";
7675 case DW_TAG_MIPS_loop
:
7676 return "DW_TAG_MIPS_loop";
7677 case DW_TAG_format_label
:
7678 return "DW_TAG_format_label";
7679 case DW_TAG_function_template
:
7680 return "DW_TAG_function_template";
7681 case DW_TAG_class_template
:
7682 return "DW_TAG_class_template";
7684 return "DW_TAG_<unknown>";
7688 /* Convert a DWARF attribute code into its string name. */
7691 dwarf_attr_name (unsigned attr
)
7696 return "DW_AT_sibling";
7697 case DW_AT_location
:
7698 return "DW_AT_location";
7700 return "DW_AT_name";
7701 case DW_AT_ordering
:
7702 return "DW_AT_ordering";
7703 case DW_AT_subscr_data
:
7704 return "DW_AT_subscr_data";
7705 case DW_AT_byte_size
:
7706 return "DW_AT_byte_size";
7707 case DW_AT_bit_offset
:
7708 return "DW_AT_bit_offset";
7709 case DW_AT_bit_size
:
7710 return "DW_AT_bit_size";
7711 case DW_AT_element_list
:
7712 return "DW_AT_element_list";
7713 case DW_AT_stmt_list
:
7714 return "DW_AT_stmt_list";
7716 return "DW_AT_low_pc";
7718 return "DW_AT_high_pc";
7719 case DW_AT_language
:
7720 return "DW_AT_language";
7722 return "DW_AT_member";
7724 return "DW_AT_discr";
7725 case DW_AT_discr_value
:
7726 return "DW_AT_discr_value";
7727 case DW_AT_visibility
:
7728 return "DW_AT_visibility";
7730 return "DW_AT_import";
7731 case DW_AT_string_length
:
7732 return "DW_AT_string_length";
7733 case DW_AT_common_reference
:
7734 return "DW_AT_common_reference";
7735 case DW_AT_comp_dir
:
7736 return "DW_AT_comp_dir";
7737 case DW_AT_const_value
:
7738 return "DW_AT_const_value";
7739 case DW_AT_containing_type
:
7740 return "DW_AT_containing_type";
7741 case DW_AT_default_value
:
7742 return "DW_AT_default_value";
7744 return "DW_AT_inline";
7745 case DW_AT_is_optional
:
7746 return "DW_AT_is_optional";
7747 case DW_AT_lower_bound
:
7748 return "DW_AT_lower_bound";
7749 case DW_AT_producer
:
7750 return "DW_AT_producer";
7751 case DW_AT_prototyped
:
7752 return "DW_AT_prototyped";
7753 case DW_AT_return_addr
:
7754 return "DW_AT_return_addr";
7755 case DW_AT_start_scope
:
7756 return "DW_AT_start_scope";
7757 case DW_AT_stride_size
:
7758 return "DW_AT_stride_size";
7759 case DW_AT_upper_bound
:
7760 return "DW_AT_upper_bound";
7761 case DW_AT_abstract_origin
:
7762 return "DW_AT_abstract_origin";
7763 case DW_AT_accessibility
:
7764 return "DW_AT_accessibility";
7765 case DW_AT_address_class
:
7766 return "DW_AT_address_class";
7767 case DW_AT_artificial
:
7768 return "DW_AT_artificial";
7769 case DW_AT_base_types
:
7770 return "DW_AT_base_types";
7771 case DW_AT_calling_convention
:
7772 return "DW_AT_calling_convention";
7774 return "DW_AT_count";
7775 case DW_AT_data_member_location
:
7776 return "DW_AT_data_member_location";
7777 case DW_AT_decl_column
:
7778 return "DW_AT_decl_column";
7779 case DW_AT_decl_file
:
7780 return "DW_AT_decl_file";
7781 case DW_AT_decl_line
:
7782 return "DW_AT_decl_line";
7783 case DW_AT_declaration
:
7784 return "DW_AT_declaration";
7785 case DW_AT_discr_list
:
7786 return "DW_AT_discr_list";
7787 case DW_AT_encoding
:
7788 return "DW_AT_encoding";
7789 case DW_AT_external
:
7790 return "DW_AT_external";
7791 case DW_AT_frame_base
:
7792 return "DW_AT_frame_base";
7794 return "DW_AT_friend";
7795 case DW_AT_identifier_case
:
7796 return "DW_AT_identifier_case";
7797 case DW_AT_macro_info
:
7798 return "DW_AT_macro_info";
7799 case DW_AT_namelist_items
:
7800 return "DW_AT_namelist_items";
7801 case DW_AT_priority
:
7802 return "DW_AT_priority";
7804 return "DW_AT_segment";
7805 case DW_AT_specification
:
7806 return "DW_AT_specification";
7807 case DW_AT_static_link
:
7808 return "DW_AT_static_link";
7810 return "DW_AT_type";
7811 case DW_AT_use_location
:
7812 return "DW_AT_use_location";
7813 case DW_AT_variable_parameter
:
7814 return "DW_AT_variable_parameter";
7815 case DW_AT_virtuality
:
7816 return "DW_AT_virtuality";
7817 case DW_AT_vtable_elem_location
:
7818 return "DW_AT_vtable_elem_location";
7819 case DW_AT_allocated
:
7820 return "DW_AT_allocated";
7821 case DW_AT_associated
:
7822 return "DW_AT_associated";
7823 case DW_AT_data_location
:
7824 return "DW_AT_data_location";
7826 return "DW_AT_stride";
7827 case DW_AT_entry_pc
:
7828 return "DW_AT_entry_pc";
7829 case DW_AT_use_UTF8
:
7830 return "DW_AT_use_UTF8";
7831 case DW_AT_extension
:
7832 return "DW_AT_extension";
7834 return "DW_AT_ranges";
7835 case DW_AT_trampoline
:
7836 return "DW_AT_trampoline";
7837 case DW_AT_call_column
:
7838 return "DW_AT_call_column";
7839 case DW_AT_call_file
:
7840 return "DW_AT_call_file";
7841 case DW_AT_call_line
:
7842 return "DW_AT_call_line";
7844 case DW_AT_MIPS_fde
:
7845 return "DW_AT_MIPS_fde";
7846 case DW_AT_MIPS_loop_begin
:
7847 return "DW_AT_MIPS_loop_begin";
7848 case DW_AT_MIPS_tail_loop_begin
:
7849 return "DW_AT_MIPS_tail_loop_begin";
7850 case DW_AT_MIPS_epilog_begin
:
7851 return "DW_AT_MIPS_epilog_begin";
7852 case DW_AT_MIPS_loop_unroll_factor
:
7853 return "DW_AT_MIPS_loop_unroll_factor";
7854 case DW_AT_MIPS_software_pipeline_depth
:
7855 return "DW_AT_MIPS_software_pipeline_depth";
7857 case DW_AT_MIPS_linkage_name
:
7858 return "DW_AT_MIPS_linkage_name";
7860 case DW_AT_sf_names
:
7861 return "DW_AT_sf_names";
7862 case DW_AT_src_info
:
7863 return "DW_AT_src_info";
7864 case DW_AT_mac_info
:
7865 return "DW_AT_mac_info";
7866 case DW_AT_src_coords
:
7867 return "DW_AT_src_coords";
7868 case DW_AT_body_begin
:
7869 return "DW_AT_body_begin";
7870 case DW_AT_body_end
:
7871 return "DW_AT_body_end";
7872 case DW_AT_GNU_vector
:
7873 return "DW_AT_GNU_vector";
7875 return "DW_AT_<unknown>";
7879 /* Convert a DWARF value form code into its string name. */
7882 dwarf_form_name (unsigned form
)
7887 return "DW_FORM_addr";
7888 case DW_FORM_block2
:
7889 return "DW_FORM_block2";
7890 case DW_FORM_block4
:
7891 return "DW_FORM_block4";
7893 return "DW_FORM_data2";
7895 return "DW_FORM_data4";
7897 return "DW_FORM_data8";
7898 case DW_FORM_string
:
7899 return "DW_FORM_string";
7901 return "DW_FORM_block";
7902 case DW_FORM_block1
:
7903 return "DW_FORM_block1";
7905 return "DW_FORM_data1";
7907 return "DW_FORM_flag";
7909 return "DW_FORM_sdata";
7911 return "DW_FORM_strp";
7913 return "DW_FORM_udata";
7914 case DW_FORM_ref_addr
:
7915 return "DW_FORM_ref_addr";
7917 return "DW_FORM_ref1";
7919 return "DW_FORM_ref2";
7921 return "DW_FORM_ref4";
7923 return "DW_FORM_ref8";
7924 case DW_FORM_ref_udata
:
7925 return "DW_FORM_ref_udata";
7926 case DW_FORM_indirect
:
7927 return "DW_FORM_indirect";
7929 return "DW_FORM_<unknown>";
7933 /* Convert a DWARF stack opcode into its string name. */
7936 dwarf_stack_op_name (unsigned op
)
7941 return "DW_OP_addr";
7943 return "DW_OP_deref";
7945 return "DW_OP_const1u";
7947 return "DW_OP_const1s";
7949 return "DW_OP_const2u";
7951 return "DW_OP_const2s";
7953 return "DW_OP_const4u";
7955 return "DW_OP_const4s";
7957 return "DW_OP_const8u";
7959 return "DW_OP_const8s";
7961 return "DW_OP_constu";
7963 return "DW_OP_consts";
7967 return "DW_OP_drop";
7969 return "DW_OP_over";
7971 return "DW_OP_pick";
7973 return "DW_OP_swap";
7977 return "DW_OP_xderef";
7985 return "DW_OP_minus";
7997 return "DW_OP_plus";
7998 case DW_OP_plus_uconst
:
7999 return "DW_OP_plus_uconst";
8005 return "DW_OP_shra";
8023 return "DW_OP_skip";
8025 return "DW_OP_lit0";
8027 return "DW_OP_lit1";
8029 return "DW_OP_lit2";
8031 return "DW_OP_lit3";
8033 return "DW_OP_lit4";
8035 return "DW_OP_lit5";
8037 return "DW_OP_lit6";
8039 return "DW_OP_lit7";
8041 return "DW_OP_lit8";
8043 return "DW_OP_lit9";
8045 return "DW_OP_lit10";
8047 return "DW_OP_lit11";
8049 return "DW_OP_lit12";
8051 return "DW_OP_lit13";
8053 return "DW_OP_lit14";
8055 return "DW_OP_lit15";
8057 return "DW_OP_lit16";
8059 return "DW_OP_lit17";
8061 return "DW_OP_lit18";
8063 return "DW_OP_lit19";
8065 return "DW_OP_lit20";
8067 return "DW_OP_lit21";
8069 return "DW_OP_lit22";
8071 return "DW_OP_lit23";
8073 return "DW_OP_lit24";
8075 return "DW_OP_lit25";
8077 return "DW_OP_lit26";
8079 return "DW_OP_lit27";
8081 return "DW_OP_lit28";
8083 return "DW_OP_lit29";
8085 return "DW_OP_lit30";
8087 return "DW_OP_lit31";
8089 return "DW_OP_reg0";
8091 return "DW_OP_reg1";
8093 return "DW_OP_reg2";
8095 return "DW_OP_reg3";
8097 return "DW_OP_reg4";
8099 return "DW_OP_reg5";
8101 return "DW_OP_reg6";
8103 return "DW_OP_reg7";
8105 return "DW_OP_reg8";
8107 return "DW_OP_reg9";
8109 return "DW_OP_reg10";
8111 return "DW_OP_reg11";
8113 return "DW_OP_reg12";
8115 return "DW_OP_reg13";
8117 return "DW_OP_reg14";
8119 return "DW_OP_reg15";
8121 return "DW_OP_reg16";
8123 return "DW_OP_reg17";
8125 return "DW_OP_reg18";
8127 return "DW_OP_reg19";
8129 return "DW_OP_reg20";
8131 return "DW_OP_reg21";
8133 return "DW_OP_reg22";
8135 return "DW_OP_reg23";
8137 return "DW_OP_reg24";
8139 return "DW_OP_reg25";
8141 return "DW_OP_reg26";
8143 return "DW_OP_reg27";
8145 return "DW_OP_reg28";
8147 return "DW_OP_reg29";
8149 return "DW_OP_reg30";
8151 return "DW_OP_reg31";
8153 return "DW_OP_breg0";
8155 return "DW_OP_breg1";
8157 return "DW_OP_breg2";
8159 return "DW_OP_breg3";
8161 return "DW_OP_breg4";
8163 return "DW_OP_breg5";
8165 return "DW_OP_breg6";
8167 return "DW_OP_breg7";
8169 return "DW_OP_breg8";
8171 return "DW_OP_breg9";
8173 return "DW_OP_breg10";
8175 return "DW_OP_breg11";
8177 return "DW_OP_breg12";
8179 return "DW_OP_breg13";
8181 return "DW_OP_breg14";
8183 return "DW_OP_breg15";
8185 return "DW_OP_breg16";
8187 return "DW_OP_breg17";
8189 return "DW_OP_breg18";
8191 return "DW_OP_breg19";
8193 return "DW_OP_breg20";
8195 return "DW_OP_breg21";
8197 return "DW_OP_breg22";
8199 return "DW_OP_breg23";
8201 return "DW_OP_breg24";
8203 return "DW_OP_breg25";
8205 return "DW_OP_breg26";
8207 return "DW_OP_breg27";
8209 return "DW_OP_breg28";
8211 return "DW_OP_breg29";
8213 return "DW_OP_breg30";
8215 return "DW_OP_breg31";
8217 return "DW_OP_regx";
8219 return "DW_OP_fbreg";
8221 return "DW_OP_bregx";
8223 return "DW_OP_piece";
8224 case DW_OP_deref_size
:
8225 return "DW_OP_deref_size";
8226 case DW_OP_xderef_size
:
8227 return "DW_OP_xderef_size";
8230 /* DWARF 3 extensions. */
8231 case DW_OP_push_object_address
:
8232 return "DW_OP_push_object_address";
8234 return "DW_OP_call2";
8236 return "DW_OP_call4";
8237 case DW_OP_call_ref
:
8238 return "DW_OP_call_ref";
8239 /* GNU extensions. */
8240 case DW_OP_GNU_push_tls_address
:
8241 return "DW_OP_GNU_push_tls_address";
8243 return "OP_<unknown>";
8248 dwarf_bool_name (unsigned mybool
)
8256 /* Convert a DWARF type code into its string name. */
8259 dwarf_type_encoding_name (unsigned enc
)
8263 case DW_ATE_address
:
8264 return "DW_ATE_address";
8265 case DW_ATE_boolean
:
8266 return "DW_ATE_boolean";
8267 case DW_ATE_complex_float
:
8268 return "DW_ATE_complex_float";
8270 return "DW_ATE_float";
8272 return "DW_ATE_signed";
8273 case DW_ATE_signed_char
:
8274 return "DW_ATE_signed_char";
8275 case DW_ATE_unsigned
:
8276 return "DW_ATE_unsigned";
8277 case DW_ATE_unsigned_char
:
8278 return "DW_ATE_unsigned_char";
8279 case DW_ATE_imaginary_float
:
8280 return "DW_ATE_imaginary_float";
8282 return "DW_ATE_<unknown>";
8286 /* Convert a DWARF call frame info operation to its string name. */
8290 dwarf_cfi_name (unsigned cfi_opc
)
8294 case DW_CFA_advance_loc
:
8295 return "DW_CFA_advance_loc";
8297 return "DW_CFA_offset";
8298 case DW_CFA_restore
:
8299 return "DW_CFA_restore";
8301 return "DW_CFA_nop";
8302 case DW_CFA_set_loc
:
8303 return "DW_CFA_set_loc";
8304 case DW_CFA_advance_loc1
:
8305 return "DW_CFA_advance_loc1";
8306 case DW_CFA_advance_loc2
:
8307 return "DW_CFA_advance_loc2";
8308 case DW_CFA_advance_loc4
:
8309 return "DW_CFA_advance_loc4";
8310 case DW_CFA_offset_extended
:
8311 return "DW_CFA_offset_extended";
8312 case DW_CFA_restore_extended
:
8313 return "DW_CFA_restore_extended";
8314 case DW_CFA_undefined
:
8315 return "DW_CFA_undefined";
8316 case DW_CFA_same_value
:
8317 return "DW_CFA_same_value";
8318 case DW_CFA_register
:
8319 return "DW_CFA_register";
8320 case DW_CFA_remember_state
:
8321 return "DW_CFA_remember_state";
8322 case DW_CFA_restore_state
:
8323 return "DW_CFA_restore_state";
8324 case DW_CFA_def_cfa
:
8325 return "DW_CFA_def_cfa";
8326 case DW_CFA_def_cfa_register
:
8327 return "DW_CFA_def_cfa_register";
8328 case DW_CFA_def_cfa_offset
:
8329 return "DW_CFA_def_cfa_offset";
8332 case DW_CFA_def_cfa_expression
:
8333 return "DW_CFA_def_cfa_expression";
8334 case DW_CFA_expression
:
8335 return "DW_CFA_expression";
8336 case DW_CFA_offset_extended_sf
:
8337 return "DW_CFA_offset_extended_sf";
8338 case DW_CFA_def_cfa_sf
:
8339 return "DW_CFA_def_cfa_sf";
8340 case DW_CFA_def_cfa_offset_sf
:
8341 return "DW_CFA_def_cfa_offset_sf";
8343 /* SGI/MIPS specific */
8344 case DW_CFA_MIPS_advance_loc8
:
8345 return "DW_CFA_MIPS_advance_loc8";
8347 /* GNU extensions */
8348 case DW_CFA_GNU_window_save
:
8349 return "DW_CFA_GNU_window_save";
8350 case DW_CFA_GNU_args_size
:
8351 return "DW_CFA_GNU_args_size";
8352 case DW_CFA_GNU_negative_offset_extended
:
8353 return "DW_CFA_GNU_negative_offset_extended";
8356 return "DW_CFA_<unknown>";
8362 dump_die (struct die_info
*die
)
8366 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8367 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8368 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8369 dwarf_bool_name (die
->child
!= NULL
));
8371 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8372 for (i
= 0; i
< die
->num_attrs
; ++i
)
8374 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8375 dwarf_attr_name (die
->attrs
[i
].name
),
8376 dwarf_form_name (die
->attrs
[i
].form
));
8377 switch (die
->attrs
[i
].form
)
8379 case DW_FORM_ref_addr
:
8381 fprintf_unfiltered (gdb_stderr
, "address: ");
8382 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8384 case DW_FORM_block2
:
8385 case DW_FORM_block4
:
8387 case DW_FORM_block1
:
8388 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8393 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8394 (long) (DW_ADDR (&die
->attrs
[i
])));
8402 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8404 case DW_FORM_string
:
8406 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8407 DW_STRING (&die
->attrs
[i
])
8408 ? DW_STRING (&die
->attrs
[i
]) : "");
8411 if (DW_UNSND (&die
->attrs
[i
]))
8412 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8414 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8416 case DW_FORM_indirect
:
8417 /* the reader will have reduced the indirect form to
8418 the "base form" so this form should not occur */
8419 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8422 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8423 die
->attrs
[i
].form
);
8425 fprintf_unfiltered (gdb_stderr
, "\n");
8430 dump_die_list (struct die_info
*die
)
8435 if (die
->child
!= NULL
)
8436 dump_die_list (die
->child
);
8437 if (die
->sibling
!= NULL
)
8438 dump_die_list (die
->sibling
);
8443 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8444 struct dwarf2_cu
*cu
)
8447 struct die_info
*old
;
8449 h
= (offset
% REF_HASH_SIZE
);
8450 old
= cu
->die_ref_table
[h
];
8451 die
->next_ref
= old
;
8452 cu
->die_ref_table
[h
] = die
;
8456 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8458 unsigned int result
= 0;
8462 case DW_FORM_ref_addr
:
8467 case DW_FORM_ref_udata
:
8468 result
= DW_ADDR (attr
);
8471 complaint (&symfile_complaints
,
8472 _("unsupported die ref attribute form: '%s'"),
8473 dwarf_form_name (attr
->form
));
8478 /* Return the constant value held by the given attribute. Return -1
8479 if the value held by the attribute is not constant. */
8482 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8484 if (attr
->form
== DW_FORM_sdata
)
8485 return DW_SND (attr
);
8486 else if (attr
->form
== DW_FORM_udata
8487 || attr
->form
== DW_FORM_data1
8488 || attr
->form
== DW_FORM_data2
8489 || attr
->form
== DW_FORM_data4
8490 || attr
->form
== DW_FORM_data8
)
8491 return DW_UNSND (attr
);
8494 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8495 dwarf_form_name (attr
->form
));
8496 return default_value
;
8500 static struct die_info
*
8501 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8502 struct dwarf2_cu
*cu
)
8504 struct die_info
*die
;
8505 unsigned int offset
;
8507 struct die_info temp_die
;
8508 struct dwarf2_cu
*target_cu
;
8510 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8512 if (DW_ADDR (attr
) < cu
->header
.offset
8513 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8515 struct dwarf2_per_cu_data
*per_cu
;
8516 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8518 target_cu
= per_cu
->cu
;
8523 h
= (offset
% REF_HASH_SIZE
);
8524 die
= target_cu
->die_ref_table
[h
];
8527 if (die
->offset
== offset
)
8529 die
= die
->next_ref
;
8532 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8533 "at 0x%lx [in module %s]"),
8534 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8539 static struct type
*
8540 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8541 struct dwarf2_cu
*cu
)
8543 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8545 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8546 typeid, objfile
->name
);
8549 /* Look for this particular type in the fundamental type vector. If
8550 one is not found, create and install one appropriate for the
8551 current language and the current target machine. */
8553 if (cu
->ftypes
[typeid] == NULL
)
8555 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8558 return (cu
->ftypes
[typeid]);
8561 /* Decode simple location descriptions.
8562 Given a pointer to a dwarf block that defines a location, compute
8563 the location and return the value.
8565 NOTE drow/2003-11-18: This function is called in two situations
8566 now: for the address of static or global variables (partial symbols
8567 only) and for offsets into structures which are expected to be
8568 (more or less) constant. The partial symbol case should go away,
8569 and only the constant case should remain. That will let this
8570 function complain more accurately. A few special modes are allowed
8571 without complaint for global variables (for instance, global
8572 register values and thread-local values).
8574 A location description containing no operations indicates that the
8575 object is optimized out. The return value is 0 for that case.
8576 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8577 callers will only want a very basic result and this can become a
8580 Note that stack[0] is unused except as a default error return.
8581 Note that stack overflow is not yet handled. */
8584 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8586 struct objfile
*objfile
= cu
->objfile
;
8587 struct comp_unit_head
*cu_header
= &cu
->header
;
8589 int size
= blk
->size
;
8590 gdb_byte
*data
= blk
->data
;
8591 CORE_ADDR stack
[64];
8593 unsigned int bytes_read
, unsnd
;
8637 stack
[++stacki
] = op
- DW_OP_lit0
;
8672 stack
[++stacki
] = op
- DW_OP_reg0
;
8674 dwarf2_complex_location_expr_complaint ();
8678 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8680 stack
[++stacki
] = unsnd
;
8682 dwarf2_complex_location_expr_complaint ();
8686 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8692 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8697 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8702 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8707 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8712 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8717 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8722 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8728 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8733 stack
[stacki
+ 1] = stack
[stacki
];
8738 stack
[stacki
- 1] += stack
[stacki
];
8742 case DW_OP_plus_uconst
:
8743 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8748 stack
[stacki
- 1] -= stack
[stacki
];
8753 /* If we're not the last op, then we definitely can't encode
8754 this using GDB's address_class enum. This is valid for partial
8755 global symbols, although the variable's address will be bogus
8758 dwarf2_complex_location_expr_complaint ();
8761 case DW_OP_GNU_push_tls_address
:
8762 /* The top of the stack has the offset from the beginning
8763 of the thread control block at which the variable is located. */
8764 /* Nothing should follow this operator, so the top of stack would
8766 /* This is valid for partial global symbols, but the variable's
8767 address will be bogus in the psymtab. */
8769 dwarf2_complex_location_expr_complaint ();
8773 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8774 dwarf_stack_op_name (op
));
8775 return (stack
[stacki
]);
8778 return (stack
[stacki
]);
8781 /* memory allocation interface */
8783 static struct dwarf_block
*
8784 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8786 struct dwarf_block
*blk
;
8788 blk
= (struct dwarf_block
*)
8789 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8793 static struct abbrev_info
*
8794 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8796 struct abbrev_info
*abbrev
;
8798 abbrev
= (struct abbrev_info
*)
8799 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8800 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8804 static struct die_info
*
8805 dwarf_alloc_die (void)
8807 struct die_info
*die
;
8809 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8810 memset (die
, 0, sizeof (struct die_info
));
8815 /* Macro support. */
8818 /* Return the full name of file number I in *LH's file name table.
8819 Use COMP_DIR as the name of the current directory of the
8820 compilation. The result is allocated using xmalloc; the caller is
8821 responsible for freeing it. */
8823 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8825 /* Is the file number a valid index into the line header's file name
8826 table? Remember that file numbers start with one, not zero. */
8827 if (1 <= file
&& file
<= lh
->num_file_names
)
8829 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8831 if (IS_ABSOLUTE_PATH (fe
->name
))
8832 return xstrdup (fe
->name
);
8840 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8846 dir_len
= strlen (dir
);
8847 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8848 strcpy (full_name
, dir
);
8849 full_name
[dir_len
] = '/';
8850 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8854 return xstrdup (fe
->name
);
8859 /* The compiler produced a bogus file number. We can at least
8860 record the macro definitions made in the file, even if we
8861 won't be able to find the file by name. */
8863 sprintf (fake_name
, "<bad macro file number %d>", file
);
8865 complaint (&symfile_complaints
,
8866 _("bad file number in macro information (%d)"),
8869 return xstrdup (fake_name
);
8874 static struct macro_source_file
*
8875 macro_start_file (int file
, int line
,
8876 struct macro_source_file
*current_file
,
8877 const char *comp_dir
,
8878 struct line_header
*lh
, struct objfile
*objfile
)
8880 /* The full name of this source file. */
8881 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8883 /* We don't create a macro table for this compilation unit
8884 at all until we actually get a filename. */
8885 if (! pending_macros
)
8886 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8887 objfile
->macro_cache
);
8890 /* If we have no current file, then this must be the start_file
8891 directive for the compilation unit's main source file. */
8892 current_file
= macro_set_main (pending_macros
, full_name
);
8894 current_file
= macro_include (current_file
, line
, full_name
);
8898 return current_file
;
8902 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8903 followed by a null byte. */
8905 copy_string (const char *buf
, int len
)
8907 char *s
= xmalloc (len
+ 1);
8908 memcpy (s
, buf
, len
);
8916 consume_improper_spaces (const char *p
, const char *body
)
8920 complaint (&symfile_complaints
,
8921 _("macro definition contains spaces in formal argument list:\n`%s'"),
8933 parse_macro_definition (struct macro_source_file
*file
, int line
,
8938 /* The body string takes one of two forms. For object-like macro
8939 definitions, it should be:
8941 <macro name> " " <definition>
8943 For function-like macro definitions, it should be:
8945 <macro name> "() " <definition>
8947 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8949 Spaces may appear only where explicitly indicated, and in the
8952 The Dwarf 2 spec says that an object-like macro's name is always
8953 followed by a space, but versions of GCC around March 2002 omit
8954 the space when the macro's definition is the empty string.
8956 The Dwarf 2 spec says that there should be no spaces between the
8957 formal arguments in a function-like macro's formal argument list,
8958 but versions of GCC around March 2002 include spaces after the
8962 /* Find the extent of the macro name. The macro name is terminated
8963 by either a space or null character (for an object-like macro) or
8964 an opening paren (for a function-like macro). */
8965 for (p
= body
; *p
; p
++)
8966 if (*p
== ' ' || *p
== '(')
8969 if (*p
== ' ' || *p
== '\0')
8971 /* It's an object-like macro. */
8972 int name_len
= p
- body
;
8973 char *name
= copy_string (body
, name_len
);
8974 const char *replacement
;
8977 replacement
= body
+ name_len
+ 1;
8980 dwarf2_macro_malformed_definition_complaint (body
);
8981 replacement
= body
+ name_len
;
8984 macro_define_object (file
, line
, name
, replacement
);
8990 /* It's a function-like macro. */
8991 char *name
= copy_string (body
, p
- body
);
8994 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
8998 p
= consume_improper_spaces (p
, body
);
9000 /* Parse the formal argument list. */
9001 while (*p
&& *p
!= ')')
9003 /* Find the extent of the current argument name. */
9004 const char *arg_start
= p
;
9006 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9009 if (! *p
|| p
== arg_start
)
9010 dwarf2_macro_malformed_definition_complaint (body
);
9013 /* Make sure argv has room for the new argument. */
9014 if (argc
>= argv_size
)
9017 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9020 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9023 p
= consume_improper_spaces (p
, body
);
9025 /* Consume the comma, if present. */
9030 p
= consume_improper_spaces (p
, body
);
9039 /* Perfectly formed definition, no complaints. */
9040 macro_define_function (file
, line
, name
,
9041 argc
, (const char **) argv
,
9043 else if (*p
== '\0')
9045 /* Complain, but do define it. */
9046 dwarf2_macro_malformed_definition_complaint (body
);
9047 macro_define_function (file
, line
, name
,
9048 argc
, (const char **) argv
,
9052 /* Just complain. */
9053 dwarf2_macro_malformed_definition_complaint (body
);
9056 /* Just complain. */
9057 dwarf2_macro_malformed_definition_complaint (body
);
9063 for (i
= 0; i
< argc
; i
++)
9069 dwarf2_macro_malformed_definition_complaint (body
);
9074 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9075 char *comp_dir
, bfd
*abfd
,
9076 struct dwarf2_cu
*cu
)
9078 gdb_byte
*mac_ptr
, *mac_end
;
9079 struct macro_source_file
*current_file
= 0;
9081 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9083 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9087 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9088 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9089 + dwarf2_per_objfile
->macinfo_size
;
9093 enum dwarf_macinfo_record_type macinfo_type
;
9095 /* Do we at least have room for a macinfo type byte? */
9096 if (mac_ptr
>= mac_end
)
9098 dwarf2_macros_too_long_complaint ();
9102 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9105 switch (macinfo_type
)
9107 /* A zero macinfo type indicates the end of the macro
9112 case DW_MACINFO_define
:
9113 case DW_MACINFO_undef
:
9115 unsigned int bytes_read
;
9119 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9120 mac_ptr
+= bytes_read
;
9121 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9122 mac_ptr
+= bytes_read
;
9125 complaint (&symfile_complaints
,
9126 _("debug info gives macro %s outside of any file: %s"),
9128 DW_MACINFO_define
? "definition" : macinfo_type
==
9129 DW_MACINFO_undef
? "undefinition" :
9130 "something-or-other", body
);
9133 if (macinfo_type
== DW_MACINFO_define
)
9134 parse_macro_definition (current_file
, line
, body
);
9135 else if (macinfo_type
== DW_MACINFO_undef
)
9136 macro_undef (current_file
, line
, body
);
9141 case DW_MACINFO_start_file
:
9143 unsigned int bytes_read
;
9146 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9147 mac_ptr
+= bytes_read
;
9148 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9149 mac_ptr
+= bytes_read
;
9151 current_file
= macro_start_file (file
, line
,
9152 current_file
, comp_dir
,
9157 case DW_MACINFO_end_file
:
9159 complaint (&symfile_complaints
,
9160 _("macro debug info has an unmatched `close_file' directive"));
9163 current_file
= current_file
->included_by
;
9166 enum dwarf_macinfo_record_type next_type
;
9168 /* GCC circa March 2002 doesn't produce the zero
9169 type byte marking the end of the compilation
9170 unit. Complain if it's not there, but exit no
9173 /* Do we at least have room for a macinfo type byte? */
9174 if (mac_ptr
>= mac_end
)
9176 dwarf2_macros_too_long_complaint ();
9180 /* We don't increment mac_ptr here, so this is just
9182 next_type
= read_1_byte (abfd
, mac_ptr
);
9184 complaint (&symfile_complaints
,
9185 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9192 case DW_MACINFO_vendor_ext
:
9194 unsigned int bytes_read
;
9198 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9199 mac_ptr
+= bytes_read
;
9200 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9201 mac_ptr
+= bytes_read
;
9203 /* We don't recognize any vendor extensions. */
9210 /* Check if the attribute's form is a DW_FORM_block*
9211 if so return true else false. */
9213 attr_form_is_block (struct attribute
*attr
)
9215 return (attr
== NULL
? 0 :
9216 attr
->form
== DW_FORM_block1
9217 || attr
->form
== DW_FORM_block2
9218 || attr
->form
== DW_FORM_block4
9219 || attr
->form
== DW_FORM_block
);
9223 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9224 struct dwarf2_cu
*cu
)
9226 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9228 struct dwarf2_loclist_baton
*baton
;
9230 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9231 sizeof (struct dwarf2_loclist_baton
));
9232 baton
->objfile
= cu
->objfile
;
9234 /* We don't know how long the location list is, but make sure we
9235 don't run off the edge of the section. */
9236 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9237 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9238 baton
->base_address
= cu
->header
.base_address
;
9239 if (cu
->header
.base_known
== 0)
9240 complaint (&symfile_complaints
,
9241 _("Location list used without specifying the CU base address."));
9243 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9244 SYMBOL_LOCATION_BATON (sym
) = baton
;
9248 struct dwarf2_locexpr_baton
*baton
;
9250 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9251 sizeof (struct dwarf2_locexpr_baton
));
9252 baton
->objfile
= cu
->objfile
;
9254 if (attr_form_is_block (attr
))
9256 /* Note that we're just copying the block's data pointer
9257 here, not the actual data. We're still pointing into the
9258 info_buffer for SYM's objfile; right now we never release
9259 that buffer, but when we do clean up properly this may
9261 baton
->size
= DW_BLOCK (attr
)->size
;
9262 baton
->data
= DW_BLOCK (attr
)->data
;
9266 dwarf2_invalid_attrib_class_complaint ("location description",
9267 SYMBOL_NATURAL_NAME (sym
));
9272 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9273 SYMBOL_LOCATION_BATON (sym
) = baton
;
9277 /* Locate the compilation unit from CU's objfile which contains the
9278 DIE at OFFSET. Raises an error on failure. */
9280 static struct dwarf2_per_cu_data
*
9281 dwarf2_find_containing_comp_unit (unsigned long offset
,
9282 struct objfile
*objfile
)
9284 struct dwarf2_per_cu_data
*this_cu
;
9288 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9291 int mid
= low
+ (high
- low
) / 2;
9292 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9297 gdb_assert (low
== high
);
9298 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9301 error (_("Dwarf Error: could not find partial DIE containing "
9302 "offset 0x%lx [in module %s]"),
9303 (long) offset
, bfd_get_filename (objfile
->obfd
));
9305 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9306 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9310 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9311 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9312 && offset
>= this_cu
->offset
+ this_cu
->length
)
9313 error (_("invalid dwarf2 offset %ld"), offset
);
9314 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9319 /* Locate the compilation unit from OBJFILE which is located at exactly
9320 OFFSET. Raises an error on failure. */
9322 static struct dwarf2_per_cu_data
*
9323 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9325 struct dwarf2_per_cu_data
*this_cu
;
9326 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9327 if (this_cu
->offset
!= offset
)
9328 error (_("no compilation unit with offset %ld."), offset
);
9332 /* Release one cached compilation unit, CU. We unlink it from the tree
9333 of compilation units, but we don't remove it from the read_in_chain;
9334 the caller is responsible for that. */
9337 free_one_comp_unit (void *data
)
9339 struct dwarf2_cu
*cu
= data
;
9341 if (cu
->per_cu
!= NULL
)
9342 cu
->per_cu
->cu
= NULL
;
9345 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9347 free_die_list (cu
->dies
);
9352 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9353 when we're finished with it. We can't free the pointer itself, but be
9354 sure to unlink it from the cache. Also release any associated storage
9355 and perform cache maintenance.
9357 Only used during partial symbol parsing. */
9360 free_stack_comp_unit (void *data
)
9362 struct dwarf2_cu
*cu
= data
;
9364 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9365 cu
->partial_dies
= NULL
;
9367 if (cu
->per_cu
!= NULL
)
9369 /* This compilation unit is on the stack in our caller, so we
9370 should not xfree it. Just unlink it. */
9371 cu
->per_cu
->cu
= NULL
;
9374 /* If we had a per-cu pointer, then we may have other compilation
9375 units loaded, so age them now. */
9376 age_cached_comp_units ();
9380 /* Free all cached compilation units. */
9383 free_cached_comp_units (void *data
)
9385 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9387 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9388 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9389 while (per_cu
!= NULL
)
9391 struct dwarf2_per_cu_data
*next_cu
;
9393 next_cu
= per_cu
->cu
->read_in_chain
;
9395 free_one_comp_unit (per_cu
->cu
);
9396 *last_chain
= next_cu
;
9402 /* Increase the age counter on each cached compilation unit, and free
9403 any that are too old. */
9406 age_cached_comp_units (void)
9408 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9410 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9411 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9412 while (per_cu
!= NULL
)
9414 per_cu
->cu
->last_used
++;
9415 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9416 dwarf2_mark (per_cu
->cu
);
9417 per_cu
= per_cu
->cu
->read_in_chain
;
9420 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9421 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9422 while (per_cu
!= NULL
)
9424 struct dwarf2_per_cu_data
*next_cu
;
9426 next_cu
= per_cu
->cu
->read_in_chain
;
9428 if (!per_cu
->cu
->mark
)
9430 free_one_comp_unit (per_cu
->cu
);
9431 *last_chain
= next_cu
;
9434 last_chain
= &per_cu
->cu
->read_in_chain
;
9440 /* Remove a single compilation unit from the cache. */
9443 free_one_cached_comp_unit (void *target_cu
)
9445 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9447 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9448 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9449 while (per_cu
!= NULL
)
9451 struct dwarf2_per_cu_data
*next_cu
;
9453 next_cu
= per_cu
->cu
->read_in_chain
;
9455 if (per_cu
->cu
== target_cu
)
9457 free_one_comp_unit (per_cu
->cu
);
9458 *last_chain
= next_cu
;
9462 last_chain
= &per_cu
->cu
->read_in_chain
;
9468 /* A pair of DIE offset and GDB type pointer. We store these
9469 in a hash table separate from the DIEs, and preserve them
9470 when the DIEs are flushed out of cache. */
9472 struct dwarf2_offset_and_type
9474 unsigned int offset
;
9478 /* Hash function for a dwarf2_offset_and_type. */
9481 offset_and_type_hash (const void *item
)
9483 const struct dwarf2_offset_and_type
*ofs
= item
;
9487 /* Equality function for a dwarf2_offset_and_type. */
9490 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9492 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9493 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9494 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9497 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9498 table if necessary. */
9501 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9503 struct dwarf2_offset_and_type
**slot
, ofs
;
9507 if (cu
->per_cu
== NULL
)
9510 if (cu
->per_cu
->type_hash
== NULL
)
9511 cu
->per_cu
->type_hash
9512 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9513 offset_and_type_hash
,
9516 &cu
->objfile
->objfile_obstack
,
9517 hashtab_obstack_allocate
,
9518 dummy_obstack_deallocate
);
9520 ofs
.offset
= die
->offset
;
9522 slot
= (struct dwarf2_offset_and_type
**)
9523 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9524 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9528 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9529 have a saved type. */
9531 static struct type
*
9532 get_die_type (struct die_info
*die
, htab_t type_hash
)
9534 struct dwarf2_offset_and_type
*slot
, ofs
;
9536 ofs
.offset
= die
->offset
;
9537 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9544 /* Restore the types of the DIE tree starting at START_DIE from the hash
9545 table saved in CU. */
9548 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9550 struct die_info
*die
;
9552 if (cu
->per_cu
->type_hash
== NULL
)
9555 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9557 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9558 if (die
->child
!= NULL
)
9559 reset_die_and_siblings_types (die
->child
, cu
);
9563 /* Set the mark field in CU and in every other compilation unit in the
9564 cache that we must keep because we are keeping CU. */
9566 /* Add a dependence relationship from CU to REF_PER_CU. */
9569 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9570 struct dwarf2_per_cu_data
*ref_per_cu
)
9574 if (cu
->dependencies
== NULL
)
9576 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9577 NULL
, &cu
->comp_unit_obstack
,
9578 hashtab_obstack_allocate
,
9579 dummy_obstack_deallocate
);
9581 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9586 /* Set the mark field in CU and in every other compilation unit in the
9587 cache that we must keep because we are keeping CU. */
9590 dwarf2_mark_helper (void **slot
, void *data
)
9592 struct dwarf2_per_cu_data
*per_cu
;
9594 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9595 if (per_cu
->cu
->mark
)
9597 per_cu
->cu
->mark
= 1;
9599 if (per_cu
->cu
->dependencies
!= NULL
)
9600 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9606 dwarf2_mark (struct dwarf2_cu
*cu
)
9611 if (cu
->dependencies
!= NULL
)
9612 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9616 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9620 per_cu
->cu
->mark
= 0;
9621 per_cu
= per_cu
->cu
->read_in_chain
;
9625 /* Allocation function for the libiberty hash table which uses an
9629 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
9631 unsigned int total
= size
* count
;
9632 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
9633 memset (ptr
, 0, total
);
9637 /* Trivial deallocation function for the libiberty splay tree and hash
9638 table - don't deallocate anything. Rely on later deletion of the
9642 dummy_obstack_deallocate (void *object
, void *data
)
9647 /* Trivial hash function for partial_die_info: the hash value of a DIE
9648 is its offset in .debug_info for this objfile. */
9651 partial_die_hash (const void *item
)
9653 const struct partial_die_info
*part_die
= item
;
9654 return part_die
->offset
;
9657 /* Trivial comparison function for partial_die_info structures: two DIEs
9658 are equal if they have the same offset. */
9661 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9663 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9664 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9665 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9668 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9669 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9672 set_dwarf2_cmd (char *args
, int from_tty
)
9674 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9678 show_dwarf2_cmd (char *args
, int from_tty
)
9680 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9683 void _initialize_dwarf2_read (void);
9686 _initialize_dwarf2_read (void)
9688 dwarf2_objfile_data_key
= register_objfile_data ();
9690 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9691 Set DWARF 2 specific variables.\n\
9692 Configure DWARF 2 variables such as the cache size"),
9693 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9694 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9696 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9697 Show DWARF 2 specific variables\n\
9698 Show DWARF 2 variables such as the cache size"),
9699 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9700 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9702 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9703 &dwarf2_max_cache_age
, _("\
9704 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9705 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9706 A higher limit means that cached compilation units will be stored\n\
9707 in memory longer, and more total memory will be used. Zero disables\n\
9708 caching, which can slow down startup."),
9710 show_dwarf2_max_cache_age
,
9711 &set_dwarf2_cmdlist
,
9712 &show_dwarf2_cmdlist
);