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. */
169 char *macinfo_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
244 /* Pointer to the first die of this compilation unit. This will be
245 the first byte following the compilation unit header. */
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 char *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 char *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 char *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 (char *, int *, struct dwarf2_cu
*);
759 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
762 static struct partial_die_info
*load_partial_dies (bfd
*, char *, int,
765 static char *read_partial_die (struct partial_die_info
*,
766 struct abbrev_info
*abbrev
, unsigned int,
767 bfd
*, char *, struct dwarf2_cu
*);
769 static struct partial_die_info
*find_partial_die (unsigned long,
772 static void fixup_partial_die (struct partial_die_info
*,
775 static char *read_full_die (struct die_info
**, bfd
*, char *,
776 struct dwarf2_cu
*, int *);
778 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
779 bfd
*, char *, struct dwarf2_cu
*);
781 static char *read_attribute_value (struct attribute
*, unsigned,
782 bfd
*, char *, struct dwarf2_cu
*);
784 static unsigned int read_1_byte (bfd
*, char *);
786 static int read_1_signed_byte (bfd
*, char *);
788 static unsigned int read_2_bytes (bfd
*, char *);
790 static unsigned int read_4_bytes (bfd
*, char *);
792 static unsigned long read_8_bytes (bfd
*, char *);
794 static CORE_ADDR
read_address (bfd
*, char *ptr
, struct dwarf2_cu
*,
797 static LONGEST
read_initial_length (bfd
*, char *,
798 struct comp_unit_head
*, int *bytes_read
);
800 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
803 static char *read_n_bytes (bfd
*, char *, unsigned int);
805 static char *read_string (bfd
*, char *, unsigned int *);
807 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
810 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
812 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
814 static char *skip_leb128 (bfd
*, char *);
816 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
818 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
821 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
822 struct dwarf2_cu
*cu
);
824 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
826 static struct die_info
*die_specification (struct die_info
*die
,
829 static void free_line_header (struct line_header
*lh
);
831 static void add_file_name (struct line_header
*, char *, unsigned int,
832 unsigned int, unsigned int);
834 static struct line_header
*(dwarf_decode_line_header
835 (unsigned int offset
,
836 bfd
*abfd
, struct dwarf2_cu
*cu
));
838 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
839 struct dwarf2_cu
*, struct partial_symtab
*);
841 static void dwarf2_start_subfile (char *, char *);
843 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
846 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
849 static void dwarf2_const_value_data (struct attribute
*attr
,
853 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
855 static struct type
*die_containing_type (struct die_info
*,
858 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
860 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
862 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
864 static char *typename_concat (struct obstack
*, const char *prefix
, const char *suffix
,
867 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
869 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
871 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
873 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
875 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
877 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
879 static int dwarf2_get_pc_bounds (struct die_info
*,
880 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
882 static void get_scope_pc_bounds (struct die_info
*,
883 CORE_ADDR
*, CORE_ADDR
*,
886 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
889 static void dwarf2_attach_fields_to_type (struct field_info
*,
890 struct type
*, struct dwarf2_cu
*);
892 static void dwarf2_add_member_fn (struct field_info
*,
893 struct die_info
*, struct type
*,
896 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
897 struct type
*, struct dwarf2_cu
*);
899 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
901 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
903 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
905 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
907 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
909 static const char *namespace_name (struct die_info
*die
,
910 int *is_anonymous
, struct dwarf2_cu
*);
912 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
914 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
916 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
918 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
920 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
922 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
925 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
927 static void read_tag_ptr_to_member_type (struct die_info
*,
930 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
932 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
934 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
936 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
938 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
940 static struct die_info
*read_comp_unit (char *, bfd
*, struct dwarf2_cu
*);
942 static struct die_info
*read_die_and_children (char *info_ptr
, bfd
*abfd
,
945 struct die_info
*parent
);
947 static struct die_info
*read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
950 struct die_info
*parent
);
952 static void free_die_list (struct die_info
*);
954 static void process_die (struct die_info
*, struct dwarf2_cu
*);
956 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
958 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
960 static struct die_info
*dwarf2_extension (struct die_info
*die
,
963 static char *dwarf_tag_name (unsigned int);
965 static char *dwarf_attr_name (unsigned int);
967 static char *dwarf_form_name (unsigned int);
969 static char *dwarf_stack_op_name (unsigned int);
971 static char *dwarf_bool_name (unsigned int);
973 static char *dwarf_type_encoding_name (unsigned int);
976 static char *dwarf_cfi_name (unsigned int);
978 struct die_info
*copy_die (struct die_info
*);
981 static struct die_info
*sibling_die (struct die_info
*);
983 static void dump_die (struct die_info
*);
985 static void dump_die_list (struct die_info
*);
987 static void store_in_ref_table (unsigned int, struct die_info
*,
990 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
993 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
995 static struct die_info
*follow_die_ref (struct die_info
*,
999 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
1000 struct dwarf2_cu
*);
1002 /* memory allocation interface */
1004 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1006 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1008 static struct die_info
*dwarf_alloc_die (void);
1010 static void initialize_cu_func_list (struct dwarf2_cu
*);
1012 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1013 struct dwarf2_cu
*);
1015 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1016 char *, bfd
*, struct dwarf2_cu
*);
1018 static int attr_form_is_block (struct attribute
*);
1021 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
1022 struct dwarf2_cu
*cu
);
1024 static char *skip_one_die (char *info_ptr
, struct abbrev_info
*abbrev
,
1025 struct dwarf2_cu
*cu
);
1027 static void free_stack_comp_unit (void *);
1029 static void *hashtab_obstack_allocate (void *data
, size_t size
, size_t count
);
1031 static void dummy_obstack_deallocate (void *object
, void *data
);
1033 static hashval_t
partial_die_hash (const void *item
);
1035 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1037 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1038 (unsigned long offset
, struct objfile
*objfile
);
1040 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1041 (unsigned long offset
, struct objfile
*objfile
);
1043 static void free_one_comp_unit (void *);
1045 static void free_cached_comp_units (void *);
1047 static void age_cached_comp_units (void);
1049 static void free_one_cached_comp_unit (void *);
1051 static void set_die_type (struct die_info
*, struct type
*,
1052 struct dwarf2_cu
*);
1054 static void reset_die_and_siblings_types (struct die_info
*,
1055 struct dwarf2_cu
*);
1057 static void create_all_comp_units (struct objfile
*);
1059 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*);
1061 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1063 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1064 struct dwarf2_per_cu_data
*);
1066 static void dwarf2_mark (struct dwarf2_cu
*);
1068 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1070 /* Try to locate the sections we need for DWARF 2 debugging
1071 information and return true if we have enough to do something. */
1074 dwarf2_has_info (struct objfile
*objfile
)
1076 struct dwarf2_per_objfile
*data
;
1078 /* Initialize per-objfile state. */
1079 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1080 memset (data
, 0, sizeof (*data
));
1081 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1082 dwarf2_per_objfile
= data
;
1084 dwarf_info_section
= 0;
1085 dwarf_abbrev_section
= 0;
1086 dwarf_line_section
= 0;
1087 dwarf_str_section
= 0;
1088 dwarf_macinfo_section
= 0;
1089 dwarf_frame_section
= 0;
1090 dwarf_eh_frame_section
= 0;
1091 dwarf_ranges_section
= 0;
1092 dwarf_loc_section
= 0;
1094 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1095 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1098 /* This function is mapped across the sections and remembers the
1099 offset and size of each of the debugging sections we are interested
1103 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
1105 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1107 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1108 dwarf_info_section
= sectp
;
1110 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1112 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1113 dwarf_abbrev_section
= sectp
;
1115 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1117 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1118 dwarf_line_section
= sectp
;
1120 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1122 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1123 dwarf_pubnames_section
= sectp
;
1125 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1127 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1128 dwarf_aranges_section
= sectp
;
1130 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1132 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1133 dwarf_loc_section
= sectp
;
1135 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1137 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1138 dwarf_macinfo_section
= sectp
;
1140 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1142 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1143 dwarf_str_section
= sectp
;
1145 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1147 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1148 dwarf_frame_section
= sectp
;
1150 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1152 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1153 if (aflag
& SEC_HAS_CONTENTS
)
1155 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1156 dwarf_eh_frame_section
= sectp
;
1159 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1161 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1162 dwarf_ranges_section
= sectp
;
1166 /* Build a partial symbol table. */
1169 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1171 /* We definitely need the .debug_info and .debug_abbrev sections */
1173 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1174 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1176 if (dwarf_line_section
)
1177 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1179 dwarf2_per_objfile
->line_buffer
= NULL
;
1181 if (dwarf_str_section
)
1182 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1184 dwarf2_per_objfile
->str_buffer
= NULL
;
1186 if (dwarf_macinfo_section
)
1187 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1188 dwarf_macinfo_section
);
1190 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1192 if (dwarf_ranges_section
)
1193 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1195 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1197 if (dwarf_loc_section
)
1198 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1200 dwarf2_per_objfile
->loc_buffer
= NULL
;
1203 || (objfile
->global_psymbols
.size
== 0
1204 && objfile
->static_psymbols
.size
== 0))
1206 init_psymbol_list (objfile
, 1024);
1210 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1212 /* Things are significantly easier if we have .debug_aranges and
1213 .debug_pubnames sections */
1215 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1219 /* only test this case for now */
1221 /* In this case we have to work a bit harder */
1222 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1227 /* Build the partial symbol table from the information in the
1228 .debug_pubnames and .debug_aranges sections. */
1231 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1233 bfd
*abfd
= objfile
->obfd
;
1234 char *aranges_buffer
, *pubnames_buffer
;
1235 char *aranges_ptr
, *pubnames_ptr
;
1236 unsigned int entry_length
, version
, info_offset
, info_size
;
1238 pubnames_buffer
= dwarf2_read_section (objfile
,
1239 dwarf_pubnames_section
);
1240 pubnames_ptr
= pubnames_buffer
;
1241 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1243 struct comp_unit_head cu_header
;
1246 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1248 pubnames_ptr
+= bytes_read
;
1249 version
= read_1_byte (abfd
, pubnames_ptr
);
1251 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1253 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1257 aranges_buffer
= dwarf2_read_section (objfile
,
1258 dwarf_aranges_section
);
1263 /* Read in the comp unit header information from the debug_info at
1267 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1268 char *info_ptr
, bfd
*abfd
)
1272 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1274 info_ptr
+= bytes_read
;
1275 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1277 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1279 info_ptr
+= bytes_read
;
1280 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1282 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1283 if (signed_addr
< 0)
1284 internal_error (__FILE__
, __LINE__
,
1285 _("read_comp_unit_head: dwarf from non elf file"));
1286 cu_header
->signed_addr_p
= signed_addr
;
1291 partial_read_comp_unit_head (struct comp_unit_head
*header
, char *info_ptr
,
1294 char *beg_of_comp_unit
= info_ptr
;
1296 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1298 if (header
->version
!= 2)
1299 error (_("Dwarf Error: wrong version in compilation unit header "
1300 "(is %d, should be %d) [in module %s]"), header
->version
,
1301 2, bfd_get_filename (abfd
));
1303 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1304 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1305 "(offset 0x%lx + 6) [in module %s]"),
1306 (long) header
->abbrev_offset
,
1307 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1308 bfd_get_filename (abfd
));
1310 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1311 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1312 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1313 "(offset 0x%lx + 0) [in module %s]"),
1314 (long) header
->length
,
1315 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1316 bfd_get_filename (abfd
));
1321 /* Allocate a new partial symtab for file named NAME and mark this new
1322 partial symtab as being an include of PST. */
1325 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1326 struct objfile
*objfile
)
1328 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1330 subpst
->section_offsets
= pst
->section_offsets
;
1331 subpst
->textlow
= 0;
1332 subpst
->texthigh
= 0;
1334 subpst
->dependencies
= (struct partial_symtab
**)
1335 obstack_alloc (&objfile
->objfile_obstack
,
1336 sizeof (struct partial_symtab
*));
1337 subpst
->dependencies
[0] = pst
;
1338 subpst
->number_of_dependencies
= 1;
1340 subpst
->globals_offset
= 0;
1341 subpst
->n_global_syms
= 0;
1342 subpst
->statics_offset
= 0;
1343 subpst
->n_static_syms
= 0;
1344 subpst
->symtab
= NULL
;
1345 subpst
->read_symtab
= pst
->read_symtab
;
1348 /* No private part is necessary for include psymtabs. This property
1349 can be used to differentiate between such include psymtabs and
1350 the regular ones. */
1351 subpst
->read_symtab_private
= NULL
;
1354 /* Read the Line Number Program data and extract the list of files
1355 included by the source file represented by PST. Build an include
1356 partial symtab for each of these included files.
1358 This procedure assumes that there *is* a Line Number Program in
1359 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1360 before calling this procedure. */
1363 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1364 struct partial_die_info
*pdi
,
1365 struct partial_symtab
*pst
)
1367 struct objfile
*objfile
= cu
->objfile
;
1368 bfd
*abfd
= objfile
->obfd
;
1369 struct line_header
*lh
;
1371 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1373 return; /* No linetable, so no includes. */
1375 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1377 free_line_header (lh
);
1381 /* Build the partial symbol table by doing a quick pass through the
1382 .debug_info and .debug_abbrev sections. */
1385 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1387 /* Instead of reading this into a big buffer, we should probably use
1388 mmap() on architectures that support it. (FIXME) */
1389 bfd
*abfd
= objfile
->obfd
;
1391 char *beg_of_comp_unit
;
1392 struct partial_die_info comp_unit_die
;
1393 struct partial_symtab
*pst
;
1394 struct cleanup
*back_to
;
1395 CORE_ADDR lowpc
, highpc
, baseaddr
;
1397 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1399 /* Any cached compilation units will be linked by the per-objfile
1400 read_in_chain. Make sure to free them when we're done. */
1401 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1403 create_all_comp_units (objfile
);
1405 /* Since the objects we're extracting from .debug_info vary in
1406 length, only the individual functions to extract them (like
1407 read_comp_unit_head and load_partial_die) can really know whether
1408 the buffer is large enough to hold another complete object.
1410 At the moment, they don't actually check that. If .debug_info
1411 holds just one extra byte after the last compilation unit's dies,
1412 then read_comp_unit_head will happily read off the end of the
1413 buffer. read_partial_die is similarly casual. Those functions
1416 For this loop condition, simply checking whether there's any data
1417 left at all should be sufficient. */
1418 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1419 + dwarf2_per_objfile
->info_size
))
1421 struct cleanup
*back_to_inner
;
1422 struct dwarf2_cu cu
;
1423 struct abbrev_info
*abbrev
;
1424 unsigned int bytes_read
;
1425 struct dwarf2_per_cu_data
*this_cu
;
1427 beg_of_comp_unit
= info_ptr
;
1429 memset (&cu
, 0, sizeof (cu
));
1431 obstack_init (&cu
.comp_unit_obstack
);
1433 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1435 cu
.objfile
= objfile
;
1436 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1438 /* Complete the cu_header */
1439 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1440 cu
.header
.first_die_ptr
= info_ptr
;
1441 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1443 cu
.list_in_scope
= &file_symbols
;
1445 /* Read the abbrevs for this compilation unit into a table */
1446 dwarf2_read_abbrevs (abfd
, &cu
);
1447 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1449 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1451 /* Read the compilation unit die */
1452 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1453 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1454 abfd
, info_ptr
, &cu
);
1456 /* Set the language we're debugging */
1457 set_cu_language (comp_unit_die
.language
, &cu
);
1459 /* Allocate a new partial symbol table structure */
1460 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1461 comp_unit_die
.name
? comp_unit_die
.name
: "",
1462 comp_unit_die
.lowpc
,
1463 objfile
->global_psymbols
.next
,
1464 objfile
->static_psymbols
.next
);
1466 if (comp_unit_die
.dirname
)
1467 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1469 pst
->read_symtab_private
= (char *) this_cu
;
1471 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1473 /* Store the function that reads in the rest of the symbol table */
1474 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1476 /* If this compilation unit was already read in, free the
1477 cached copy in order to read it in again. This is
1478 necessary because we skipped some symbols when we first
1479 read in the compilation unit (see load_partial_dies).
1480 This problem could be avoided, but the benefit is
1482 if (this_cu
->cu
!= NULL
)
1483 free_one_cached_comp_unit (this_cu
->cu
);
1485 cu
.per_cu
= this_cu
;
1487 /* Note that this is a pointer to our stack frame, being
1488 added to a global data structure. It will be cleaned up
1489 in free_stack_comp_unit when we finish with this
1490 compilation unit. */
1493 this_cu
->psymtab
= pst
;
1495 /* Check if comp unit has_children.
1496 If so, read the rest of the partial symbols from this comp unit.
1497 If not, there's no more debug_info for this comp unit. */
1498 if (comp_unit_die
.has_children
)
1500 struct partial_die_info
*first_die
;
1502 lowpc
= ((CORE_ADDR
) -1);
1503 highpc
= ((CORE_ADDR
) 0);
1505 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1507 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1509 /* If we didn't find a lowpc, set it to highpc to avoid
1510 complaints from `maint check'. */
1511 if (lowpc
== ((CORE_ADDR
) -1))
1514 /* If the compilation unit didn't have an explicit address range,
1515 then use the information extracted from its child dies. */
1516 if (! comp_unit_die
.has_pc_info
)
1518 comp_unit_die
.lowpc
= lowpc
;
1519 comp_unit_die
.highpc
= highpc
;
1522 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1523 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1525 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1526 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1527 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1528 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1529 sort_pst_symbols (pst
);
1531 /* If there is already a psymtab or symtab for a file of this
1532 name, remove it. (If there is a symtab, more drastic things
1533 also happen.) This happens in VxWorks. */
1534 free_named_symtabs (pst
->filename
);
1536 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1537 + cu
.header
.initial_length_size
;
1539 if (comp_unit_die
.has_stmt_list
)
1541 /* Get the list of files included in the current compilation unit,
1542 and build a psymtab for each of them. */
1543 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1546 do_cleanups (back_to_inner
);
1548 do_cleanups (back_to
);
1551 /* Load the DIEs for a secondary CU into memory. */
1554 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1556 bfd
*abfd
= objfile
->obfd
;
1557 char *info_ptr
, *beg_of_comp_unit
;
1558 struct partial_die_info comp_unit_die
;
1559 struct dwarf2_cu
*cu
;
1560 struct abbrev_info
*abbrev
;
1561 unsigned int bytes_read
;
1562 struct cleanup
*back_to
;
1564 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1565 beg_of_comp_unit
= info_ptr
;
1567 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1568 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1570 obstack_init (&cu
->comp_unit_obstack
);
1572 cu
->objfile
= objfile
;
1573 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1575 /* Complete the cu_header. */
1576 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1577 cu
->header
.first_die_ptr
= info_ptr
;
1578 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1580 /* Read the abbrevs for this compilation unit into a table. */
1581 dwarf2_read_abbrevs (abfd
, cu
);
1582 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1584 /* Read the compilation unit die. */
1585 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1586 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1587 abfd
, info_ptr
, cu
);
1589 /* Set the language we're debugging. */
1590 set_cu_language (comp_unit_die
.language
, cu
);
1592 /* Link this compilation unit into the compilation unit tree. */
1594 cu
->per_cu
= this_cu
;
1596 /* Check if comp unit has_children.
1597 If so, read the rest of the partial symbols from this comp unit.
1598 If not, there's no more debug_info for this comp unit. */
1599 if (comp_unit_die
.has_children
)
1600 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1602 do_cleanups (back_to
);
1605 /* Create a list of all compilation units in OBJFILE. We do this only
1606 if an inter-comp-unit reference is found; presumably if there is one,
1607 there will be many, and one will occur early in the .debug_info section.
1608 So there's no point in building this list incrementally. */
1611 create_all_comp_units (struct objfile
*objfile
)
1615 struct dwarf2_per_cu_data
**all_comp_units
;
1616 char *info_ptr
= dwarf2_per_objfile
->info_buffer
;
1620 all_comp_units
= xmalloc (n_allocated
1621 * sizeof (struct dwarf2_per_cu_data
*));
1623 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1625 struct comp_unit_head cu_header
;
1626 char *beg_of_comp_unit
;
1627 struct dwarf2_per_cu_data
*this_cu
;
1628 unsigned long offset
;
1631 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1633 /* Read just enough information to find out where the next
1634 compilation unit is. */
1635 cu_header
.initial_length_size
= 0;
1636 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1637 &cu_header
, &bytes_read
);
1639 /* Save the compilation unit for later lookup. */
1640 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1641 sizeof (struct dwarf2_per_cu_data
));
1642 memset (this_cu
, 0, sizeof (*this_cu
));
1643 this_cu
->offset
= offset
;
1644 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1646 if (n_comp_units
== n_allocated
)
1649 all_comp_units
= xrealloc (all_comp_units
,
1651 * sizeof (struct dwarf2_per_cu_data
*));
1653 all_comp_units
[n_comp_units
++] = this_cu
;
1655 info_ptr
= info_ptr
+ this_cu
->length
;
1658 dwarf2_per_objfile
->all_comp_units
1659 = obstack_alloc (&objfile
->objfile_obstack
,
1660 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1661 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1662 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1663 xfree (all_comp_units
);
1664 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1667 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1668 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1672 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1673 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1675 struct objfile
*objfile
= cu
->objfile
;
1676 bfd
*abfd
= objfile
->obfd
;
1677 struct partial_die_info
*pdi
;
1679 /* Now, march along the PDI's, descending into ones which have
1680 interesting children but skipping the children of the other ones,
1681 until we reach the end of the compilation unit. */
1687 fixup_partial_die (pdi
, cu
);
1689 /* Anonymous namespaces have no name but have interesting
1690 children, so we need to look at them. Ditto for anonymous
1693 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1694 || pdi
->tag
== DW_TAG_enumeration_type
)
1698 case DW_TAG_subprogram
:
1699 if (pdi
->has_pc_info
)
1701 if (pdi
->lowpc
< *lowpc
)
1703 *lowpc
= pdi
->lowpc
;
1705 if (pdi
->highpc
> *highpc
)
1707 *highpc
= pdi
->highpc
;
1709 if (!pdi
->is_declaration
)
1711 add_partial_symbol (pdi
, cu
);
1715 case DW_TAG_variable
:
1716 case DW_TAG_typedef
:
1717 case DW_TAG_union_type
:
1718 if (!pdi
->is_declaration
)
1720 add_partial_symbol (pdi
, cu
);
1723 case DW_TAG_class_type
:
1724 case DW_TAG_structure_type
:
1725 if (!pdi
->is_declaration
)
1727 add_partial_symbol (pdi
, cu
);
1730 case DW_TAG_enumeration_type
:
1731 if (!pdi
->is_declaration
)
1732 add_partial_enumeration (pdi
, cu
);
1734 case DW_TAG_base_type
:
1735 case DW_TAG_subrange_type
:
1736 /* File scope base type definitions are added to the partial
1738 add_partial_symbol (pdi
, cu
);
1740 case DW_TAG_namespace
:
1741 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1748 /* If the die has a sibling, skip to the sibling. */
1750 pdi
= pdi
->die_sibling
;
1754 /* Functions used to compute the fully scoped name of a partial DIE.
1756 Normally, this is simple. For C++, the parent DIE's fully scoped
1757 name is concatenated with "::" and the partial DIE's name. For
1758 Java, the same thing occurs except that "." is used instead of "::".
1759 Enumerators are an exception; they use the scope of their parent
1760 enumeration type, i.e. the name of the enumeration type is not
1761 prepended to the enumerator.
1763 There are two complexities. One is DW_AT_specification; in this
1764 case "parent" means the parent of the target of the specification,
1765 instead of the direct parent of the DIE. The other is compilers
1766 which do not emit DW_TAG_namespace; in this case we try to guess
1767 the fully qualified name of structure types from their members'
1768 linkage names. This must be done using the DIE's children rather
1769 than the children of any DW_AT_specification target. We only need
1770 to do this for structures at the top level, i.e. if the target of
1771 any DW_AT_specification (if any; otherwise the DIE itself) does not
1774 /* Compute the scope prefix associated with PDI's parent, in
1775 compilation unit CU. The result will be allocated on CU's
1776 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1777 field. NULL is returned if no prefix is necessary. */
1779 partial_die_parent_scope (struct partial_die_info
*pdi
,
1780 struct dwarf2_cu
*cu
)
1782 char *grandparent_scope
;
1783 struct partial_die_info
*parent
, *real_pdi
;
1785 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1786 then this means the parent of the specification DIE. */
1789 while (real_pdi
->has_specification
)
1790 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1792 parent
= real_pdi
->die_parent
;
1796 if (parent
->scope_set
)
1797 return parent
->scope
;
1799 fixup_partial_die (parent
, cu
);
1801 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1803 if (parent
->tag
== DW_TAG_namespace
1804 || parent
->tag
== DW_TAG_structure_type
1805 || parent
->tag
== DW_TAG_class_type
1806 || parent
->tag
== DW_TAG_union_type
)
1808 if (grandparent_scope
== NULL
)
1809 parent
->scope
= parent
->name
;
1811 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1814 else if (parent
->tag
== DW_TAG_enumeration_type
)
1815 /* Enumerators should not get the name of the enumeration as a prefix. */
1816 parent
->scope
= grandparent_scope
;
1819 /* FIXME drow/2004-04-01: What should we be doing with
1820 function-local names? For partial symbols, we should probably be
1822 complaint (&symfile_complaints
,
1823 _("unhandled containing DIE tag %d for DIE at %d"),
1824 parent
->tag
, pdi
->offset
);
1825 parent
->scope
= grandparent_scope
;
1828 parent
->scope_set
= 1;
1829 return parent
->scope
;
1832 /* Return the fully scoped name associated with PDI, from compilation unit
1833 CU. The result will be allocated with malloc. */
1835 partial_die_full_name (struct partial_die_info
*pdi
,
1836 struct dwarf2_cu
*cu
)
1840 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1841 if (parent_scope
== NULL
)
1844 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1848 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1850 struct objfile
*objfile
= cu
->objfile
;
1853 const char *my_prefix
;
1854 const struct partial_symbol
*psym
= NULL
;
1856 int built_actual_name
= 0;
1858 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1862 if (pdi_needs_namespace (pdi
->tag
))
1864 actual_name
= partial_die_full_name (pdi
, cu
);
1866 built_actual_name
= 1;
1869 if (actual_name
== NULL
)
1870 actual_name
= pdi
->name
;
1874 case DW_TAG_subprogram
:
1875 if (pdi
->is_external
)
1877 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1878 mst_text, objfile); */
1879 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1880 VAR_DOMAIN
, LOC_BLOCK
,
1881 &objfile
->global_psymbols
,
1882 0, pdi
->lowpc
+ baseaddr
,
1883 cu
->language
, objfile
);
1887 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1888 mst_file_text, objfile); */
1889 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1890 VAR_DOMAIN
, LOC_BLOCK
,
1891 &objfile
->static_psymbols
,
1892 0, pdi
->lowpc
+ baseaddr
,
1893 cu
->language
, objfile
);
1896 case DW_TAG_variable
:
1897 if (pdi
->is_external
)
1900 Don't enter into the minimal symbol tables as there is
1901 a minimal symbol table entry from the ELF symbols already.
1902 Enter into partial symbol table if it has a location
1903 descriptor or a type.
1904 If the location descriptor is missing, new_symbol will create
1905 a LOC_UNRESOLVED symbol, the address of the variable will then
1906 be determined from the minimal symbol table whenever the variable
1908 The address for the partial symbol table entry is not
1909 used by GDB, but it comes in handy for debugging partial symbol
1913 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1914 if (pdi
->locdesc
|| pdi
->has_type
)
1915 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1916 VAR_DOMAIN
, LOC_STATIC
,
1917 &objfile
->global_psymbols
,
1919 cu
->language
, objfile
);
1923 /* Static Variable. Skip symbols without location descriptors. */
1924 if (pdi
->locdesc
== NULL
)
1926 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1927 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1928 mst_file_data, objfile); */
1929 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1930 VAR_DOMAIN
, LOC_STATIC
,
1931 &objfile
->static_psymbols
,
1933 cu
->language
, objfile
);
1936 case DW_TAG_typedef
:
1937 case DW_TAG_base_type
:
1938 case DW_TAG_subrange_type
:
1939 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1940 VAR_DOMAIN
, LOC_TYPEDEF
,
1941 &objfile
->static_psymbols
,
1942 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1944 case DW_TAG_namespace
:
1945 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1946 VAR_DOMAIN
, LOC_TYPEDEF
,
1947 &objfile
->global_psymbols
,
1948 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1950 case DW_TAG_class_type
:
1951 case DW_TAG_structure_type
:
1952 case DW_TAG_union_type
:
1953 case DW_TAG_enumeration_type
:
1954 /* Skip aggregate types without children, these are external
1956 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1957 static vs. global. */
1958 if (pdi
->has_children
== 0)
1960 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1961 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1962 (cu
->language
== language_cplus
1963 || cu
->language
== language_java
)
1964 ? &objfile
->global_psymbols
1965 : &objfile
->static_psymbols
,
1966 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1968 if (cu
->language
== language_cplus
1969 || cu
->language
== language_java
)
1971 /* For C++ and Java, these implicitly act as typedefs as well. */
1972 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1973 VAR_DOMAIN
, LOC_TYPEDEF
,
1974 &objfile
->global_psymbols
,
1975 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1978 case DW_TAG_enumerator
:
1979 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1980 VAR_DOMAIN
, LOC_CONST
,
1981 (cu
->language
== language_cplus
1982 || cu
->language
== language_java
)
1983 ? &objfile
->global_psymbols
1984 : &objfile
->static_psymbols
,
1985 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1991 /* Check to see if we should scan the name for possible namespace
1992 info. Only do this if this is C++, if we don't have namespace
1993 debugging info in the file, if the psym is of an appropriate type
1994 (otherwise we'll have psym == NULL), and if we actually had a
1995 mangled name to begin with. */
1997 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
1998 cases which do not set PSYM above? */
2000 if (cu
->language
== language_cplus
2001 && cu
->has_namespace_info
== 0
2003 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2004 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2007 if (built_actual_name
)
2008 xfree (actual_name
);
2011 /* Determine whether a die of type TAG living in a C++ class or
2012 namespace needs to have the name of the scope prepended to the
2013 name listed in the die. */
2016 pdi_needs_namespace (enum dwarf_tag tag
)
2020 case DW_TAG_namespace
:
2021 case DW_TAG_typedef
:
2022 case DW_TAG_class_type
:
2023 case DW_TAG_structure_type
:
2024 case DW_TAG_union_type
:
2025 case DW_TAG_enumeration_type
:
2026 case DW_TAG_enumerator
:
2033 /* Read a partial die corresponding to a namespace; also, add a symbol
2034 corresponding to that namespace to the symbol table. NAMESPACE is
2035 the name of the enclosing namespace. */
2038 add_partial_namespace (struct partial_die_info
*pdi
,
2039 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2040 struct dwarf2_cu
*cu
)
2042 struct objfile
*objfile
= cu
->objfile
;
2044 /* Add a symbol for the namespace. */
2046 add_partial_symbol (pdi
, cu
);
2048 /* Now scan partial symbols in that namespace. */
2050 if (pdi
->has_children
)
2051 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2054 /* See if we can figure out if the class lives in a namespace. We do
2055 this by looking for a member function; its demangled name will
2056 contain namespace info, if there is any. */
2059 guess_structure_name (struct partial_die_info
*struct_pdi
,
2060 struct dwarf2_cu
*cu
)
2062 if ((cu
->language
== language_cplus
2063 || cu
->language
== language_java
)
2064 && cu
->has_namespace_info
== 0
2065 && struct_pdi
->has_children
)
2067 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2068 what template types look like, because the demangler
2069 frequently doesn't give the same name as the debug info. We
2070 could fix this by only using the demangled name to get the
2071 prefix (but see comment in read_structure_type). */
2073 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2074 struct partial_die_info
*real_pdi
;
2076 /* If this DIE (this DIE's specification, if any) has a parent, then
2077 we should not do this. We'll prepend the parent's fully qualified
2078 name when we create the partial symbol. */
2080 real_pdi
= struct_pdi
;
2081 while (real_pdi
->has_specification
)
2082 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2084 if (real_pdi
->die_parent
!= NULL
)
2087 while (child_pdi
!= NULL
)
2089 if (child_pdi
->tag
== DW_TAG_subprogram
)
2091 char *actual_class_name
2092 = language_class_name_from_physname (cu
->language_defn
,
2094 if (actual_class_name
!= NULL
)
2097 = obsavestring (actual_class_name
,
2098 strlen (actual_class_name
),
2099 &cu
->comp_unit_obstack
);
2100 xfree (actual_class_name
);
2105 child_pdi
= child_pdi
->die_sibling
;
2110 /* Read a partial die corresponding to an enumeration type. */
2113 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2114 struct dwarf2_cu
*cu
)
2116 struct objfile
*objfile
= cu
->objfile
;
2117 bfd
*abfd
= objfile
->obfd
;
2118 struct partial_die_info
*pdi
;
2120 if (enum_pdi
->name
!= NULL
)
2121 add_partial_symbol (enum_pdi
, cu
);
2123 pdi
= enum_pdi
->die_child
;
2126 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2127 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2129 add_partial_symbol (pdi
, cu
);
2130 pdi
= pdi
->die_sibling
;
2134 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2135 Return the corresponding abbrev, or NULL if the number is zero (indicating
2136 an empty DIE). In either case *BYTES_READ will be set to the length of
2137 the initial number. */
2139 static struct abbrev_info
*
2140 peek_die_abbrev (char *info_ptr
, int *bytes_read
, struct dwarf2_cu
*cu
)
2142 bfd
*abfd
= cu
->objfile
->obfd
;
2143 unsigned int abbrev_number
;
2144 struct abbrev_info
*abbrev
;
2146 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2148 if (abbrev_number
== 0)
2151 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2154 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2155 bfd_get_filename (abfd
));
2161 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2162 pointer to the end of a series of DIEs, terminated by an empty
2163 DIE. Any children of the skipped DIEs will also be skipped. */
2166 skip_children (char *info_ptr
, struct dwarf2_cu
*cu
)
2168 struct abbrev_info
*abbrev
;
2169 unsigned int bytes_read
;
2173 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2175 return info_ptr
+ bytes_read
;
2177 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2181 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2182 should point just after the initial uleb128 of a DIE, and the
2183 abbrev corresponding to that skipped uleb128 should be passed in
2184 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2188 skip_one_die (char *info_ptr
, struct abbrev_info
*abbrev
,
2189 struct dwarf2_cu
*cu
)
2191 unsigned int bytes_read
;
2192 struct attribute attr
;
2193 bfd
*abfd
= cu
->objfile
->obfd
;
2194 unsigned int form
, i
;
2196 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2198 /* The only abbrev we care about is DW_AT_sibling. */
2199 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2201 read_attribute (&attr
, &abbrev
->attrs
[i
],
2202 abfd
, info_ptr
, cu
);
2203 if (attr
.form
== DW_FORM_ref_addr
)
2204 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2206 return dwarf2_per_objfile
->info_buffer
2207 + dwarf2_get_ref_die_offset (&attr
, cu
);
2210 /* If it isn't DW_AT_sibling, skip this attribute. */
2211 form
= abbrev
->attrs
[i
].form
;
2216 case DW_FORM_ref_addr
:
2217 info_ptr
+= cu
->header
.addr_size
;
2236 case DW_FORM_string
:
2237 read_string (abfd
, info_ptr
, &bytes_read
);
2238 info_ptr
+= bytes_read
;
2241 info_ptr
+= cu
->header
.offset_size
;
2244 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2245 info_ptr
+= bytes_read
;
2247 case DW_FORM_block1
:
2248 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2250 case DW_FORM_block2
:
2251 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2253 case DW_FORM_block4
:
2254 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2258 case DW_FORM_ref_udata
:
2259 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2261 case DW_FORM_indirect
:
2262 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2263 info_ptr
+= bytes_read
;
2264 /* We need to continue parsing from here, so just go back to
2266 goto skip_attribute
;
2269 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2270 dwarf_form_name (form
),
2271 bfd_get_filename (abfd
));
2275 if (abbrev
->has_children
)
2276 return skip_children (info_ptr
, cu
);
2281 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2282 the next DIE after ORIG_PDI. */
2285 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
2286 bfd
*abfd
, struct dwarf2_cu
*cu
)
2288 /* Do we know the sibling already? */
2290 if (orig_pdi
->sibling
)
2291 return orig_pdi
->sibling
;
2293 /* Are there any children to deal with? */
2295 if (!orig_pdi
->has_children
)
2298 /* Skip the children the long way. */
2300 return skip_children (info_ptr
, cu
);
2303 /* Expand this partial symbol table into a full symbol table. */
2306 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2308 /* FIXME: This is barely more than a stub. */
2313 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2319 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2320 gdb_flush (gdb_stdout
);
2323 /* Restore our global data. */
2324 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2325 dwarf2_objfile_data_key
);
2327 psymtab_to_symtab_1 (pst
);
2329 /* Finish up the debug error message. */
2331 printf_filtered (_("done.\n"));
2336 /* Add PER_CU to the queue. */
2339 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2341 struct dwarf2_queue_item
*item
;
2344 item
= xmalloc (sizeof (*item
));
2345 item
->per_cu
= per_cu
;
2348 if (dwarf2_queue
== NULL
)
2349 dwarf2_queue
= item
;
2351 dwarf2_queue_tail
->next
= item
;
2353 dwarf2_queue_tail
= item
;
2356 /* Process the queue. */
2359 process_queue (struct objfile
*objfile
)
2361 struct dwarf2_queue_item
*item
, *next_item
;
2363 /* Initially, there is just one item on the queue. Load its DIEs,
2364 and the DIEs of any other compilation units it requires,
2367 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2369 /* Read in this compilation unit. This may add new items to
2370 the end of the queue. */
2371 load_full_comp_unit (item
->per_cu
);
2373 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2374 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2376 /* If this compilation unit has already had full symbols created,
2377 reset the TYPE fields in each DIE. */
2378 if (item
->per_cu
->psymtab
->readin
)
2379 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2383 /* Now everything left on the queue needs to be read in. Process
2384 them, one at a time, removing from the queue as we finish. */
2385 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2387 if (!item
->per_cu
->psymtab
->readin
)
2388 process_full_comp_unit (item
->per_cu
);
2390 item
->per_cu
->queued
= 0;
2391 next_item
= item
->next
;
2395 dwarf2_queue_tail
= NULL
;
2398 /* Free all allocated queue entries. This function only releases anything if
2399 an error was thrown; if the queue was processed then it would have been
2400 freed as we went along. */
2403 dwarf2_release_queue (void *dummy
)
2405 struct dwarf2_queue_item
*item
, *last
;
2407 item
= dwarf2_queue
;
2410 /* Anything still marked queued is likely to be in an
2411 inconsistent state, so discard it. */
2412 if (item
->per_cu
->queued
)
2414 if (item
->per_cu
->cu
!= NULL
)
2415 free_one_cached_comp_unit (item
->per_cu
->cu
);
2416 item
->per_cu
->queued
= 0;
2424 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2427 /* Read in full symbols for PST, and anything it depends on. */
2430 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2432 struct dwarf2_per_cu_data
*per_cu
;
2433 struct cleanup
*back_to
;
2436 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2437 if (!pst
->dependencies
[i
]->readin
)
2439 /* Inform about additional files that need to be read in. */
2442 /* FIXME: i18n: Need to make this a single string. */
2443 fputs_filtered (" ", gdb_stdout
);
2445 fputs_filtered ("and ", gdb_stdout
);
2447 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2448 wrap_here (""); /* Flush output */
2449 gdb_flush (gdb_stdout
);
2451 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2454 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2458 /* It's an include file, no symbols to read for it.
2459 Everything is in the parent symtab. */
2464 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2466 queue_comp_unit (per_cu
);
2468 process_queue (pst
->objfile
);
2470 /* Age the cache, releasing compilation units that have not
2471 been used recently. */
2472 age_cached_comp_units ();
2474 do_cleanups (back_to
);
2477 /* Load the DIEs associated with PST and PER_CU into memory. */
2479 static struct dwarf2_cu
*
2480 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2482 struct partial_symtab
*pst
= per_cu
->psymtab
;
2483 bfd
*abfd
= pst
->objfile
->obfd
;
2484 struct dwarf2_cu
*cu
;
2485 unsigned long offset
;
2487 struct cleanup
*back_to
, *free_cu_cleanup
;
2488 struct attribute
*attr
;
2491 /* Set local variables from the partial symbol table info. */
2492 offset
= per_cu
->offset
;
2494 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2496 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2497 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2499 /* If an error occurs while loading, release our storage. */
2500 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2502 cu
->objfile
= pst
->objfile
;
2504 /* read in the comp_unit header */
2505 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2507 /* Read the abbrevs for this compilation unit */
2508 dwarf2_read_abbrevs (abfd
, cu
);
2509 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2511 cu
->header
.offset
= offset
;
2513 cu
->per_cu
= per_cu
;
2516 /* We use this obstack for block values in dwarf_alloc_block. */
2517 obstack_init (&cu
->comp_unit_obstack
);
2519 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2521 /* We try not to read any attributes in this function, because not
2522 all objfiles needed for references have been loaded yet, and symbol
2523 table processing isn't initialized. But we have to set the CU language,
2524 or we won't be able to build types correctly. */
2525 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2527 set_cu_language (DW_UNSND (attr
), cu
);
2529 set_cu_language (language_minimal
, cu
);
2531 do_cleanups (back_to
);
2533 /* We've successfully allocated this compilation unit. Let our caller
2534 clean it up when finished with it. */
2535 discard_cleanups (free_cu_cleanup
);
2540 /* Generate full symbol information for PST and CU, whose DIEs have
2541 already been loaded into memory. */
2544 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2546 struct partial_symtab
*pst
= per_cu
->psymtab
;
2547 struct dwarf2_cu
*cu
= per_cu
->cu
;
2548 struct objfile
*objfile
= pst
->objfile
;
2549 bfd
*abfd
= objfile
->obfd
;
2550 CORE_ADDR lowpc
, highpc
;
2551 struct symtab
*symtab
;
2552 struct cleanup
*back_to
;
2553 struct attribute
*attr
;
2556 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2558 /* We're in the global namespace. */
2559 processing_current_prefix
= "";
2562 back_to
= make_cleanup (really_free_pendings
, NULL
);
2564 cu
->list_in_scope
= &file_symbols
;
2566 /* Find the base address of the compilation unit for range lists and
2567 location lists. It will normally be specified by DW_AT_low_pc.
2568 In DWARF-3 draft 4, the base address could be overridden by
2569 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2570 compilation units with discontinuous ranges. */
2572 cu
->header
.base_known
= 0;
2573 cu
->header
.base_address
= 0;
2575 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2578 cu
->header
.base_address
= DW_ADDR (attr
);
2579 cu
->header
.base_known
= 1;
2583 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2586 cu
->header
.base_address
= DW_ADDR (attr
);
2587 cu
->header
.base_known
= 1;
2591 /* Do line number decoding in read_file_scope () */
2592 process_die (cu
->dies
, cu
);
2594 /* Some compilers don't define a DW_AT_high_pc attribute for the
2595 compilation unit. If the DW_AT_high_pc is missing, synthesize
2596 it, by scanning the DIE's below the compilation unit. */
2597 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2599 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2601 /* Set symtab language to language from DW_AT_language.
2602 If the compilation is from a C file generated by language preprocessors,
2603 do not set the language if it was already deduced by start_subfile. */
2605 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2607 symtab
->language
= cu
->language
;
2609 pst
->symtab
= symtab
;
2612 do_cleanups (back_to
);
2615 /* Process a die and its children. */
2618 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2622 case DW_TAG_padding
:
2624 case DW_TAG_compile_unit
:
2625 read_file_scope (die
, cu
);
2627 case DW_TAG_subprogram
:
2628 read_subroutine_type (die
, cu
);
2629 read_func_scope (die
, cu
);
2631 case DW_TAG_inlined_subroutine
:
2632 /* FIXME: These are ignored for now.
2633 They could be used to set breakpoints on all inlined instances
2634 of a function and make GDB `next' properly over inlined functions. */
2636 case DW_TAG_lexical_block
:
2637 case DW_TAG_try_block
:
2638 case DW_TAG_catch_block
:
2639 read_lexical_block_scope (die
, cu
);
2641 case DW_TAG_class_type
:
2642 case DW_TAG_structure_type
:
2643 case DW_TAG_union_type
:
2644 read_structure_type (die
, cu
);
2645 process_structure_scope (die
, cu
);
2647 case DW_TAG_enumeration_type
:
2648 read_enumeration_type (die
, cu
);
2649 process_enumeration_scope (die
, cu
);
2652 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2653 a symbol or process any children. Therefore it doesn't do anything
2654 that won't be done on-demand by read_type_die. */
2655 case DW_TAG_subroutine_type
:
2656 read_subroutine_type (die
, cu
);
2658 case DW_TAG_array_type
:
2659 read_array_type (die
, cu
);
2661 case DW_TAG_pointer_type
:
2662 read_tag_pointer_type (die
, cu
);
2664 case DW_TAG_ptr_to_member_type
:
2665 read_tag_ptr_to_member_type (die
, cu
);
2667 case DW_TAG_reference_type
:
2668 read_tag_reference_type (die
, cu
);
2670 case DW_TAG_string_type
:
2671 read_tag_string_type (die
, cu
);
2675 case DW_TAG_base_type
:
2676 read_base_type (die
, cu
);
2677 /* Add a typedef symbol for the type definition, if it has a
2679 new_symbol (die
, die
->type
, cu
);
2681 case DW_TAG_subrange_type
:
2682 read_subrange_type (die
, cu
);
2683 /* Add a typedef symbol for the type definition, if it has a
2685 new_symbol (die
, die
->type
, cu
);
2687 case DW_TAG_common_block
:
2688 read_common_block (die
, cu
);
2690 case DW_TAG_common_inclusion
:
2692 case DW_TAG_namespace
:
2693 processing_has_namespace_info
= 1;
2694 read_namespace (die
, cu
);
2696 case DW_TAG_imported_declaration
:
2697 case DW_TAG_imported_module
:
2698 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2699 information contained in these. DW_TAG_imported_declaration
2700 dies shouldn't have children; DW_TAG_imported_module dies
2701 shouldn't in the C++ case, but conceivably could in the
2702 Fortran case, so we'll have to replace this gdb_assert if
2703 Fortran compilers start generating that info. */
2704 processing_has_namespace_info
= 1;
2705 gdb_assert (die
->child
== NULL
);
2708 new_symbol (die
, NULL
, cu
);
2714 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2716 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2720 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2722 struct objfile
*objfile
= cu
->objfile
;
2723 struct comp_unit_head
*cu_header
= &cu
->header
;
2724 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2725 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2726 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2727 struct attribute
*attr
;
2728 char *name
= "<unknown>";
2729 char *comp_dir
= NULL
;
2730 struct die_info
*child_die
;
2731 bfd
*abfd
= objfile
->obfd
;
2732 struct line_header
*line_header
= 0;
2735 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2737 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2739 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2740 from finish_block. */
2741 if (lowpc
== ((CORE_ADDR
) -1))
2746 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2749 name
= DW_STRING (attr
);
2751 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2754 comp_dir
= DW_STRING (attr
);
2757 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2758 directory, get rid of it. */
2759 char *cp
= strchr (comp_dir
, ':');
2761 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2766 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2769 set_cu_language (DW_UNSND (attr
), cu
);
2772 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2774 cu
->producer
= DW_STRING (attr
);
2776 /* We assume that we're processing GCC output. */
2777 processing_gcc_compilation
= 2;
2779 /* FIXME:Do something here. */
2780 if (dip
->at_producer
!= NULL
)
2782 handle_producer (dip
->at_producer
);
2786 /* The compilation unit may be in a different language or objfile,
2787 zero out all remembered fundamental types. */
2788 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2790 start_symtab (name
, comp_dir
, lowpc
);
2791 record_debugformat ("DWARF 2");
2793 initialize_cu_func_list (cu
);
2795 /* Process all dies in compilation unit. */
2796 if (die
->child
!= NULL
)
2798 child_die
= die
->child
;
2799 while (child_die
&& child_die
->tag
)
2801 process_die (child_die
, cu
);
2802 child_die
= sibling_die (child_die
);
2806 /* Decode line number information if present. */
2807 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2810 unsigned int line_offset
= DW_UNSND (attr
);
2811 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2814 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2815 (void *) line_header
);
2816 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2820 /* Decode macro information, if present. Dwarf 2 macro information
2821 refers to information in the line number info statement program
2822 header, so we can only read it if we've read the header
2824 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2825 if (attr
&& line_header
)
2827 unsigned int macro_offset
= DW_UNSND (attr
);
2828 dwarf_decode_macros (line_header
, macro_offset
,
2829 comp_dir
, abfd
, cu
);
2831 do_cleanups (back_to
);
2835 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2836 struct dwarf2_cu
*cu
)
2838 struct function_range
*thisfn
;
2840 thisfn
= (struct function_range
*)
2841 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2842 thisfn
->name
= name
;
2843 thisfn
->lowpc
= lowpc
;
2844 thisfn
->highpc
= highpc
;
2845 thisfn
->seen_line
= 0;
2846 thisfn
->next
= NULL
;
2848 if (cu
->last_fn
== NULL
)
2849 cu
->first_fn
= thisfn
;
2851 cu
->last_fn
->next
= thisfn
;
2853 cu
->last_fn
= thisfn
;
2857 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2859 struct objfile
*objfile
= cu
->objfile
;
2860 struct context_stack
*new;
2863 struct die_info
*child_die
;
2864 struct attribute
*attr
;
2866 const char *previous_prefix
= processing_current_prefix
;
2867 struct cleanup
*back_to
= NULL
;
2870 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2872 name
= dwarf2_linkage_name (die
, cu
);
2874 /* Ignore functions with missing or empty names and functions with
2875 missing or invalid low and high pc attributes. */
2876 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2879 if (cu
->language
== language_cplus
2880 || cu
->language
== language_java
)
2882 struct die_info
*spec_die
= die_specification (die
, cu
);
2884 /* NOTE: carlton/2004-01-23: We have to be careful in the
2885 presence of DW_AT_specification. For example, with GCC 3.4,
2890 // Definition of N::foo.
2894 then we'll have a tree of DIEs like this:
2896 1: DW_TAG_compile_unit
2897 2: DW_TAG_namespace // N
2898 3: DW_TAG_subprogram // declaration of N::foo
2899 4: DW_TAG_subprogram // definition of N::foo
2900 DW_AT_specification // refers to die #3
2902 Thus, when processing die #4, we have to pretend that we're
2903 in the context of its DW_AT_specification, namely the contex
2906 if (spec_die
!= NULL
)
2908 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2909 processing_current_prefix
= specification_prefix
;
2910 back_to
= make_cleanup (xfree
, specification_prefix
);
2917 /* Record the function range for dwarf_decode_lines. */
2918 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2920 new = push_context (0, lowpc
);
2921 new->name
= new_symbol (die
, die
->type
, cu
);
2923 /* If there is a location expression for DW_AT_frame_base, record
2925 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2927 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2928 expression is being recorded directly in the function's symbol
2929 and not in a separate frame-base object. I guess this hack is
2930 to avoid adding some sort of frame-base adjunct/annex to the
2931 function's symbol :-(. The problem with doing this is that it
2932 results in a function symbol with a location expression that
2933 has nothing to do with the location of the function, ouch! The
2934 relationship should be: a function's symbol has-a frame base; a
2935 frame-base has-a location expression. */
2936 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2938 cu
->list_in_scope
= &local_symbols
;
2940 if (die
->child
!= NULL
)
2942 child_die
= die
->child
;
2943 while (child_die
&& child_die
->tag
)
2945 process_die (child_die
, cu
);
2946 child_die
= sibling_die (child_die
);
2950 new = pop_context ();
2951 /* Make a block for the local symbols within. */
2952 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2953 lowpc
, highpc
, objfile
);
2955 /* In C++, we can have functions nested inside functions (e.g., when
2956 a function declares a class that has methods). This means that
2957 when we finish processing a function scope, we may need to go
2958 back to building a containing block's symbol lists. */
2959 local_symbols
= new->locals
;
2960 param_symbols
= new->params
;
2962 /* If we've finished processing a top-level function, subsequent
2963 symbols go in the file symbol list. */
2964 if (outermost_context_p ())
2965 cu
->list_in_scope
= &file_symbols
;
2967 processing_current_prefix
= previous_prefix
;
2968 if (back_to
!= NULL
)
2969 do_cleanups (back_to
);
2972 /* Process all the DIES contained within a lexical block scope. Start
2973 a new scope, process the dies, and then close the scope. */
2976 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2978 struct objfile
*objfile
= cu
->objfile
;
2979 struct context_stack
*new;
2980 CORE_ADDR lowpc
, highpc
;
2981 struct die_info
*child_die
;
2984 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2986 /* Ignore blocks with missing or invalid low and high pc attributes. */
2987 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2988 as multiple lexical blocks? Handling children in a sane way would
2989 be nasty. Might be easier to properly extend generic blocks to
2991 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2996 push_context (0, lowpc
);
2997 if (die
->child
!= NULL
)
2999 child_die
= die
->child
;
3000 while (child_die
&& child_die
->tag
)
3002 process_die (child_die
, cu
);
3003 child_die
= sibling_die (child_die
);
3006 new = pop_context ();
3008 if (local_symbols
!= NULL
)
3010 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3013 local_symbols
= new->locals
;
3016 /* Get low and high pc attributes from a die. Return 1 if the attributes
3017 are present and valid, otherwise, return 0. Return -1 if the range is
3018 discontinuous, i.e. derived from DW_AT_ranges information. */
3020 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3021 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3023 struct objfile
*objfile
= cu
->objfile
;
3024 struct comp_unit_head
*cu_header
= &cu
->header
;
3025 struct attribute
*attr
;
3026 bfd
*obfd
= objfile
->obfd
;
3031 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3034 high
= DW_ADDR (attr
);
3035 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3037 low
= DW_ADDR (attr
);
3039 /* Found high w/o low attribute. */
3042 /* Found consecutive range of addresses. */
3047 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3050 unsigned int addr_size
= cu_header
->addr_size
;
3051 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3052 /* Value of the DW_AT_ranges attribute is the offset in the
3053 .debug_ranges section. */
3054 unsigned int offset
= DW_UNSND (attr
);
3055 /* Base address selection entry. */
3063 found_base
= cu_header
->base_known
;
3064 base
= cu_header
->base_address
;
3066 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3068 complaint (&symfile_complaints
,
3069 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3073 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3075 /* Read in the largest possible address. */
3076 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3077 if ((marker
& mask
) == mask
)
3079 /* If we found the largest possible address, then
3080 read the base address. */
3081 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3082 buffer
+= 2 * addr_size
;
3083 offset
+= 2 * addr_size
;
3091 CORE_ADDR range_beginning
, range_end
;
3093 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3094 buffer
+= addr_size
;
3095 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3096 buffer
+= addr_size
;
3097 offset
+= 2 * addr_size
;
3099 /* An end of list marker is a pair of zero addresses. */
3100 if (range_beginning
== 0 && range_end
== 0)
3101 /* Found the end of list entry. */
3104 /* Each base address selection entry is a pair of 2 values.
3105 The first is the largest possible address, the second is
3106 the base address. Check for a base address here. */
3107 if ((range_beginning
& mask
) == mask
)
3109 /* If we found the largest possible address, then
3110 read the base address. */
3111 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3118 /* We have no valid base address for the ranges
3120 complaint (&symfile_complaints
,
3121 _("Invalid .debug_ranges data (no base address)"));
3125 range_beginning
+= base
;
3128 /* FIXME: This is recording everything as a low-high
3129 segment of consecutive addresses. We should have a
3130 data structure for discontiguous block ranges
3134 low
= range_beginning
;
3140 if (range_beginning
< low
)
3141 low
= range_beginning
;
3142 if (range_end
> high
)
3148 /* If the first entry is an end-of-list marker, the range
3149 describes an empty scope, i.e. no instructions. */
3159 /* When using the GNU linker, .gnu.linkonce. sections are used to
3160 eliminate duplicate copies of functions and vtables and such.
3161 The linker will arbitrarily choose one and discard the others.
3162 The AT_*_pc values for such functions refer to local labels in
3163 these sections. If the section from that file was discarded, the
3164 labels are not in the output, so the relocs get a value of 0.
3165 If this is a discarded function, mark the pc bounds as invalid,
3166 so that GDB will ignore it. */
3167 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
3175 /* Get the low and high pc's represented by the scope DIE, and store
3176 them in *LOWPC and *HIGHPC. If the correct values can't be
3177 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3180 get_scope_pc_bounds (struct die_info
*die
,
3181 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3182 struct dwarf2_cu
*cu
)
3184 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3185 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3186 CORE_ADDR current_low
, current_high
;
3188 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3190 best_low
= current_low
;
3191 best_high
= current_high
;
3195 struct die_info
*child
= die
->child
;
3197 while (child
&& child
->tag
)
3199 switch (child
->tag
) {
3200 case DW_TAG_subprogram
:
3201 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3203 best_low
= min (best_low
, current_low
);
3204 best_high
= max (best_high
, current_high
);
3207 case DW_TAG_namespace
:
3208 /* FIXME: carlton/2004-01-16: Should we do this for
3209 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3210 that current GCC's always emit the DIEs corresponding
3211 to definitions of methods of classes as children of a
3212 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3213 the DIEs giving the declarations, which could be
3214 anywhere). But I don't see any reason why the
3215 standards says that they have to be there. */
3216 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3218 if (current_low
!= ((CORE_ADDR
) -1))
3220 best_low
= min (best_low
, current_low
);
3221 best_high
= max (best_high
, current_high
);
3229 child
= sibling_die (child
);
3234 *highpc
= best_high
;
3237 /* Add an aggregate field to the field list. */
3240 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3241 struct dwarf2_cu
*cu
)
3243 struct objfile
*objfile
= cu
->objfile
;
3244 struct nextfield
*new_field
;
3245 struct attribute
*attr
;
3247 char *fieldname
= "";
3249 /* Allocate a new field list entry and link it in. */
3250 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3251 make_cleanup (xfree
, new_field
);
3252 memset (new_field
, 0, sizeof (struct nextfield
));
3253 new_field
->next
= fip
->fields
;
3254 fip
->fields
= new_field
;
3257 /* Handle accessibility and virtuality of field.
3258 The default accessibility for members is public, the default
3259 accessibility for inheritance is private. */
3260 if (die
->tag
!= DW_TAG_inheritance
)
3261 new_field
->accessibility
= DW_ACCESS_public
;
3263 new_field
->accessibility
= DW_ACCESS_private
;
3264 new_field
->virtuality
= DW_VIRTUALITY_none
;
3266 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3268 new_field
->accessibility
= DW_UNSND (attr
);
3269 if (new_field
->accessibility
!= DW_ACCESS_public
)
3270 fip
->non_public_fields
= 1;
3271 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3273 new_field
->virtuality
= DW_UNSND (attr
);
3275 fp
= &new_field
->field
;
3277 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3279 /* Data member other than a C++ static data member. */
3281 /* Get type of field. */
3282 fp
->type
= die_type (die
, cu
);
3284 FIELD_STATIC_KIND (*fp
) = 0;
3286 /* Get bit size of field (zero if none). */
3287 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3290 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3294 FIELD_BITSIZE (*fp
) = 0;
3297 /* Get bit offset of field. */
3298 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3301 FIELD_BITPOS (*fp
) =
3302 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3305 FIELD_BITPOS (*fp
) = 0;
3306 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3309 if (BITS_BIG_ENDIAN
)
3311 /* For big endian bits, the DW_AT_bit_offset gives the
3312 additional bit offset from the MSB of the containing
3313 anonymous object to the MSB of the field. We don't
3314 have to do anything special since we don't need to
3315 know the size of the anonymous object. */
3316 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3320 /* For little endian bits, compute the bit offset to the
3321 MSB of the anonymous object, subtract off the number of
3322 bits from the MSB of the field to the MSB of the
3323 object, and then subtract off the number of bits of
3324 the field itself. The result is the bit offset of
3325 the LSB of the field. */
3327 int bit_offset
= DW_UNSND (attr
);
3329 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3332 /* The size of the anonymous object containing
3333 the bit field is explicit, so use the
3334 indicated size (in bytes). */
3335 anonymous_size
= DW_UNSND (attr
);
3339 /* The size of the anonymous object containing
3340 the bit field must be inferred from the type
3341 attribute of the data member containing the
3343 anonymous_size
= TYPE_LENGTH (fp
->type
);
3345 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3346 - bit_offset
- FIELD_BITSIZE (*fp
);
3350 /* Get name of field. */
3351 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3352 if (attr
&& DW_STRING (attr
))
3353 fieldname
= DW_STRING (attr
);
3355 /* The name is already allocated along with this objfile, so we don't
3356 need to duplicate it for the type. */
3357 fp
->name
= fieldname
;
3359 /* Change accessibility for artificial fields (e.g. virtual table
3360 pointer or virtual base class pointer) to private. */
3361 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3363 new_field
->accessibility
= DW_ACCESS_private
;
3364 fip
->non_public_fields
= 1;
3367 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3369 /* C++ static member. */
3371 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3372 is a declaration, but all versions of G++ as of this writing
3373 (so through at least 3.2.1) incorrectly generate
3374 DW_TAG_variable tags. */
3378 /* Get name of field. */
3379 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3380 if (attr
&& DW_STRING (attr
))
3381 fieldname
= DW_STRING (attr
);
3385 /* Get physical name. */
3386 physname
= dwarf2_linkage_name (die
, cu
);
3388 /* The name is already allocated along with this objfile, so we don't
3389 need to duplicate it for the type. */
3390 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3391 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3392 FIELD_NAME (*fp
) = fieldname
;
3394 else if (die
->tag
== DW_TAG_inheritance
)
3396 /* C++ base class field. */
3397 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3399 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3401 FIELD_BITSIZE (*fp
) = 0;
3402 FIELD_STATIC_KIND (*fp
) = 0;
3403 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3404 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3405 fip
->nbaseclasses
++;
3409 /* Create the vector of fields, and attach it to the type. */
3412 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3413 struct dwarf2_cu
*cu
)
3415 int nfields
= fip
->nfields
;
3417 /* Record the field count, allocate space for the array of fields,
3418 and create blank accessibility bitfields if necessary. */
3419 TYPE_NFIELDS (type
) = nfields
;
3420 TYPE_FIELDS (type
) = (struct field
*)
3421 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3422 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3424 if (fip
->non_public_fields
)
3426 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3428 TYPE_FIELD_PRIVATE_BITS (type
) =
3429 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3430 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3432 TYPE_FIELD_PROTECTED_BITS (type
) =
3433 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3434 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3436 TYPE_FIELD_IGNORE_BITS (type
) =
3437 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3438 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3441 /* If the type has baseclasses, allocate and clear a bit vector for
3442 TYPE_FIELD_VIRTUAL_BITS. */
3443 if (fip
->nbaseclasses
)
3445 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3448 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3449 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3450 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3451 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3452 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3455 /* Copy the saved-up fields into the field vector. Start from the head
3456 of the list, adding to the tail of the field array, so that they end
3457 up in the same order in the array in which they were added to the list. */
3458 while (nfields
-- > 0)
3460 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3461 switch (fip
->fields
->accessibility
)
3463 case DW_ACCESS_private
:
3464 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3467 case DW_ACCESS_protected
:
3468 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3471 case DW_ACCESS_public
:
3475 /* Unknown accessibility. Complain and treat it as public. */
3477 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3478 fip
->fields
->accessibility
);
3482 if (nfields
< fip
->nbaseclasses
)
3484 switch (fip
->fields
->virtuality
)
3486 case DW_VIRTUALITY_virtual
:
3487 case DW_VIRTUALITY_pure_virtual
:
3488 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3492 fip
->fields
= fip
->fields
->next
;
3496 /* Add a member function to the proper fieldlist. */
3499 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3500 struct type
*type
, struct dwarf2_cu
*cu
)
3502 struct objfile
*objfile
= cu
->objfile
;
3503 struct attribute
*attr
;
3504 struct fnfieldlist
*flp
;
3506 struct fn_field
*fnp
;
3509 struct nextfnfield
*new_fnfield
;
3511 /* Get name of member function. */
3512 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3513 if (attr
&& DW_STRING (attr
))
3514 fieldname
= DW_STRING (attr
);
3518 /* Get the mangled name. */
3519 physname
= dwarf2_linkage_name (die
, cu
);
3521 /* Look up member function name in fieldlist. */
3522 for (i
= 0; i
< fip
->nfnfields
; i
++)
3524 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3528 /* Create new list element if necessary. */
3529 if (i
< fip
->nfnfields
)
3530 flp
= &fip
->fnfieldlists
[i
];
3533 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3535 fip
->fnfieldlists
= (struct fnfieldlist
*)
3536 xrealloc (fip
->fnfieldlists
,
3537 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3538 * sizeof (struct fnfieldlist
));
3539 if (fip
->nfnfields
== 0)
3540 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3542 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3543 flp
->name
= fieldname
;
3549 /* Create a new member function field and chain it to the field list
3551 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3552 make_cleanup (xfree
, new_fnfield
);
3553 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3554 new_fnfield
->next
= flp
->head
;
3555 flp
->head
= new_fnfield
;
3558 /* Fill in the member function field info. */
3559 fnp
= &new_fnfield
->fnfield
;
3560 /* The name is already allocated along with this objfile, so we don't
3561 need to duplicate it for the type. */
3562 fnp
->physname
= physname
? physname
: "";
3563 fnp
->type
= alloc_type (objfile
);
3564 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3566 int nparams
= TYPE_NFIELDS (die
->type
);
3568 /* TYPE is the domain of this method, and DIE->TYPE is the type
3569 of the method itself (TYPE_CODE_METHOD). */
3570 smash_to_method_type (fnp
->type
, type
,
3571 TYPE_TARGET_TYPE (die
->type
),
3572 TYPE_FIELDS (die
->type
),
3573 TYPE_NFIELDS (die
->type
),
3574 TYPE_VARARGS (die
->type
));
3576 /* Handle static member functions.
3577 Dwarf2 has no clean way to discern C++ static and non-static
3578 member functions. G++ helps GDB by marking the first
3579 parameter for non-static member functions (which is the
3580 this pointer) as artificial. We obtain this information
3581 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3582 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3583 fnp
->voffset
= VOFFSET_STATIC
;
3586 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3589 /* Get fcontext from DW_AT_containing_type if present. */
3590 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3591 fnp
->fcontext
= die_containing_type (die
, cu
);
3593 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3594 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3596 /* Get accessibility. */
3597 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3600 switch (DW_UNSND (attr
))
3602 case DW_ACCESS_private
:
3603 fnp
->is_private
= 1;
3605 case DW_ACCESS_protected
:
3606 fnp
->is_protected
= 1;
3611 /* Check for artificial methods. */
3612 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3613 if (attr
&& DW_UNSND (attr
) != 0)
3614 fnp
->is_artificial
= 1;
3616 /* Get index in virtual function table if it is a virtual member function. */
3617 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3620 /* Support the .debug_loc offsets */
3621 if (attr_form_is_block (attr
))
3623 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3625 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3627 dwarf2_complex_location_expr_complaint ();
3631 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3637 /* Create the vector of member function fields, and attach it to the type. */
3640 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3641 struct dwarf2_cu
*cu
)
3643 struct fnfieldlist
*flp
;
3644 int total_length
= 0;
3647 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3648 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3649 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3651 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3653 struct nextfnfield
*nfp
= flp
->head
;
3654 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3657 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3658 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3659 fn_flp
->fn_fields
= (struct fn_field
*)
3660 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3661 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3662 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3664 total_length
+= flp
->length
;
3667 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3668 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3672 /* Returns non-zero if NAME is the name of a vtable member in CU's
3673 language, zero otherwise. */
3675 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3677 static const char vptr
[] = "_vptr";
3678 static const char vtable
[] = "vtable";
3680 /* Look for the C++ and Java forms of the vtable. */
3681 if ((cu
->language
== language_java
3682 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3683 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3684 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3691 /* Called when we find the DIE that starts a structure or union scope
3692 (definition) to process all dies that define the members of the
3695 NOTE: we need to call struct_type regardless of whether or not the
3696 DIE has an at_name attribute, since it might be an anonymous
3697 structure or union. This gets the type entered into our set of
3700 However, if the structure is incomplete (an opaque struct/union)
3701 then suppress creating a symbol table entry for it since gdb only
3702 wants to find the one with the complete definition. Note that if
3703 it is complete, we just call new_symbol, which does it's own
3704 checking about whether the struct/union is anonymous or not (and
3705 suppresses creating a symbol table entry itself). */
3708 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3710 struct objfile
*objfile
= cu
->objfile
;
3712 struct attribute
*attr
;
3713 const char *previous_prefix
= processing_current_prefix
;
3714 struct cleanup
*back_to
= NULL
;
3719 type
= alloc_type (objfile
);
3721 INIT_CPLUS_SPECIFIC (type
);
3722 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3723 if (attr
&& DW_STRING (attr
))
3725 if (cu
->language
== language_cplus
3726 || cu
->language
== language_java
)
3728 char *new_prefix
= determine_class_name (die
, cu
);
3729 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3730 strlen (new_prefix
),
3731 &objfile
->objfile_obstack
);
3732 back_to
= make_cleanup (xfree
, new_prefix
);
3733 processing_current_prefix
= new_prefix
;
3737 /* The name is already allocated along with this objfile, so
3738 we don't need to duplicate it for the type. */
3739 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3743 if (die
->tag
== DW_TAG_structure_type
)
3745 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3747 else if (die
->tag
== DW_TAG_union_type
)
3749 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3753 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3755 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3758 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3761 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3765 TYPE_LENGTH (type
) = 0;
3768 if (die_is_declaration (die
, cu
))
3769 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3771 /* We need to add the type field to the die immediately so we don't
3772 infinitely recurse when dealing with pointers to the structure
3773 type within the structure itself. */
3774 set_die_type (die
, type
, cu
);
3776 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3778 struct field_info fi
;
3779 struct die_info
*child_die
;
3780 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3782 memset (&fi
, 0, sizeof (struct field_info
));
3784 child_die
= die
->child
;
3786 while (child_die
&& child_die
->tag
)
3788 if (child_die
->tag
== DW_TAG_member
3789 || child_die
->tag
== DW_TAG_variable
)
3791 /* NOTE: carlton/2002-11-05: A C++ static data member
3792 should be a DW_TAG_member that is a declaration, but
3793 all versions of G++ as of this writing (so through at
3794 least 3.2.1) incorrectly generate DW_TAG_variable
3795 tags for them instead. */
3796 dwarf2_add_field (&fi
, child_die
, cu
);
3798 else if (child_die
->tag
== DW_TAG_subprogram
)
3800 /* C++ member function. */
3801 read_type_die (child_die
, cu
);
3802 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3804 else if (child_die
->tag
== DW_TAG_inheritance
)
3806 /* C++ base class field. */
3807 dwarf2_add_field (&fi
, child_die
, cu
);
3809 child_die
= sibling_die (child_die
);
3812 /* Attach fields and member functions to the type. */
3814 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3817 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3819 /* Get the type which refers to the base class (possibly this
3820 class itself) which contains the vtable pointer for the current
3821 class from the DW_AT_containing_type attribute. */
3823 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3825 struct type
*t
= die_containing_type (die
, cu
);
3827 TYPE_VPTR_BASETYPE (type
) = t
;
3832 /* Our own class provides vtbl ptr. */
3833 for (i
= TYPE_NFIELDS (t
) - 1;
3834 i
>= TYPE_N_BASECLASSES (t
);
3837 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3839 if (is_vtable_name (fieldname
, cu
))
3841 TYPE_VPTR_FIELDNO (type
) = i
;
3846 /* Complain if virtual function table field not found. */
3847 if (i
< TYPE_N_BASECLASSES (t
))
3848 complaint (&symfile_complaints
,
3849 _("virtual function table pointer not found when defining class '%s'"),
3850 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3855 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3858 else if (cu
->producer
3859 && strncmp (cu
->producer
,
3860 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3862 /* The IBM XLC compiler does not provide direct indication
3863 of the containing type, but the vtable pointer is
3864 always named __vfp. */
3868 for (i
= TYPE_NFIELDS (type
) - 1;
3869 i
>= TYPE_N_BASECLASSES (type
);
3872 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3874 TYPE_VPTR_FIELDNO (type
) = i
;
3875 TYPE_VPTR_BASETYPE (type
) = type
;
3882 do_cleanups (back_to
);
3885 processing_current_prefix
= previous_prefix
;
3886 if (back_to
!= NULL
)
3887 do_cleanups (back_to
);
3891 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3893 struct objfile
*objfile
= cu
->objfile
;
3894 const char *previous_prefix
= processing_current_prefix
;
3895 struct die_info
*child_die
= die
->child
;
3897 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3898 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3900 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3901 snapshots) has been known to create a die giving a declaration
3902 for a class that has, as a child, a die giving a definition for a
3903 nested class. So we have to process our children even if the
3904 current die is a declaration. Normally, of course, a declaration
3905 won't have any children at all. */
3907 while (child_die
!= NULL
&& child_die
->tag
)
3909 if (child_die
->tag
== DW_TAG_member
3910 || child_die
->tag
== DW_TAG_variable
3911 || child_die
->tag
== DW_TAG_inheritance
)
3916 process_die (child_die
, cu
);
3918 child_die
= sibling_die (child_die
);
3921 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3922 new_symbol (die
, die
->type
, cu
);
3924 processing_current_prefix
= previous_prefix
;
3927 /* Given a DW_AT_enumeration_type die, set its type. We do not
3928 complete the type's fields yet, or create any symbols. */
3931 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3933 struct objfile
*objfile
= cu
->objfile
;
3935 struct attribute
*attr
;
3940 type
= alloc_type (objfile
);
3942 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3943 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3944 if (attr
&& DW_STRING (attr
))
3946 char *name
= DW_STRING (attr
);
3948 if (processing_has_namespace_info
)
3950 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
3951 processing_current_prefix
,
3956 /* The name is already allocated along with this objfile, so
3957 we don't need to duplicate it for the type. */
3958 TYPE_TAG_NAME (type
) = name
;
3962 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3965 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3969 TYPE_LENGTH (type
) = 0;
3972 set_die_type (die
, type
, cu
);
3975 /* Determine the name of the type represented by DIE, which should be
3976 a named C++ or Java compound type. Return the name in question; the caller
3977 is responsible for xfree()'ing it. */
3980 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3982 struct cleanup
*back_to
= NULL
;
3983 struct die_info
*spec_die
= die_specification (die
, cu
);
3984 char *new_prefix
= NULL
;
3986 /* If this is the definition of a class that is declared by another
3987 die, then processing_current_prefix may not be accurate; see
3988 read_func_scope for a similar example. */
3989 if (spec_die
!= NULL
)
3991 char *specification_prefix
= determine_prefix (spec_die
, cu
);
3992 processing_current_prefix
= specification_prefix
;
3993 back_to
= make_cleanup (xfree
, specification_prefix
);
3996 /* If we don't have namespace debug info, guess the name by trying
3997 to demangle the names of members, just like we did in
3998 guess_structure_name. */
3999 if (!processing_has_namespace_info
)
4001 struct die_info
*child
;
4003 for (child
= die
->child
;
4004 child
!= NULL
&& child
->tag
!= 0;
4005 child
= sibling_die (child
))
4007 if (child
->tag
== DW_TAG_subprogram
)
4010 = language_class_name_from_physname (cu
->language_defn
,
4014 if (new_prefix
!= NULL
)
4020 if (new_prefix
== NULL
)
4022 const char *name
= dwarf2_name (die
, cu
);
4023 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4024 name
? name
: "<<anonymous>>",
4028 if (back_to
!= NULL
)
4029 do_cleanups (back_to
);
4034 /* Given a pointer to a die which begins an enumeration, process all
4035 the dies that define the members of the enumeration, and create the
4036 symbol for the enumeration type.
4038 NOTE: We reverse the order of the element list. */
4041 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4043 struct objfile
*objfile
= cu
->objfile
;
4044 struct die_info
*child_die
;
4045 struct field
*fields
;
4046 struct attribute
*attr
;
4049 int unsigned_enum
= 1;
4053 if (die
->child
!= NULL
)
4055 child_die
= die
->child
;
4056 while (child_die
&& child_die
->tag
)
4058 if (child_die
->tag
!= DW_TAG_enumerator
)
4060 process_die (child_die
, cu
);
4064 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4067 sym
= new_symbol (child_die
, die
->type
, cu
);
4068 if (SYMBOL_VALUE (sym
) < 0)
4071 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4073 fields
= (struct field
*)
4075 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4076 * sizeof (struct field
));
4079 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4080 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4081 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4082 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4083 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4089 child_die
= sibling_die (child_die
);
4094 TYPE_NFIELDS (die
->type
) = num_fields
;
4095 TYPE_FIELDS (die
->type
) = (struct field
*)
4096 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4097 memcpy (TYPE_FIELDS (die
->type
), fields
,
4098 sizeof (struct field
) * num_fields
);
4102 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4105 new_symbol (die
, die
->type
, cu
);
4108 /* Extract all information from a DW_TAG_array_type DIE and put it in
4109 the DIE's type field. For now, this only handles one dimensional
4113 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4115 struct objfile
*objfile
= cu
->objfile
;
4116 struct die_info
*child_die
;
4117 struct type
*type
= NULL
;
4118 struct type
*element_type
, *range_type
, *index_type
;
4119 struct type
**range_types
= NULL
;
4120 struct attribute
*attr
;
4122 struct cleanup
*back_to
;
4124 /* Return if we've already decoded this type. */
4130 element_type
= die_type (die
, cu
);
4132 /* Irix 6.2 native cc creates array types without children for
4133 arrays with unspecified length. */
4134 if (die
->child
== NULL
)
4136 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4137 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4138 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4143 back_to
= make_cleanup (null_cleanup
, NULL
);
4144 child_die
= die
->child
;
4145 while (child_die
&& child_die
->tag
)
4147 if (child_die
->tag
== DW_TAG_subrange_type
)
4149 read_subrange_type (child_die
, cu
);
4151 if (child_die
->type
!= NULL
)
4153 /* The range type was succesfully read. Save it for
4154 the array type creation. */
4155 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4157 range_types
= (struct type
**)
4158 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4159 * sizeof (struct type
*));
4161 make_cleanup (free_current_contents
, &range_types
);
4163 range_types
[ndim
++] = child_die
->type
;
4166 child_die
= sibling_die (child_die
);
4169 /* Dwarf2 dimensions are output from left to right, create the
4170 necessary array types in backwards order. */
4172 type
= element_type
;
4174 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4178 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4183 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4186 /* Understand Dwarf2 support for vector types (like they occur on
4187 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4188 array type. This is not part of the Dwarf2/3 standard yet, but a
4189 custom vendor extension. The main difference between a regular
4190 array and the vector variant is that vectors are passed by value
4192 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4194 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4196 do_cleanups (back_to
);
4198 /* Install the type in the die. */
4199 set_die_type (die
, type
, cu
);
4202 static enum dwarf_array_dim_ordering
4203 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4205 struct attribute
*attr
;
4207 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4209 if (attr
) return DW_SND (attr
);
4212 GNU F77 is a special case, as at 08/2004 array type info is the
4213 opposite order to the dwarf2 specification, but data is still
4214 laid out as per normal fortran.
4216 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4220 if (cu
->language
== language_fortran
&&
4221 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4223 return DW_ORD_row_major
;
4226 switch (cu
->language_defn
->la_array_ordering
)
4228 case array_column_major
:
4229 return DW_ORD_col_major
;
4230 case array_row_major
:
4232 return DW_ORD_row_major
;
4237 /* First cut: install each common block member as a global variable. */
4240 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4242 struct die_info
*child_die
;
4243 struct attribute
*attr
;
4245 CORE_ADDR base
= (CORE_ADDR
) 0;
4247 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4250 /* Support the .debug_loc offsets */
4251 if (attr_form_is_block (attr
))
4253 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4255 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4257 dwarf2_complex_location_expr_complaint ();
4261 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4262 "common block member");
4265 if (die
->child
!= NULL
)
4267 child_die
= die
->child
;
4268 while (child_die
&& child_die
->tag
)
4270 sym
= new_symbol (child_die
, NULL
, cu
);
4271 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4274 SYMBOL_VALUE_ADDRESS (sym
) =
4275 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4276 add_symbol_to_list (sym
, &global_symbols
);
4278 child_die
= sibling_die (child_die
);
4283 /* Read a C++ namespace. */
4286 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4288 struct objfile
*objfile
= cu
->objfile
;
4289 const char *previous_prefix
= processing_current_prefix
;
4292 struct die_info
*current_die
;
4293 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4295 name
= namespace_name (die
, &is_anonymous
, cu
);
4297 /* Now build the name of the current namespace. */
4299 if (previous_prefix
[0] == '\0')
4301 processing_current_prefix
= name
;
4305 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4306 make_cleanup (xfree
, temp_name
);
4307 processing_current_prefix
= temp_name
;
4310 /* Add a symbol associated to this if we haven't seen the namespace
4311 before. Also, add a using directive if it's an anonymous
4314 if (dwarf2_extension (die
, cu
) == NULL
)
4318 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4319 this cast will hopefully become unnecessary. */
4320 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4321 (char *) processing_current_prefix
,
4323 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4325 new_symbol (die
, type
, cu
);
4326 set_die_type (die
, type
, cu
);
4329 cp_add_using_directive (processing_current_prefix
,
4330 strlen (previous_prefix
),
4331 strlen (processing_current_prefix
));
4334 if (die
->child
!= NULL
)
4336 struct die_info
*child_die
= die
->child
;
4338 while (child_die
&& child_die
->tag
)
4340 process_die (child_die
, cu
);
4341 child_die
= sibling_die (child_die
);
4345 processing_current_prefix
= previous_prefix
;
4346 do_cleanups (back_to
);
4349 /* Return the name of the namespace represented by DIE. Set
4350 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4354 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4356 struct die_info
*current_die
;
4357 const char *name
= NULL
;
4359 /* Loop through the extensions until we find a name. */
4361 for (current_die
= die
;
4362 current_die
!= NULL
;
4363 current_die
= dwarf2_extension (die
, cu
))
4365 name
= dwarf2_name (current_die
, cu
);
4370 /* Is it an anonymous namespace? */
4372 *is_anonymous
= (name
== NULL
);
4374 name
= "(anonymous namespace)";
4379 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4380 the user defined type vector. */
4383 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4385 struct comp_unit_head
*cu_header
= &cu
->header
;
4387 struct attribute
*attr_byte_size
;
4388 struct attribute
*attr_address_class
;
4389 int byte_size
, addr_class
;
4396 type
= lookup_pointer_type (die_type (die
, cu
));
4398 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4400 byte_size
= DW_UNSND (attr_byte_size
);
4402 byte_size
= cu_header
->addr_size
;
4404 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4405 if (attr_address_class
)
4406 addr_class
= DW_UNSND (attr_address_class
);
4408 addr_class
= DW_ADDR_none
;
4410 /* If the pointer size or address class is different than the
4411 default, create a type variant marked as such and set the
4412 length accordingly. */
4413 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4415 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4419 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4420 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4421 type
= make_type_with_address_space (type
, type_flags
);
4423 else if (TYPE_LENGTH (type
) != byte_size
)
4425 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4428 /* Should we also complain about unhandled address classes? */
4432 TYPE_LENGTH (type
) = byte_size
;
4433 set_die_type (die
, type
, cu
);
4436 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4437 the user defined type vector. */
4440 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4442 struct objfile
*objfile
= cu
->objfile
;
4444 struct type
*to_type
;
4445 struct type
*domain
;
4452 type
= alloc_type (objfile
);
4453 to_type
= die_type (die
, cu
);
4454 domain
= die_containing_type (die
, cu
);
4455 smash_to_member_type (type
, domain
, to_type
);
4457 set_die_type (die
, type
, cu
);
4460 /* Extract all information from a DW_TAG_reference_type DIE and add to
4461 the user defined type vector. */
4464 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4466 struct comp_unit_head
*cu_header
= &cu
->header
;
4468 struct attribute
*attr
;
4475 type
= lookup_reference_type (die_type (die
, cu
));
4476 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4479 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4483 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4485 set_die_type (die
, type
, cu
);
4489 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4491 struct type
*base_type
;
4498 base_type
= die_type (die
, cu
);
4499 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4504 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4506 struct type
*base_type
;
4513 base_type
= die_type (die
, cu
);
4514 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4518 /* Extract all information from a DW_TAG_string_type DIE and add to
4519 the user defined type vector. It isn't really a user defined type,
4520 but it behaves like one, with other DIE's using an AT_user_def_type
4521 attribute to reference it. */
4524 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4526 struct objfile
*objfile
= cu
->objfile
;
4527 struct type
*type
, *range_type
, *index_type
, *char_type
;
4528 struct attribute
*attr
;
4529 unsigned int length
;
4536 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4539 length
= DW_UNSND (attr
);
4543 /* check for the DW_AT_byte_size attribute */
4544 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4547 length
= DW_UNSND (attr
);
4554 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4555 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4556 if (cu
->language
== language_fortran
)
4558 /* Need to create a unique string type for bounds
4560 type
= create_string_type (0, range_type
);
4564 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4565 type
= create_string_type (char_type
, range_type
);
4567 set_die_type (die
, type
, cu
);
4570 /* Handle DIES due to C code like:
4574 int (*funcp)(int a, long l);
4578 ('funcp' generates a DW_TAG_subroutine_type DIE)
4582 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4584 struct type
*type
; /* Type that this function returns */
4585 struct type
*ftype
; /* Function that returns above type */
4586 struct attribute
*attr
;
4588 /* Decode the type that this subroutine returns */
4593 type
= die_type (die
, cu
);
4594 ftype
= make_function_type (type
, (struct type
**) 0);
4596 /* All functions in C++ and Java have prototypes. */
4597 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4598 if ((attr
&& (DW_UNSND (attr
) != 0))
4599 || cu
->language
== language_cplus
4600 || cu
->language
== language_java
)
4601 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4603 if (die
->child
!= NULL
)
4605 struct die_info
*child_die
;
4609 /* Count the number of parameters.
4610 FIXME: GDB currently ignores vararg functions, but knows about
4611 vararg member functions. */
4612 child_die
= die
->child
;
4613 while (child_die
&& child_die
->tag
)
4615 if (child_die
->tag
== DW_TAG_formal_parameter
)
4617 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4618 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4619 child_die
= sibling_die (child_die
);
4622 /* Allocate storage for parameters and fill them in. */
4623 TYPE_NFIELDS (ftype
) = nparams
;
4624 TYPE_FIELDS (ftype
) = (struct field
*)
4625 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
4627 child_die
= die
->child
;
4628 while (child_die
&& child_die
->tag
)
4630 if (child_die
->tag
== DW_TAG_formal_parameter
)
4632 /* Dwarf2 has no clean way to discern C++ static and non-static
4633 member functions. G++ helps GDB by marking the first
4634 parameter for non-static member functions (which is the
4635 this pointer) as artificial. We pass this information
4636 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4637 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4639 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4641 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4642 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4645 child_die
= sibling_die (child_die
);
4649 set_die_type (die
, ftype
, cu
);
4653 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4655 struct objfile
*objfile
= cu
->objfile
;
4656 struct attribute
*attr
;
4661 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4662 if (attr
&& DW_STRING (attr
))
4664 name
= DW_STRING (attr
);
4666 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4667 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4669 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4673 /* Find a representation of a given base type and install
4674 it in the TYPE field of the die. */
4677 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4679 struct objfile
*objfile
= cu
->objfile
;
4681 struct attribute
*attr
;
4682 int encoding
= 0, size
= 0;
4684 /* If we've already decoded this die, this is a no-op. */
4690 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4693 encoding
= DW_UNSND (attr
);
4695 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4698 size
= DW_UNSND (attr
);
4700 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4701 if (attr
&& DW_STRING (attr
))
4703 enum type_code code
= TYPE_CODE_INT
;
4708 case DW_ATE_address
:
4709 /* Turn DW_ATE_address into a void * pointer. */
4710 code
= TYPE_CODE_PTR
;
4711 type_flags
|= TYPE_FLAG_UNSIGNED
;
4713 case DW_ATE_boolean
:
4714 code
= TYPE_CODE_BOOL
;
4715 type_flags
|= TYPE_FLAG_UNSIGNED
;
4717 case DW_ATE_complex_float
:
4718 code
= TYPE_CODE_COMPLEX
;
4721 code
= TYPE_CODE_FLT
;
4724 case DW_ATE_signed_char
:
4726 case DW_ATE_unsigned
:
4727 case DW_ATE_unsigned_char
:
4728 type_flags
|= TYPE_FLAG_UNSIGNED
;
4731 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4732 dwarf_type_encoding_name (encoding
));
4735 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4736 if (encoding
== DW_ATE_address
)
4737 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4739 else if (encoding
== DW_ATE_complex_float
)
4742 TYPE_TARGET_TYPE (type
)
4743 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4744 else if (size
== 16)
4745 TYPE_TARGET_TYPE (type
)
4746 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4748 TYPE_TARGET_TYPE (type
)
4749 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4754 type
= dwarf_base_type (encoding
, size
, cu
);
4756 set_die_type (die
, type
, cu
);
4759 /* Read the given DW_AT_subrange DIE. */
4762 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4764 struct type
*base_type
;
4765 struct type
*range_type
;
4766 struct attribute
*attr
;
4770 /* If we have already decoded this die, then nothing more to do. */
4774 base_type
= die_type (die
, cu
);
4775 if (base_type
== NULL
)
4777 complaint (&symfile_complaints
,
4778 _("DW_AT_type missing from DW_TAG_subrange_type"));
4782 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4783 base_type
= alloc_type (NULL
);
4785 if (cu
->language
== language_fortran
)
4787 /* FORTRAN implies a lower bound of 1, if not given. */
4791 /* FIXME: For variable sized arrays either of these could be
4792 a variable rather than a constant value. We'll allow it,
4793 but we don't know how to handle it. */
4794 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4796 low
= dwarf2_get_attr_constant_value (attr
, 0);
4798 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4801 if (attr
->form
== DW_FORM_block1
)
4803 /* GCC encodes arrays with unspecified or dynamic length
4804 with a DW_FORM_block1 attribute.
4805 FIXME: GDB does not yet know how to handle dynamic
4806 arrays properly, treat them as arrays with unspecified
4809 FIXME: jimb/2003-09-22: GDB does not really know
4810 how to handle arrays of unspecified length
4811 either; we just represent them as zero-length
4812 arrays. Choose an appropriate upper bound given
4813 the lower bound we've computed above. */
4817 high
= dwarf2_get_attr_constant_value (attr
, 1);
4820 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4822 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4823 if (attr
&& DW_STRING (attr
))
4824 TYPE_NAME (range_type
) = DW_STRING (attr
);
4826 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4828 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4830 set_die_type (die
, range_type
, cu
);
4834 /* Read a whole compilation unit into a linked list of dies. */
4836 static struct die_info
*
4837 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4839 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4842 /* Read a single die and all its descendents. Set the die's sibling
4843 field to NULL; set other fields in the die correctly, and set all
4844 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4845 location of the info_ptr after reading all of those dies. PARENT
4846 is the parent of the die in question. */
4848 static struct die_info
*
4849 read_die_and_children (char *info_ptr
, bfd
*abfd
,
4850 struct dwarf2_cu
*cu
,
4851 char **new_info_ptr
,
4852 struct die_info
*parent
)
4854 struct die_info
*die
;
4858 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4859 store_in_ref_table (die
->offset
, die
, cu
);
4863 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4869 *new_info_ptr
= cur_ptr
;
4872 die
->sibling
= NULL
;
4873 die
->parent
= parent
;
4877 /* Read a die, all of its descendents, and all of its siblings; set
4878 all of the fields of all of the dies correctly. Arguments are as
4879 in read_die_and_children. */
4881 static struct die_info
*
4882 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
4883 struct dwarf2_cu
*cu
,
4884 char **new_info_ptr
,
4885 struct die_info
*parent
)
4887 struct die_info
*first_die
, *last_sibling
;
4891 first_die
= last_sibling
= NULL
;
4895 struct die_info
*die
4896 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4904 last_sibling
->sibling
= die
;
4909 *new_info_ptr
= cur_ptr
;
4919 /* Free a linked list of dies. */
4922 free_die_list (struct die_info
*dies
)
4924 struct die_info
*die
, *next
;
4929 if (die
->child
!= NULL
)
4930 free_die_list (die
->child
);
4931 next
= die
->sibling
;
4938 /* Read the contents of the section at OFFSET and of size SIZE from the
4939 object file specified by OBJFILE into the objfile_obstack and return it. */
4942 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4944 bfd
*abfd
= objfile
->obfd
;
4946 bfd_size_type size
= bfd_get_section_size (sectp
);
4951 buf
= (char *) obstack_alloc (&objfile
->objfile_obstack
, size
);
4953 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
4957 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4958 || bfd_bread (buf
, size
, abfd
) != size
)
4959 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
4960 bfd_get_filename (abfd
));
4965 /* In DWARF version 2, the description of the debugging information is
4966 stored in a separate .debug_abbrev section. Before we read any
4967 dies from a section we read in all abbreviations and install them
4968 in a hash table. This function also sets flags in CU describing
4969 the data found in the abbrev table. */
4972 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4974 struct comp_unit_head
*cu_header
= &cu
->header
;
4976 struct abbrev_info
*cur_abbrev
;
4977 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4978 unsigned int abbrev_form
, hash_number
;
4979 struct attr_abbrev
*cur_attrs
;
4980 unsigned int allocated_attrs
;
4982 /* Initialize dwarf2 abbrevs */
4983 obstack_init (&cu
->abbrev_obstack
);
4984 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
4986 * sizeof (struct abbrev_info
*)));
4987 memset (cu
->dwarf2_abbrevs
, 0,
4988 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
4990 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
4991 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4992 abbrev_ptr
+= bytes_read
;
4994 allocated_attrs
= ATTR_ALLOC_CHUNK
;
4995 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
4997 /* loop until we reach an abbrev number of 0 */
4998 while (abbrev_number
)
5000 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5002 /* read in abbrev header */
5003 cur_abbrev
->number
= abbrev_number
;
5004 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5005 abbrev_ptr
+= bytes_read
;
5006 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5009 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5010 cu
->has_namespace_info
= 1;
5012 /* now read in declarations */
5013 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5014 abbrev_ptr
+= bytes_read
;
5015 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5016 abbrev_ptr
+= bytes_read
;
5019 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5021 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5023 = xrealloc (cur_attrs
, (allocated_attrs
5024 * sizeof (struct attr_abbrev
)));
5027 /* Record whether this compilation unit might have
5028 inter-compilation-unit references. If we don't know what form
5029 this attribute will have, then it might potentially be a
5030 DW_FORM_ref_addr, so we conservatively expect inter-CU
5033 if (abbrev_form
== DW_FORM_ref_addr
5034 || abbrev_form
== DW_FORM_indirect
)
5035 cu
->has_form_ref_addr
= 1;
5037 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5038 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5039 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5040 abbrev_ptr
+= bytes_read
;
5041 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5042 abbrev_ptr
+= bytes_read
;
5045 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5046 (cur_abbrev
->num_attrs
5047 * sizeof (struct attr_abbrev
)));
5048 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5049 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5051 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5052 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5053 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5055 /* Get next abbreviation.
5056 Under Irix6 the abbreviations for a compilation unit are not
5057 always properly terminated with an abbrev number of 0.
5058 Exit loop if we encounter an abbreviation which we have
5059 already read (which means we are about to read the abbreviations
5060 for the next compile unit) or if the end of the abbreviation
5061 table is reached. */
5062 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5063 >= dwarf2_per_objfile
->abbrev_size
)
5065 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5066 abbrev_ptr
+= bytes_read
;
5067 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5074 /* Release the memory used by the abbrev table for a compilation unit. */
5077 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5079 struct dwarf2_cu
*cu
= ptr_to_cu
;
5081 obstack_free (&cu
->abbrev_obstack
, NULL
);
5082 cu
->dwarf2_abbrevs
= NULL
;
5085 /* Lookup an abbrev_info structure in the abbrev hash table. */
5087 static struct abbrev_info
*
5088 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5090 unsigned int hash_number
;
5091 struct abbrev_info
*abbrev
;
5093 hash_number
= number
% ABBREV_HASH_SIZE
;
5094 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5098 if (abbrev
->number
== number
)
5101 abbrev
= abbrev
->next
;
5106 /* Returns nonzero if TAG represents a type that we might generate a partial
5110 is_type_tag_for_partial (int tag
)
5115 /* Some types that would be reasonable to generate partial symbols for,
5116 that we don't at present. */
5117 case DW_TAG_array_type
:
5118 case DW_TAG_file_type
:
5119 case DW_TAG_ptr_to_member_type
:
5120 case DW_TAG_set_type
:
5121 case DW_TAG_string_type
:
5122 case DW_TAG_subroutine_type
:
5124 case DW_TAG_base_type
:
5125 case DW_TAG_class_type
:
5126 case DW_TAG_enumeration_type
:
5127 case DW_TAG_structure_type
:
5128 case DW_TAG_subrange_type
:
5129 case DW_TAG_typedef
:
5130 case DW_TAG_union_type
:
5137 /* Load all DIEs that are interesting for partial symbols into memory. */
5139 static struct partial_die_info
*
5140 load_partial_dies (bfd
*abfd
, char *info_ptr
, int building_psymtab
,
5141 struct dwarf2_cu
*cu
)
5143 struct partial_die_info
*part_die
;
5144 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5145 struct abbrev_info
*abbrev
;
5146 unsigned int bytes_read
;
5148 int nesting_level
= 1;
5154 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5158 &cu
->comp_unit_obstack
,
5159 hashtab_obstack_allocate
,
5160 dummy_obstack_deallocate
);
5162 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5163 sizeof (struct partial_die_info
));
5167 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5169 /* A NULL abbrev means the end of a series of children. */
5172 if (--nesting_level
== 0)
5174 /* PART_DIE was probably the last thing allocated on the
5175 comp_unit_obstack, so we could call obstack_free
5176 here. We don't do that because the waste is small,
5177 and will be cleaned up when we're done with this
5178 compilation unit. This way, we're also more robust
5179 against other users of the comp_unit_obstack. */
5182 info_ptr
+= bytes_read
;
5183 last_die
= parent_die
;
5184 parent_die
= parent_die
->die_parent
;
5188 /* Check whether this DIE is interesting enough to save. */
5189 if (!is_type_tag_for_partial (abbrev
->tag
)
5190 && abbrev
->tag
!= DW_TAG_enumerator
5191 && abbrev
->tag
!= DW_TAG_subprogram
5192 && abbrev
->tag
!= DW_TAG_variable
5193 && abbrev
->tag
!= DW_TAG_namespace
)
5195 /* Otherwise we skip to the next sibling, if any. */
5196 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5200 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5201 abfd
, info_ptr
, cu
);
5203 /* This two-pass algorithm for processing partial symbols has a
5204 high cost in cache pressure. Thus, handle some simple cases
5205 here which cover the majority of C partial symbols. DIEs
5206 which neither have specification tags in them, nor could have
5207 specification tags elsewhere pointing at them, can simply be
5208 processed and discarded.
5210 This segment is also optional; scan_partial_symbols and
5211 add_partial_symbol will handle these DIEs if we chain
5212 them in normally. When compilers which do not emit large
5213 quantities of duplicate debug information are more common,
5214 this code can probably be removed. */
5216 /* Any complete simple types at the top level (pretty much all
5217 of them, for a language without namespaces), can be processed
5219 if (parent_die
== NULL
5220 && part_die
->has_specification
== 0
5221 && part_die
->is_declaration
== 0
5222 && (part_die
->tag
== DW_TAG_typedef
5223 || part_die
->tag
== DW_TAG_base_type
5224 || part_die
->tag
== DW_TAG_subrange_type
))
5226 if (building_psymtab
&& part_die
->name
!= NULL
)
5227 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5228 VAR_DOMAIN
, LOC_TYPEDEF
,
5229 &cu
->objfile
->static_psymbols
,
5230 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5231 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5235 /* If we're at the second level, and we're an enumerator, and
5236 our parent has no specification (meaning possibly lives in a
5237 namespace elsewhere), then we can add the partial symbol now
5238 instead of queueing it. */
5239 if (part_die
->tag
== DW_TAG_enumerator
5240 && parent_die
!= NULL
5241 && parent_die
->die_parent
== NULL
5242 && parent_die
->tag
== DW_TAG_enumeration_type
5243 && parent_die
->has_specification
== 0)
5245 if (part_die
->name
== NULL
)
5246 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5247 else if (building_psymtab
)
5248 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5249 VAR_DOMAIN
, LOC_CONST
,
5250 (cu
->language
== language_cplus
5251 || cu
->language
== language_java
)
5252 ? &cu
->objfile
->global_psymbols
5253 : &cu
->objfile
->static_psymbols
,
5254 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5256 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5260 /* We'll save this DIE so link it in. */
5261 part_die
->die_parent
= parent_die
;
5262 part_die
->die_sibling
= NULL
;
5263 part_die
->die_child
= NULL
;
5265 if (last_die
&& last_die
== parent_die
)
5266 last_die
->die_child
= part_die
;
5268 last_die
->die_sibling
= part_die
;
5270 last_die
= part_die
;
5272 if (first_die
== NULL
)
5273 first_die
= part_die
;
5275 /* Maybe add the DIE to the hash table. Not all DIEs that we
5276 find interesting need to be in the hash table, because we
5277 also have the parent/sibling/child chains; only those that we
5278 might refer to by offset later during partial symbol reading.
5280 For now this means things that might have be the target of a
5281 DW_AT_specification, DW_AT_abstract_origin, or
5282 DW_AT_extension. DW_AT_extension will refer only to
5283 namespaces; DW_AT_abstract_origin refers to functions (and
5284 many things under the function DIE, but we do not recurse
5285 into function DIEs during partial symbol reading) and
5286 possibly variables as well; DW_AT_specification refers to
5287 declarations. Declarations ought to have the DW_AT_declaration
5288 flag. It happens that GCC forgets to put it in sometimes, but
5289 only for functions, not for types.
5291 Adding more things than necessary to the hash table is harmless
5292 except for the performance cost. Adding too few will result in
5293 internal errors in find_partial_die. */
5295 if (abbrev
->tag
== DW_TAG_subprogram
5296 || abbrev
->tag
== DW_TAG_variable
5297 || abbrev
->tag
== DW_TAG_namespace
5298 || part_die
->is_declaration
)
5302 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5303 part_die
->offset
, INSERT
);
5307 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5308 sizeof (struct partial_die_info
));
5310 /* For some DIEs we want to follow their children (if any). For C
5311 we have no reason to follow the children of structures; for other
5312 languages we have to, both so that we can get at method physnames
5313 to infer fully qualified class names, and for DW_AT_specification. */
5314 if (last_die
->has_children
5315 && (last_die
->tag
== DW_TAG_namespace
5316 || last_die
->tag
== DW_TAG_enumeration_type
5317 || (cu
->language
!= language_c
5318 && (last_die
->tag
== DW_TAG_class_type
5319 || last_die
->tag
== DW_TAG_structure_type
5320 || last_die
->tag
== DW_TAG_union_type
))))
5323 parent_die
= last_die
;
5327 /* Otherwise we skip to the next sibling, if any. */
5328 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5330 /* Back to the top, do it again. */
5334 /* Read a minimal amount of information into the minimal die structure. */
5337 read_partial_die (struct partial_die_info
*part_die
,
5338 struct abbrev_info
*abbrev
,
5339 unsigned int abbrev_len
, bfd
*abfd
,
5340 char *info_ptr
, struct dwarf2_cu
*cu
)
5342 unsigned int bytes_read
, i
;
5343 struct attribute attr
;
5344 int has_low_pc_attr
= 0;
5345 int has_high_pc_attr
= 0;
5347 memset (part_die
, 0, sizeof (struct partial_die_info
));
5349 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5351 info_ptr
+= abbrev_len
;
5356 part_die
->tag
= abbrev
->tag
;
5357 part_die
->has_children
= abbrev
->has_children
;
5359 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5361 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5363 /* Store the data if it is of an attribute we want to keep in a
5364 partial symbol table. */
5369 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5370 if (part_die
->name
== NULL
)
5371 part_die
->name
= DW_STRING (&attr
);
5373 case DW_AT_comp_dir
:
5374 if (part_die
->dirname
== NULL
)
5375 part_die
->dirname
= DW_STRING (&attr
);
5377 case DW_AT_MIPS_linkage_name
:
5378 part_die
->name
= DW_STRING (&attr
);
5381 has_low_pc_attr
= 1;
5382 part_die
->lowpc
= DW_ADDR (&attr
);
5385 has_high_pc_attr
= 1;
5386 part_die
->highpc
= DW_ADDR (&attr
);
5388 case DW_AT_location
:
5389 /* Support the .debug_loc offsets */
5390 if (attr_form_is_block (&attr
))
5392 part_die
->locdesc
= DW_BLOCK (&attr
);
5394 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5396 dwarf2_complex_location_expr_complaint ();
5400 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5401 "partial symbol information");
5404 case DW_AT_language
:
5405 part_die
->language
= DW_UNSND (&attr
);
5407 case DW_AT_external
:
5408 part_die
->is_external
= DW_UNSND (&attr
);
5410 case DW_AT_declaration
:
5411 part_die
->is_declaration
= DW_UNSND (&attr
);
5414 part_die
->has_type
= 1;
5416 case DW_AT_abstract_origin
:
5417 case DW_AT_specification
:
5418 case DW_AT_extension
:
5419 part_die
->has_specification
= 1;
5420 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5423 /* Ignore absolute siblings, they might point outside of
5424 the current compile unit. */
5425 if (attr
.form
== DW_FORM_ref_addr
)
5426 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5428 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5429 + dwarf2_get_ref_die_offset (&attr
, cu
);
5431 case DW_AT_stmt_list
:
5432 part_die
->has_stmt_list
= 1;
5433 part_die
->line_offset
= DW_UNSND (&attr
);
5440 /* When using the GNU linker, .gnu.linkonce. sections are used to
5441 eliminate duplicate copies of functions and vtables and such.
5442 The linker will arbitrarily choose one and discard the others.
5443 The AT_*_pc values for such functions refer to local labels in
5444 these sections. If the section from that file was discarded, the
5445 labels are not in the output, so the relocs get a value of 0.
5446 If this is a discarded function, mark the pc bounds as invalid,
5447 so that GDB will ignore it. */
5448 if (has_low_pc_attr
&& has_high_pc_attr
5449 && part_die
->lowpc
< part_die
->highpc
5450 && (part_die
->lowpc
!= 0
5451 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5452 part_die
->has_pc_info
= 1;
5456 /* Find a cached partial DIE at OFFSET in CU. */
5458 static struct partial_die_info
*
5459 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5461 struct partial_die_info
*lookup_die
= NULL
;
5462 struct partial_die_info part_die
;
5464 part_die
.offset
= offset
;
5465 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5467 if (lookup_die
== NULL
)
5468 internal_error (__FILE__
, __LINE__
,
5469 _("could not find partial DIE in cache\n"));
5474 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5476 static struct partial_die_info
*
5477 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5479 struct dwarf2_per_cu_data
*per_cu
;
5481 if (offset
>= cu
->header
.offset
5482 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5483 return find_partial_die_in_comp_unit (offset
, cu
);
5485 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5487 if (per_cu
->cu
== NULL
)
5489 load_comp_unit (per_cu
, cu
->objfile
);
5490 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5491 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5494 per_cu
->cu
->last_used
= 0;
5495 return find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5498 /* Adjust PART_DIE before generating a symbol for it. This function
5499 may set the is_external flag or change the DIE's name. */
5502 fixup_partial_die (struct partial_die_info
*part_die
,
5503 struct dwarf2_cu
*cu
)
5505 /* If we found a reference attribute and the DIE has no name, try
5506 to find a name in the referred to DIE. */
5508 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5510 struct partial_die_info
*spec_die
;
5512 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5514 fixup_partial_die (spec_die
, cu
);
5518 part_die
->name
= spec_die
->name
;
5520 /* Copy DW_AT_external attribute if it is set. */
5521 if (spec_die
->is_external
)
5522 part_die
->is_external
= spec_die
->is_external
;
5526 /* Set default names for some unnamed DIEs. */
5527 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5528 || part_die
->tag
== DW_TAG_class_type
))
5529 part_die
->name
= "(anonymous class)";
5531 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5532 part_die
->name
= "(anonymous namespace)";
5534 if (part_die
->tag
== DW_TAG_structure_type
5535 || part_die
->tag
== DW_TAG_class_type
5536 || part_die
->tag
== DW_TAG_union_type
)
5537 guess_structure_name (part_die
, cu
);
5540 /* Read the die from the .debug_info section buffer. Set DIEP to
5541 point to a newly allocated die with its information, except for its
5542 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5543 whether the die has children or not. */
5546 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
5547 struct dwarf2_cu
*cu
, int *has_children
)
5549 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5550 struct abbrev_info
*abbrev
;
5551 struct die_info
*die
;
5553 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5554 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5555 info_ptr
+= bytes_read
;
5558 die
= dwarf_alloc_die ();
5560 die
->abbrev
= abbrev_number
;
5567 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5570 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5572 bfd_get_filename (abfd
));
5574 die
= dwarf_alloc_die ();
5575 die
->offset
= offset
;
5576 die
->tag
= abbrev
->tag
;
5577 die
->abbrev
= abbrev_number
;
5580 die
->num_attrs
= abbrev
->num_attrs
;
5581 die
->attrs
= (struct attribute
*)
5582 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5584 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5586 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5587 abfd
, info_ptr
, cu
);
5589 /* If this attribute is an absolute reference to a different
5590 compilation unit, make sure that compilation unit is loaded
5592 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5593 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5594 || (DW_ADDR (&die
->attrs
[i
])
5595 >= cu
->header
.offset
+ cu
->header
.length
)))
5597 struct dwarf2_per_cu_data
*per_cu
;
5598 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5601 /* Mark the dependence relation so that we don't flush PER_CU
5603 dwarf2_add_dependence (cu
, per_cu
);
5605 /* If it's already on the queue, we have nothing to do. */
5609 /* If the compilation unit is already loaded, just mark it as
5611 if (per_cu
->cu
!= NULL
)
5613 per_cu
->cu
->last_used
= 0;
5617 /* Add it to the queue. */
5618 queue_comp_unit (per_cu
);
5623 *has_children
= abbrev
->has_children
;
5627 /* Read an attribute value described by an attribute form. */
5630 read_attribute_value (struct attribute
*attr
, unsigned form
,
5631 bfd
*abfd
, char *info_ptr
,
5632 struct dwarf2_cu
*cu
)
5634 struct comp_unit_head
*cu_header
= &cu
->header
;
5635 unsigned int bytes_read
;
5636 struct dwarf_block
*blk
;
5642 case DW_FORM_ref_addr
:
5643 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5644 info_ptr
+= bytes_read
;
5646 case DW_FORM_block2
:
5647 blk
= dwarf_alloc_block (cu
);
5648 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5650 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5651 info_ptr
+= blk
->size
;
5652 DW_BLOCK (attr
) = blk
;
5654 case DW_FORM_block4
:
5655 blk
= dwarf_alloc_block (cu
);
5656 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5658 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5659 info_ptr
+= blk
->size
;
5660 DW_BLOCK (attr
) = blk
;
5663 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5667 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5671 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5674 case DW_FORM_string
:
5675 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5676 info_ptr
+= bytes_read
;
5679 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5681 info_ptr
+= bytes_read
;
5684 blk
= dwarf_alloc_block (cu
);
5685 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5686 info_ptr
+= bytes_read
;
5687 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5688 info_ptr
+= blk
->size
;
5689 DW_BLOCK (attr
) = blk
;
5691 case DW_FORM_block1
:
5692 blk
= dwarf_alloc_block (cu
);
5693 blk
->size
= read_1_byte (abfd
, info_ptr
);
5695 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5696 info_ptr
+= blk
->size
;
5697 DW_BLOCK (attr
) = blk
;
5700 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5704 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5708 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5709 info_ptr
+= bytes_read
;
5712 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5713 info_ptr
+= bytes_read
;
5716 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5720 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5724 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5728 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5731 case DW_FORM_ref_udata
:
5732 DW_ADDR (attr
) = (cu
->header
.offset
5733 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5734 info_ptr
+= bytes_read
;
5736 case DW_FORM_indirect
:
5737 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5738 info_ptr
+= bytes_read
;
5739 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5742 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5743 dwarf_form_name (form
),
5744 bfd_get_filename (abfd
));
5749 /* Read an attribute described by an abbreviated attribute. */
5752 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5753 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
5755 attr
->name
= abbrev
->name
;
5756 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5759 /* read dwarf information from a buffer */
5762 read_1_byte (bfd
*abfd
, char *buf
)
5764 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
5768 read_1_signed_byte (bfd
*abfd
, char *buf
)
5770 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
5774 read_2_bytes (bfd
*abfd
, char *buf
)
5776 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5780 read_2_signed_bytes (bfd
*abfd
, char *buf
)
5782 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5786 read_4_bytes (bfd
*abfd
, char *buf
)
5788 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5792 read_4_signed_bytes (bfd
*abfd
, char *buf
)
5794 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5797 static unsigned long
5798 read_8_bytes (bfd
*abfd
, char *buf
)
5800 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5804 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
5806 struct comp_unit_head
*cu_header
= &cu
->header
;
5807 CORE_ADDR retval
= 0;
5809 if (cu_header
->signed_addr_p
)
5811 switch (cu_header
->addr_size
)
5814 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5817 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5820 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
5823 internal_error (__FILE__
, __LINE__
,
5824 _("read_address: bad switch, signed [in module %s]"),
5825 bfd_get_filename (abfd
));
5830 switch (cu_header
->addr_size
)
5833 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5836 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5839 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5842 internal_error (__FILE__
, __LINE__
,
5843 _("read_address: bad switch, unsigned [in module %s]"),
5844 bfd_get_filename (abfd
));
5848 *bytes_read
= cu_header
->addr_size
;
5852 /* Read the initial length from a section. The (draft) DWARF 3
5853 specification allows the initial length to take up either 4 bytes
5854 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5855 bytes describe the length and all offsets will be 8 bytes in length
5858 An older, non-standard 64-bit format is also handled by this
5859 function. The older format in question stores the initial length
5860 as an 8-byte quantity without an escape value. Lengths greater
5861 than 2^32 aren't very common which means that the initial 4 bytes
5862 is almost always zero. Since a length value of zero doesn't make
5863 sense for the 32-bit format, this initial zero can be considered to
5864 be an escape value which indicates the presence of the older 64-bit
5865 format. As written, the code can't detect (old format) lengths
5866 greater than 4GB. If it becomes necessary to handle lengths
5867 somewhat larger than 4GB, we could allow other small values (such
5868 as the non-sensical values of 1, 2, and 3) to also be used as
5869 escape values indicating the presence of the old format.
5871 The value returned via bytes_read should be used to increment the
5872 relevant pointer after calling read_initial_length().
5874 As a side effect, this function sets the fields initial_length_size
5875 and offset_size in cu_header to the values appropriate for the
5876 length field. (The format of the initial length field determines
5877 the width of file offsets to be fetched later with read_offset().)
5879 [ Note: read_initial_length() and read_offset() are based on the
5880 document entitled "DWARF Debugging Information Format", revision
5881 3, draft 8, dated November 19, 2001. This document was obtained
5884 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5886 This document is only a draft and is subject to change. (So beware.)
5888 Details regarding the older, non-standard 64-bit format were
5889 determined empirically by examining 64-bit ELF files produced by
5890 the SGI toolchain on an IRIX 6.5 machine.
5892 - Kevin, July 16, 2002
5896 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
5899 LONGEST length
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5901 if (length
== 0xffffffff)
5903 length
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
5906 else if (length
== 0)
5908 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
5909 length
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5919 gdb_assert (cu_header
->initial_length_size
== 0
5920 || cu_header
->initial_length_size
== 4
5921 || cu_header
->initial_length_size
== 8
5922 || cu_header
->initial_length_size
== 12);
5924 if (cu_header
->initial_length_size
!= 0
5925 && cu_header
->initial_length_size
!= *bytes_read
)
5926 complaint (&symfile_complaints
,
5927 _("intermixed 32-bit and 64-bit DWARF sections"));
5929 cu_header
->initial_length_size
= *bytes_read
;
5930 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
5936 /* Read an offset from the data stream. The size of the offset is
5937 given by cu_header->offset_size. */
5940 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
5945 switch (cu_header
->offset_size
)
5948 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5952 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5956 internal_error (__FILE__
, __LINE__
,
5957 _("read_offset: bad switch [in module %s]"),
5958 bfd_get_filename (abfd
));
5965 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
5967 /* If the size of a host char is 8 bits, we can return a pointer
5968 to the buffer, otherwise we have to copy the data to a buffer
5969 allocated on the temporary obstack. */
5970 gdb_assert (HOST_CHAR_BIT
== 8);
5975 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5977 /* If the size of a host char is 8 bits, we can return a pointer
5978 to the string, otherwise we have to copy the string to a buffer
5979 allocated on the temporary obstack. */
5980 gdb_assert (HOST_CHAR_BIT
== 8);
5983 *bytes_read_ptr
= 1;
5986 *bytes_read_ptr
= strlen (buf
) + 1;
5991 read_indirect_string (bfd
*abfd
, char *buf
,
5992 const struct comp_unit_head
*cu_header
,
5993 unsigned int *bytes_read_ptr
)
5995 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
5996 (int *) bytes_read_ptr
);
5998 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6000 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6001 bfd_get_filename (abfd
));
6004 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6006 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6007 bfd_get_filename (abfd
));
6010 gdb_assert (HOST_CHAR_BIT
== 8);
6011 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6013 return dwarf2_per_objfile
->str_buffer
+ str_offset
;
6016 static unsigned long
6017 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
6019 unsigned long result
;
6020 unsigned int num_read
;
6030 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6033 result
|= ((unsigned long)(byte
& 127) << shift
);
6034 if ((byte
& 128) == 0)
6040 *bytes_read_ptr
= num_read
;
6045 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
6048 int i
, shift
, num_read
;
6057 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6060 result
|= ((long)(byte
& 127) << shift
);
6062 if ((byte
& 128) == 0)
6067 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6068 result
|= -(((long)1) << shift
);
6069 *bytes_read_ptr
= num_read
;
6073 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6076 skip_leb128 (bfd
*abfd
, char *buf
)
6082 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6084 if ((byte
& 128) == 0)
6090 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6096 cu
->language
= language_c
;
6098 case DW_LANG_C_plus_plus
:
6099 cu
->language
= language_cplus
;
6101 case DW_LANG_Fortran77
:
6102 case DW_LANG_Fortran90
:
6103 case DW_LANG_Fortran95
:
6104 cu
->language
= language_fortran
;
6106 case DW_LANG_Mips_Assembler
:
6107 cu
->language
= language_asm
;
6110 cu
->language
= language_java
;
6114 cu
->language
= language_ada
;
6116 case DW_LANG_Cobol74
:
6117 case DW_LANG_Cobol85
:
6118 case DW_LANG_Pascal83
:
6119 case DW_LANG_Modula2
:
6121 cu
->language
= language_minimal
;
6124 cu
->language_defn
= language_def (cu
->language
);
6127 /* Return the named attribute or NULL if not there. */
6129 static struct attribute
*
6130 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6133 struct attribute
*spec
= NULL
;
6135 for (i
= 0; i
< die
->num_attrs
; ++i
)
6137 if (die
->attrs
[i
].name
== name
)
6138 return &die
->attrs
[i
];
6139 if (die
->attrs
[i
].name
== DW_AT_specification
6140 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6141 spec
= &die
->attrs
[i
];
6145 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6150 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6151 and holds a non-zero value. This function should only be used for
6152 DW_FORM_flag attributes. */
6155 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6157 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6159 return (attr
&& DW_UNSND (attr
));
6163 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6165 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6166 which value is non-zero. However, we have to be careful with
6167 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6168 (via dwarf2_flag_true_p) follows this attribute. So we may
6169 end up accidently finding a declaration attribute that belongs
6170 to a different DIE referenced by the specification attribute,
6171 even though the given DIE does not have a declaration attribute. */
6172 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6173 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6176 /* Return the die giving the specification for DIE, if there is
6179 static struct die_info
*
6180 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6182 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6184 if (spec_attr
== NULL
)
6187 return follow_die_ref (die
, spec_attr
, cu
);
6190 /* Free the line_header structure *LH, and any arrays and strings it
6193 free_line_header (struct line_header
*lh
)
6195 if (lh
->standard_opcode_lengths
)
6196 xfree (lh
->standard_opcode_lengths
);
6198 /* Remember that all the lh->file_names[i].name pointers are
6199 pointers into debug_line_buffer, and don't need to be freed. */
6201 xfree (lh
->file_names
);
6203 /* Similarly for the include directory names. */
6204 if (lh
->include_dirs
)
6205 xfree (lh
->include_dirs
);
6211 /* Add an entry to LH's include directory table. */
6213 add_include_dir (struct line_header
*lh
, char *include_dir
)
6215 /* Grow the array if necessary. */
6216 if (lh
->include_dirs_size
== 0)
6218 lh
->include_dirs_size
= 1; /* for testing */
6219 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6220 * sizeof (*lh
->include_dirs
));
6222 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6224 lh
->include_dirs_size
*= 2;
6225 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6226 (lh
->include_dirs_size
6227 * sizeof (*lh
->include_dirs
)));
6230 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6234 /* Add an entry to LH's file name table. */
6236 add_file_name (struct line_header
*lh
,
6238 unsigned int dir_index
,
6239 unsigned int mod_time
,
6240 unsigned int length
)
6242 struct file_entry
*fe
;
6244 /* Grow the array if necessary. */
6245 if (lh
->file_names_size
== 0)
6247 lh
->file_names_size
= 1; /* for testing */
6248 lh
->file_names
= xmalloc (lh
->file_names_size
6249 * sizeof (*lh
->file_names
));
6251 else if (lh
->num_file_names
>= lh
->file_names_size
)
6253 lh
->file_names_size
*= 2;
6254 lh
->file_names
= xrealloc (lh
->file_names
,
6255 (lh
->file_names_size
6256 * sizeof (*lh
->file_names
)));
6259 fe
= &lh
->file_names
[lh
->num_file_names
++];
6261 fe
->dir_index
= dir_index
;
6262 fe
->mod_time
= mod_time
;
6263 fe
->length
= length
;
6268 /* Read the statement program header starting at OFFSET in
6269 .debug_line, according to the endianness of ABFD. Return a pointer
6270 to a struct line_header, allocated using xmalloc.
6272 NOTE: the strings in the include directory and file name tables of
6273 the returned object point into debug_line_buffer, and must not be
6275 static struct line_header
*
6276 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6277 struct dwarf2_cu
*cu
)
6279 struct cleanup
*back_to
;
6280 struct line_header
*lh
;
6284 char *cur_dir
, *cur_file
;
6286 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6288 complaint (&symfile_complaints
, _("missing .debug_line section"));
6292 /* Make sure that at least there's room for the total_length field.
6293 That could be 12 bytes long, but we're just going to fudge that. */
6294 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6296 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6300 lh
= xmalloc (sizeof (*lh
));
6301 memset (lh
, 0, sizeof (*lh
));
6302 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6305 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6307 /* Read in the header. */
6309 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6310 line_ptr
+= bytes_read
;
6311 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6312 + dwarf2_per_objfile
->line_size
))
6314 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6317 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6318 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6320 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6321 line_ptr
+= bytes_read
;
6322 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6324 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6326 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6328 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6330 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6332 lh
->standard_opcode_lengths
6333 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
6335 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6336 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6338 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6342 /* Read directory table. */
6343 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6345 line_ptr
+= bytes_read
;
6346 add_include_dir (lh
, cur_dir
);
6348 line_ptr
+= bytes_read
;
6350 /* Read file name table. */
6351 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6353 unsigned int dir_index
, mod_time
, length
;
6355 line_ptr
+= bytes_read
;
6356 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6357 line_ptr
+= bytes_read
;
6358 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6359 line_ptr
+= bytes_read
;
6360 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6361 line_ptr
+= bytes_read
;
6363 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6365 line_ptr
+= bytes_read
;
6366 lh
->statement_program_start
= line_ptr
;
6368 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6369 + dwarf2_per_objfile
->line_size
))
6370 complaint (&symfile_complaints
,
6371 _("line number info header doesn't fit in `.debug_line' section"));
6373 discard_cleanups (back_to
);
6377 /* This function exists to work around a bug in certain compilers
6378 (particularly GCC 2.95), in which the first line number marker of a
6379 function does not show up until after the prologue, right before
6380 the second line number marker. This function shifts ADDRESS down
6381 to the beginning of the function if necessary, and is called on
6382 addresses passed to record_line. */
6385 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6387 struct function_range
*fn
;
6389 /* Find the function_range containing address. */
6394 cu
->cached_fn
= cu
->first_fn
;
6398 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6404 while (fn
&& fn
!= cu
->cached_fn
)
6405 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6415 if (address
!= fn
->lowpc
)
6416 complaint (&symfile_complaints
,
6417 _("misplaced first line number at 0x%lx for '%s'"),
6418 (unsigned long) address
, fn
->name
);
6423 /* Decode the Line Number Program (LNP) for the given line_header
6424 structure and CU. The actual information extracted and the type
6425 of structures created from the LNP depends on the value of PST.
6427 1. If PST is NULL, then this procedure uses the data from the program
6428 to create all necessary symbol tables, and their linetables.
6429 The compilation directory of the file is passed in COMP_DIR,
6430 and must not be NULL.
6432 2. If PST is not NULL, this procedure reads the program to determine
6433 the list of files included by the unit represented by PST, and
6434 builds all the associated partial symbol tables. In this case,
6435 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6436 is not used to compute the full name of the symtab, and therefore
6437 omitting it when building the partial symtab does not introduce
6438 the potential for inconsistency - a partial symtab and its associated
6439 symbtab having a different fullname -). */
6442 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6443 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6447 unsigned int bytes_read
;
6448 unsigned char op_code
, extended_op
, adj_opcode
;
6450 struct objfile
*objfile
= cu
->objfile
;
6451 const int decode_for_pst_p
= (pst
!= NULL
);
6453 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6455 line_ptr
= lh
->statement_program_start
;
6456 line_end
= lh
->statement_program_end
;
6458 /* Read the statement sequences until there's nothing left. */
6459 while (line_ptr
< line_end
)
6461 /* state machine registers */
6462 CORE_ADDR address
= 0;
6463 unsigned int file
= 1;
6464 unsigned int line
= 1;
6465 unsigned int column
= 0;
6466 int is_stmt
= lh
->default_is_stmt
;
6467 int basic_block
= 0;
6468 int end_sequence
= 0;
6470 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6472 /* Start a subfile for the current file of the state machine. */
6473 /* lh->include_dirs and lh->file_names are 0-based, but the
6474 directory and file name numbers in the statement program
6476 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6480 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6483 dwarf2_start_subfile (fe
->name
, dir
);
6486 /* Decode the table. */
6487 while (!end_sequence
)
6489 op_code
= read_1_byte (abfd
, line_ptr
);
6492 if (op_code
>= lh
->opcode_base
)
6494 /* Special operand. */
6495 adj_opcode
= op_code
- lh
->opcode_base
;
6496 address
+= (adj_opcode
/ lh
->line_range
)
6497 * lh
->minimum_instruction_length
;
6498 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6499 lh
->file_names
[file
- 1].included_p
= 1;
6500 if (!decode_for_pst_p
)
6502 /* Append row to matrix using current values. */
6503 record_line (current_subfile
, line
,
6504 check_cu_functions (address
, cu
));
6508 else switch (op_code
)
6510 case DW_LNS_extended_op
:
6511 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6512 line_ptr
+= bytes_read
;
6513 extended_op
= read_1_byte (abfd
, line_ptr
);
6515 switch (extended_op
)
6517 case DW_LNE_end_sequence
:
6519 lh
->file_names
[file
- 1].included_p
= 1;
6520 if (!decode_for_pst_p
)
6521 record_line (current_subfile
, 0, address
);
6523 case DW_LNE_set_address
:
6524 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6525 line_ptr
+= bytes_read
;
6526 address
+= baseaddr
;
6528 case DW_LNE_define_file
:
6531 unsigned int dir_index
, mod_time
, length
;
6533 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6534 line_ptr
+= bytes_read
;
6536 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6537 line_ptr
+= bytes_read
;
6539 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6540 line_ptr
+= bytes_read
;
6542 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6543 line_ptr
+= bytes_read
;
6544 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6548 complaint (&symfile_complaints
,
6549 _("mangled .debug_line section"));
6554 lh
->file_names
[file
- 1].included_p
= 1;
6555 if (!decode_for_pst_p
)
6556 record_line (current_subfile
, line
,
6557 check_cu_functions (address
, cu
));
6560 case DW_LNS_advance_pc
:
6561 address
+= lh
->minimum_instruction_length
6562 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6563 line_ptr
+= bytes_read
;
6565 case DW_LNS_advance_line
:
6566 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6567 line_ptr
+= bytes_read
;
6569 case DW_LNS_set_file
:
6571 /* The arrays lh->include_dirs and lh->file_names are
6572 0-based, but the directory and file name numbers in
6573 the statement program are 1-based. */
6574 struct file_entry
*fe
;
6577 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6578 line_ptr
+= bytes_read
;
6579 fe
= &lh
->file_names
[file
- 1];
6581 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6584 if (!decode_for_pst_p
)
6585 dwarf2_start_subfile (fe
->name
, dir
);
6588 case DW_LNS_set_column
:
6589 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6590 line_ptr
+= bytes_read
;
6592 case DW_LNS_negate_stmt
:
6593 is_stmt
= (!is_stmt
);
6595 case DW_LNS_set_basic_block
:
6598 /* Add to the address register of the state machine the
6599 address increment value corresponding to special opcode
6600 255. I.e., this value is scaled by the minimum
6601 instruction length since special opcode 255 would have
6602 scaled the the increment. */
6603 case DW_LNS_const_add_pc
:
6604 address
+= (lh
->minimum_instruction_length
6605 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6607 case DW_LNS_fixed_advance_pc
:
6608 address
+= read_2_bytes (abfd
, line_ptr
);
6613 /* Unknown standard opcode, ignore it. */
6616 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6618 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6619 line_ptr
+= bytes_read
;
6626 if (decode_for_pst_p
)
6630 /* Now that we're done scanning the Line Header Program, we can
6631 create the psymtab of each included file. */
6632 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6633 if (lh
->file_names
[file_index
].included_p
== 1)
6635 const struct file_entry fe
= lh
->file_names
[file_index
];
6636 char *include_name
= fe
.name
;
6637 char *dir_name
= NULL
;
6638 char *pst_filename
= pst
->filename
;
6641 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6643 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6645 include_name
= concat (dir_name
, SLASH_STRING
,
6646 include_name
, (char *)NULL
);
6647 make_cleanup (xfree
, include_name
);
6650 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6652 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6653 pst_filename
, (char *)NULL
);
6654 make_cleanup (xfree
, pst_filename
);
6657 if (strcmp (include_name
, pst_filename
) != 0)
6658 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6663 /* Start a subfile for DWARF. FILENAME is the name of the file and
6664 DIRNAME the name of the source directory which contains FILENAME
6665 or NULL if not known.
6666 This routine tries to keep line numbers from identical absolute and
6667 relative file names in a common subfile.
6669 Using the `list' example from the GDB testsuite, which resides in
6670 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6671 of /srcdir/list0.c yields the following debugging information for list0.c:
6673 DW_AT_name: /srcdir/list0.c
6674 DW_AT_comp_dir: /compdir
6675 files.files[0].name: list0.h
6676 files.files[0].dir: /srcdir
6677 files.files[1].name: list0.c
6678 files.files[1].dir: /srcdir
6680 The line number information for list0.c has to end up in a single
6681 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6684 dwarf2_start_subfile (char *filename
, char *dirname
)
6686 /* If the filename isn't absolute, try to match an existing subfile
6687 with the full pathname. */
6689 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6691 struct subfile
*subfile
;
6692 char *fullname
= concat (dirname
, "/", filename
, (char *)NULL
);
6694 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
6696 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
6698 current_subfile
= subfile
;
6705 start_subfile (filename
, dirname
);
6709 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6710 struct dwarf2_cu
*cu
)
6712 struct objfile
*objfile
= cu
->objfile
;
6713 struct comp_unit_head
*cu_header
= &cu
->header
;
6715 /* NOTE drow/2003-01-30: There used to be a comment and some special
6716 code here to turn a symbol with DW_AT_external and a
6717 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6718 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6719 with some versions of binutils) where shared libraries could have
6720 relocations against symbols in their debug information - the
6721 minimal symbol would have the right address, but the debug info
6722 would not. It's no longer necessary, because we will explicitly
6723 apply relocations when we read in the debug information now. */
6725 /* A DW_AT_location attribute with no contents indicates that a
6726 variable has been optimized away. */
6727 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6729 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6733 /* Handle one degenerate form of location expression specially, to
6734 preserve GDB's previous behavior when section offsets are
6735 specified. If this is just a DW_OP_addr then mark this symbol
6738 if (attr_form_is_block (attr
)
6739 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6740 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6744 SYMBOL_VALUE_ADDRESS (sym
) =
6745 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6746 fixup_symbol_section (sym
, objfile
);
6747 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6748 SYMBOL_SECTION (sym
));
6749 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6753 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6754 expression evaluator, and use LOC_COMPUTED only when necessary
6755 (i.e. when the value of a register or memory location is
6756 referenced, or a thread-local block, etc.). Then again, it might
6757 not be worthwhile. I'm assuming that it isn't unless performance
6758 or memory numbers show me otherwise. */
6760 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6761 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6764 /* Given a pointer to a DWARF information entry, figure out if we need
6765 to make a symbol table entry for it, and if so, create a new entry
6766 and return a pointer to it.
6767 If TYPE is NULL, determine symbol type from the die, otherwise
6768 used the passed type. */
6770 static struct symbol
*
6771 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6773 struct objfile
*objfile
= cu
->objfile
;
6774 struct symbol
*sym
= NULL
;
6776 struct attribute
*attr
= NULL
;
6777 struct attribute
*attr2
= NULL
;
6780 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6782 if (die
->tag
!= DW_TAG_namespace
)
6783 name
= dwarf2_linkage_name (die
, cu
);
6785 name
= TYPE_NAME (type
);
6789 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6790 sizeof (struct symbol
));
6791 OBJSTAT (objfile
, n_syms
++);
6792 memset (sym
, 0, sizeof (struct symbol
));
6794 /* Cache this symbol's name and the name's demangled form (if any). */
6795 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6796 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6798 /* Default assumptions.
6799 Use the passed type or decode it from the die. */
6800 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6801 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6803 SYMBOL_TYPE (sym
) = type
;
6805 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6806 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6809 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6814 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6817 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6819 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6821 case DW_TAG_subprogram
:
6822 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6824 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6825 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6826 if (attr2
&& (DW_UNSND (attr2
) != 0))
6828 add_symbol_to_list (sym
, &global_symbols
);
6832 add_symbol_to_list (sym
, cu
->list_in_scope
);
6835 case DW_TAG_variable
:
6836 /* Compilation with minimal debug info may result in variables
6837 with missing type entries. Change the misleading `void' type
6838 to something sensible. */
6839 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6840 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6841 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6842 "<variable, no debug info>",
6844 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6847 dwarf2_const_value (attr
, sym
, cu
);
6848 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6849 if (attr2
&& (DW_UNSND (attr2
) != 0))
6850 add_symbol_to_list (sym
, &global_symbols
);
6852 add_symbol_to_list (sym
, cu
->list_in_scope
);
6855 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6858 var_decode_location (attr
, sym
, cu
);
6859 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6860 if (attr2
&& (DW_UNSND (attr2
) != 0))
6861 add_symbol_to_list (sym
, &global_symbols
);
6863 add_symbol_to_list (sym
, cu
->list_in_scope
);
6867 /* We do not know the address of this symbol.
6868 If it is an external symbol and we have type information
6869 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6870 The address of the variable will then be determined from
6871 the minimal symbol table whenever the variable is
6873 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6874 if (attr2
&& (DW_UNSND (attr2
) != 0)
6875 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6877 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6878 add_symbol_to_list (sym
, &global_symbols
);
6882 case DW_TAG_formal_parameter
:
6883 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6886 var_decode_location (attr
, sym
, cu
);
6887 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6888 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6889 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6891 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6894 dwarf2_const_value (attr
, sym
, cu
);
6896 add_symbol_to_list (sym
, cu
->list_in_scope
);
6898 case DW_TAG_unspecified_parameters
:
6899 /* From varargs functions; gdb doesn't seem to have any
6900 interest in this information, so just ignore it for now.
6903 case DW_TAG_class_type
:
6904 case DW_TAG_structure_type
:
6905 case DW_TAG_union_type
:
6906 case DW_TAG_enumeration_type
:
6907 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6908 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6910 /* Make sure that the symbol includes appropriate enclosing
6911 classes/namespaces in its name. These are calculated in
6912 read_structure_type, and the correct name is saved in
6915 if (cu
->language
== language_cplus
6916 || cu
->language
== language_java
)
6918 struct type
*type
= SYMBOL_TYPE (sym
);
6920 if (TYPE_TAG_NAME (type
) != NULL
)
6922 /* FIXME: carlton/2003-11-10: Should this use
6923 SYMBOL_SET_NAMES instead? (The same problem also
6924 arises further down in this function.) */
6925 /* The type's name is already allocated along with
6926 this objfile, so we don't need to duplicate it
6928 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
6933 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6934 really ever be static objects: otherwise, if you try
6935 to, say, break of a class's method and you're in a file
6936 which doesn't mention that class, it won't work unless
6937 the check for all static symbols in lookup_symbol_aux
6938 saves you. See the OtherFileClass tests in
6939 gdb.c++/namespace.exp. */
6941 struct pending
**list_to_add
;
6943 list_to_add
= (cu
->list_in_scope
== &file_symbols
6944 && (cu
->language
== language_cplus
6945 || cu
->language
== language_java
)
6946 ? &global_symbols
: cu
->list_in_scope
);
6948 add_symbol_to_list (sym
, list_to_add
);
6950 /* The semantics of C++ state that "struct foo { ... }" also
6951 defines a typedef for "foo". A Java class declaration also
6952 defines a typedef for the class. Synthesize a typedef symbol
6953 so that "ptype foo" works as expected. */
6954 if (cu
->language
== language_cplus
6955 || cu
->language
== language_java
)
6957 struct symbol
*typedef_sym
= (struct symbol
*)
6958 obstack_alloc (&objfile
->objfile_obstack
,
6959 sizeof (struct symbol
));
6960 *typedef_sym
= *sym
;
6961 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
6962 /* The symbol's name is already allocated along with
6963 this objfile, so we don't need to duplicate it for
6965 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
6966 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
6967 add_symbol_to_list (typedef_sym
, list_to_add
);
6971 case DW_TAG_typedef
:
6972 if (processing_has_namespace_info
6973 && processing_current_prefix
[0] != '\0')
6975 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6976 processing_current_prefix
,
6979 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6980 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6981 add_symbol_to_list (sym
, cu
->list_in_scope
);
6983 case DW_TAG_base_type
:
6984 case DW_TAG_subrange_type
:
6985 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6986 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6987 add_symbol_to_list (sym
, cu
->list_in_scope
);
6989 case DW_TAG_enumerator
:
6990 if (processing_has_namespace_info
6991 && processing_current_prefix
[0] != '\0')
6993 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6994 processing_current_prefix
,
6997 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7000 dwarf2_const_value (attr
, sym
, cu
);
7003 /* NOTE: carlton/2003-11-10: See comment above in the
7004 DW_TAG_class_type, etc. block. */
7006 struct pending
**list_to_add
;
7008 list_to_add
= (cu
->list_in_scope
== &file_symbols
7009 && (cu
->language
== language_cplus
7010 || cu
->language
== language_java
)
7011 ? &global_symbols
: cu
->list_in_scope
);
7013 add_symbol_to_list (sym
, list_to_add
);
7016 case DW_TAG_namespace
:
7017 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7018 add_symbol_to_list (sym
, &global_symbols
);
7021 /* Not a tag we recognize. Hopefully we aren't processing
7022 trash data, but since we must specifically ignore things
7023 we don't recognize, there is nothing else we should do at
7025 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7026 dwarf_tag_name (die
->tag
));
7033 /* Copy constant value from an attribute to a symbol. */
7036 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7037 struct dwarf2_cu
*cu
)
7039 struct objfile
*objfile
= cu
->objfile
;
7040 struct comp_unit_head
*cu_header
= &cu
->header
;
7041 struct dwarf_block
*blk
;
7046 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7047 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7048 cu_header
->addr_size
,
7049 TYPE_LENGTH (SYMBOL_TYPE
7051 SYMBOL_VALUE_BYTES (sym
) = (char *)
7052 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7053 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7054 it's body - store_unsigned_integer. */
7055 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7057 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7059 case DW_FORM_block1
:
7060 case DW_FORM_block2
:
7061 case DW_FORM_block4
:
7063 blk
= DW_BLOCK (attr
);
7064 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7065 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7067 TYPE_LENGTH (SYMBOL_TYPE
7069 SYMBOL_VALUE_BYTES (sym
) = (char *)
7070 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7071 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7072 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7075 /* The DW_AT_const_value attributes are supposed to carry the
7076 symbol's value "represented as it would be on the target
7077 architecture." By the time we get here, it's already been
7078 converted to host endianness, so we just need to sign- or
7079 zero-extend it as appropriate. */
7081 dwarf2_const_value_data (attr
, sym
, 8);
7084 dwarf2_const_value_data (attr
, sym
, 16);
7087 dwarf2_const_value_data (attr
, sym
, 32);
7090 dwarf2_const_value_data (attr
, sym
, 64);
7094 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7095 SYMBOL_CLASS (sym
) = LOC_CONST
;
7099 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7100 SYMBOL_CLASS (sym
) = LOC_CONST
;
7104 complaint (&symfile_complaints
,
7105 _("unsupported const value attribute form: '%s'"),
7106 dwarf_form_name (attr
->form
));
7107 SYMBOL_VALUE (sym
) = 0;
7108 SYMBOL_CLASS (sym
) = LOC_CONST
;
7114 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7115 or zero-extend it as appropriate for the symbol's type. */
7117 dwarf2_const_value_data (struct attribute
*attr
,
7121 LONGEST l
= DW_UNSND (attr
);
7123 if (bits
< sizeof (l
) * 8)
7125 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7126 l
&= ((LONGEST
) 1 << bits
) - 1;
7128 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7131 SYMBOL_VALUE (sym
) = l
;
7132 SYMBOL_CLASS (sym
) = LOC_CONST
;
7136 /* Return the type of the die in question using its DW_AT_type attribute. */
7138 static struct type
*
7139 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7142 struct attribute
*type_attr
;
7143 struct die_info
*type_die
;
7145 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7148 /* A missing DW_AT_type represents a void type. */
7149 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7152 type_die
= follow_die_ref (die
, type_attr
, cu
);
7154 type
= tag_type_to_type (type_die
, cu
);
7157 dump_die (type_die
);
7158 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7164 /* Return the containing type of the die in question using its
7165 DW_AT_containing_type attribute. */
7167 static struct type
*
7168 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7170 struct type
*type
= NULL
;
7171 struct attribute
*type_attr
;
7172 struct die_info
*type_die
= NULL
;
7174 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7177 type_die
= follow_die_ref (die
, type_attr
, cu
);
7178 type
= tag_type_to_type (type_die
, cu
);
7183 dump_die (type_die
);
7184 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7190 static struct type
*
7191 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7199 read_type_die (die
, cu
);
7203 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7211 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7213 char *prefix
= determine_prefix (die
, cu
);
7214 const char *old_prefix
= processing_current_prefix
;
7215 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7216 processing_current_prefix
= prefix
;
7220 case DW_TAG_class_type
:
7221 case DW_TAG_structure_type
:
7222 case DW_TAG_union_type
:
7223 read_structure_type (die
, cu
);
7225 case DW_TAG_enumeration_type
:
7226 read_enumeration_type (die
, cu
);
7228 case DW_TAG_subprogram
:
7229 case DW_TAG_subroutine_type
:
7230 read_subroutine_type (die
, cu
);
7232 case DW_TAG_array_type
:
7233 read_array_type (die
, cu
);
7235 case DW_TAG_pointer_type
:
7236 read_tag_pointer_type (die
, cu
);
7238 case DW_TAG_ptr_to_member_type
:
7239 read_tag_ptr_to_member_type (die
, cu
);
7241 case DW_TAG_reference_type
:
7242 read_tag_reference_type (die
, cu
);
7244 case DW_TAG_const_type
:
7245 read_tag_const_type (die
, cu
);
7247 case DW_TAG_volatile_type
:
7248 read_tag_volatile_type (die
, cu
);
7250 case DW_TAG_string_type
:
7251 read_tag_string_type (die
, cu
);
7253 case DW_TAG_typedef
:
7254 read_typedef (die
, cu
);
7256 case DW_TAG_subrange_type
:
7257 read_subrange_type (die
, cu
);
7259 case DW_TAG_base_type
:
7260 read_base_type (die
, cu
);
7263 complaint (&symfile_complaints
, _("unexepected tag in read_type_die: '%s'"),
7264 dwarf_tag_name (die
->tag
));
7268 processing_current_prefix
= old_prefix
;
7269 do_cleanups (back_to
);
7272 /* Return the name of the namespace/class that DIE is defined within,
7273 or "" if we can't tell. The caller should xfree the result. */
7275 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7276 therein) for an example of how to use this function to deal with
7277 DW_AT_specification. */
7280 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7282 struct die_info
*parent
;
7284 if (cu
->language
!= language_cplus
7285 && cu
->language
!= language_java
)
7288 parent
= die
->parent
;
7292 return xstrdup ("");
7296 switch (parent
->tag
) {
7297 case DW_TAG_namespace
:
7299 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7300 before doing this check? */
7301 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7303 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7308 char *parent_prefix
= determine_prefix (parent
, cu
);
7309 char *retval
= typename_concat (NULL
, parent_prefix
,
7310 namespace_name (parent
, &dummy
,
7313 xfree (parent_prefix
);
7318 case DW_TAG_class_type
:
7319 case DW_TAG_structure_type
:
7321 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7323 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7327 const char *old_prefix
= processing_current_prefix
;
7328 char *new_prefix
= determine_prefix (parent
, cu
);
7331 processing_current_prefix
= new_prefix
;
7332 retval
= determine_class_name (parent
, cu
);
7333 processing_current_prefix
= old_prefix
;
7340 return determine_prefix (parent
, cu
);
7345 /* Return a newly-allocated string formed by concatenating PREFIX and
7346 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7347 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7348 perform an obconcat, otherwise allocate storage for the result. The CU argument
7349 is used to determine the language and hence, the appropriate separator. */
7351 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7354 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7355 struct dwarf2_cu
*cu
)
7359 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7361 else if (cu
->language
== language_java
)
7368 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7373 strcpy (retval
, prefix
);
7374 strcat (retval
, sep
);
7377 strcat (retval
, suffix
);
7383 /* We have an obstack. */
7384 return obconcat (obs
, prefix
, sep
, suffix
);
7388 static struct type
*
7389 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7391 struct objfile
*objfile
= cu
->objfile
;
7393 /* FIXME - this should not produce a new (struct type *)
7394 every time. It should cache base types. */
7398 case DW_ATE_address
:
7399 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7401 case DW_ATE_boolean
:
7402 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7404 case DW_ATE_complex_float
:
7407 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7411 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7417 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7421 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7428 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7431 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7435 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7439 case DW_ATE_signed_char
:
7440 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7442 case DW_ATE_unsigned
:
7446 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7449 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7453 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7457 case DW_ATE_unsigned_char
:
7458 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7461 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7468 copy_die (struct die_info
*old_die
)
7470 struct die_info
*new_die
;
7473 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7474 memset (new_die
, 0, sizeof (struct die_info
));
7476 new_die
->tag
= old_die
->tag
;
7477 new_die
->has_children
= old_die
->has_children
;
7478 new_die
->abbrev
= old_die
->abbrev
;
7479 new_die
->offset
= old_die
->offset
;
7480 new_die
->type
= NULL
;
7482 num_attrs
= old_die
->num_attrs
;
7483 new_die
->num_attrs
= num_attrs
;
7484 new_die
->attrs
= (struct attribute
*)
7485 xmalloc (num_attrs
* sizeof (struct attribute
));
7487 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7489 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7490 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7491 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7494 new_die
->next
= NULL
;
7499 /* Return sibling of die, NULL if no sibling. */
7501 static struct die_info
*
7502 sibling_die (struct die_info
*die
)
7504 return die
->sibling
;
7507 /* Get linkage name of a die, return NULL if not found. */
7510 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7512 struct attribute
*attr
;
7514 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7515 if (attr
&& DW_STRING (attr
))
7516 return DW_STRING (attr
);
7517 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7518 if (attr
&& DW_STRING (attr
))
7519 return DW_STRING (attr
);
7523 /* Get name of a die, return NULL if not found. */
7526 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7528 struct attribute
*attr
;
7530 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7531 if (attr
&& DW_STRING (attr
))
7532 return DW_STRING (attr
);
7536 /* Return the die that this die in an extension of, or NULL if there
7539 static struct die_info
*
7540 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7542 struct attribute
*attr
;
7544 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7548 return follow_die_ref (die
, attr
, cu
);
7551 /* Convert a DIE tag into its string name. */
7554 dwarf_tag_name (unsigned tag
)
7558 case DW_TAG_padding
:
7559 return "DW_TAG_padding";
7560 case DW_TAG_array_type
:
7561 return "DW_TAG_array_type";
7562 case DW_TAG_class_type
:
7563 return "DW_TAG_class_type";
7564 case DW_TAG_entry_point
:
7565 return "DW_TAG_entry_point";
7566 case DW_TAG_enumeration_type
:
7567 return "DW_TAG_enumeration_type";
7568 case DW_TAG_formal_parameter
:
7569 return "DW_TAG_formal_parameter";
7570 case DW_TAG_imported_declaration
:
7571 return "DW_TAG_imported_declaration";
7573 return "DW_TAG_label";
7574 case DW_TAG_lexical_block
:
7575 return "DW_TAG_lexical_block";
7577 return "DW_TAG_member";
7578 case DW_TAG_pointer_type
:
7579 return "DW_TAG_pointer_type";
7580 case DW_TAG_reference_type
:
7581 return "DW_TAG_reference_type";
7582 case DW_TAG_compile_unit
:
7583 return "DW_TAG_compile_unit";
7584 case DW_TAG_string_type
:
7585 return "DW_TAG_string_type";
7586 case DW_TAG_structure_type
:
7587 return "DW_TAG_structure_type";
7588 case DW_TAG_subroutine_type
:
7589 return "DW_TAG_subroutine_type";
7590 case DW_TAG_typedef
:
7591 return "DW_TAG_typedef";
7592 case DW_TAG_union_type
:
7593 return "DW_TAG_union_type";
7594 case DW_TAG_unspecified_parameters
:
7595 return "DW_TAG_unspecified_parameters";
7596 case DW_TAG_variant
:
7597 return "DW_TAG_variant";
7598 case DW_TAG_common_block
:
7599 return "DW_TAG_common_block";
7600 case DW_TAG_common_inclusion
:
7601 return "DW_TAG_common_inclusion";
7602 case DW_TAG_inheritance
:
7603 return "DW_TAG_inheritance";
7604 case DW_TAG_inlined_subroutine
:
7605 return "DW_TAG_inlined_subroutine";
7607 return "DW_TAG_module";
7608 case DW_TAG_ptr_to_member_type
:
7609 return "DW_TAG_ptr_to_member_type";
7610 case DW_TAG_set_type
:
7611 return "DW_TAG_set_type";
7612 case DW_TAG_subrange_type
:
7613 return "DW_TAG_subrange_type";
7614 case DW_TAG_with_stmt
:
7615 return "DW_TAG_with_stmt";
7616 case DW_TAG_access_declaration
:
7617 return "DW_TAG_access_declaration";
7618 case DW_TAG_base_type
:
7619 return "DW_TAG_base_type";
7620 case DW_TAG_catch_block
:
7621 return "DW_TAG_catch_block";
7622 case DW_TAG_const_type
:
7623 return "DW_TAG_const_type";
7624 case DW_TAG_constant
:
7625 return "DW_TAG_constant";
7626 case DW_TAG_enumerator
:
7627 return "DW_TAG_enumerator";
7628 case DW_TAG_file_type
:
7629 return "DW_TAG_file_type";
7631 return "DW_TAG_friend";
7632 case DW_TAG_namelist
:
7633 return "DW_TAG_namelist";
7634 case DW_TAG_namelist_item
:
7635 return "DW_TAG_namelist_item";
7636 case DW_TAG_packed_type
:
7637 return "DW_TAG_packed_type";
7638 case DW_TAG_subprogram
:
7639 return "DW_TAG_subprogram";
7640 case DW_TAG_template_type_param
:
7641 return "DW_TAG_template_type_param";
7642 case DW_TAG_template_value_param
:
7643 return "DW_TAG_template_value_param";
7644 case DW_TAG_thrown_type
:
7645 return "DW_TAG_thrown_type";
7646 case DW_TAG_try_block
:
7647 return "DW_TAG_try_block";
7648 case DW_TAG_variant_part
:
7649 return "DW_TAG_variant_part";
7650 case DW_TAG_variable
:
7651 return "DW_TAG_variable";
7652 case DW_TAG_volatile_type
:
7653 return "DW_TAG_volatile_type";
7654 case DW_TAG_dwarf_procedure
:
7655 return "DW_TAG_dwarf_procedure";
7656 case DW_TAG_restrict_type
:
7657 return "DW_TAG_restrict_type";
7658 case DW_TAG_interface_type
:
7659 return "DW_TAG_interface_type";
7660 case DW_TAG_namespace
:
7661 return "DW_TAG_namespace";
7662 case DW_TAG_imported_module
:
7663 return "DW_TAG_imported_module";
7664 case DW_TAG_unspecified_type
:
7665 return "DW_TAG_unspecified_type";
7666 case DW_TAG_partial_unit
:
7667 return "DW_TAG_partial_unit";
7668 case DW_TAG_imported_unit
:
7669 return "DW_TAG_imported_unit";
7670 case DW_TAG_MIPS_loop
:
7671 return "DW_TAG_MIPS_loop";
7672 case DW_TAG_format_label
:
7673 return "DW_TAG_format_label";
7674 case DW_TAG_function_template
:
7675 return "DW_TAG_function_template";
7676 case DW_TAG_class_template
:
7677 return "DW_TAG_class_template";
7679 return "DW_TAG_<unknown>";
7683 /* Convert a DWARF attribute code into its string name. */
7686 dwarf_attr_name (unsigned attr
)
7691 return "DW_AT_sibling";
7692 case DW_AT_location
:
7693 return "DW_AT_location";
7695 return "DW_AT_name";
7696 case DW_AT_ordering
:
7697 return "DW_AT_ordering";
7698 case DW_AT_subscr_data
:
7699 return "DW_AT_subscr_data";
7700 case DW_AT_byte_size
:
7701 return "DW_AT_byte_size";
7702 case DW_AT_bit_offset
:
7703 return "DW_AT_bit_offset";
7704 case DW_AT_bit_size
:
7705 return "DW_AT_bit_size";
7706 case DW_AT_element_list
:
7707 return "DW_AT_element_list";
7708 case DW_AT_stmt_list
:
7709 return "DW_AT_stmt_list";
7711 return "DW_AT_low_pc";
7713 return "DW_AT_high_pc";
7714 case DW_AT_language
:
7715 return "DW_AT_language";
7717 return "DW_AT_member";
7719 return "DW_AT_discr";
7720 case DW_AT_discr_value
:
7721 return "DW_AT_discr_value";
7722 case DW_AT_visibility
:
7723 return "DW_AT_visibility";
7725 return "DW_AT_import";
7726 case DW_AT_string_length
:
7727 return "DW_AT_string_length";
7728 case DW_AT_common_reference
:
7729 return "DW_AT_common_reference";
7730 case DW_AT_comp_dir
:
7731 return "DW_AT_comp_dir";
7732 case DW_AT_const_value
:
7733 return "DW_AT_const_value";
7734 case DW_AT_containing_type
:
7735 return "DW_AT_containing_type";
7736 case DW_AT_default_value
:
7737 return "DW_AT_default_value";
7739 return "DW_AT_inline";
7740 case DW_AT_is_optional
:
7741 return "DW_AT_is_optional";
7742 case DW_AT_lower_bound
:
7743 return "DW_AT_lower_bound";
7744 case DW_AT_producer
:
7745 return "DW_AT_producer";
7746 case DW_AT_prototyped
:
7747 return "DW_AT_prototyped";
7748 case DW_AT_return_addr
:
7749 return "DW_AT_return_addr";
7750 case DW_AT_start_scope
:
7751 return "DW_AT_start_scope";
7752 case DW_AT_stride_size
:
7753 return "DW_AT_stride_size";
7754 case DW_AT_upper_bound
:
7755 return "DW_AT_upper_bound";
7756 case DW_AT_abstract_origin
:
7757 return "DW_AT_abstract_origin";
7758 case DW_AT_accessibility
:
7759 return "DW_AT_accessibility";
7760 case DW_AT_address_class
:
7761 return "DW_AT_address_class";
7762 case DW_AT_artificial
:
7763 return "DW_AT_artificial";
7764 case DW_AT_base_types
:
7765 return "DW_AT_base_types";
7766 case DW_AT_calling_convention
:
7767 return "DW_AT_calling_convention";
7769 return "DW_AT_count";
7770 case DW_AT_data_member_location
:
7771 return "DW_AT_data_member_location";
7772 case DW_AT_decl_column
:
7773 return "DW_AT_decl_column";
7774 case DW_AT_decl_file
:
7775 return "DW_AT_decl_file";
7776 case DW_AT_decl_line
:
7777 return "DW_AT_decl_line";
7778 case DW_AT_declaration
:
7779 return "DW_AT_declaration";
7780 case DW_AT_discr_list
:
7781 return "DW_AT_discr_list";
7782 case DW_AT_encoding
:
7783 return "DW_AT_encoding";
7784 case DW_AT_external
:
7785 return "DW_AT_external";
7786 case DW_AT_frame_base
:
7787 return "DW_AT_frame_base";
7789 return "DW_AT_friend";
7790 case DW_AT_identifier_case
:
7791 return "DW_AT_identifier_case";
7792 case DW_AT_macro_info
:
7793 return "DW_AT_macro_info";
7794 case DW_AT_namelist_items
:
7795 return "DW_AT_namelist_items";
7796 case DW_AT_priority
:
7797 return "DW_AT_priority";
7799 return "DW_AT_segment";
7800 case DW_AT_specification
:
7801 return "DW_AT_specification";
7802 case DW_AT_static_link
:
7803 return "DW_AT_static_link";
7805 return "DW_AT_type";
7806 case DW_AT_use_location
:
7807 return "DW_AT_use_location";
7808 case DW_AT_variable_parameter
:
7809 return "DW_AT_variable_parameter";
7810 case DW_AT_virtuality
:
7811 return "DW_AT_virtuality";
7812 case DW_AT_vtable_elem_location
:
7813 return "DW_AT_vtable_elem_location";
7814 case DW_AT_allocated
:
7815 return "DW_AT_allocated";
7816 case DW_AT_associated
:
7817 return "DW_AT_associated";
7818 case DW_AT_data_location
:
7819 return "DW_AT_data_location";
7821 return "DW_AT_stride";
7822 case DW_AT_entry_pc
:
7823 return "DW_AT_entry_pc";
7824 case DW_AT_use_UTF8
:
7825 return "DW_AT_use_UTF8";
7826 case DW_AT_extension
:
7827 return "DW_AT_extension";
7829 return "DW_AT_ranges";
7830 case DW_AT_trampoline
:
7831 return "DW_AT_trampoline";
7832 case DW_AT_call_column
:
7833 return "DW_AT_call_column";
7834 case DW_AT_call_file
:
7835 return "DW_AT_call_file";
7836 case DW_AT_call_line
:
7837 return "DW_AT_call_line";
7839 case DW_AT_MIPS_fde
:
7840 return "DW_AT_MIPS_fde";
7841 case DW_AT_MIPS_loop_begin
:
7842 return "DW_AT_MIPS_loop_begin";
7843 case DW_AT_MIPS_tail_loop_begin
:
7844 return "DW_AT_MIPS_tail_loop_begin";
7845 case DW_AT_MIPS_epilog_begin
:
7846 return "DW_AT_MIPS_epilog_begin";
7847 case DW_AT_MIPS_loop_unroll_factor
:
7848 return "DW_AT_MIPS_loop_unroll_factor";
7849 case DW_AT_MIPS_software_pipeline_depth
:
7850 return "DW_AT_MIPS_software_pipeline_depth";
7852 case DW_AT_MIPS_linkage_name
:
7853 return "DW_AT_MIPS_linkage_name";
7855 case DW_AT_sf_names
:
7856 return "DW_AT_sf_names";
7857 case DW_AT_src_info
:
7858 return "DW_AT_src_info";
7859 case DW_AT_mac_info
:
7860 return "DW_AT_mac_info";
7861 case DW_AT_src_coords
:
7862 return "DW_AT_src_coords";
7863 case DW_AT_body_begin
:
7864 return "DW_AT_body_begin";
7865 case DW_AT_body_end
:
7866 return "DW_AT_body_end";
7867 case DW_AT_GNU_vector
:
7868 return "DW_AT_GNU_vector";
7870 return "DW_AT_<unknown>";
7874 /* Convert a DWARF value form code into its string name. */
7877 dwarf_form_name (unsigned form
)
7882 return "DW_FORM_addr";
7883 case DW_FORM_block2
:
7884 return "DW_FORM_block2";
7885 case DW_FORM_block4
:
7886 return "DW_FORM_block4";
7888 return "DW_FORM_data2";
7890 return "DW_FORM_data4";
7892 return "DW_FORM_data8";
7893 case DW_FORM_string
:
7894 return "DW_FORM_string";
7896 return "DW_FORM_block";
7897 case DW_FORM_block1
:
7898 return "DW_FORM_block1";
7900 return "DW_FORM_data1";
7902 return "DW_FORM_flag";
7904 return "DW_FORM_sdata";
7906 return "DW_FORM_strp";
7908 return "DW_FORM_udata";
7909 case DW_FORM_ref_addr
:
7910 return "DW_FORM_ref_addr";
7912 return "DW_FORM_ref1";
7914 return "DW_FORM_ref2";
7916 return "DW_FORM_ref4";
7918 return "DW_FORM_ref8";
7919 case DW_FORM_ref_udata
:
7920 return "DW_FORM_ref_udata";
7921 case DW_FORM_indirect
:
7922 return "DW_FORM_indirect";
7924 return "DW_FORM_<unknown>";
7928 /* Convert a DWARF stack opcode into its string name. */
7931 dwarf_stack_op_name (unsigned op
)
7936 return "DW_OP_addr";
7938 return "DW_OP_deref";
7940 return "DW_OP_const1u";
7942 return "DW_OP_const1s";
7944 return "DW_OP_const2u";
7946 return "DW_OP_const2s";
7948 return "DW_OP_const4u";
7950 return "DW_OP_const4s";
7952 return "DW_OP_const8u";
7954 return "DW_OP_const8s";
7956 return "DW_OP_constu";
7958 return "DW_OP_consts";
7962 return "DW_OP_drop";
7964 return "DW_OP_over";
7966 return "DW_OP_pick";
7968 return "DW_OP_swap";
7972 return "DW_OP_xderef";
7980 return "DW_OP_minus";
7992 return "DW_OP_plus";
7993 case DW_OP_plus_uconst
:
7994 return "DW_OP_plus_uconst";
8000 return "DW_OP_shra";
8018 return "DW_OP_skip";
8020 return "DW_OP_lit0";
8022 return "DW_OP_lit1";
8024 return "DW_OP_lit2";
8026 return "DW_OP_lit3";
8028 return "DW_OP_lit4";
8030 return "DW_OP_lit5";
8032 return "DW_OP_lit6";
8034 return "DW_OP_lit7";
8036 return "DW_OP_lit8";
8038 return "DW_OP_lit9";
8040 return "DW_OP_lit10";
8042 return "DW_OP_lit11";
8044 return "DW_OP_lit12";
8046 return "DW_OP_lit13";
8048 return "DW_OP_lit14";
8050 return "DW_OP_lit15";
8052 return "DW_OP_lit16";
8054 return "DW_OP_lit17";
8056 return "DW_OP_lit18";
8058 return "DW_OP_lit19";
8060 return "DW_OP_lit20";
8062 return "DW_OP_lit21";
8064 return "DW_OP_lit22";
8066 return "DW_OP_lit23";
8068 return "DW_OP_lit24";
8070 return "DW_OP_lit25";
8072 return "DW_OP_lit26";
8074 return "DW_OP_lit27";
8076 return "DW_OP_lit28";
8078 return "DW_OP_lit29";
8080 return "DW_OP_lit30";
8082 return "DW_OP_lit31";
8084 return "DW_OP_reg0";
8086 return "DW_OP_reg1";
8088 return "DW_OP_reg2";
8090 return "DW_OP_reg3";
8092 return "DW_OP_reg4";
8094 return "DW_OP_reg5";
8096 return "DW_OP_reg6";
8098 return "DW_OP_reg7";
8100 return "DW_OP_reg8";
8102 return "DW_OP_reg9";
8104 return "DW_OP_reg10";
8106 return "DW_OP_reg11";
8108 return "DW_OP_reg12";
8110 return "DW_OP_reg13";
8112 return "DW_OP_reg14";
8114 return "DW_OP_reg15";
8116 return "DW_OP_reg16";
8118 return "DW_OP_reg17";
8120 return "DW_OP_reg18";
8122 return "DW_OP_reg19";
8124 return "DW_OP_reg20";
8126 return "DW_OP_reg21";
8128 return "DW_OP_reg22";
8130 return "DW_OP_reg23";
8132 return "DW_OP_reg24";
8134 return "DW_OP_reg25";
8136 return "DW_OP_reg26";
8138 return "DW_OP_reg27";
8140 return "DW_OP_reg28";
8142 return "DW_OP_reg29";
8144 return "DW_OP_reg30";
8146 return "DW_OP_reg31";
8148 return "DW_OP_breg0";
8150 return "DW_OP_breg1";
8152 return "DW_OP_breg2";
8154 return "DW_OP_breg3";
8156 return "DW_OP_breg4";
8158 return "DW_OP_breg5";
8160 return "DW_OP_breg6";
8162 return "DW_OP_breg7";
8164 return "DW_OP_breg8";
8166 return "DW_OP_breg9";
8168 return "DW_OP_breg10";
8170 return "DW_OP_breg11";
8172 return "DW_OP_breg12";
8174 return "DW_OP_breg13";
8176 return "DW_OP_breg14";
8178 return "DW_OP_breg15";
8180 return "DW_OP_breg16";
8182 return "DW_OP_breg17";
8184 return "DW_OP_breg18";
8186 return "DW_OP_breg19";
8188 return "DW_OP_breg20";
8190 return "DW_OP_breg21";
8192 return "DW_OP_breg22";
8194 return "DW_OP_breg23";
8196 return "DW_OP_breg24";
8198 return "DW_OP_breg25";
8200 return "DW_OP_breg26";
8202 return "DW_OP_breg27";
8204 return "DW_OP_breg28";
8206 return "DW_OP_breg29";
8208 return "DW_OP_breg30";
8210 return "DW_OP_breg31";
8212 return "DW_OP_regx";
8214 return "DW_OP_fbreg";
8216 return "DW_OP_bregx";
8218 return "DW_OP_piece";
8219 case DW_OP_deref_size
:
8220 return "DW_OP_deref_size";
8221 case DW_OP_xderef_size
:
8222 return "DW_OP_xderef_size";
8225 /* DWARF 3 extensions. */
8226 case DW_OP_push_object_address
:
8227 return "DW_OP_push_object_address";
8229 return "DW_OP_call2";
8231 return "DW_OP_call4";
8232 case DW_OP_call_ref
:
8233 return "DW_OP_call_ref";
8234 /* GNU extensions. */
8235 case DW_OP_GNU_push_tls_address
:
8236 return "DW_OP_GNU_push_tls_address";
8238 return "OP_<unknown>";
8243 dwarf_bool_name (unsigned mybool
)
8251 /* Convert a DWARF type code into its string name. */
8254 dwarf_type_encoding_name (unsigned enc
)
8258 case DW_ATE_address
:
8259 return "DW_ATE_address";
8260 case DW_ATE_boolean
:
8261 return "DW_ATE_boolean";
8262 case DW_ATE_complex_float
:
8263 return "DW_ATE_complex_float";
8265 return "DW_ATE_float";
8267 return "DW_ATE_signed";
8268 case DW_ATE_signed_char
:
8269 return "DW_ATE_signed_char";
8270 case DW_ATE_unsigned
:
8271 return "DW_ATE_unsigned";
8272 case DW_ATE_unsigned_char
:
8273 return "DW_ATE_unsigned_char";
8274 case DW_ATE_imaginary_float
:
8275 return "DW_ATE_imaginary_float";
8277 return "DW_ATE_<unknown>";
8281 /* Convert a DWARF call frame info operation to its string name. */
8285 dwarf_cfi_name (unsigned cfi_opc
)
8289 case DW_CFA_advance_loc
:
8290 return "DW_CFA_advance_loc";
8292 return "DW_CFA_offset";
8293 case DW_CFA_restore
:
8294 return "DW_CFA_restore";
8296 return "DW_CFA_nop";
8297 case DW_CFA_set_loc
:
8298 return "DW_CFA_set_loc";
8299 case DW_CFA_advance_loc1
:
8300 return "DW_CFA_advance_loc1";
8301 case DW_CFA_advance_loc2
:
8302 return "DW_CFA_advance_loc2";
8303 case DW_CFA_advance_loc4
:
8304 return "DW_CFA_advance_loc4";
8305 case DW_CFA_offset_extended
:
8306 return "DW_CFA_offset_extended";
8307 case DW_CFA_restore_extended
:
8308 return "DW_CFA_restore_extended";
8309 case DW_CFA_undefined
:
8310 return "DW_CFA_undefined";
8311 case DW_CFA_same_value
:
8312 return "DW_CFA_same_value";
8313 case DW_CFA_register
:
8314 return "DW_CFA_register";
8315 case DW_CFA_remember_state
:
8316 return "DW_CFA_remember_state";
8317 case DW_CFA_restore_state
:
8318 return "DW_CFA_restore_state";
8319 case DW_CFA_def_cfa
:
8320 return "DW_CFA_def_cfa";
8321 case DW_CFA_def_cfa_register
:
8322 return "DW_CFA_def_cfa_register";
8323 case DW_CFA_def_cfa_offset
:
8324 return "DW_CFA_def_cfa_offset";
8327 case DW_CFA_def_cfa_expression
:
8328 return "DW_CFA_def_cfa_expression";
8329 case DW_CFA_expression
:
8330 return "DW_CFA_expression";
8331 case DW_CFA_offset_extended_sf
:
8332 return "DW_CFA_offset_extended_sf";
8333 case DW_CFA_def_cfa_sf
:
8334 return "DW_CFA_def_cfa_sf";
8335 case DW_CFA_def_cfa_offset_sf
:
8336 return "DW_CFA_def_cfa_offset_sf";
8338 /* SGI/MIPS specific */
8339 case DW_CFA_MIPS_advance_loc8
:
8340 return "DW_CFA_MIPS_advance_loc8";
8342 /* GNU extensions */
8343 case DW_CFA_GNU_window_save
:
8344 return "DW_CFA_GNU_window_save";
8345 case DW_CFA_GNU_args_size
:
8346 return "DW_CFA_GNU_args_size";
8347 case DW_CFA_GNU_negative_offset_extended
:
8348 return "DW_CFA_GNU_negative_offset_extended";
8351 return "DW_CFA_<unknown>";
8357 dump_die (struct die_info
*die
)
8361 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8362 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8363 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8364 dwarf_bool_name (die
->child
!= NULL
));
8366 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8367 for (i
= 0; i
< die
->num_attrs
; ++i
)
8369 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8370 dwarf_attr_name (die
->attrs
[i
].name
),
8371 dwarf_form_name (die
->attrs
[i
].form
));
8372 switch (die
->attrs
[i
].form
)
8374 case DW_FORM_ref_addr
:
8376 fprintf_unfiltered (gdb_stderr
, "address: ");
8377 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8379 case DW_FORM_block2
:
8380 case DW_FORM_block4
:
8382 case DW_FORM_block1
:
8383 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8388 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8389 (long) (DW_ADDR (&die
->attrs
[i
])));
8397 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8399 case DW_FORM_string
:
8401 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8402 DW_STRING (&die
->attrs
[i
])
8403 ? DW_STRING (&die
->attrs
[i
]) : "");
8406 if (DW_UNSND (&die
->attrs
[i
]))
8407 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8409 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8411 case DW_FORM_indirect
:
8412 /* the reader will have reduced the indirect form to
8413 the "base form" so this form should not occur */
8414 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8417 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8418 die
->attrs
[i
].form
);
8420 fprintf_unfiltered (gdb_stderr
, "\n");
8425 dump_die_list (struct die_info
*die
)
8430 if (die
->child
!= NULL
)
8431 dump_die_list (die
->child
);
8432 if (die
->sibling
!= NULL
)
8433 dump_die_list (die
->sibling
);
8438 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8439 struct dwarf2_cu
*cu
)
8442 struct die_info
*old
;
8444 h
= (offset
% REF_HASH_SIZE
);
8445 old
= cu
->die_ref_table
[h
];
8446 die
->next_ref
= old
;
8447 cu
->die_ref_table
[h
] = die
;
8451 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8453 unsigned int result
= 0;
8457 case DW_FORM_ref_addr
:
8462 case DW_FORM_ref_udata
:
8463 result
= DW_ADDR (attr
);
8466 complaint (&symfile_complaints
,
8467 _("unsupported die ref attribute form: '%s'"),
8468 dwarf_form_name (attr
->form
));
8473 /* Return the constant value held by the given attribute. Return -1
8474 if the value held by the attribute is not constant. */
8477 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8479 if (attr
->form
== DW_FORM_sdata
)
8480 return DW_SND (attr
);
8481 else if (attr
->form
== DW_FORM_udata
8482 || attr
->form
== DW_FORM_data1
8483 || attr
->form
== DW_FORM_data2
8484 || attr
->form
== DW_FORM_data4
8485 || attr
->form
== DW_FORM_data8
)
8486 return DW_UNSND (attr
);
8489 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8490 dwarf_form_name (attr
->form
));
8491 return default_value
;
8495 static struct die_info
*
8496 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8497 struct dwarf2_cu
*cu
)
8499 struct die_info
*die
;
8500 unsigned int offset
;
8502 struct die_info temp_die
;
8503 struct dwarf2_cu
*target_cu
;
8505 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8507 if (DW_ADDR (attr
) < cu
->header
.offset
8508 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8510 struct dwarf2_per_cu_data
*per_cu
;
8511 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8513 target_cu
= per_cu
->cu
;
8518 h
= (offset
% REF_HASH_SIZE
);
8519 die
= target_cu
->die_ref_table
[h
];
8522 if (die
->offset
== offset
)
8524 die
= die
->next_ref
;
8527 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8528 "at 0x%lx [in module %s]"),
8529 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8534 static struct type
*
8535 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8536 struct dwarf2_cu
*cu
)
8538 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8540 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8541 typeid, objfile
->name
);
8544 /* Look for this particular type in the fundamental type vector. If
8545 one is not found, create and install one appropriate for the
8546 current language and the current target machine. */
8548 if (cu
->ftypes
[typeid] == NULL
)
8550 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8553 return (cu
->ftypes
[typeid]);
8556 /* Decode simple location descriptions.
8557 Given a pointer to a dwarf block that defines a location, compute
8558 the location and return the value.
8560 NOTE drow/2003-11-18: This function is called in two situations
8561 now: for the address of static or global variables (partial symbols
8562 only) and for offsets into structures which are expected to be
8563 (more or less) constant. The partial symbol case should go away,
8564 and only the constant case should remain. That will let this
8565 function complain more accurately. A few special modes are allowed
8566 without complaint for global variables (for instance, global
8567 register values and thread-local values).
8569 A location description containing no operations indicates that the
8570 object is optimized out. The return value is 0 for that case.
8571 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8572 callers will only want a very basic result and this can become a
8575 Note that stack[0] is unused except as a default error return.
8576 Note that stack overflow is not yet handled. */
8579 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8581 struct objfile
*objfile
= cu
->objfile
;
8582 struct comp_unit_head
*cu_header
= &cu
->header
;
8584 int size
= blk
->size
;
8585 char *data
= blk
->data
;
8586 CORE_ADDR stack
[64];
8588 unsigned int bytes_read
, unsnd
;
8632 stack
[++stacki
] = op
- DW_OP_lit0
;
8667 stack
[++stacki
] = op
- DW_OP_reg0
;
8669 dwarf2_complex_location_expr_complaint ();
8673 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8675 stack
[++stacki
] = unsnd
;
8677 dwarf2_complex_location_expr_complaint ();
8681 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8687 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8692 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8697 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8702 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8707 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8712 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8717 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8723 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8728 stack
[stacki
+ 1] = stack
[stacki
];
8733 stack
[stacki
- 1] += stack
[stacki
];
8737 case DW_OP_plus_uconst
:
8738 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8743 stack
[stacki
- 1] -= stack
[stacki
];
8748 /* If we're not the last op, then we definitely can't encode
8749 this using GDB's address_class enum. This is valid for partial
8750 global symbols, although the variable's address will be bogus
8753 dwarf2_complex_location_expr_complaint ();
8756 case DW_OP_GNU_push_tls_address
:
8757 /* The top of the stack has the offset from the beginning
8758 of the thread control block at which the variable is located. */
8759 /* Nothing should follow this operator, so the top of stack would
8761 /* This is valid for partial global symbols, but the variable's
8762 address will be bogus in the psymtab. */
8764 dwarf2_complex_location_expr_complaint ();
8768 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8769 dwarf_stack_op_name (op
));
8770 return (stack
[stacki
]);
8773 return (stack
[stacki
]);
8776 /* memory allocation interface */
8778 static struct dwarf_block
*
8779 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8781 struct dwarf_block
*blk
;
8783 blk
= (struct dwarf_block
*)
8784 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8788 static struct abbrev_info
*
8789 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8791 struct abbrev_info
*abbrev
;
8793 abbrev
= (struct abbrev_info
*)
8794 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8795 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8799 static struct die_info
*
8800 dwarf_alloc_die (void)
8802 struct die_info
*die
;
8804 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8805 memset (die
, 0, sizeof (struct die_info
));
8810 /* Macro support. */
8813 /* Return the full name of file number I in *LH's file name table.
8814 Use COMP_DIR as the name of the current directory of the
8815 compilation. The result is allocated using xmalloc; the caller is
8816 responsible for freeing it. */
8818 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8820 /* Is the file number a valid index into the line header's file name
8821 table? Remember that file numbers start with one, not zero. */
8822 if (1 <= file
&& file
<= lh
->num_file_names
)
8824 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8826 if (IS_ABSOLUTE_PATH (fe
->name
))
8827 return xstrdup (fe
->name
);
8835 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8841 dir_len
= strlen (dir
);
8842 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8843 strcpy (full_name
, dir
);
8844 full_name
[dir_len
] = '/';
8845 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8849 return xstrdup (fe
->name
);
8854 /* The compiler produced a bogus file number. We can at least
8855 record the macro definitions made in the file, even if we
8856 won't be able to find the file by name. */
8858 sprintf (fake_name
, "<bad macro file number %d>", file
);
8860 complaint (&symfile_complaints
,
8861 _("bad file number in macro information (%d)"),
8864 return xstrdup (fake_name
);
8869 static struct macro_source_file
*
8870 macro_start_file (int file
, int line
,
8871 struct macro_source_file
*current_file
,
8872 const char *comp_dir
,
8873 struct line_header
*lh
, struct objfile
*objfile
)
8875 /* The full name of this source file. */
8876 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8878 /* We don't create a macro table for this compilation unit
8879 at all until we actually get a filename. */
8880 if (! pending_macros
)
8881 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8882 objfile
->macro_cache
);
8885 /* If we have no current file, then this must be the start_file
8886 directive for the compilation unit's main source file. */
8887 current_file
= macro_set_main (pending_macros
, full_name
);
8889 current_file
= macro_include (current_file
, line
, full_name
);
8893 return current_file
;
8897 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8898 followed by a null byte. */
8900 copy_string (const char *buf
, int len
)
8902 char *s
= xmalloc (len
+ 1);
8903 memcpy (s
, buf
, len
);
8911 consume_improper_spaces (const char *p
, const char *body
)
8915 complaint (&symfile_complaints
,
8916 _("macro definition contains spaces in formal argument list:\n`%s'"),
8928 parse_macro_definition (struct macro_source_file
*file
, int line
,
8933 /* The body string takes one of two forms. For object-like macro
8934 definitions, it should be:
8936 <macro name> " " <definition>
8938 For function-like macro definitions, it should be:
8940 <macro name> "() " <definition>
8942 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8944 Spaces may appear only where explicitly indicated, and in the
8947 The Dwarf 2 spec says that an object-like macro's name is always
8948 followed by a space, but versions of GCC around March 2002 omit
8949 the space when the macro's definition is the empty string.
8951 The Dwarf 2 spec says that there should be no spaces between the
8952 formal arguments in a function-like macro's formal argument list,
8953 but versions of GCC around March 2002 include spaces after the
8957 /* Find the extent of the macro name. The macro name is terminated
8958 by either a space or null character (for an object-like macro) or
8959 an opening paren (for a function-like macro). */
8960 for (p
= body
; *p
; p
++)
8961 if (*p
== ' ' || *p
== '(')
8964 if (*p
== ' ' || *p
== '\0')
8966 /* It's an object-like macro. */
8967 int name_len
= p
- body
;
8968 char *name
= copy_string (body
, name_len
);
8969 const char *replacement
;
8972 replacement
= body
+ name_len
+ 1;
8975 dwarf2_macro_malformed_definition_complaint (body
);
8976 replacement
= body
+ name_len
;
8979 macro_define_object (file
, line
, name
, replacement
);
8985 /* It's a function-like macro. */
8986 char *name
= copy_string (body
, p
- body
);
8989 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
8993 p
= consume_improper_spaces (p
, body
);
8995 /* Parse the formal argument list. */
8996 while (*p
&& *p
!= ')')
8998 /* Find the extent of the current argument name. */
8999 const char *arg_start
= p
;
9001 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9004 if (! *p
|| p
== arg_start
)
9005 dwarf2_macro_malformed_definition_complaint (body
);
9008 /* Make sure argv has room for the new argument. */
9009 if (argc
>= argv_size
)
9012 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9015 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9018 p
= consume_improper_spaces (p
, body
);
9020 /* Consume the comma, if present. */
9025 p
= consume_improper_spaces (p
, body
);
9034 /* Perfectly formed definition, no complaints. */
9035 macro_define_function (file
, line
, name
,
9036 argc
, (const char **) argv
,
9038 else if (*p
== '\0')
9040 /* Complain, but do define it. */
9041 dwarf2_macro_malformed_definition_complaint (body
);
9042 macro_define_function (file
, line
, name
,
9043 argc
, (const char **) argv
,
9047 /* Just complain. */
9048 dwarf2_macro_malformed_definition_complaint (body
);
9051 /* Just complain. */
9052 dwarf2_macro_malformed_definition_complaint (body
);
9058 for (i
= 0; i
< argc
; i
++)
9064 dwarf2_macro_malformed_definition_complaint (body
);
9069 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9070 char *comp_dir
, bfd
*abfd
,
9071 struct dwarf2_cu
*cu
)
9073 char *mac_ptr
, *mac_end
;
9074 struct macro_source_file
*current_file
= 0;
9076 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9078 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9082 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9083 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9084 + dwarf2_per_objfile
->macinfo_size
;
9088 enum dwarf_macinfo_record_type macinfo_type
;
9090 /* Do we at least have room for a macinfo type byte? */
9091 if (mac_ptr
>= mac_end
)
9093 dwarf2_macros_too_long_complaint ();
9097 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9100 switch (macinfo_type
)
9102 /* A zero macinfo type indicates the end of the macro
9107 case DW_MACINFO_define
:
9108 case DW_MACINFO_undef
:
9114 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9115 mac_ptr
+= bytes_read
;
9116 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9117 mac_ptr
+= bytes_read
;
9120 complaint (&symfile_complaints
,
9121 _("debug info gives macro %s outside of any file: %s"),
9123 DW_MACINFO_define
? "definition" : macinfo_type
==
9124 DW_MACINFO_undef
? "undefinition" :
9125 "something-or-other", body
);
9128 if (macinfo_type
== DW_MACINFO_define
)
9129 parse_macro_definition (current_file
, line
, body
);
9130 else if (macinfo_type
== DW_MACINFO_undef
)
9131 macro_undef (current_file
, line
, body
);
9136 case DW_MACINFO_start_file
:
9141 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9142 mac_ptr
+= bytes_read
;
9143 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9144 mac_ptr
+= bytes_read
;
9146 current_file
= macro_start_file (file
, line
,
9147 current_file
, comp_dir
,
9152 case DW_MACINFO_end_file
:
9154 complaint (&symfile_complaints
,
9155 _("macro debug info has an unmatched `close_file' directive"));
9158 current_file
= current_file
->included_by
;
9161 enum dwarf_macinfo_record_type next_type
;
9163 /* GCC circa March 2002 doesn't produce the zero
9164 type byte marking the end of the compilation
9165 unit. Complain if it's not there, but exit no
9168 /* Do we at least have room for a macinfo type byte? */
9169 if (mac_ptr
>= mac_end
)
9171 dwarf2_macros_too_long_complaint ();
9175 /* We don't increment mac_ptr here, so this is just
9177 next_type
= read_1_byte (abfd
, mac_ptr
);
9179 complaint (&symfile_complaints
,
9180 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9187 case DW_MACINFO_vendor_ext
:
9193 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9194 mac_ptr
+= bytes_read
;
9195 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9196 mac_ptr
+= bytes_read
;
9198 /* We don't recognize any vendor extensions. */
9205 /* Check if the attribute's form is a DW_FORM_block*
9206 if so return true else false. */
9208 attr_form_is_block (struct attribute
*attr
)
9210 return (attr
== NULL
? 0 :
9211 attr
->form
== DW_FORM_block1
9212 || attr
->form
== DW_FORM_block2
9213 || attr
->form
== DW_FORM_block4
9214 || attr
->form
== DW_FORM_block
);
9218 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9219 struct dwarf2_cu
*cu
)
9221 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9223 struct dwarf2_loclist_baton
*baton
;
9225 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9226 sizeof (struct dwarf2_loclist_baton
));
9227 baton
->objfile
= cu
->objfile
;
9229 /* We don't know how long the location list is, but make sure we
9230 don't run off the edge of the section. */
9231 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9232 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9233 baton
->base_address
= cu
->header
.base_address
;
9234 if (cu
->header
.base_known
== 0)
9235 complaint (&symfile_complaints
,
9236 _("Location list used without specifying the CU base address."));
9238 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9239 SYMBOL_LOCATION_BATON (sym
) = baton
;
9243 struct dwarf2_locexpr_baton
*baton
;
9245 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9246 sizeof (struct dwarf2_locexpr_baton
));
9247 baton
->objfile
= cu
->objfile
;
9249 if (attr_form_is_block (attr
))
9251 /* Note that we're just copying the block's data pointer
9252 here, not the actual data. We're still pointing into the
9253 info_buffer for SYM's objfile; right now we never release
9254 that buffer, but when we do clean up properly this may
9256 baton
->size
= DW_BLOCK (attr
)->size
;
9257 baton
->data
= DW_BLOCK (attr
)->data
;
9261 dwarf2_invalid_attrib_class_complaint ("location description",
9262 SYMBOL_NATURAL_NAME (sym
));
9267 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9268 SYMBOL_LOCATION_BATON (sym
) = baton
;
9272 /* Locate the compilation unit from CU's objfile which contains the
9273 DIE at OFFSET. Raises an error on failure. */
9275 static struct dwarf2_per_cu_data
*
9276 dwarf2_find_containing_comp_unit (unsigned long offset
,
9277 struct objfile
*objfile
)
9279 struct dwarf2_per_cu_data
*this_cu
;
9283 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9286 int mid
= low
+ (high
- low
) / 2;
9287 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9292 gdb_assert (low
== high
);
9293 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9296 error (_("Dwarf Error: could not find partial DIE containing "
9297 "offset 0x%lx [in module %s]"),
9298 (long) offset
, bfd_get_filename (objfile
->obfd
));
9300 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9301 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9305 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9306 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9307 && offset
>= this_cu
->offset
+ this_cu
->length
)
9308 error (_("invalid dwarf2 offset %ld"), offset
);
9309 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9314 /* Locate the compilation unit from OBJFILE which is located at exactly
9315 OFFSET. Raises an error on failure. */
9317 static struct dwarf2_per_cu_data
*
9318 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9320 struct dwarf2_per_cu_data
*this_cu
;
9321 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9322 if (this_cu
->offset
!= offset
)
9323 error (_("no compilation unit with offset %ld."), offset
);
9327 /* Release one cached compilation unit, CU. We unlink it from the tree
9328 of compilation units, but we don't remove it from the read_in_chain;
9329 the caller is responsible for that. */
9332 free_one_comp_unit (void *data
)
9334 struct dwarf2_cu
*cu
= data
;
9336 if (cu
->per_cu
!= NULL
)
9337 cu
->per_cu
->cu
= NULL
;
9340 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9342 free_die_list (cu
->dies
);
9347 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9348 when we're finished with it. We can't free the pointer itself, but be
9349 sure to unlink it from the cache. Also release any associated storage
9350 and perform cache maintenance.
9352 Only used during partial symbol parsing. */
9355 free_stack_comp_unit (void *data
)
9357 struct dwarf2_cu
*cu
= data
;
9359 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9360 cu
->partial_dies
= NULL
;
9362 if (cu
->per_cu
!= NULL
)
9364 /* This compilation unit is on the stack in our caller, so we
9365 should not xfree it. Just unlink it. */
9366 cu
->per_cu
->cu
= NULL
;
9369 /* If we had a per-cu pointer, then we may have other compilation
9370 units loaded, so age them now. */
9371 age_cached_comp_units ();
9375 /* Free all cached compilation units. */
9378 free_cached_comp_units (void *data
)
9380 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9382 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9383 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9384 while (per_cu
!= NULL
)
9386 struct dwarf2_per_cu_data
*next_cu
;
9388 next_cu
= per_cu
->cu
->read_in_chain
;
9390 free_one_comp_unit (per_cu
->cu
);
9391 *last_chain
= next_cu
;
9397 /* Increase the age counter on each cached compilation unit, and free
9398 any that are too old. */
9401 age_cached_comp_units (void)
9403 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9405 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9406 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9407 while (per_cu
!= NULL
)
9409 per_cu
->cu
->last_used
++;
9410 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9411 dwarf2_mark (per_cu
->cu
);
9412 per_cu
= per_cu
->cu
->read_in_chain
;
9415 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9416 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9417 while (per_cu
!= NULL
)
9419 struct dwarf2_per_cu_data
*next_cu
;
9421 next_cu
= per_cu
->cu
->read_in_chain
;
9423 if (!per_cu
->cu
->mark
)
9425 free_one_comp_unit (per_cu
->cu
);
9426 *last_chain
= next_cu
;
9429 last_chain
= &per_cu
->cu
->read_in_chain
;
9435 /* Remove a single compilation unit from the cache. */
9438 free_one_cached_comp_unit (void *target_cu
)
9440 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9442 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9443 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9444 while (per_cu
!= NULL
)
9446 struct dwarf2_per_cu_data
*next_cu
;
9448 next_cu
= per_cu
->cu
->read_in_chain
;
9450 if (per_cu
->cu
== target_cu
)
9452 free_one_comp_unit (per_cu
->cu
);
9453 *last_chain
= next_cu
;
9457 last_chain
= &per_cu
->cu
->read_in_chain
;
9463 /* A pair of DIE offset and GDB type pointer. We store these
9464 in a hash table separate from the DIEs, and preserve them
9465 when the DIEs are flushed out of cache. */
9467 struct dwarf2_offset_and_type
9469 unsigned int offset
;
9473 /* Hash function for a dwarf2_offset_and_type. */
9476 offset_and_type_hash (const void *item
)
9478 const struct dwarf2_offset_and_type
*ofs
= item
;
9482 /* Equality function for a dwarf2_offset_and_type. */
9485 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9487 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9488 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9489 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9492 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9493 table if necessary. */
9496 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9498 struct dwarf2_offset_and_type
**slot
, ofs
;
9502 if (cu
->per_cu
== NULL
)
9505 if (cu
->per_cu
->type_hash
== NULL
)
9506 cu
->per_cu
->type_hash
9507 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9508 offset_and_type_hash
,
9511 &cu
->objfile
->objfile_obstack
,
9512 hashtab_obstack_allocate
,
9513 dummy_obstack_deallocate
);
9515 ofs
.offset
= die
->offset
;
9517 slot
= (struct dwarf2_offset_and_type
**)
9518 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9519 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9523 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9524 have a saved type. */
9526 static struct type
*
9527 get_die_type (struct die_info
*die
, htab_t type_hash
)
9529 struct dwarf2_offset_and_type
*slot
, ofs
;
9531 ofs
.offset
= die
->offset
;
9532 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9539 /* Restore the types of the DIE tree starting at START_DIE from the hash
9540 table saved in CU. */
9543 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9545 struct die_info
*die
;
9547 if (cu
->per_cu
->type_hash
== NULL
)
9550 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9552 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9553 if (die
->child
!= NULL
)
9554 reset_die_and_siblings_types (die
->child
, cu
);
9558 /* Set the mark field in CU and in every other compilation unit in the
9559 cache that we must keep because we are keeping CU. */
9561 /* Add a dependence relationship from CU to REF_PER_CU. */
9564 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9565 struct dwarf2_per_cu_data
*ref_per_cu
)
9569 if (cu
->dependencies
== NULL
)
9571 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9572 NULL
, &cu
->comp_unit_obstack
,
9573 hashtab_obstack_allocate
,
9574 dummy_obstack_deallocate
);
9576 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9581 /* Set the mark field in CU and in every other compilation unit in the
9582 cache that we must keep because we are keeping CU. */
9585 dwarf2_mark_helper (void **slot
, void *data
)
9587 struct dwarf2_per_cu_data
*per_cu
;
9589 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9590 if (per_cu
->cu
->mark
)
9592 per_cu
->cu
->mark
= 1;
9594 if (per_cu
->cu
->dependencies
!= NULL
)
9595 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9601 dwarf2_mark (struct dwarf2_cu
*cu
)
9606 if (cu
->dependencies
!= NULL
)
9607 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9611 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9615 per_cu
->cu
->mark
= 0;
9616 per_cu
= per_cu
->cu
->read_in_chain
;
9620 /* Allocation function for the libiberty hash table which uses an
9624 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
9626 unsigned int total
= size
* count
;
9627 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
9628 memset (ptr
, 0, total
);
9632 /* Trivial deallocation function for the libiberty splay tree and hash
9633 table - don't deallocate anything. Rely on later deletion of the
9637 dummy_obstack_deallocate (void *object
, void *data
)
9642 /* Trivial hash function for partial_die_info: the hash value of a DIE
9643 is its offset in .debug_info for this objfile. */
9646 partial_die_hash (const void *item
)
9648 const struct partial_die_info
*part_die
= item
;
9649 return part_die
->offset
;
9652 /* Trivial comparison function for partial_die_info structures: two DIEs
9653 are equal if they have the same offset. */
9656 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9658 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9659 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9660 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9663 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9664 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9667 set_dwarf2_cmd (char *args
, int from_tty
)
9669 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9673 show_dwarf2_cmd (char *args
, int from_tty
)
9675 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9678 void _initialize_dwarf2_read (void);
9681 _initialize_dwarf2_read (void)
9683 dwarf2_objfile_data_key
= register_objfile_data ();
9685 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9686 Set DWARF 2 specific variables.\n\
9687 Configure DWARF 2 variables such as the cache size"),
9688 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9689 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9691 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9692 Show DWARF 2 specific variables\n\
9693 Show DWARF 2 variables such as the cache size"),
9694 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9695 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9697 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9698 &dwarf2_max_cache_age
, _("\
9699 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9700 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9701 A higher limit means that cached compilation units will be stored\n\
9702 in memory longer, and more total memory will be used. Zero disables\n\
9703 caching, which can slow down startup."),
9705 show_dwarf2_max_cache_age
,
9706 &set_dwarf2_cmdlist
,
9707 &show_dwarf2_cmdlist
);