1 /* DWARF 2 debugging format support for GDB.
3 Copyright 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., 59 Temple Place - Suite 330,
29 Boston, MA 02111-1307, 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
);
3860 do_cleanups (back_to
);
3863 processing_current_prefix
= previous_prefix
;
3864 if (back_to
!= NULL
)
3865 do_cleanups (back_to
);
3869 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3871 struct objfile
*objfile
= cu
->objfile
;
3872 const char *previous_prefix
= processing_current_prefix
;
3873 struct die_info
*child_die
= die
->child
;
3875 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3876 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3878 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3879 snapshots) has been known to create a die giving a declaration
3880 for a class that has, as a child, a die giving a definition for a
3881 nested class. So we have to process our children even if the
3882 current die is a declaration. Normally, of course, a declaration
3883 won't have any children at all. */
3885 while (child_die
!= NULL
&& child_die
->tag
)
3887 if (child_die
->tag
== DW_TAG_member
3888 || child_die
->tag
== DW_TAG_variable
3889 || child_die
->tag
== DW_TAG_inheritance
)
3894 process_die (child_die
, cu
);
3896 child_die
= sibling_die (child_die
);
3899 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3900 new_symbol (die
, die
->type
, cu
);
3902 processing_current_prefix
= previous_prefix
;
3905 /* Given a DW_AT_enumeration_type die, set its type. We do not
3906 complete the type's fields yet, or create any symbols. */
3909 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3911 struct objfile
*objfile
= cu
->objfile
;
3913 struct attribute
*attr
;
3918 type
= alloc_type (objfile
);
3920 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3921 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3922 if (attr
&& DW_STRING (attr
))
3924 char *name
= DW_STRING (attr
);
3926 if (processing_has_namespace_info
)
3928 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
3929 processing_current_prefix
,
3934 /* The name is already allocated along with this objfile, so
3935 we don't need to duplicate it for the type. */
3936 TYPE_TAG_NAME (type
) = name
;
3940 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3943 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3947 TYPE_LENGTH (type
) = 0;
3950 set_die_type (die
, type
, cu
);
3953 /* Determine the name of the type represented by DIE, which should be
3954 a named C++ or Java compound type. Return the name in question; the caller
3955 is responsible for xfree()'ing it. */
3958 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3960 struct cleanup
*back_to
= NULL
;
3961 struct die_info
*spec_die
= die_specification (die
, cu
);
3962 char *new_prefix
= NULL
;
3964 /* If this is the definition of a class that is declared by another
3965 die, then processing_current_prefix may not be accurate; see
3966 read_func_scope for a similar example. */
3967 if (spec_die
!= NULL
)
3969 char *specification_prefix
= determine_prefix (spec_die
, cu
);
3970 processing_current_prefix
= specification_prefix
;
3971 back_to
= make_cleanup (xfree
, specification_prefix
);
3974 /* If we don't have namespace debug info, guess the name by trying
3975 to demangle the names of members, just like we did in
3976 guess_structure_name. */
3977 if (!processing_has_namespace_info
)
3979 struct die_info
*child
;
3981 for (child
= die
->child
;
3982 child
!= NULL
&& child
->tag
!= 0;
3983 child
= sibling_die (child
))
3985 if (child
->tag
== DW_TAG_subprogram
)
3988 = language_class_name_from_physname (cu
->language_defn
,
3992 if (new_prefix
!= NULL
)
3998 if (new_prefix
== NULL
)
4000 const char *name
= dwarf2_name (die
, cu
);
4001 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4002 name
? name
: "<<anonymous>>",
4006 if (back_to
!= NULL
)
4007 do_cleanups (back_to
);
4012 /* Given a pointer to a die which begins an enumeration, process all
4013 the dies that define the members of the enumeration, and create the
4014 symbol for the enumeration type.
4016 NOTE: We reverse the order of the element list. */
4019 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4021 struct objfile
*objfile
= cu
->objfile
;
4022 struct die_info
*child_die
;
4023 struct field
*fields
;
4024 struct attribute
*attr
;
4027 int unsigned_enum
= 1;
4031 if (die
->child
!= NULL
)
4033 child_die
= die
->child
;
4034 while (child_die
&& child_die
->tag
)
4036 if (child_die
->tag
!= DW_TAG_enumerator
)
4038 process_die (child_die
, cu
);
4042 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4045 sym
= new_symbol (child_die
, die
->type
, cu
);
4046 if (SYMBOL_VALUE (sym
) < 0)
4049 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4051 fields
= (struct field
*)
4053 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4054 * sizeof (struct field
));
4057 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4058 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4059 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4060 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4061 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4067 child_die
= sibling_die (child_die
);
4072 TYPE_NFIELDS (die
->type
) = num_fields
;
4073 TYPE_FIELDS (die
->type
) = (struct field
*)
4074 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4075 memcpy (TYPE_FIELDS (die
->type
), fields
,
4076 sizeof (struct field
) * num_fields
);
4080 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4083 new_symbol (die
, die
->type
, cu
);
4086 /* Extract all information from a DW_TAG_array_type DIE and put it in
4087 the DIE's type field. For now, this only handles one dimensional
4091 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4093 struct objfile
*objfile
= cu
->objfile
;
4094 struct die_info
*child_die
;
4095 struct type
*type
= NULL
;
4096 struct type
*element_type
, *range_type
, *index_type
;
4097 struct type
**range_types
= NULL
;
4098 struct attribute
*attr
;
4100 struct cleanup
*back_to
;
4102 /* Return if we've already decoded this type. */
4108 element_type
= die_type (die
, cu
);
4110 /* Irix 6.2 native cc creates array types without children for
4111 arrays with unspecified length. */
4112 if (die
->child
== NULL
)
4114 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4115 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4116 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4121 back_to
= make_cleanup (null_cleanup
, NULL
);
4122 child_die
= die
->child
;
4123 while (child_die
&& child_die
->tag
)
4125 if (child_die
->tag
== DW_TAG_subrange_type
)
4127 read_subrange_type (child_die
, cu
);
4129 if (child_die
->type
!= NULL
)
4131 /* The range type was succesfully read. Save it for
4132 the array type creation. */
4133 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4135 range_types
= (struct type
**)
4136 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4137 * sizeof (struct type
*));
4139 make_cleanup (free_current_contents
, &range_types
);
4141 range_types
[ndim
++] = child_die
->type
;
4144 child_die
= sibling_die (child_die
);
4147 /* Dwarf2 dimensions are output from left to right, create the
4148 necessary array types in backwards order. */
4150 type
= element_type
;
4152 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4156 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4161 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4164 /* Understand Dwarf2 support for vector types (like they occur on
4165 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4166 array type. This is not part of the Dwarf2/3 standard yet, but a
4167 custom vendor extension. The main difference between a regular
4168 array and the vector variant is that vectors are passed by value
4170 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4172 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4174 do_cleanups (back_to
);
4176 /* Install the type in the die. */
4177 set_die_type (die
, type
, cu
);
4180 static enum dwarf_array_dim_ordering
4181 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4183 struct attribute
*attr
;
4185 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4187 if (attr
) return DW_SND (attr
);
4190 GNU F77 is a special case, as at 08/2004 array type info is the
4191 opposite order to the dwarf2 specification, but data is still
4192 laid out as per normal fortran.
4194 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4198 if (cu
->language
== language_fortran
&&
4199 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4201 return DW_ORD_row_major
;
4204 switch (cu
->language_defn
->la_array_ordering
)
4206 case array_column_major
:
4207 return DW_ORD_col_major
;
4208 case array_row_major
:
4210 return DW_ORD_row_major
;
4215 /* First cut: install each common block member as a global variable. */
4218 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4220 struct die_info
*child_die
;
4221 struct attribute
*attr
;
4223 CORE_ADDR base
= (CORE_ADDR
) 0;
4225 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4228 /* Support the .debug_loc offsets */
4229 if (attr_form_is_block (attr
))
4231 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4233 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4235 dwarf2_complex_location_expr_complaint ();
4239 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4240 "common block member");
4243 if (die
->child
!= NULL
)
4245 child_die
= die
->child
;
4246 while (child_die
&& child_die
->tag
)
4248 sym
= new_symbol (child_die
, NULL
, cu
);
4249 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4252 SYMBOL_VALUE_ADDRESS (sym
) =
4253 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4254 add_symbol_to_list (sym
, &global_symbols
);
4256 child_die
= sibling_die (child_die
);
4261 /* Read a C++ namespace. */
4264 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4266 struct objfile
*objfile
= cu
->objfile
;
4267 const char *previous_prefix
= processing_current_prefix
;
4270 struct die_info
*current_die
;
4271 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4273 name
= namespace_name (die
, &is_anonymous
, cu
);
4275 /* Now build the name of the current namespace. */
4277 if (previous_prefix
[0] == '\0')
4279 processing_current_prefix
= name
;
4283 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4284 make_cleanup (xfree
, temp_name
);
4285 processing_current_prefix
= temp_name
;
4288 /* Add a symbol associated to this if we haven't seen the namespace
4289 before. Also, add a using directive if it's an anonymous
4292 if (dwarf2_extension (die
, cu
) == NULL
)
4296 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4297 this cast will hopefully become unnecessary. */
4298 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4299 (char *) processing_current_prefix
,
4301 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4303 new_symbol (die
, type
, cu
);
4304 set_die_type (die
, type
, cu
);
4307 cp_add_using_directive (processing_current_prefix
,
4308 strlen (previous_prefix
),
4309 strlen (processing_current_prefix
));
4312 if (die
->child
!= NULL
)
4314 struct die_info
*child_die
= die
->child
;
4316 while (child_die
&& child_die
->tag
)
4318 process_die (child_die
, cu
);
4319 child_die
= sibling_die (child_die
);
4323 processing_current_prefix
= previous_prefix
;
4324 do_cleanups (back_to
);
4327 /* Return the name of the namespace represented by DIE. Set
4328 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4332 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4334 struct die_info
*current_die
;
4335 const char *name
= NULL
;
4337 /* Loop through the extensions until we find a name. */
4339 for (current_die
= die
;
4340 current_die
!= NULL
;
4341 current_die
= dwarf2_extension (die
, cu
))
4343 name
= dwarf2_name (current_die
, cu
);
4348 /* Is it an anonymous namespace? */
4350 *is_anonymous
= (name
== NULL
);
4352 name
= "(anonymous namespace)";
4357 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4358 the user defined type vector. */
4361 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4363 struct comp_unit_head
*cu_header
= &cu
->header
;
4365 struct attribute
*attr_byte_size
;
4366 struct attribute
*attr_address_class
;
4367 int byte_size
, addr_class
;
4374 type
= lookup_pointer_type (die_type (die
, cu
));
4376 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4378 byte_size
= DW_UNSND (attr_byte_size
);
4380 byte_size
= cu_header
->addr_size
;
4382 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4383 if (attr_address_class
)
4384 addr_class
= DW_UNSND (attr_address_class
);
4386 addr_class
= DW_ADDR_none
;
4388 /* If the pointer size or address class is different than the
4389 default, create a type variant marked as such and set the
4390 length accordingly. */
4391 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4393 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4397 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4398 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4399 type
= make_type_with_address_space (type
, type_flags
);
4401 else if (TYPE_LENGTH (type
) != byte_size
)
4403 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4406 /* Should we also complain about unhandled address classes? */
4410 TYPE_LENGTH (type
) = byte_size
;
4411 set_die_type (die
, type
, cu
);
4414 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4415 the user defined type vector. */
4418 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4420 struct objfile
*objfile
= cu
->objfile
;
4422 struct type
*to_type
;
4423 struct type
*domain
;
4430 type
= alloc_type (objfile
);
4431 to_type
= die_type (die
, cu
);
4432 domain
= die_containing_type (die
, cu
);
4433 smash_to_member_type (type
, domain
, to_type
);
4435 set_die_type (die
, type
, cu
);
4438 /* Extract all information from a DW_TAG_reference_type DIE and add to
4439 the user defined type vector. */
4442 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4444 struct comp_unit_head
*cu_header
= &cu
->header
;
4446 struct attribute
*attr
;
4453 type
= lookup_reference_type (die_type (die
, cu
));
4454 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4457 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4461 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4463 set_die_type (die
, type
, cu
);
4467 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4469 struct type
*base_type
;
4476 base_type
= die_type (die
, cu
);
4477 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4482 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4484 struct type
*base_type
;
4491 base_type
= die_type (die
, cu
);
4492 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4496 /* Extract all information from a DW_TAG_string_type DIE and add to
4497 the user defined type vector. It isn't really a user defined type,
4498 but it behaves like one, with other DIE's using an AT_user_def_type
4499 attribute to reference it. */
4502 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4504 struct objfile
*objfile
= cu
->objfile
;
4505 struct type
*type
, *range_type
, *index_type
, *char_type
;
4506 struct attribute
*attr
;
4507 unsigned int length
;
4514 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4517 length
= DW_UNSND (attr
);
4521 /* check for the DW_AT_byte_size attribute */
4522 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4525 length
= DW_UNSND (attr
);
4532 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4533 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4534 if (cu
->language
== language_fortran
)
4536 /* Need to create a unique string type for bounds
4538 type
= create_string_type (0, range_type
);
4542 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4543 type
= create_string_type (char_type
, range_type
);
4545 set_die_type (die
, type
, cu
);
4548 /* Handle DIES due to C code like:
4552 int (*funcp)(int a, long l);
4556 ('funcp' generates a DW_TAG_subroutine_type DIE)
4560 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4562 struct type
*type
; /* Type that this function returns */
4563 struct type
*ftype
; /* Function that returns above type */
4564 struct attribute
*attr
;
4566 /* Decode the type that this subroutine returns */
4571 type
= die_type (die
, cu
);
4572 ftype
= make_function_type (type
, (struct type
**) 0);
4574 /* All functions in C++ and Java have prototypes. */
4575 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4576 if ((attr
&& (DW_UNSND (attr
) != 0))
4577 || cu
->language
== language_cplus
4578 || cu
->language
== language_java
)
4579 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4581 if (die
->child
!= NULL
)
4583 struct die_info
*child_die
;
4587 /* Count the number of parameters.
4588 FIXME: GDB currently ignores vararg functions, but knows about
4589 vararg member functions. */
4590 child_die
= die
->child
;
4591 while (child_die
&& child_die
->tag
)
4593 if (child_die
->tag
== DW_TAG_formal_parameter
)
4595 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4596 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4597 child_die
= sibling_die (child_die
);
4600 /* Allocate storage for parameters and fill them in. */
4601 TYPE_NFIELDS (ftype
) = nparams
;
4602 TYPE_FIELDS (ftype
) = (struct field
*)
4603 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
4605 child_die
= die
->child
;
4606 while (child_die
&& child_die
->tag
)
4608 if (child_die
->tag
== DW_TAG_formal_parameter
)
4610 /* Dwarf2 has no clean way to discern C++ static and non-static
4611 member functions. G++ helps GDB by marking the first
4612 parameter for non-static member functions (which is the
4613 this pointer) as artificial. We pass this information
4614 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4615 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4617 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4619 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4620 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4623 child_die
= sibling_die (child_die
);
4627 set_die_type (die
, ftype
, cu
);
4631 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4633 struct objfile
*objfile
= cu
->objfile
;
4634 struct attribute
*attr
;
4639 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4640 if (attr
&& DW_STRING (attr
))
4642 name
= DW_STRING (attr
);
4644 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4645 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4647 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4651 /* Find a representation of a given base type and install
4652 it in the TYPE field of the die. */
4655 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4657 struct objfile
*objfile
= cu
->objfile
;
4659 struct attribute
*attr
;
4660 int encoding
= 0, size
= 0;
4662 /* If we've already decoded this die, this is a no-op. */
4668 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4671 encoding
= DW_UNSND (attr
);
4673 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4676 size
= DW_UNSND (attr
);
4678 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4679 if (attr
&& DW_STRING (attr
))
4681 enum type_code code
= TYPE_CODE_INT
;
4686 case DW_ATE_address
:
4687 /* Turn DW_ATE_address into a void * pointer. */
4688 code
= TYPE_CODE_PTR
;
4689 type_flags
|= TYPE_FLAG_UNSIGNED
;
4691 case DW_ATE_boolean
:
4692 code
= TYPE_CODE_BOOL
;
4693 type_flags
|= TYPE_FLAG_UNSIGNED
;
4695 case DW_ATE_complex_float
:
4696 code
= TYPE_CODE_COMPLEX
;
4699 code
= TYPE_CODE_FLT
;
4702 case DW_ATE_signed_char
:
4704 case DW_ATE_unsigned
:
4705 case DW_ATE_unsigned_char
:
4706 type_flags
|= TYPE_FLAG_UNSIGNED
;
4709 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4710 dwarf_type_encoding_name (encoding
));
4713 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4714 if (encoding
== DW_ATE_address
)
4715 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4717 else if (encoding
== DW_ATE_complex_float
)
4720 TYPE_TARGET_TYPE (type
)
4721 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4722 else if (size
== 16)
4723 TYPE_TARGET_TYPE (type
)
4724 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4726 TYPE_TARGET_TYPE (type
)
4727 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4732 type
= dwarf_base_type (encoding
, size
, cu
);
4734 set_die_type (die
, type
, cu
);
4737 /* Read the given DW_AT_subrange DIE. */
4740 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4742 struct type
*base_type
;
4743 struct type
*range_type
;
4744 struct attribute
*attr
;
4748 /* If we have already decoded this die, then nothing more to do. */
4752 base_type
= die_type (die
, cu
);
4753 if (base_type
== NULL
)
4755 complaint (&symfile_complaints
,
4756 _("DW_AT_type missing from DW_TAG_subrange_type"));
4760 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4761 base_type
= alloc_type (NULL
);
4763 if (cu
->language
== language_fortran
)
4765 /* FORTRAN implies a lower bound of 1, if not given. */
4769 /* FIXME: For variable sized arrays either of these could be
4770 a variable rather than a constant value. We'll allow it,
4771 but we don't know how to handle it. */
4772 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4774 low
= dwarf2_get_attr_constant_value (attr
, 0);
4776 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4779 if (attr
->form
== DW_FORM_block1
)
4781 /* GCC encodes arrays with unspecified or dynamic length
4782 with a DW_FORM_block1 attribute.
4783 FIXME: GDB does not yet know how to handle dynamic
4784 arrays properly, treat them as arrays with unspecified
4787 FIXME: jimb/2003-09-22: GDB does not really know
4788 how to handle arrays of unspecified length
4789 either; we just represent them as zero-length
4790 arrays. Choose an appropriate upper bound given
4791 the lower bound we've computed above. */
4795 high
= dwarf2_get_attr_constant_value (attr
, 1);
4798 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4800 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4801 if (attr
&& DW_STRING (attr
))
4802 TYPE_NAME (range_type
) = DW_STRING (attr
);
4804 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4806 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4808 set_die_type (die
, range_type
, cu
);
4812 /* Read a whole compilation unit into a linked list of dies. */
4814 static struct die_info
*
4815 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4817 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4820 /* Read a single die and all its descendents. Set the die's sibling
4821 field to NULL; set other fields in the die correctly, and set all
4822 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4823 location of the info_ptr after reading all of those dies. PARENT
4824 is the parent of the die in question. */
4826 static struct die_info
*
4827 read_die_and_children (char *info_ptr
, bfd
*abfd
,
4828 struct dwarf2_cu
*cu
,
4829 char **new_info_ptr
,
4830 struct die_info
*parent
)
4832 struct die_info
*die
;
4836 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4837 store_in_ref_table (die
->offset
, die
, cu
);
4841 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4847 *new_info_ptr
= cur_ptr
;
4850 die
->sibling
= NULL
;
4851 die
->parent
= parent
;
4855 /* Read a die, all of its descendents, and all of its siblings; set
4856 all of the fields of all of the dies correctly. Arguments are as
4857 in read_die_and_children. */
4859 static struct die_info
*
4860 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
4861 struct dwarf2_cu
*cu
,
4862 char **new_info_ptr
,
4863 struct die_info
*parent
)
4865 struct die_info
*first_die
, *last_sibling
;
4869 first_die
= last_sibling
= NULL
;
4873 struct die_info
*die
4874 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4882 last_sibling
->sibling
= die
;
4887 *new_info_ptr
= cur_ptr
;
4897 /* Free a linked list of dies. */
4900 free_die_list (struct die_info
*dies
)
4902 struct die_info
*die
, *next
;
4907 if (die
->child
!= NULL
)
4908 free_die_list (die
->child
);
4909 next
= die
->sibling
;
4916 /* Read the contents of the section at OFFSET and of size SIZE from the
4917 object file specified by OBJFILE into the objfile_obstack and return it. */
4920 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4922 bfd
*abfd
= objfile
->obfd
;
4924 bfd_size_type size
= bfd_get_section_size (sectp
);
4929 buf
= (char *) obstack_alloc (&objfile
->objfile_obstack
, size
);
4931 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
4935 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4936 || bfd_bread (buf
, size
, abfd
) != size
)
4937 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
4938 bfd_get_filename (abfd
));
4943 /* In DWARF version 2, the description of the debugging information is
4944 stored in a separate .debug_abbrev section. Before we read any
4945 dies from a section we read in all abbreviations and install them
4946 in a hash table. This function also sets flags in CU describing
4947 the data found in the abbrev table. */
4950 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4952 struct comp_unit_head
*cu_header
= &cu
->header
;
4954 struct abbrev_info
*cur_abbrev
;
4955 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4956 unsigned int abbrev_form
, hash_number
;
4957 struct attr_abbrev
*cur_attrs
;
4958 unsigned int allocated_attrs
;
4960 /* Initialize dwarf2 abbrevs */
4961 obstack_init (&cu
->abbrev_obstack
);
4962 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
4964 * sizeof (struct abbrev_info
*)));
4965 memset (cu
->dwarf2_abbrevs
, 0,
4966 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
4968 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
4969 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4970 abbrev_ptr
+= bytes_read
;
4972 allocated_attrs
= ATTR_ALLOC_CHUNK
;
4973 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
4975 /* loop until we reach an abbrev number of 0 */
4976 while (abbrev_number
)
4978 cur_abbrev
= dwarf_alloc_abbrev (cu
);
4980 /* read in abbrev header */
4981 cur_abbrev
->number
= abbrev_number
;
4982 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4983 abbrev_ptr
+= bytes_read
;
4984 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
4987 if (cur_abbrev
->tag
== DW_TAG_namespace
)
4988 cu
->has_namespace_info
= 1;
4990 /* now read in declarations */
4991 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4992 abbrev_ptr
+= bytes_read
;
4993 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4994 abbrev_ptr
+= bytes_read
;
4997 if (cur_abbrev
->num_attrs
== allocated_attrs
)
4999 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5001 = xrealloc (cur_attrs
, (allocated_attrs
5002 * sizeof (struct attr_abbrev
)));
5005 /* Record whether this compilation unit might have
5006 inter-compilation-unit references. If we don't know what form
5007 this attribute will have, then it might potentially be a
5008 DW_FORM_ref_addr, so we conservatively expect inter-CU
5011 if (abbrev_form
== DW_FORM_ref_addr
5012 || abbrev_form
== DW_FORM_indirect
)
5013 cu
->has_form_ref_addr
= 1;
5015 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5016 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5017 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5018 abbrev_ptr
+= bytes_read
;
5019 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5020 abbrev_ptr
+= bytes_read
;
5023 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5024 (cur_abbrev
->num_attrs
5025 * sizeof (struct attr_abbrev
)));
5026 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5027 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5029 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5030 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5031 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5033 /* Get next abbreviation.
5034 Under Irix6 the abbreviations for a compilation unit are not
5035 always properly terminated with an abbrev number of 0.
5036 Exit loop if we encounter an abbreviation which we have
5037 already read (which means we are about to read the abbreviations
5038 for the next compile unit) or if the end of the abbreviation
5039 table is reached. */
5040 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5041 >= dwarf2_per_objfile
->abbrev_size
)
5043 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5044 abbrev_ptr
+= bytes_read
;
5045 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5052 /* Release the memory used by the abbrev table for a compilation unit. */
5055 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5057 struct dwarf2_cu
*cu
= ptr_to_cu
;
5059 obstack_free (&cu
->abbrev_obstack
, NULL
);
5060 cu
->dwarf2_abbrevs
= NULL
;
5063 /* Lookup an abbrev_info structure in the abbrev hash table. */
5065 static struct abbrev_info
*
5066 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5068 unsigned int hash_number
;
5069 struct abbrev_info
*abbrev
;
5071 hash_number
= number
% ABBREV_HASH_SIZE
;
5072 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5076 if (abbrev
->number
== number
)
5079 abbrev
= abbrev
->next
;
5084 /* Returns nonzero if TAG represents a type that we might generate a partial
5088 is_type_tag_for_partial (int tag
)
5093 /* Some types that would be reasonable to generate partial symbols for,
5094 that we don't at present. */
5095 case DW_TAG_array_type
:
5096 case DW_TAG_file_type
:
5097 case DW_TAG_ptr_to_member_type
:
5098 case DW_TAG_set_type
:
5099 case DW_TAG_string_type
:
5100 case DW_TAG_subroutine_type
:
5102 case DW_TAG_base_type
:
5103 case DW_TAG_class_type
:
5104 case DW_TAG_enumeration_type
:
5105 case DW_TAG_structure_type
:
5106 case DW_TAG_subrange_type
:
5107 case DW_TAG_typedef
:
5108 case DW_TAG_union_type
:
5115 /* Load all DIEs that are interesting for partial symbols into memory. */
5117 static struct partial_die_info
*
5118 load_partial_dies (bfd
*abfd
, char *info_ptr
, int building_psymtab
,
5119 struct dwarf2_cu
*cu
)
5121 struct partial_die_info
*part_die
;
5122 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5123 struct abbrev_info
*abbrev
;
5124 unsigned int bytes_read
;
5126 int nesting_level
= 1;
5132 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5136 &cu
->comp_unit_obstack
,
5137 hashtab_obstack_allocate
,
5138 dummy_obstack_deallocate
);
5140 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5141 sizeof (struct partial_die_info
));
5145 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5147 /* A NULL abbrev means the end of a series of children. */
5150 if (--nesting_level
== 0)
5152 /* PART_DIE was probably the last thing allocated on the
5153 comp_unit_obstack, so we could call obstack_free
5154 here. We don't do that because the waste is small,
5155 and will be cleaned up when we're done with this
5156 compilation unit. This way, we're also more robust
5157 against other users of the comp_unit_obstack. */
5160 info_ptr
+= bytes_read
;
5161 last_die
= parent_die
;
5162 parent_die
= parent_die
->die_parent
;
5166 /* Check whether this DIE is interesting enough to save. */
5167 if (!is_type_tag_for_partial (abbrev
->tag
)
5168 && abbrev
->tag
!= DW_TAG_enumerator
5169 && abbrev
->tag
!= DW_TAG_subprogram
5170 && abbrev
->tag
!= DW_TAG_variable
5171 && abbrev
->tag
!= DW_TAG_namespace
)
5173 /* Otherwise we skip to the next sibling, if any. */
5174 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5178 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5179 abfd
, info_ptr
, cu
);
5181 /* This two-pass algorithm for processing partial symbols has a
5182 high cost in cache pressure. Thus, handle some simple cases
5183 here which cover the majority of C partial symbols. DIEs
5184 which neither have specification tags in them, nor could have
5185 specification tags elsewhere pointing at them, can simply be
5186 processed and discarded.
5188 This segment is also optional; scan_partial_symbols and
5189 add_partial_symbol will handle these DIEs if we chain
5190 them in normally. When compilers which do not emit large
5191 quantities of duplicate debug information are more common,
5192 this code can probably be removed. */
5194 /* Any complete simple types at the top level (pretty much all
5195 of them, for a language without namespaces), can be processed
5197 if (parent_die
== NULL
5198 && part_die
->has_specification
== 0
5199 && part_die
->is_declaration
== 0
5200 && (part_die
->tag
== DW_TAG_typedef
5201 || part_die
->tag
== DW_TAG_base_type
5202 || part_die
->tag
== DW_TAG_subrange_type
))
5204 if (building_psymtab
&& part_die
->name
!= NULL
)
5205 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5206 VAR_DOMAIN
, LOC_TYPEDEF
,
5207 &cu
->objfile
->static_psymbols
,
5208 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5209 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5213 /* If we're at the second level, and we're an enumerator, and
5214 our parent has no specification (meaning possibly lives in a
5215 namespace elsewhere), then we can add the partial symbol now
5216 instead of queueing it. */
5217 if (part_die
->tag
== DW_TAG_enumerator
5218 && parent_die
!= NULL
5219 && parent_die
->die_parent
== NULL
5220 && parent_die
->tag
== DW_TAG_enumeration_type
5221 && parent_die
->has_specification
== 0)
5223 if (part_die
->name
== NULL
)
5224 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5225 else if (building_psymtab
)
5226 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5227 VAR_DOMAIN
, LOC_CONST
,
5228 (cu
->language
== language_cplus
5229 || cu
->language
== language_java
)
5230 ? &cu
->objfile
->global_psymbols
5231 : &cu
->objfile
->static_psymbols
,
5232 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5234 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5238 /* We'll save this DIE so link it in. */
5239 part_die
->die_parent
= parent_die
;
5240 part_die
->die_sibling
= NULL
;
5241 part_die
->die_child
= NULL
;
5243 if (last_die
&& last_die
== parent_die
)
5244 last_die
->die_child
= part_die
;
5246 last_die
->die_sibling
= part_die
;
5248 last_die
= part_die
;
5250 if (first_die
== NULL
)
5251 first_die
= part_die
;
5253 /* Maybe add the DIE to the hash table. Not all DIEs that we
5254 find interesting need to be in the hash table, because we
5255 also have the parent/sibling/child chains; only those that we
5256 might refer to by offset later during partial symbol reading.
5258 For now this means things that might have be the target of a
5259 DW_AT_specification, DW_AT_abstract_origin, or
5260 DW_AT_extension. DW_AT_extension will refer only to
5261 namespaces; DW_AT_abstract_origin refers to functions (and
5262 many things under the function DIE, but we do not recurse
5263 into function DIEs during partial symbol reading) and
5264 possibly variables as well; DW_AT_specification refers to
5265 declarations. Declarations ought to have the DW_AT_declaration
5266 flag. It happens that GCC forgets to put it in sometimes, but
5267 only for functions, not for types.
5269 Adding more things than necessary to the hash table is harmless
5270 except for the performance cost. Adding too few will result in
5271 internal errors in find_partial_die. */
5273 if (abbrev
->tag
== DW_TAG_subprogram
5274 || abbrev
->tag
== DW_TAG_variable
5275 || abbrev
->tag
== DW_TAG_namespace
5276 || part_die
->is_declaration
)
5280 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5281 part_die
->offset
, INSERT
);
5285 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5286 sizeof (struct partial_die_info
));
5288 /* For some DIEs we want to follow their children (if any). For C
5289 we have no reason to follow the children of structures; for other
5290 languages we have to, both so that we can get at method physnames
5291 to infer fully qualified class names, and for DW_AT_specification. */
5292 if (last_die
->has_children
5293 && (last_die
->tag
== DW_TAG_namespace
5294 || last_die
->tag
== DW_TAG_enumeration_type
5295 || (cu
->language
!= language_c
5296 && (last_die
->tag
== DW_TAG_class_type
5297 || last_die
->tag
== DW_TAG_structure_type
5298 || last_die
->tag
== DW_TAG_union_type
))))
5301 parent_die
= last_die
;
5305 /* Otherwise we skip to the next sibling, if any. */
5306 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5308 /* Back to the top, do it again. */
5312 /* Read a minimal amount of information into the minimal die structure. */
5315 read_partial_die (struct partial_die_info
*part_die
,
5316 struct abbrev_info
*abbrev
,
5317 unsigned int abbrev_len
, bfd
*abfd
,
5318 char *info_ptr
, struct dwarf2_cu
*cu
)
5320 unsigned int bytes_read
, i
;
5321 struct attribute attr
;
5322 int has_low_pc_attr
= 0;
5323 int has_high_pc_attr
= 0;
5325 memset (part_die
, 0, sizeof (struct partial_die_info
));
5327 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5329 info_ptr
+= abbrev_len
;
5334 part_die
->tag
= abbrev
->tag
;
5335 part_die
->has_children
= abbrev
->has_children
;
5337 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5339 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5341 /* Store the data if it is of an attribute we want to keep in a
5342 partial symbol table. */
5347 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5348 if (part_die
->name
== NULL
)
5349 part_die
->name
= DW_STRING (&attr
);
5351 case DW_AT_comp_dir
:
5352 if (part_die
->dirname
== NULL
)
5353 part_die
->dirname
= DW_STRING (&attr
);
5355 case DW_AT_MIPS_linkage_name
:
5356 part_die
->name
= DW_STRING (&attr
);
5359 has_low_pc_attr
= 1;
5360 part_die
->lowpc
= DW_ADDR (&attr
);
5363 has_high_pc_attr
= 1;
5364 part_die
->highpc
= DW_ADDR (&attr
);
5366 case DW_AT_location
:
5367 /* Support the .debug_loc offsets */
5368 if (attr_form_is_block (&attr
))
5370 part_die
->locdesc
= DW_BLOCK (&attr
);
5372 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5374 dwarf2_complex_location_expr_complaint ();
5378 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5379 "partial symbol information");
5382 case DW_AT_language
:
5383 part_die
->language
= DW_UNSND (&attr
);
5385 case DW_AT_external
:
5386 part_die
->is_external
= DW_UNSND (&attr
);
5388 case DW_AT_declaration
:
5389 part_die
->is_declaration
= DW_UNSND (&attr
);
5392 part_die
->has_type
= 1;
5394 case DW_AT_abstract_origin
:
5395 case DW_AT_specification
:
5396 case DW_AT_extension
:
5397 part_die
->has_specification
= 1;
5398 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5401 /* Ignore absolute siblings, they might point outside of
5402 the current compile unit. */
5403 if (attr
.form
== DW_FORM_ref_addr
)
5404 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5406 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5407 + dwarf2_get_ref_die_offset (&attr
, cu
);
5409 case DW_AT_stmt_list
:
5410 part_die
->has_stmt_list
= 1;
5411 part_die
->line_offset
= DW_UNSND (&attr
);
5418 /* When using the GNU linker, .gnu.linkonce. sections are used to
5419 eliminate duplicate copies of functions and vtables and such.
5420 The linker will arbitrarily choose one and discard the others.
5421 The AT_*_pc values for such functions refer to local labels in
5422 these sections. If the section from that file was discarded, the
5423 labels are not in the output, so the relocs get a value of 0.
5424 If this is a discarded function, mark the pc bounds as invalid,
5425 so that GDB will ignore it. */
5426 if (has_low_pc_attr
&& has_high_pc_attr
5427 && part_die
->lowpc
< part_die
->highpc
5428 && (part_die
->lowpc
!= 0
5429 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5430 part_die
->has_pc_info
= 1;
5434 /* Find a cached partial DIE at OFFSET in CU. */
5436 static struct partial_die_info
*
5437 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5439 struct partial_die_info
*lookup_die
= NULL
;
5440 struct partial_die_info part_die
;
5442 part_die
.offset
= offset
;
5443 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5445 if (lookup_die
== NULL
)
5446 internal_error (__FILE__
, __LINE__
,
5447 _("could not find partial DIE in cache\n"));
5452 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5454 static struct partial_die_info
*
5455 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5457 struct dwarf2_per_cu_data
*per_cu
;
5459 if (offset
>= cu
->header
.offset
5460 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5461 return find_partial_die_in_comp_unit (offset
, cu
);
5463 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5465 if (per_cu
->cu
== NULL
)
5467 load_comp_unit (per_cu
, cu
->objfile
);
5468 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5469 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5472 per_cu
->cu
->last_used
= 0;
5473 return find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5476 /* Adjust PART_DIE before generating a symbol for it. This function
5477 may set the is_external flag or change the DIE's name. */
5480 fixup_partial_die (struct partial_die_info
*part_die
,
5481 struct dwarf2_cu
*cu
)
5483 /* If we found a reference attribute and the DIE has no name, try
5484 to find a name in the referred to DIE. */
5486 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5488 struct partial_die_info
*spec_die
;
5490 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5492 fixup_partial_die (spec_die
, cu
);
5496 part_die
->name
= spec_die
->name
;
5498 /* Copy DW_AT_external attribute if it is set. */
5499 if (spec_die
->is_external
)
5500 part_die
->is_external
= spec_die
->is_external
;
5504 /* Set default names for some unnamed DIEs. */
5505 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5506 || part_die
->tag
== DW_TAG_class_type
))
5507 part_die
->name
= "(anonymous class)";
5509 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5510 part_die
->name
= "(anonymous namespace)";
5512 if (part_die
->tag
== DW_TAG_structure_type
5513 || part_die
->tag
== DW_TAG_class_type
5514 || part_die
->tag
== DW_TAG_union_type
)
5515 guess_structure_name (part_die
, cu
);
5518 /* Read the die from the .debug_info section buffer. Set DIEP to
5519 point to a newly allocated die with its information, except for its
5520 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5521 whether the die has children or not. */
5524 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
5525 struct dwarf2_cu
*cu
, int *has_children
)
5527 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5528 struct abbrev_info
*abbrev
;
5529 struct die_info
*die
;
5531 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5532 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5533 info_ptr
+= bytes_read
;
5536 die
= dwarf_alloc_die ();
5538 die
->abbrev
= abbrev_number
;
5545 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5548 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5550 bfd_get_filename (abfd
));
5552 die
= dwarf_alloc_die ();
5553 die
->offset
= offset
;
5554 die
->tag
= abbrev
->tag
;
5555 die
->abbrev
= abbrev_number
;
5558 die
->num_attrs
= abbrev
->num_attrs
;
5559 die
->attrs
= (struct attribute
*)
5560 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5562 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5564 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5565 abfd
, info_ptr
, cu
);
5567 /* If this attribute is an absolute reference to a different
5568 compilation unit, make sure that compilation unit is loaded
5570 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5571 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5572 || (DW_ADDR (&die
->attrs
[i
])
5573 >= cu
->header
.offset
+ cu
->header
.length
)))
5575 struct dwarf2_per_cu_data
*per_cu
;
5576 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5579 /* Mark the dependence relation so that we don't flush PER_CU
5581 dwarf2_add_dependence (cu
, per_cu
);
5583 /* If it's already on the queue, we have nothing to do. */
5587 /* If the compilation unit is already loaded, just mark it as
5589 if (per_cu
->cu
!= NULL
)
5591 per_cu
->cu
->last_used
= 0;
5595 /* Add it to the queue. */
5596 queue_comp_unit (per_cu
);
5601 *has_children
= abbrev
->has_children
;
5605 /* Read an attribute value described by an attribute form. */
5608 read_attribute_value (struct attribute
*attr
, unsigned form
,
5609 bfd
*abfd
, char *info_ptr
,
5610 struct dwarf2_cu
*cu
)
5612 struct comp_unit_head
*cu_header
= &cu
->header
;
5613 unsigned int bytes_read
;
5614 struct dwarf_block
*blk
;
5620 case DW_FORM_ref_addr
:
5621 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5622 info_ptr
+= bytes_read
;
5624 case DW_FORM_block2
:
5625 blk
= dwarf_alloc_block (cu
);
5626 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5628 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5629 info_ptr
+= blk
->size
;
5630 DW_BLOCK (attr
) = blk
;
5632 case DW_FORM_block4
:
5633 blk
= dwarf_alloc_block (cu
);
5634 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5636 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5637 info_ptr
+= blk
->size
;
5638 DW_BLOCK (attr
) = blk
;
5641 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5645 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5649 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5652 case DW_FORM_string
:
5653 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5654 info_ptr
+= bytes_read
;
5657 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5659 info_ptr
+= bytes_read
;
5662 blk
= dwarf_alloc_block (cu
);
5663 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5664 info_ptr
+= bytes_read
;
5665 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5666 info_ptr
+= blk
->size
;
5667 DW_BLOCK (attr
) = blk
;
5669 case DW_FORM_block1
:
5670 blk
= dwarf_alloc_block (cu
);
5671 blk
->size
= read_1_byte (abfd
, info_ptr
);
5673 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5674 info_ptr
+= blk
->size
;
5675 DW_BLOCK (attr
) = blk
;
5678 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5682 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5686 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5687 info_ptr
+= bytes_read
;
5690 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5691 info_ptr
+= bytes_read
;
5694 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5698 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5702 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5706 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5709 case DW_FORM_ref_udata
:
5710 DW_ADDR (attr
) = (cu
->header
.offset
5711 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5712 info_ptr
+= bytes_read
;
5714 case DW_FORM_indirect
:
5715 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5716 info_ptr
+= bytes_read
;
5717 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5720 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5721 dwarf_form_name (form
),
5722 bfd_get_filename (abfd
));
5727 /* Read an attribute described by an abbreviated attribute. */
5730 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5731 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
5733 attr
->name
= abbrev
->name
;
5734 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5737 /* read dwarf information from a buffer */
5740 read_1_byte (bfd
*abfd
, char *buf
)
5742 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
5746 read_1_signed_byte (bfd
*abfd
, char *buf
)
5748 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
5752 read_2_bytes (bfd
*abfd
, char *buf
)
5754 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5758 read_2_signed_bytes (bfd
*abfd
, char *buf
)
5760 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5764 read_4_bytes (bfd
*abfd
, char *buf
)
5766 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5770 read_4_signed_bytes (bfd
*abfd
, char *buf
)
5772 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5775 static unsigned long
5776 read_8_bytes (bfd
*abfd
, char *buf
)
5778 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5782 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
5784 struct comp_unit_head
*cu_header
= &cu
->header
;
5785 CORE_ADDR retval
= 0;
5787 if (cu_header
->signed_addr_p
)
5789 switch (cu_header
->addr_size
)
5792 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5795 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5798 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
5801 internal_error (__FILE__
, __LINE__
,
5802 _("read_address: bad switch, signed [in module %s]"),
5803 bfd_get_filename (abfd
));
5808 switch (cu_header
->addr_size
)
5811 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5814 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5817 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5820 internal_error (__FILE__
, __LINE__
,
5821 _("read_address: bad switch, unsigned [in module %s]"),
5822 bfd_get_filename (abfd
));
5826 *bytes_read
= cu_header
->addr_size
;
5830 /* Read the initial length from a section. The (draft) DWARF 3
5831 specification allows the initial length to take up either 4 bytes
5832 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5833 bytes describe the length and all offsets will be 8 bytes in length
5836 An older, non-standard 64-bit format is also handled by this
5837 function. The older format in question stores the initial length
5838 as an 8-byte quantity without an escape value. Lengths greater
5839 than 2^32 aren't very common which means that the initial 4 bytes
5840 is almost always zero. Since a length value of zero doesn't make
5841 sense for the 32-bit format, this initial zero can be considered to
5842 be an escape value which indicates the presence of the older 64-bit
5843 format. As written, the code can't detect (old format) lengths
5844 greater than 4GB. If it becomes necessary to handle lengths
5845 somewhat larger than 4GB, we could allow other small values (such
5846 as the non-sensical values of 1, 2, and 3) to also be used as
5847 escape values indicating the presence of the old format.
5849 The value returned via bytes_read should be used to increment the
5850 relevant pointer after calling read_initial_length().
5852 As a side effect, this function sets the fields initial_length_size
5853 and offset_size in cu_header to the values appropriate for the
5854 length field. (The format of the initial length field determines
5855 the width of file offsets to be fetched later with read_offset().)
5857 [ Note: read_initial_length() and read_offset() are based on the
5858 document entitled "DWARF Debugging Information Format", revision
5859 3, draft 8, dated November 19, 2001. This document was obtained
5862 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5864 This document is only a draft and is subject to change. (So beware.)
5866 Details regarding the older, non-standard 64-bit format were
5867 determined empirically by examining 64-bit ELF files produced by
5868 the SGI toolchain on an IRIX 6.5 machine.
5870 - Kevin, July 16, 2002
5874 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
5877 LONGEST length
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5879 if (length
== 0xffffffff)
5881 length
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
5884 else if (length
== 0)
5886 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
5887 length
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5897 gdb_assert (cu_header
->initial_length_size
== 0
5898 || cu_header
->initial_length_size
== 4
5899 || cu_header
->initial_length_size
== 8
5900 || cu_header
->initial_length_size
== 12);
5902 if (cu_header
->initial_length_size
!= 0
5903 && cu_header
->initial_length_size
!= *bytes_read
)
5904 complaint (&symfile_complaints
,
5905 _("intermixed 32-bit and 64-bit DWARF sections"));
5907 cu_header
->initial_length_size
= *bytes_read
;
5908 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
5914 /* Read an offset from the data stream. The size of the offset is
5915 given by cu_header->offset_size. */
5918 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
5923 switch (cu_header
->offset_size
)
5926 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5930 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5934 internal_error (__FILE__
, __LINE__
,
5935 _("read_offset: bad switch [in module %s]"),
5936 bfd_get_filename (abfd
));
5943 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
5945 /* If the size of a host char is 8 bits, we can return a pointer
5946 to the buffer, otherwise we have to copy the data to a buffer
5947 allocated on the temporary obstack. */
5948 gdb_assert (HOST_CHAR_BIT
== 8);
5953 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5955 /* If the size of a host char is 8 bits, we can return a pointer
5956 to the string, otherwise we have to copy the string to a buffer
5957 allocated on the temporary obstack. */
5958 gdb_assert (HOST_CHAR_BIT
== 8);
5961 *bytes_read_ptr
= 1;
5964 *bytes_read_ptr
= strlen (buf
) + 1;
5969 read_indirect_string (bfd
*abfd
, char *buf
,
5970 const struct comp_unit_head
*cu_header
,
5971 unsigned int *bytes_read_ptr
)
5973 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
5974 (int *) bytes_read_ptr
);
5976 if (dwarf2_per_objfile
->str_buffer
== NULL
)
5978 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
5979 bfd_get_filename (abfd
));
5982 if (str_offset
>= dwarf2_per_objfile
->str_size
)
5984 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
5985 bfd_get_filename (abfd
));
5988 gdb_assert (HOST_CHAR_BIT
== 8);
5989 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
5991 return dwarf2_per_objfile
->str_buffer
+ str_offset
;
5994 static unsigned long
5995 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5997 unsigned long result
;
5998 unsigned int num_read
;
6008 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6011 result
|= ((unsigned long)(byte
& 127) << shift
);
6012 if ((byte
& 128) == 0)
6018 *bytes_read_ptr
= num_read
;
6023 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
6026 int i
, shift
, num_read
;
6035 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6038 result
|= ((long)(byte
& 127) << shift
);
6040 if ((byte
& 128) == 0)
6045 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6046 result
|= -(((long)1) << shift
);
6047 *bytes_read_ptr
= num_read
;
6051 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6054 skip_leb128 (bfd
*abfd
, char *buf
)
6060 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6062 if ((byte
& 128) == 0)
6068 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6074 cu
->language
= language_c
;
6076 case DW_LANG_C_plus_plus
:
6077 cu
->language
= language_cplus
;
6079 case DW_LANG_Fortran77
:
6080 case DW_LANG_Fortran90
:
6081 case DW_LANG_Fortran95
:
6082 cu
->language
= language_fortran
;
6084 case DW_LANG_Mips_Assembler
:
6085 cu
->language
= language_asm
;
6088 cu
->language
= language_java
;
6092 cu
->language
= language_ada
;
6094 case DW_LANG_Cobol74
:
6095 case DW_LANG_Cobol85
:
6096 case DW_LANG_Pascal83
:
6097 case DW_LANG_Modula2
:
6099 cu
->language
= language_minimal
;
6102 cu
->language_defn
= language_def (cu
->language
);
6105 /* Return the named attribute or NULL if not there. */
6107 static struct attribute
*
6108 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6111 struct attribute
*spec
= NULL
;
6113 for (i
= 0; i
< die
->num_attrs
; ++i
)
6115 if (die
->attrs
[i
].name
== name
)
6116 return &die
->attrs
[i
];
6117 if (die
->attrs
[i
].name
== DW_AT_specification
6118 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6119 spec
= &die
->attrs
[i
];
6123 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6128 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6129 and holds a non-zero value. This function should only be used for
6130 DW_FORM_flag attributes. */
6133 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6135 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6137 return (attr
&& DW_UNSND (attr
));
6141 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6143 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6144 which value is non-zero. However, we have to be careful with
6145 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6146 (via dwarf2_flag_true_p) follows this attribute. So we may
6147 end up accidently finding a declaration attribute that belongs
6148 to a different DIE referenced by the specification attribute,
6149 even though the given DIE does not have a declaration attribute. */
6150 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6151 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6154 /* Return the die giving the specification for DIE, if there is
6157 static struct die_info
*
6158 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6160 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6162 if (spec_attr
== NULL
)
6165 return follow_die_ref (die
, spec_attr
, cu
);
6168 /* Free the line_header structure *LH, and any arrays and strings it
6171 free_line_header (struct line_header
*lh
)
6173 if (lh
->standard_opcode_lengths
)
6174 xfree (lh
->standard_opcode_lengths
);
6176 /* Remember that all the lh->file_names[i].name pointers are
6177 pointers into debug_line_buffer, and don't need to be freed. */
6179 xfree (lh
->file_names
);
6181 /* Similarly for the include directory names. */
6182 if (lh
->include_dirs
)
6183 xfree (lh
->include_dirs
);
6189 /* Add an entry to LH's include directory table. */
6191 add_include_dir (struct line_header
*lh
, char *include_dir
)
6193 /* Grow the array if necessary. */
6194 if (lh
->include_dirs_size
== 0)
6196 lh
->include_dirs_size
= 1; /* for testing */
6197 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6198 * sizeof (*lh
->include_dirs
));
6200 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6202 lh
->include_dirs_size
*= 2;
6203 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6204 (lh
->include_dirs_size
6205 * sizeof (*lh
->include_dirs
)));
6208 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6212 /* Add an entry to LH's file name table. */
6214 add_file_name (struct line_header
*lh
,
6216 unsigned int dir_index
,
6217 unsigned int mod_time
,
6218 unsigned int length
)
6220 struct file_entry
*fe
;
6222 /* Grow the array if necessary. */
6223 if (lh
->file_names_size
== 0)
6225 lh
->file_names_size
= 1; /* for testing */
6226 lh
->file_names
= xmalloc (lh
->file_names_size
6227 * sizeof (*lh
->file_names
));
6229 else if (lh
->num_file_names
>= lh
->file_names_size
)
6231 lh
->file_names_size
*= 2;
6232 lh
->file_names
= xrealloc (lh
->file_names
,
6233 (lh
->file_names_size
6234 * sizeof (*lh
->file_names
)));
6237 fe
= &lh
->file_names
[lh
->num_file_names
++];
6239 fe
->dir_index
= dir_index
;
6240 fe
->mod_time
= mod_time
;
6241 fe
->length
= length
;
6246 /* Read the statement program header starting at OFFSET in
6247 .debug_line, according to the endianness of ABFD. Return a pointer
6248 to a struct line_header, allocated using xmalloc.
6250 NOTE: the strings in the include directory and file name tables of
6251 the returned object point into debug_line_buffer, and must not be
6253 static struct line_header
*
6254 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6255 struct dwarf2_cu
*cu
)
6257 struct cleanup
*back_to
;
6258 struct line_header
*lh
;
6262 char *cur_dir
, *cur_file
;
6264 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6266 complaint (&symfile_complaints
, _("missing .debug_line section"));
6270 /* Make sure that at least there's room for the total_length field.
6271 That could be 12 bytes long, but we're just going to fudge that. */
6272 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6274 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6278 lh
= xmalloc (sizeof (*lh
));
6279 memset (lh
, 0, sizeof (*lh
));
6280 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6283 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6285 /* Read in the header. */
6287 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6288 line_ptr
+= bytes_read
;
6289 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6290 + dwarf2_per_objfile
->line_size
))
6292 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6295 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6296 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6298 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6299 line_ptr
+= bytes_read
;
6300 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6302 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6304 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6306 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6308 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6310 lh
->standard_opcode_lengths
6311 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
6313 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6314 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6316 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6320 /* Read directory table. */
6321 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6323 line_ptr
+= bytes_read
;
6324 add_include_dir (lh
, cur_dir
);
6326 line_ptr
+= bytes_read
;
6328 /* Read file name table. */
6329 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6331 unsigned int dir_index
, mod_time
, length
;
6333 line_ptr
+= bytes_read
;
6334 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6335 line_ptr
+= bytes_read
;
6336 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6337 line_ptr
+= bytes_read
;
6338 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6339 line_ptr
+= bytes_read
;
6341 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6343 line_ptr
+= bytes_read
;
6344 lh
->statement_program_start
= line_ptr
;
6346 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6347 + dwarf2_per_objfile
->line_size
))
6348 complaint (&symfile_complaints
,
6349 _("line number info header doesn't fit in `.debug_line' section"));
6351 discard_cleanups (back_to
);
6355 /* This function exists to work around a bug in certain compilers
6356 (particularly GCC 2.95), in which the first line number marker of a
6357 function does not show up until after the prologue, right before
6358 the second line number marker. This function shifts ADDRESS down
6359 to the beginning of the function if necessary, and is called on
6360 addresses passed to record_line. */
6363 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6365 struct function_range
*fn
;
6367 /* Find the function_range containing address. */
6372 cu
->cached_fn
= cu
->first_fn
;
6376 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6382 while (fn
&& fn
!= cu
->cached_fn
)
6383 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6393 if (address
!= fn
->lowpc
)
6394 complaint (&symfile_complaints
,
6395 _("misplaced first line number at 0x%lx for '%s'"),
6396 (unsigned long) address
, fn
->name
);
6401 /* Decode the Line Number Program (LNP) for the given line_header
6402 structure and CU. The actual information extracted and the type
6403 of structures created from the LNP depends on the value of PST.
6405 1. If PST is NULL, then this procedure uses the data from the program
6406 to create all necessary symbol tables, and their linetables.
6407 The compilation directory of the file is passed in COMP_DIR,
6408 and must not be NULL.
6410 2. If PST is not NULL, this procedure reads the program to determine
6411 the list of files included by the unit represented by PST, and
6412 builds all the associated partial symbol tables. In this case,
6413 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6414 is not used to compute the full name of the symtab, and therefore
6415 omitting it when building the partial symtab does not introduce
6416 the potential for inconsistency - a partial symtab and its associated
6417 symbtab having a different fullname -). */
6420 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6421 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6425 unsigned int bytes_read
;
6426 unsigned char op_code
, extended_op
, adj_opcode
;
6428 struct objfile
*objfile
= cu
->objfile
;
6429 const int decode_for_pst_p
= (pst
!= NULL
);
6431 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6433 line_ptr
= lh
->statement_program_start
;
6434 line_end
= lh
->statement_program_end
;
6436 /* Read the statement sequences until there's nothing left. */
6437 while (line_ptr
< line_end
)
6439 /* state machine registers */
6440 CORE_ADDR address
= 0;
6441 unsigned int file
= 1;
6442 unsigned int line
= 1;
6443 unsigned int column
= 0;
6444 int is_stmt
= lh
->default_is_stmt
;
6445 int basic_block
= 0;
6446 int end_sequence
= 0;
6448 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6450 /* Start a subfile for the current file of the state machine. */
6451 /* lh->include_dirs and lh->file_names are 0-based, but the
6452 directory and file name numbers in the statement program
6454 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6458 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6461 dwarf2_start_subfile (fe
->name
, dir
);
6464 /* Decode the table. */
6465 while (!end_sequence
)
6467 op_code
= read_1_byte (abfd
, line_ptr
);
6470 if (op_code
>= lh
->opcode_base
)
6472 /* Special operand. */
6473 adj_opcode
= op_code
- lh
->opcode_base
;
6474 address
+= (adj_opcode
/ lh
->line_range
)
6475 * lh
->minimum_instruction_length
;
6476 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6477 lh
->file_names
[file
- 1].included_p
= 1;
6478 if (!decode_for_pst_p
)
6480 /* Append row to matrix using current values. */
6481 record_line (current_subfile
, line
,
6482 check_cu_functions (address
, cu
));
6486 else switch (op_code
)
6488 case DW_LNS_extended_op
:
6489 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6490 line_ptr
+= bytes_read
;
6491 extended_op
= read_1_byte (abfd
, line_ptr
);
6493 switch (extended_op
)
6495 case DW_LNE_end_sequence
:
6497 lh
->file_names
[file
- 1].included_p
= 1;
6498 if (!decode_for_pst_p
)
6499 record_line (current_subfile
, 0, address
);
6501 case DW_LNE_set_address
:
6502 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6503 line_ptr
+= bytes_read
;
6504 address
+= baseaddr
;
6506 case DW_LNE_define_file
:
6509 unsigned int dir_index
, mod_time
, length
;
6511 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6512 line_ptr
+= bytes_read
;
6514 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6515 line_ptr
+= bytes_read
;
6517 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6518 line_ptr
+= bytes_read
;
6520 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6521 line_ptr
+= bytes_read
;
6522 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6526 complaint (&symfile_complaints
,
6527 _("mangled .debug_line section"));
6532 lh
->file_names
[file
- 1].included_p
= 1;
6533 if (!decode_for_pst_p
)
6534 record_line (current_subfile
, line
,
6535 check_cu_functions (address
, cu
));
6538 case DW_LNS_advance_pc
:
6539 address
+= lh
->minimum_instruction_length
6540 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6541 line_ptr
+= bytes_read
;
6543 case DW_LNS_advance_line
:
6544 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6545 line_ptr
+= bytes_read
;
6547 case DW_LNS_set_file
:
6549 /* The arrays lh->include_dirs and lh->file_names are
6550 0-based, but the directory and file name numbers in
6551 the statement program are 1-based. */
6552 struct file_entry
*fe
;
6555 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6556 line_ptr
+= bytes_read
;
6557 fe
= &lh
->file_names
[file
- 1];
6559 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6562 if (!decode_for_pst_p
)
6563 dwarf2_start_subfile (fe
->name
, dir
);
6566 case DW_LNS_set_column
:
6567 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6568 line_ptr
+= bytes_read
;
6570 case DW_LNS_negate_stmt
:
6571 is_stmt
= (!is_stmt
);
6573 case DW_LNS_set_basic_block
:
6576 /* Add to the address register of the state machine the
6577 address increment value corresponding to special opcode
6578 255. I.e., this value is scaled by the minimum
6579 instruction length since special opcode 255 would have
6580 scaled the the increment. */
6581 case DW_LNS_const_add_pc
:
6582 address
+= (lh
->minimum_instruction_length
6583 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6585 case DW_LNS_fixed_advance_pc
:
6586 address
+= read_2_bytes (abfd
, line_ptr
);
6591 /* Unknown standard opcode, ignore it. */
6594 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6596 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6597 line_ptr
+= bytes_read
;
6604 if (decode_for_pst_p
)
6608 /* Now that we're done scanning the Line Header Program, we can
6609 create the psymtab of each included file. */
6610 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6611 if (lh
->file_names
[file_index
].included_p
== 1)
6613 const struct file_entry fe
= lh
->file_names
[file_index
];
6614 char *include_name
= fe
.name
;
6615 char *dir_name
= NULL
;
6616 char *pst_filename
= pst
->filename
;
6619 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6621 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6623 include_name
= concat (dir_name
, SLASH_STRING
,
6624 include_name
, (char *)NULL
);
6625 make_cleanup (xfree
, include_name
);
6628 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6630 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6631 pst_filename
, (char *)NULL
);
6632 make_cleanup (xfree
, pst_filename
);
6635 if (strcmp (include_name
, pst_filename
) != 0)
6636 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6641 /* Start a subfile for DWARF. FILENAME is the name of the file and
6642 DIRNAME the name of the source directory which contains FILENAME
6643 or NULL if not known.
6644 This routine tries to keep line numbers from identical absolute and
6645 relative file names in a common subfile.
6647 Using the `list' example from the GDB testsuite, which resides in
6648 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6649 of /srcdir/list0.c yields the following debugging information for list0.c:
6651 DW_AT_name: /srcdir/list0.c
6652 DW_AT_comp_dir: /compdir
6653 files.files[0].name: list0.h
6654 files.files[0].dir: /srcdir
6655 files.files[1].name: list0.c
6656 files.files[1].dir: /srcdir
6658 The line number information for list0.c has to end up in a single
6659 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6662 dwarf2_start_subfile (char *filename
, char *dirname
)
6664 /* If the filename isn't absolute, try to match an existing subfile
6665 with the full pathname. */
6667 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6669 struct subfile
*subfile
;
6670 char *fullname
= concat (dirname
, "/", filename
, (char *)NULL
);
6672 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
6674 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
6676 current_subfile
= subfile
;
6683 start_subfile (filename
, dirname
);
6687 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6688 struct dwarf2_cu
*cu
)
6690 struct objfile
*objfile
= cu
->objfile
;
6691 struct comp_unit_head
*cu_header
= &cu
->header
;
6693 /* NOTE drow/2003-01-30: There used to be a comment and some special
6694 code here to turn a symbol with DW_AT_external and a
6695 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6696 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6697 with some versions of binutils) where shared libraries could have
6698 relocations against symbols in their debug information - the
6699 minimal symbol would have the right address, but the debug info
6700 would not. It's no longer necessary, because we will explicitly
6701 apply relocations when we read in the debug information now. */
6703 /* A DW_AT_location attribute with no contents indicates that a
6704 variable has been optimized away. */
6705 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6707 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6711 /* Handle one degenerate form of location expression specially, to
6712 preserve GDB's previous behavior when section offsets are
6713 specified. If this is just a DW_OP_addr then mark this symbol
6716 if (attr_form_is_block (attr
)
6717 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6718 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6722 SYMBOL_VALUE_ADDRESS (sym
) =
6723 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6724 fixup_symbol_section (sym
, objfile
);
6725 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6726 SYMBOL_SECTION (sym
));
6727 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6731 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6732 expression evaluator, and use LOC_COMPUTED only when necessary
6733 (i.e. when the value of a register or memory location is
6734 referenced, or a thread-local block, etc.). Then again, it might
6735 not be worthwhile. I'm assuming that it isn't unless performance
6736 or memory numbers show me otherwise. */
6738 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6739 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6742 /* Given a pointer to a DWARF information entry, figure out if we need
6743 to make a symbol table entry for it, and if so, create a new entry
6744 and return a pointer to it.
6745 If TYPE is NULL, determine symbol type from the die, otherwise
6746 used the passed type. */
6748 static struct symbol
*
6749 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6751 struct objfile
*objfile
= cu
->objfile
;
6752 struct symbol
*sym
= NULL
;
6754 struct attribute
*attr
= NULL
;
6755 struct attribute
*attr2
= NULL
;
6758 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6760 if (die
->tag
!= DW_TAG_namespace
)
6761 name
= dwarf2_linkage_name (die
, cu
);
6763 name
= TYPE_NAME (type
);
6767 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6768 sizeof (struct symbol
));
6769 OBJSTAT (objfile
, n_syms
++);
6770 memset (sym
, 0, sizeof (struct symbol
));
6772 /* Cache this symbol's name and the name's demangled form (if any). */
6773 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6774 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6776 /* Default assumptions.
6777 Use the passed type or decode it from the die. */
6778 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6779 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6781 SYMBOL_TYPE (sym
) = type
;
6783 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6784 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6787 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6792 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6795 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6797 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6799 case DW_TAG_subprogram
:
6800 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6802 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6803 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6804 if (attr2
&& (DW_UNSND (attr2
) != 0))
6806 add_symbol_to_list (sym
, &global_symbols
);
6810 add_symbol_to_list (sym
, cu
->list_in_scope
);
6813 case DW_TAG_variable
:
6814 /* Compilation with minimal debug info may result in variables
6815 with missing type entries. Change the misleading `void' type
6816 to something sensible. */
6817 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6818 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6819 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6820 "<variable, no debug info>",
6822 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6825 dwarf2_const_value (attr
, sym
, cu
);
6826 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6827 if (attr2
&& (DW_UNSND (attr2
) != 0))
6828 add_symbol_to_list (sym
, &global_symbols
);
6830 add_symbol_to_list (sym
, cu
->list_in_scope
);
6833 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6836 var_decode_location (attr
, sym
, cu
);
6837 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6838 if (attr2
&& (DW_UNSND (attr2
) != 0))
6839 add_symbol_to_list (sym
, &global_symbols
);
6841 add_symbol_to_list (sym
, cu
->list_in_scope
);
6845 /* We do not know the address of this symbol.
6846 If it is an external symbol and we have type information
6847 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6848 The address of the variable will then be determined from
6849 the minimal symbol table whenever the variable is
6851 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6852 if (attr2
&& (DW_UNSND (attr2
) != 0)
6853 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6855 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6856 add_symbol_to_list (sym
, &global_symbols
);
6860 case DW_TAG_formal_parameter
:
6861 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6864 var_decode_location (attr
, sym
, cu
);
6865 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6866 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6867 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6869 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6872 dwarf2_const_value (attr
, sym
, cu
);
6874 add_symbol_to_list (sym
, cu
->list_in_scope
);
6876 case DW_TAG_unspecified_parameters
:
6877 /* From varargs functions; gdb doesn't seem to have any
6878 interest in this information, so just ignore it for now.
6881 case DW_TAG_class_type
:
6882 case DW_TAG_structure_type
:
6883 case DW_TAG_union_type
:
6884 case DW_TAG_enumeration_type
:
6885 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6886 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6888 /* Make sure that the symbol includes appropriate enclosing
6889 classes/namespaces in its name. These are calculated in
6890 read_structure_type, and the correct name is saved in
6893 if (cu
->language
== language_cplus
6894 || cu
->language
== language_java
)
6896 struct type
*type
= SYMBOL_TYPE (sym
);
6898 if (TYPE_TAG_NAME (type
) != NULL
)
6900 /* FIXME: carlton/2003-11-10: Should this use
6901 SYMBOL_SET_NAMES instead? (The same problem also
6902 arises further down in this function.) */
6903 /* The type's name is already allocated along with
6904 this objfile, so we don't need to duplicate it
6906 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
6911 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6912 really ever be static objects: otherwise, if you try
6913 to, say, break of a class's method and you're in a file
6914 which doesn't mention that class, it won't work unless
6915 the check for all static symbols in lookup_symbol_aux
6916 saves you. See the OtherFileClass tests in
6917 gdb.c++/namespace.exp. */
6919 struct pending
**list_to_add
;
6921 list_to_add
= (cu
->list_in_scope
== &file_symbols
6922 && (cu
->language
== language_cplus
6923 || cu
->language
== language_java
)
6924 ? &global_symbols
: cu
->list_in_scope
);
6926 add_symbol_to_list (sym
, list_to_add
);
6928 /* The semantics of C++ state that "struct foo { ... }" also
6929 defines a typedef for "foo". A Java class declaration also
6930 defines a typedef for the class. Synthesize a typedef symbol
6931 so that "ptype foo" works as expected. */
6932 if (cu
->language
== language_cplus
6933 || cu
->language
== language_java
)
6935 struct symbol
*typedef_sym
= (struct symbol
*)
6936 obstack_alloc (&objfile
->objfile_obstack
,
6937 sizeof (struct symbol
));
6938 *typedef_sym
= *sym
;
6939 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
6940 /* The symbol's name is already allocated along with
6941 this objfile, so we don't need to duplicate it for
6943 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
6944 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
6945 add_symbol_to_list (typedef_sym
, list_to_add
);
6949 case DW_TAG_typedef
:
6950 if (processing_has_namespace_info
6951 && processing_current_prefix
[0] != '\0')
6953 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6954 processing_current_prefix
,
6957 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6958 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6959 add_symbol_to_list (sym
, cu
->list_in_scope
);
6961 case DW_TAG_base_type
:
6962 case DW_TAG_subrange_type
:
6963 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6964 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6965 add_symbol_to_list (sym
, cu
->list_in_scope
);
6967 case DW_TAG_enumerator
:
6968 if (processing_has_namespace_info
6969 && processing_current_prefix
[0] != '\0')
6971 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6972 processing_current_prefix
,
6975 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6978 dwarf2_const_value (attr
, sym
, cu
);
6981 /* NOTE: carlton/2003-11-10: See comment above in the
6982 DW_TAG_class_type, etc. block. */
6984 struct pending
**list_to_add
;
6986 list_to_add
= (cu
->list_in_scope
== &file_symbols
6987 && (cu
->language
== language_cplus
6988 || cu
->language
== language_java
)
6989 ? &global_symbols
: cu
->list_in_scope
);
6991 add_symbol_to_list (sym
, list_to_add
);
6994 case DW_TAG_namespace
:
6995 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6996 add_symbol_to_list (sym
, &global_symbols
);
6999 /* Not a tag we recognize. Hopefully we aren't processing
7000 trash data, but since we must specifically ignore things
7001 we don't recognize, there is nothing else we should do at
7003 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7004 dwarf_tag_name (die
->tag
));
7011 /* Copy constant value from an attribute to a symbol. */
7014 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7015 struct dwarf2_cu
*cu
)
7017 struct objfile
*objfile
= cu
->objfile
;
7018 struct comp_unit_head
*cu_header
= &cu
->header
;
7019 struct dwarf_block
*blk
;
7024 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7025 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7026 cu_header
->addr_size
,
7027 TYPE_LENGTH (SYMBOL_TYPE
7029 SYMBOL_VALUE_BYTES (sym
) = (char *)
7030 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7031 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7032 it's body - store_unsigned_integer. */
7033 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7035 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7037 case DW_FORM_block1
:
7038 case DW_FORM_block2
:
7039 case DW_FORM_block4
:
7041 blk
= DW_BLOCK (attr
);
7042 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7043 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7045 TYPE_LENGTH (SYMBOL_TYPE
7047 SYMBOL_VALUE_BYTES (sym
) = (char *)
7048 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7049 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7050 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7053 /* The DW_AT_const_value attributes are supposed to carry the
7054 symbol's value "represented as it would be on the target
7055 architecture." By the time we get here, it's already been
7056 converted to host endianness, so we just need to sign- or
7057 zero-extend it as appropriate. */
7059 dwarf2_const_value_data (attr
, sym
, 8);
7062 dwarf2_const_value_data (attr
, sym
, 16);
7065 dwarf2_const_value_data (attr
, sym
, 32);
7068 dwarf2_const_value_data (attr
, sym
, 64);
7072 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7073 SYMBOL_CLASS (sym
) = LOC_CONST
;
7077 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7078 SYMBOL_CLASS (sym
) = LOC_CONST
;
7082 complaint (&symfile_complaints
,
7083 _("unsupported const value attribute form: '%s'"),
7084 dwarf_form_name (attr
->form
));
7085 SYMBOL_VALUE (sym
) = 0;
7086 SYMBOL_CLASS (sym
) = LOC_CONST
;
7092 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7093 or zero-extend it as appropriate for the symbol's type. */
7095 dwarf2_const_value_data (struct attribute
*attr
,
7099 LONGEST l
= DW_UNSND (attr
);
7101 if (bits
< sizeof (l
) * 8)
7103 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7104 l
&= ((LONGEST
) 1 << bits
) - 1;
7106 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7109 SYMBOL_VALUE (sym
) = l
;
7110 SYMBOL_CLASS (sym
) = LOC_CONST
;
7114 /* Return the type of the die in question using its DW_AT_type attribute. */
7116 static struct type
*
7117 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7120 struct attribute
*type_attr
;
7121 struct die_info
*type_die
;
7123 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7126 /* A missing DW_AT_type represents a void type. */
7127 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7130 type_die
= follow_die_ref (die
, type_attr
, cu
);
7132 type
= tag_type_to_type (type_die
, cu
);
7135 dump_die (type_die
);
7136 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7142 /* Return the containing type of the die in question using its
7143 DW_AT_containing_type attribute. */
7145 static struct type
*
7146 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7148 struct type
*type
= NULL
;
7149 struct attribute
*type_attr
;
7150 struct die_info
*type_die
= NULL
;
7152 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7155 type_die
= follow_die_ref (die
, type_attr
, cu
);
7156 type
= tag_type_to_type (type_die
, cu
);
7161 dump_die (type_die
);
7162 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7168 static struct type
*
7169 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7177 read_type_die (die
, cu
);
7181 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7189 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7191 char *prefix
= determine_prefix (die
, cu
);
7192 const char *old_prefix
= processing_current_prefix
;
7193 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7194 processing_current_prefix
= prefix
;
7198 case DW_TAG_class_type
:
7199 case DW_TAG_structure_type
:
7200 case DW_TAG_union_type
:
7201 read_structure_type (die
, cu
);
7203 case DW_TAG_enumeration_type
:
7204 read_enumeration_type (die
, cu
);
7206 case DW_TAG_subprogram
:
7207 case DW_TAG_subroutine_type
:
7208 read_subroutine_type (die
, cu
);
7210 case DW_TAG_array_type
:
7211 read_array_type (die
, cu
);
7213 case DW_TAG_pointer_type
:
7214 read_tag_pointer_type (die
, cu
);
7216 case DW_TAG_ptr_to_member_type
:
7217 read_tag_ptr_to_member_type (die
, cu
);
7219 case DW_TAG_reference_type
:
7220 read_tag_reference_type (die
, cu
);
7222 case DW_TAG_const_type
:
7223 read_tag_const_type (die
, cu
);
7225 case DW_TAG_volatile_type
:
7226 read_tag_volatile_type (die
, cu
);
7228 case DW_TAG_string_type
:
7229 read_tag_string_type (die
, cu
);
7231 case DW_TAG_typedef
:
7232 read_typedef (die
, cu
);
7234 case DW_TAG_subrange_type
:
7235 read_subrange_type (die
, cu
);
7237 case DW_TAG_base_type
:
7238 read_base_type (die
, cu
);
7241 complaint (&symfile_complaints
, _("unexepected tag in read_type_die: '%s'"),
7242 dwarf_tag_name (die
->tag
));
7246 processing_current_prefix
= old_prefix
;
7247 do_cleanups (back_to
);
7250 /* Return the name of the namespace/class that DIE is defined within,
7251 or "" if we can't tell. The caller should xfree the result. */
7253 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7254 therein) for an example of how to use this function to deal with
7255 DW_AT_specification. */
7258 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7260 struct die_info
*parent
;
7262 if (cu
->language
!= language_cplus
7263 && cu
->language
!= language_java
)
7266 parent
= die
->parent
;
7270 return xstrdup ("");
7274 switch (parent
->tag
) {
7275 case DW_TAG_namespace
:
7277 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7278 before doing this check? */
7279 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7281 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7286 char *parent_prefix
= determine_prefix (parent
, cu
);
7287 char *retval
= typename_concat (NULL
, parent_prefix
,
7288 namespace_name (parent
, &dummy
,
7291 xfree (parent_prefix
);
7296 case DW_TAG_class_type
:
7297 case DW_TAG_structure_type
:
7299 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7301 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7305 const char *old_prefix
= processing_current_prefix
;
7306 char *new_prefix
= determine_prefix (parent
, cu
);
7309 processing_current_prefix
= new_prefix
;
7310 retval
= determine_class_name (parent
, cu
);
7311 processing_current_prefix
= old_prefix
;
7318 return determine_prefix (parent
, cu
);
7323 /* Return a newly-allocated string formed by concatenating PREFIX and
7324 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7325 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7326 perform an obconcat, otherwise allocate storage for the result. The CU argument
7327 is used to determine the language and hence, the appropriate separator. */
7329 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7332 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7333 struct dwarf2_cu
*cu
)
7337 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7339 else if (cu
->language
== language_java
)
7346 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7351 strcpy (retval
, prefix
);
7352 strcat (retval
, sep
);
7355 strcat (retval
, suffix
);
7361 /* We have an obstack. */
7362 return obconcat (obs
, prefix
, sep
, suffix
);
7366 static struct type
*
7367 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7369 struct objfile
*objfile
= cu
->objfile
;
7371 /* FIXME - this should not produce a new (struct type *)
7372 every time. It should cache base types. */
7376 case DW_ATE_address
:
7377 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7379 case DW_ATE_boolean
:
7380 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7382 case DW_ATE_complex_float
:
7385 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7389 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7395 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7399 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7406 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7409 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7413 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7417 case DW_ATE_signed_char
:
7418 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7420 case DW_ATE_unsigned
:
7424 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7427 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7431 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7435 case DW_ATE_unsigned_char
:
7436 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7439 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7446 copy_die (struct die_info
*old_die
)
7448 struct die_info
*new_die
;
7451 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7452 memset (new_die
, 0, sizeof (struct die_info
));
7454 new_die
->tag
= old_die
->tag
;
7455 new_die
->has_children
= old_die
->has_children
;
7456 new_die
->abbrev
= old_die
->abbrev
;
7457 new_die
->offset
= old_die
->offset
;
7458 new_die
->type
= NULL
;
7460 num_attrs
= old_die
->num_attrs
;
7461 new_die
->num_attrs
= num_attrs
;
7462 new_die
->attrs
= (struct attribute
*)
7463 xmalloc (num_attrs
* sizeof (struct attribute
));
7465 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7467 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7468 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7469 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7472 new_die
->next
= NULL
;
7477 /* Return sibling of die, NULL if no sibling. */
7479 static struct die_info
*
7480 sibling_die (struct die_info
*die
)
7482 return die
->sibling
;
7485 /* Get linkage name of a die, return NULL if not found. */
7488 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7490 struct attribute
*attr
;
7492 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7493 if (attr
&& DW_STRING (attr
))
7494 return DW_STRING (attr
);
7495 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7496 if (attr
&& DW_STRING (attr
))
7497 return DW_STRING (attr
);
7501 /* Get name of a die, return NULL if not found. */
7504 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7506 struct attribute
*attr
;
7508 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7509 if (attr
&& DW_STRING (attr
))
7510 return DW_STRING (attr
);
7514 /* Return the die that this die in an extension of, or NULL if there
7517 static struct die_info
*
7518 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7520 struct attribute
*attr
;
7522 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7526 return follow_die_ref (die
, attr
, cu
);
7529 /* Convert a DIE tag into its string name. */
7532 dwarf_tag_name (unsigned tag
)
7536 case DW_TAG_padding
:
7537 return "DW_TAG_padding";
7538 case DW_TAG_array_type
:
7539 return "DW_TAG_array_type";
7540 case DW_TAG_class_type
:
7541 return "DW_TAG_class_type";
7542 case DW_TAG_entry_point
:
7543 return "DW_TAG_entry_point";
7544 case DW_TAG_enumeration_type
:
7545 return "DW_TAG_enumeration_type";
7546 case DW_TAG_formal_parameter
:
7547 return "DW_TAG_formal_parameter";
7548 case DW_TAG_imported_declaration
:
7549 return "DW_TAG_imported_declaration";
7551 return "DW_TAG_label";
7552 case DW_TAG_lexical_block
:
7553 return "DW_TAG_lexical_block";
7555 return "DW_TAG_member";
7556 case DW_TAG_pointer_type
:
7557 return "DW_TAG_pointer_type";
7558 case DW_TAG_reference_type
:
7559 return "DW_TAG_reference_type";
7560 case DW_TAG_compile_unit
:
7561 return "DW_TAG_compile_unit";
7562 case DW_TAG_string_type
:
7563 return "DW_TAG_string_type";
7564 case DW_TAG_structure_type
:
7565 return "DW_TAG_structure_type";
7566 case DW_TAG_subroutine_type
:
7567 return "DW_TAG_subroutine_type";
7568 case DW_TAG_typedef
:
7569 return "DW_TAG_typedef";
7570 case DW_TAG_union_type
:
7571 return "DW_TAG_union_type";
7572 case DW_TAG_unspecified_parameters
:
7573 return "DW_TAG_unspecified_parameters";
7574 case DW_TAG_variant
:
7575 return "DW_TAG_variant";
7576 case DW_TAG_common_block
:
7577 return "DW_TAG_common_block";
7578 case DW_TAG_common_inclusion
:
7579 return "DW_TAG_common_inclusion";
7580 case DW_TAG_inheritance
:
7581 return "DW_TAG_inheritance";
7582 case DW_TAG_inlined_subroutine
:
7583 return "DW_TAG_inlined_subroutine";
7585 return "DW_TAG_module";
7586 case DW_TAG_ptr_to_member_type
:
7587 return "DW_TAG_ptr_to_member_type";
7588 case DW_TAG_set_type
:
7589 return "DW_TAG_set_type";
7590 case DW_TAG_subrange_type
:
7591 return "DW_TAG_subrange_type";
7592 case DW_TAG_with_stmt
:
7593 return "DW_TAG_with_stmt";
7594 case DW_TAG_access_declaration
:
7595 return "DW_TAG_access_declaration";
7596 case DW_TAG_base_type
:
7597 return "DW_TAG_base_type";
7598 case DW_TAG_catch_block
:
7599 return "DW_TAG_catch_block";
7600 case DW_TAG_const_type
:
7601 return "DW_TAG_const_type";
7602 case DW_TAG_constant
:
7603 return "DW_TAG_constant";
7604 case DW_TAG_enumerator
:
7605 return "DW_TAG_enumerator";
7606 case DW_TAG_file_type
:
7607 return "DW_TAG_file_type";
7609 return "DW_TAG_friend";
7610 case DW_TAG_namelist
:
7611 return "DW_TAG_namelist";
7612 case DW_TAG_namelist_item
:
7613 return "DW_TAG_namelist_item";
7614 case DW_TAG_packed_type
:
7615 return "DW_TAG_packed_type";
7616 case DW_TAG_subprogram
:
7617 return "DW_TAG_subprogram";
7618 case DW_TAG_template_type_param
:
7619 return "DW_TAG_template_type_param";
7620 case DW_TAG_template_value_param
:
7621 return "DW_TAG_template_value_param";
7622 case DW_TAG_thrown_type
:
7623 return "DW_TAG_thrown_type";
7624 case DW_TAG_try_block
:
7625 return "DW_TAG_try_block";
7626 case DW_TAG_variant_part
:
7627 return "DW_TAG_variant_part";
7628 case DW_TAG_variable
:
7629 return "DW_TAG_variable";
7630 case DW_TAG_volatile_type
:
7631 return "DW_TAG_volatile_type";
7632 case DW_TAG_dwarf_procedure
:
7633 return "DW_TAG_dwarf_procedure";
7634 case DW_TAG_restrict_type
:
7635 return "DW_TAG_restrict_type";
7636 case DW_TAG_interface_type
:
7637 return "DW_TAG_interface_type";
7638 case DW_TAG_namespace
:
7639 return "DW_TAG_namespace";
7640 case DW_TAG_imported_module
:
7641 return "DW_TAG_imported_module";
7642 case DW_TAG_unspecified_type
:
7643 return "DW_TAG_unspecified_type";
7644 case DW_TAG_partial_unit
:
7645 return "DW_TAG_partial_unit";
7646 case DW_TAG_imported_unit
:
7647 return "DW_TAG_imported_unit";
7648 case DW_TAG_MIPS_loop
:
7649 return "DW_TAG_MIPS_loop";
7650 case DW_TAG_format_label
:
7651 return "DW_TAG_format_label";
7652 case DW_TAG_function_template
:
7653 return "DW_TAG_function_template";
7654 case DW_TAG_class_template
:
7655 return "DW_TAG_class_template";
7657 return "DW_TAG_<unknown>";
7661 /* Convert a DWARF attribute code into its string name. */
7664 dwarf_attr_name (unsigned attr
)
7669 return "DW_AT_sibling";
7670 case DW_AT_location
:
7671 return "DW_AT_location";
7673 return "DW_AT_name";
7674 case DW_AT_ordering
:
7675 return "DW_AT_ordering";
7676 case DW_AT_subscr_data
:
7677 return "DW_AT_subscr_data";
7678 case DW_AT_byte_size
:
7679 return "DW_AT_byte_size";
7680 case DW_AT_bit_offset
:
7681 return "DW_AT_bit_offset";
7682 case DW_AT_bit_size
:
7683 return "DW_AT_bit_size";
7684 case DW_AT_element_list
:
7685 return "DW_AT_element_list";
7686 case DW_AT_stmt_list
:
7687 return "DW_AT_stmt_list";
7689 return "DW_AT_low_pc";
7691 return "DW_AT_high_pc";
7692 case DW_AT_language
:
7693 return "DW_AT_language";
7695 return "DW_AT_member";
7697 return "DW_AT_discr";
7698 case DW_AT_discr_value
:
7699 return "DW_AT_discr_value";
7700 case DW_AT_visibility
:
7701 return "DW_AT_visibility";
7703 return "DW_AT_import";
7704 case DW_AT_string_length
:
7705 return "DW_AT_string_length";
7706 case DW_AT_common_reference
:
7707 return "DW_AT_common_reference";
7708 case DW_AT_comp_dir
:
7709 return "DW_AT_comp_dir";
7710 case DW_AT_const_value
:
7711 return "DW_AT_const_value";
7712 case DW_AT_containing_type
:
7713 return "DW_AT_containing_type";
7714 case DW_AT_default_value
:
7715 return "DW_AT_default_value";
7717 return "DW_AT_inline";
7718 case DW_AT_is_optional
:
7719 return "DW_AT_is_optional";
7720 case DW_AT_lower_bound
:
7721 return "DW_AT_lower_bound";
7722 case DW_AT_producer
:
7723 return "DW_AT_producer";
7724 case DW_AT_prototyped
:
7725 return "DW_AT_prototyped";
7726 case DW_AT_return_addr
:
7727 return "DW_AT_return_addr";
7728 case DW_AT_start_scope
:
7729 return "DW_AT_start_scope";
7730 case DW_AT_stride_size
:
7731 return "DW_AT_stride_size";
7732 case DW_AT_upper_bound
:
7733 return "DW_AT_upper_bound";
7734 case DW_AT_abstract_origin
:
7735 return "DW_AT_abstract_origin";
7736 case DW_AT_accessibility
:
7737 return "DW_AT_accessibility";
7738 case DW_AT_address_class
:
7739 return "DW_AT_address_class";
7740 case DW_AT_artificial
:
7741 return "DW_AT_artificial";
7742 case DW_AT_base_types
:
7743 return "DW_AT_base_types";
7744 case DW_AT_calling_convention
:
7745 return "DW_AT_calling_convention";
7747 return "DW_AT_count";
7748 case DW_AT_data_member_location
:
7749 return "DW_AT_data_member_location";
7750 case DW_AT_decl_column
:
7751 return "DW_AT_decl_column";
7752 case DW_AT_decl_file
:
7753 return "DW_AT_decl_file";
7754 case DW_AT_decl_line
:
7755 return "DW_AT_decl_line";
7756 case DW_AT_declaration
:
7757 return "DW_AT_declaration";
7758 case DW_AT_discr_list
:
7759 return "DW_AT_discr_list";
7760 case DW_AT_encoding
:
7761 return "DW_AT_encoding";
7762 case DW_AT_external
:
7763 return "DW_AT_external";
7764 case DW_AT_frame_base
:
7765 return "DW_AT_frame_base";
7767 return "DW_AT_friend";
7768 case DW_AT_identifier_case
:
7769 return "DW_AT_identifier_case";
7770 case DW_AT_macro_info
:
7771 return "DW_AT_macro_info";
7772 case DW_AT_namelist_items
:
7773 return "DW_AT_namelist_items";
7774 case DW_AT_priority
:
7775 return "DW_AT_priority";
7777 return "DW_AT_segment";
7778 case DW_AT_specification
:
7779 return "DW_AT_specification";
7780 case DW_AT_static_link
:
7781 return "DW_AT_static_link";
7783 return "DW_AT_type";
7784 case DW_AT_use_location
:
7785 return "DW_AT_use_location";
7786 case DW_AT_variable_parameter
:
7787 return "DW_AT_variable_parameter";
7788 case DW_AT_virtuality
:
7789 return "DW_AT_virtuality";
7790 case DW_AT_vtable_elem_location
:
7791 return "DW_AT_vtable_elem_location";
7792 case DW_AT_allocated
:
7793 return "DW_AT_allocated";
7794 case DW_AT_associated
:
7795 return "DW_AT_associated";
7796 case DW_AT_data_location
:
7797 return "DW_AT_data_location";
7799 return "DW_AT_stride";
7800 case DW_AT_entry_pc
:
7801 return "DW_AT_entry_pc";
7802 case DW_AT_use_UTF8
:
7803 return "DW_AT_use_UTF8";
7804 case DW_AT_extension
:
7805 return "DW_AT_extension";
7807 return "DW_AT_ranges";
7808 case DW_AT_trampoline
:
7809 return "DW_AT_trampoline";
7810 case DW_AT_call_column
:
7811 return "DW_AT_call_column";
7812 case DW_AT_call_file
:
7813 return "DW_AT_call_file";
7814 case DW_AT_call_line
:
7815 return "DW_AT_call_line";
7817 case DW_AT_MIPS_fde
:
7818 return "DW_AT_MIPS_fde";
7819 case DW_AT_MIPS_loop_begin
:
7820 return "DW_AT_MIPS_loop_begin";
7821 case DW_AT_MIPS_tail_loop_begin
:
7822 return "DW_AT_MIPS_tail_loop_begin";
7823 case DW_AT_MIPS_epilog_begin
:
7824 return "DW_AT_MIPS_epilog_begin";
7825 case DW_AT_MIPS_loop_unroll_factor
:
7826 return "DW_AT_MIPS_loop_unroll_factor";
7827 case DW_AT_MIPS_software_pipeline_depth
:
7828 return "DW_AT_MIPS_software_pipeline_depth";
7830 case DW_AT_MIPS_linkage_name
:
7831 return "DW_AT_MIPS_linkage_name";
7833 case DW_AT_sf_names
:
7834 return "DW_AT_sf_names";
7835 case DW_AT_src_info
:
7836 return "DW_AT_src_info";
7837 case DW_AT_mac_info
:
7838 return "DW_AT_mac_info";
7839 case DW_AT_src_coords
:
7840 return "DW_AT_src_coords";
7841 case DW_AT_body_begin
:
7842 return "DW_AT_body_begin";
7843 case DW_AT_body_end
:
7844 return "DW_AT_body_end";
7845 case DW_AT_GNU_vector
:
7846 return "DW_AT_GNU_vector";
7848 return "DW_AT_<unknown>";
7852 /* Convert a DWARF value form code into its string name. */
7855 dwarf_form_name (unsigned form
)
7860 return "DW_FORM_addr";
7861 case DW_FORM_block2
:
7862 return "DW_FORM_block2";
7863 case DW_FORM_block4
:
7864 return "DW_FORM_block4";
7866 return "DW_FORM_data2";
7868 return "DW_FORM_data4";
7870 return "DW_FORM_data8";
7871 case DW_FORM_string
:
7872 return "DW_FORM_string";
7874 return "DW_FORM_block";
7875 case DW_FORM_block1
:
7876 return "DW_FORM_block1";
7878 return "DW_FORM_data1";
7880 return "DW_FORM_flag";
7882 return "DW_FORM_sdata";
7884 return "DW_FORM_strp";
7886 return "DW_FORM_udata";
7887 case DW_FORM_ref_addr
:
7888 return "DW_FORM_ref_addr";
7890 return "DW_FORM_ref1";
7892 return "DW_FORM_ref2";
7894 return "DW_FORM_ref4";
7896 return "DW_FORM_ref8";
7897 case DW_FORM_ref_udata
:
7898 return "DW_FORM_ref_udata";
7899 case DW_FORM_indirect
:
7900 return "DW_FORM_indirect";
7902 return "DW_FORM_<unknown>";
7906 /* Convert a DWARF stack opcode into its string name. */
7909 dwarf_stack_op_name (unsigned op
)
7914 return "DW_OP_addr";
7916 return "DW_OP_deref";
7918 return "DW_OP_const1u";
7920 return "DW_OP_const1s";
7922 return "DW_OP_const2u";
7924 return "DW_OP_const2s";
7926 return "DW_OP_const4u";
7928 return "DW_OP_const4s";
7930 return "DW_OP_const8u";
7932 return "DW_OP_const8s";
7934 return "DW_OP_constu";
7936 return "DW_OP_consts";
7940 return "DW_OP_drop";
7942 return "DW_OP_over";
7944 return "DW_OP_pick";
7946 return "DW_OP_swap";
7950 return "DW_OP_xderef";
7958 return "DW_OP_minus";
7970 return "DW_OP_plus";
7971 case DW_OP_plus_uconst
:
7972 return "DW_OP_plus_uconst";
7978 return "DW_OP_shra";
7996 return "DW_OP_skip";
7998 return "DW_OP_lit0";
8000 return "DW_OP_lit1";
8002 return "DW_OP_lit2";
8004 return "DW_OP_lit3";
8006 return "DW_OP_lit4";
8008 return "DW_OP_lit5";
8010 return "DW_OP_lit6";
8012 return "DW_OP_lit7";
8014 return "DW_OP_lit8";
8016 return "DW_OP_lit9";
8018 return "DW_OP_lit10";
8020 return "DW_OP_lit11";
8022 return "DW_OP_lit12";
8024 return "DW_OP_lit13";
8026 return "DW_OP_lit14";
8028 return "DW_OP_lit15";
8030 return "DW_OP_lit16";
8032 return "DW_OP_lit17";
8034 return "DW_OP_lit18";
8036 return "DW_OP_lit19";
8038 return "DW_OP_lit20";
8040 return "DW_OP_lit21";
8042 return "DW_OP_lit22";
8044 return "DW_OP_lit23";
8046 return "DW_OP_lit24";
8048 return "DW_OP_lit25";
8050 return "DW_OP_lit26";
8052 return "DW_OP_lit27";
8054 return "DW_OP_lit28";
8056 return "DW_OP_lit29";
8058 return "DW_OP_lit30";
8060 return "DW_OP_lit31";
8062 return "DW_OP_reg0";
8064 return "DW_OP_reg1";
8066 return "DW_OP_reg2";
8068 return "DW_OP_reg3";
8070 return "DW_OP_reg4";
8072 return "DW_OP_reg5";
8074 return "DW_OP_reg6";
8076 return "DW_OP_reg7";
8078 return "DW_OP_reg8";
8080 return "DW_OP_reg9";
8082 return "DW_OP_reg10";
8084 return "DW_OP_reg11";
8086 return "DW_OP_reg12";
8088 return "DW_OP_reg13";
8090 return "DW_OP_reg14";
8092 return "DW_OP_reg15";
8094 return "DW_OP_reg16";
8096 return "DW_OP_reg17";
8098 return "DW_OP_reg18";
8100 return "DW_OP_reg19";
8102 return "DW_OP_reg20";
8104 return "DW_OP_reg21";
8106 return "DW_OP_reg22";
8108 return "DW_OP_reg23";
8110 return "DW_OP_reg24";
8112 return "DW_OP_reg25";
8114 return "DW_OP_reg26";
8116 return "DW_OP_reg27";
8118 return "DW_OP_reg28";
8120 return "DW_OP_reg29";
8122 return "DW_OP_reg30";
8124 return "DW_OP_reg31";
8126 return "DW_OP_breg0";
8128 return "DW_OP_breg1";
8130 return "DW_OP_breg2";
8132 return "DW_OP_breg3";
8134 return "DW_OP_breg4";
8136 return "DW_OP_breg5";
8138 return "DW_OP_breg6";
8140 return "DW_OP_breg7";
8142 return "DW_OP_breg8";
8144 return "DW_OP_breg9";
8146 return "DW_OP_breg10";
8148 return "DW_OP_breg11";
8150 return "DW_OP_breg12";
8152 return "DW_OP_breg13";
8154 return "DW_OP_breg14";
8156 return "DW_OP_breg15";
8158 return "DW_OP_breg16";
8160 return "DW_OP_breg17";
8162 return "DW_OP_breg18";
8164 return "DW_OP_breg19";
8166 return "DW_OP_breg20";
8168 return "DW_OP_breg21";
8170 return "DW_OP_breg22";
8172 return "DW_OP_breg23";
8174 return "DW_OP_breg24";
8176 return "DW_OP_breg25";
8178 return "DW_OP_breg26";
8180 return "DW_OP_breg27";
8182 return "DW_OP_breg28";
8184 return "DW_OP_breg29";
8186 return "DW_OP_breg30";
8188 return "DW_OP_breg31";
8190 return "DW_OP_regx";
8192 return "DW_OP_fbreg";
8194 return "DW_OP_bregx";
8196 return "DW_OP_piece";
8197 case DW_OP_deref_size
:
8198 return "DW_OP_deref_size";
8199 case DW_OP_xderef_size
:
8200 return "DW_OP_xderef_size";
8203 /* DWARF 3 extensions. */
8204 case DW_OP_push_object_address
:
8205 return "DW_OP_push_object_address";
8207 return "DW_OP_call2";
8209 return "DW_OP_call4";
8210 case DW_OP_call_ref
:
8211 return "DW_OP_call_ref";
8212 /* GNU extensions. */
8213 case DW_OP_GNU_push_tls_address
:
8214 return "DW_OP_GNU_push_tls_address";
8216 return "OP_<unknown>";
8221 dwarf_bool_name (unsigned mybool
)
8229 /* Convert a DWARF type code into its string name. */
8232 dwarf_type_encoding_name (unsigned enc
)
8236 case DW_ATE_address
:
8237 return "DW_ATE_address";
8238 case DW_ATE_boolean
:
8239 return "DW_ATE_boolean";
8240 case DW_ATE_complex_float
:
8241 return "DW_ATE_complex_float";
8243 return "DW_ATE_float";
8245 return "DW_ATE_signed";
8246 case DW_ATE_signed_char
:
8247 return "DW_ATE_signed_char";
8248 case DW_ATE_unsigned
:
8249 return "DW_ATE_unsigned";
8250 case DW_ATE_unsigned_char
:
8251 return "DW_ATE_unsigned_char";
8252 case DW_ATE_imaginary_float
:
8253 return "DW_ATE_imaginary_float";
8255 return "DW_ATE_<unknown>";
8259 /* Convert a DWARF call frame info operation to its string name. */
8263 dwarf_cfi_name (unsigned cfi_opc
)
8267 case DW_CFA_advance_loc
:
8268 return "DW_CFA_advance_loc";
8270 return "DW_CFA_offset";
8271 case DW_CFA_restore
:
8272 return "DW_CFA_restore";
8274 return "DW_CFA_nop";
8275 case DW_CFA_set_loc
:
8276 return "DW_CFA_set_loc";
8277 case DW_CFA_advance_loc1
:
8278 return "DW_CFA_advance_loc1";
8279 case DW_CFA_advance_loc2
:
8280 return "DW_CFA_advance_loc2";
8281 case DW_CFA_advance_loc4
:
8282 return "DW_CFA_advance_loc4";
8283 case DW_CFA_offset_extended
:
8284 return "DW_CFA_offset_extended";
8285 case DW_CFA_restore_extended
:
8286 return "DW_CFA_restore_extended";
8287 case DW_CFA_undefined
:
8288 return "DW_CFA_undefined";
8289 case DW_CFA_same_value
:
8290 return "DW_CFA_same_value";
8291 case DW_CFA_register
:
8292 return "DW_CFA_register";
8293 case DW_CFA_remember_state
:
8294 return "DW_CFA_remember_state";
8295 case DW_CFA_restore_state
:
8296 return "DW_CFA_restore_state";
8297 case DW_CFA_def_cfa
:
8298 return "DW_CFA_def_cfa";
8299 case DW_CFA_def_cfa_register
:
8300 return "DW_CFA_def_cfa_register";
8301 case DW_CFA_def_cfa_offset
:
8302 return "DW_CFA_def_cfa_offset";
8305 case DW_CFA_def_cfa_expression
:
8306 return "DW_CFA_def_cfa_expression";
8307 case DW_CFA_expression
:
8308 return "DW_CFA_expression";
8309 case DW_CFA_offset_extended_sf
:
8310 return "DW_CFA_offset_extended_sf";
8311 case DW_CFA_def_cfa_sf
:
8312 return "DW_CFA_def_cfa_sf";
8313 case DW_CFA_def_cfa_offset_sf
:
8314 return "DW_CFA_def_cfa_offset_sf";
8316 /* SGI/MIPS specific */
8317 case DW_CFA_MIPS_advance_loc8
:
8318 return "DW_CFA_MIPS_advance_loc8";
8320 /* GNU extensions */
8321 case DW_CFA_GNU_window_save
:
8322 return "DW_CFA_GNU_window_save";
8323 case DW_CFA_GNU_args_size
:
8324 return "DW_CFA_GNU_args_size";
8325 case DW_CFA_GNU_negative_offset_extended
:
8326 return "DW_CFA_GNU_negative_offset_extended";
8329 return "DW_CFA_<unknown>";
8335 dump_die (struct die_info
*die
)
8339 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8340 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8341 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8342 dwarf_bool_name (die
->child
!= NULL
));
8344 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8345 for (i
= 0; i
< die
->num_attrs
; ++i
)
8347 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8348 dwarf_attr_name (die
->attrs
[i
].name
),
8349 dwarf_form_name (die
->attrs
[i
].form
));
8350 switch (die
->attrs
[i
].form
)
8352 case DW_FORM_ref_addr
:
8354 fprintf_unfiltered (gdb_stderr
, "address: ");
8355 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8357 case DW_FORM_block2
:
8358 case DW_FORM_block4
:
8360 case DW_FORM_block1
:
8361 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8366 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8367 (long) (DW_ADDR (&die
->attrs
[i
])));
8375 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8377 case DW_FORM_string
:
8379 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8380 DW_STRING (&die
->attrs
[i
])
8381 ? DW_STRING (&die
->attrs
[i
]) : "");
8384 if (DW_UNSND (&die
->attrs
[i
]))
8385 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8387 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8389 case DW_FORM_indirect
:
8390 /* the reader will have reduced the indirect form to
8391 the "base form" so this form should not occur */
8392 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8395 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8396 die
->attrs
[i
].form
);
8398 fprintf_unfiltered (gdb_stderr
, "\n");
8403 dump_die_list (struct die_info
*die
)
8408 if (die
->child
!= NULL
)
8409 dump_die_list (die
->child
);
8410 if (die
->sibling
!= NULL
)
8411 dump_die_list (die
->sibling
);
8416 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8417 struct dwarf2_cu
*cu
)
8420 struct die_info
*old
;
8422 h
= (offset
% REF_HASH_SIZE
);
8423 old
= cu
->die_ref_table
[h
];
8424 die
->next_ref
= old
;
8425 cu
->die_ref_table
[h
] = die
;
8429 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8431 unsigned int result
= 0;
8435 case DW_FORM_ref_addr
:
8440 case DW_FORM_ref_udata
:
8441 result
= DW_ADDR (attr
);
8444 complaint (&symfile_complaints
,
8445 _("unsupported die ref attribute form: '%s'"),
8446 dwarf_form_name (attr
->form
));
8451 /* Return the constant value held by the given attribute. Return -1
8452 if the value held by the attribute is not constant. */
8455 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8457 if (attr
->form
== DW_FORM_sdata
)
8458 return DW_SND (attr
);
8459 else if (attr
->form
== DW_FORM_udata
8460 || attr
->form
== DW_FORM_data1
8461 || attr
->form
== DW_FORM_data2
8462 || attr
->form
== DW_FORM_data4
8463 || attr
->form
== DW_FORM_data8
)
8464 return DW_UNSND (attr
);
8467 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8468 dwarf_form_name (attr
->form
));
8469 return default_value
;
8473 static struct die_info
*
8474 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8475 struct dwarf2_cu
*cu
)
8477 struct die_info
*die
;
8478 unsigned int offset
;
8480 struct die_info temp_die
;
8481 struct dwarf2_cu
*target_cu
;
8483 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8485 if (DW_ADDR (attr
) < cu
->header
.offset
8486 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8488 struct dwarf2_per_cu_data
*per_cu
;
8489 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8491 target_cu
= per_cu
->cu
;
8496 h
= (offset
% REF_HASH_SIZE
);
8497 die
= target_cu
->die_ref_table
[h
];
8500 if (die
->offset
== offset
)
8502 die
= die
->next_ref
;
8505 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8506 "at 0x%lx [in module %s]"),
8507 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8512 static struct type
*
8513 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8514 struct dwarf2_cu
*cu
)
8516 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8518 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8519 typeid, objfile
->name
);
8522 /* Look for this particular type in the fundamental type vector. If
8523 one is not found, create and install one appropriate for the
8524 current language and the current target machine. */
8526 if (cu
->ftypes
[typeid] == NULL
)
8528 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8531 return (cu
->ftypes
[typeid]);
8534 /* Decode simple location descriptions.
8535 Given a pointer to a dwarf block that defines a location, compute
8536 the location and return the value.
8538 NOTE drow/2003-11-18: This function is called in two situations
8539 now: for the address of static or global variables (partial symbols
8540 only) and for offsets into structures which are expected to be
8541 (more or less) constant. The partial symbol case should go away,
8542 and only the constant case should remain. That will let this
8543 function complain more accurately. A few special modes are allowed
8544 without complaint for global variables (for instance, global
8545 register values and thread-local values).
8547 A location description containing no operations indicates that the
8548 object is optimized out. The return value is 0 for that case.
8549 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8550 callers will only want a very basic result and this can become a
8553 Note that stack[0] is unused except as a default error return.
8554 Note that stack overflow is not yet handled. */
8557 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8559 struct objfile
*objfile
= cu
->objfile
;
8560 struct comp_unit_head
*cu_header
= &cu
->header
;
8562 int size
= blk
->size
;
8563 char *data
= blk
->data
;
8564 CORE_ADDR stack
[64];
8566 unsigned int bytes_read
, unsnd
;
8610 stack
[++stacki
] = op
- DW_OP_lit0
;
8645 stack
[++stacki
] = op
- DW_OP_reg0
;
8647 dwarf2_complex_location_expr_complaint ();
8651 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8653 stack
[++stacki
] = unsnd
;
8655 dwarf2_complex_location_expr_complaint ();
8659 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8665 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8670 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8675 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8680 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8685 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8690 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8695 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8701 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8706 stack
[stacki
+ 1] = stack
[stacki
];
8711 stack
[stacki
- 1] += stack
[stacki
];
8715 case DW_OP_plus_uconst
:
8716 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8721 stack
[stacki
- 1] -= stack
[stacki
];
8726 /* If we're not the last op, then we definitely can't encode
8727 this using GDB's address_class enum. This is valid for partial
8728 global symbols, although the variable's address will be bogus
8731 dwarf2_complex_location_expr_complaint ();
8734 case DW_OP_GNU_push_tls_address
:
8735 /* The top of the stack has the offset from the beginning
8736 of the thread control block at which the variable is located. */
8737 /* Nothing should follow this operator, so the top of stack would
8739 /* This is valid for partial global symbols, but the variable's
8740 address will be bogus in the psymtab. */
8742 dwarf2_complex_location_expr_complaint ();
8746 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8747 dwarf_stack_op_name (op
));
8748 return (stack
[stacki
]);
8751 return (stack
[stacki
]);
8754 /* memory allocation interface */
8756 static struct dwarf_block
*
8757 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8759 struct dwarf_block
*blk
;
8761 blk
= (struct dwarf_block
*)
8762 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8766 static struct abbrev_info
*
8767 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8769 struct abbrev_info
*abbrev
;
8771 abbrev
= (struct abbrev_info
*)
8772 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8773 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8777 static struct die_info
*
8778 dwarf_alloc_die (void)
8780 struct die_info
*die
;
8782 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8783 memset (die
, 0, sizeof (struct die_info
));
8788 /* Macro support. */
8791 /* Return the full name of file number I in *LH's file name table.
8792 Use COMP_DIR as the name of the current directory of the
8793 compilation. The result is allocated using xmalloc; the caller is
8794 responsible for freeing it. */
8796 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8798 /* Is the file number a valid index into the line header's file name
8799 table? Remember that file numbers start with one, not zero. */
8800 if (1 <= file
&& file
<= lh
->num_file_names
)
8802 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8804 if (IS_ABSOLUTE_PATH (fe
->name
))
8805 return xstrdup (fe
->name
);
8813 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8819 dir_len
= strlen (dir
);
8820 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8821 strcpy (full_name
, dir
);
8822 full_name
[dir_len
] = '/';
8823 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8827 return xstrdup (fe
->name
);
8832 /* The compiler produced a bogus file number. We can at least
8833 record the macro definitions made in the file, even if we
8834 won't be able to find the file by name. */
8836 sprintf (fake_name
, "<bad macro file number %d>", file
);
8838 complaint (&symfile_complaints
,
8839 _("bad file number in macro information (%d)"),
8842 return xstrdup (fake_name
);
8847 static struct macro_source_file
*
8848 macro_start_file (int file
, int line
,
8849 struct macro_source_file
*current_file
,
8850 const char *comp_dir
,
8851 struct line_header
*lh
, struct objfile
*objfile
)
8853 /* The full name of this source file. */
8854 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8856 /* We don't create a macro table for this compilation unit
8857 at all until we actually get a filename. */
8858 if (! pending_macros
)
8859 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8860 objfile
->macro_cache
);
8863 /* If we have no current file, then this must be the start_file
8864 directive for the compilation unit's main source file. */
8865 current_file
= macro_set_main (pending_macros
, full_name
);
8867 current_file
= macro_include (current_file
, line
, full_name
);
8871 return current_file
;
8875 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8876 followed by a null byte. */
8878 copy_string (const char *buf
, int len
)
8880 char *s
= xmalloc (len
+ 1);
8881 memcpy (s
, buf
, len
);
8889 consume_improper_spaces (const char *p
, const char *body
)
8893 complaint (&symfile_complaints
,
8894 _("macro definition contains spaces in formal argument list:\n`%s'"),
8906 parse_macro_definition (struct macro_source_file
*file
, int line
,
8911 /* The body string takes one of two forms. For object-like macro
8912 definitions, it should be:
8914 <macro name> " " <definition>
8916 For function-like macro definitions, it should be:
8918 <macro name> "() " <definition>
8920 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8922 Spaces may appear only where explicitly indicated, and in the
8925 The Dwarf 2 spec says that an object-like macro's name is always
8926 followed by a space, but versions of GCC around March 2002 omit
8927 the space when the macro's definition is the empty string.
8929 The Dwarf 2 spec says that there should be no spaces between the
8930 formal arguments in a function-like macro's formal argument list,
8931 but versions of GCC around March 2002 include spaces after the
8935 /* Find the extent of the macro name. The macro name is terminated
8936 by either a space or null character (for an object-like macro) or
8937 an opening paren (for a function-like macro). */
8938 for (p
= body
; *p
; p
++)
8939 if (*p
== ' ' || *p
== '(')
8942 if (*p
== ' ' || *p
== '\0')
8944 /* It's an object-like macro. */
8945 int name_len
= p
- body
;
8946 char *name
= copy_string (body
, name_len
);
8947 const char *replacement
;
8950 replacement
= body
+ name_len
+ 1;
8953 dwarf2_macro_malformed_definition_complaint (body
);
8954 replacement
= body
+ name_len
;
8957 macro_define_object (file
, line
, name
, replacement
);
8963 /* It's a function-like macro. */
8964 char *name
= copy_string (body
, p
- body
);
8967 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
8971 p
= consume_improper_spaces (p
, body
);
8973 /* Parse the formal argument list. */
8974 while (*p
&& *p
!= ')')
8976 /* Find the extent of the current argument name. */
8977 const char *arg_start
= p
;
8979 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
8982 if (! *p
|| p
== arg_start
)
8983 dwarf2_macro_malformed_definition_complaint (body
);
8986 /* Make sure argv has room for the new argument. */
8987 if (argc
>= argv_size
)
8990 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
8993 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
8996 p
= consume_improper_spaces (p
, body
);
8998 /* Consume the comma, if present. */
9003 p
= consume_improper_spaces (p
, body
);
9012 /* Perfectly formed definition, no complaints. */
9013 macro_define_function (file
, line
, name
,
9014 argc
, (const char **) argv
,
9016 else if (*p
== '\0')
9018 /* Complain, but do define it. */
9019 dwarf2_macro_malformed_definition_complaint (body
);
9020 macro_define_function (file
, line
, name
,
9021 argc
, (const char **) argv
,
9025 /* Just complain. */
9026 dwarf2_macro_malformed_definition_complaint (body
);
9029 /* Just complain. */
9030 dwarf2_macro_malformed_definition_complaint (body
);
9036 for (i
= 0; i
< argc
; i
++)
9042 dwarf2_macro_malformed_definition_complaint (body
);
9047 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9048 char *comp_dir
, bfd
*abfd
,
9049 struct dwarf2_cu
*cu
)
9051 char *mac_ptr
, *mac_end
;
9052 struct macro_source_file
*current_file
= 0;
9054 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9056 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9060 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9061 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9062 + dwarf2_per_objfile
->macinfo_size
;
9066 enum dwarf_macinfo_record_type macinfo_type
;
9068 /* Do we at least have room for a macinfo type byte? */
9069 if (mac_ptr
>= mac_end
)
9071 dwarf2_macros_too_long_complaint ();
9075 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9078 switch (macinfo_type
)
9080 /* A zero macinfo type indicates the end of the macro
9085 case DW_MACINFO_define
:
9086 case DW_MACINFO_undef
:
9092 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9093 mac_ptr
+= bytes_read
;
9094 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9095 mac_ptr
+= bytes_read
;
9098 complaint (&symfile_complaints
,
9099 _("debug info gives macro %s outside of any file: %s"),
9101 DW_MACINFO_define
? "definition" : macinfo_type
==
9102 DW_MACINFO_undef
? "undefinition" :
9103 "something-or-other", body
);
9106 if (macinfo_type
== DW_MACINFO_define
)
9107 parse_macro_definition (current_file
, line
, body
);
9108 else if (macinfo_type
== DW_MACINFO_undef
)
9109 macro_undef (current_file
, line
, body
);
9114 case DW_MACINFO_start_file
:
9119 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9120 mac_ptr
+= bytes_read
;
9121 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9122 mac_ptr
+= bytes_read
;
9124 current_file
= macro_start_file (file
, line
,
9125 current_file
, comp_dir
,
9130 case DW_MACINFO_end_file
:
9132 complaint (&symfile_complaints
,
9133 _("macro debug info has an unmatched `close_file' directive"));
9136 current_file
= current_file
->included_by
;
9139 enum dwarf_macinfo_record_type next_type
;
9141 /* GCC circa March 2002 doesn't produce the zero
9142 type byte marking the end of the compilation
9143 unit. Complain if it's not there, but exit no
9146 /* Do we at least have room for a macinfo type byte? */
9147 if (mac_ptr
>= mac_end
)
9149 dwarf2_macros_too_long_complaint ();
9153 /* We don't increment mac_ptr here, so this is just
9155 next_type
= read_1_byte (abfd
, mac_ptr
);
9157 complaint (&symfile_complaints
,
9158 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9165 case DW_MACINFO_vendor_ext
:
9171 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9172 mac_ptr
+= bytes_read
;
9173 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9174 mac_ptr
+= bytes_read
;
9176 /* We don't recognize any vendor extensions. */
9183 /* Check if the attribute's form is a DW_FORM_block*
9184 if so return true else false. */
9186 attr_form_is_block (struct attribute
*attr
)
9188 return (attr
== NULL
? 0 :
9189 attr
->form
== DW_FORM_block1
9190 || attr
->form
== DW_FORM_block2
9191 || attr
->form
== DW_FORM_block4
9192 || attr
->form
== DW_FORM_block
);
9196 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9197 struct dwarf2_cu
*cu
)
9199 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9201 struct dwarf2_loclist_baton
*baton
;
9203 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9204 sizeof (struct dwarf2_loclist_baton
));
9205 baton
->objfile
= cu
->objfile
;
9207 /* We don't know how long the location list is, but make sure we
9208 don't run off the edge of the section. */
9209 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9210 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9211 baton
->base_address
= cu
->header
.base_address
;
9212 if (cu
->header
.base_known
== 0)
9213 complaint (&symfile_complaints
,
9214 _("Location list used without specifying the CU base address."));
9216 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9217 SYMBOL_LOCATION_BATON (sym
) = baton
;
9221 struct dwarf2_locexpr_baton
*baton
;
9223 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9224 sizeof (struct dwarf2_locexpr_baton
));
9225 baton
->objfile
= cu
->objfile
;
9227 if (attr_form_is_block (attr
))
9229 /* Note that we're just copying the block's data pointer
9230 here, not the actual data. We're still pointing into the
9231 info_buffer for SYM's objfile; right now we never release
9232 that buffer, but when we do clean up properly this may
9234 baton
->size
= DW_BLOCK (attr
)->size
;
9235 baton
->data
= DW_BLOCK (attr
)->data
;
9239 dwarf2_invalid_attrib_class_complaint ("location description",
9240 SYMBOL_NATURAL_NAME (sym
));
9245 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9246 SYMBOL_LOCATION_BATON (sym
) = baton
;
9250 /* Locate the compilation unit from CU's objfile which contains the
9251 DIE at OFFSET. Raises an error on failure. */
9253 static struct dwarf2_per_cu_data
*
9254 dwarf2_find_containing_comp_unit (unsigned long offset
,
9255 struct objfile
*objfile
)
9257 struct dwarf2_per_cu_data
*this_cu
;
9261 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9264 int mid
= low
+ (high
- low
) / 2;
9265 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9270 gdb_assert (low
== high
);
9271 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9274 error (_("Dwarf Error: could not find partial DIE containing "
9275 "offset 0x%lx [in module %s]"),
9276 (long) offset
, bfd_get_filename (objfile
->obfd
));
9278 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9279 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9283 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9284 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9285 && offset
>= this_cu
->offset
+ this_cu
->length
)
9286 error (_("invalid dwarf2 offset %ld"), offset
);
9287 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9292 /* Locate the compilation unit from OBJFILE which is located at exactly
9293 OFFSET. Raises an error on failure. */
9295 static struct dwarf2_per_cu_data
*
9296 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9298 struct dwarf2_per_cu_data
*this_cu
;
9299 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9300 if (this_cu
->offset
!= offset
)
9301 error (_("no compilation unit with offset %ld."), offset
);
9305 /* Release one cached compilation unit, CU. We unlink it from the tree
9306 of compilation units, but we don't remove it from the read_in_chain;
9307 the caller is responsible for that. */
9310 free_one_comp_unit (void *data
)
9312 struct dwarf2_cu
*cu
= data
;
9314 if (cu
->per_cu
!= NULL
)
9315 cu
->per_cu
->cu
= NULL
;
9318 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9320 free_die_list (cu
->dies
);
9325 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9326 when we're finished with it. We can't free the pointer itself, but be
9327 sure to unlink it from the cache. Also release any associated storage
9328 and perform cache maintenance.
9330 Only used during partial symbol parsing. */
9333 free_stack_comp_unit (void *data
)
9335 struct dwarf2_cu
*cu
= data
;
9337 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9338 cu
->partial_dies
= NULL
;
9340 if (cu
->per_cu
!= NULL
)
9342 /* This compilation unit is on the stack in our caller, so we
9343 should not xfree it. Just unlink it. */
9344 cu
->per_cu
->cu
= NULL
;
9347 /* If we had a per-cu pointer, then we may have other compilation
9348 units loaded, so age them now. */
9349 age_cached_comp_units ();
9353 /* Free all cached compilation units. */
9356 free_cached_comp_units (void *data
)
9358 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9360 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9361 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9362 while (per_cu
!= NULL
)
9364 struct dwarf2_per_cu_data
*next_cu
;
9366 next_cu
= per_cu
->cu
->read_in_chain
;
9368 free_one_comp_unit (per_cu
->cu
);
9369 *last_chain
= next_cu
;
9375 /* Increase the age counter on each cached compilation unit, and free
9376 any that are too old. */
9379 age_cached_comp_units (void)
9381 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9383 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9384 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9385 while (per_cu
!= NULL
)
9387 per_cu
->cu
->last_used
++;
9388 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9389 dwarf2_mark (per_cu
->cu
);
9390 per_cu
= per_cu
->cu
->read_in_chain
;
9393 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9394 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9395 while (per_cu
!= NULL
)
9397 struct dwarf2_per_cu_data
*next_cu
;
9399 next_cu
= per_cu
->cu
->read_in_chain
;
9401 if (!per_cu
->cu
->mark
)
9403 free_one_comp_unit (per_cu
->cu
);
9404 *last_chain
= next_cu
;
9407 last_chain
= &per_cu
->cu
->read_in_chain
;
9413 /* Remove a single compilation unit from the cache. */
9416 free_one_cached_comp_unit (void *target_cu
)
9418 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9420 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9421 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9422 while (per_cu
!= NULL
)
9424 struct dwarf2_per_cu_data
*next_cu
;
9426 next_cu
= per_cu
->cu
->read_in_chain
;
9428 if (per_cu
->cu
== target_cu
)
9430 free_one_comp_unit (per_cu
->cu
);
9431 *last_chain
= next_cu
;
9435 last_chain
= &per_cu
->cu
->read_in_chain
;
9441 /* A pair of DIE offset and GDB type pointer. We store these
9442 in a hash table separate from the DIEs, and preserve them
9443 when the DIEs are flushed out of cache. */
9445 struct dwarf2_offset_and_type
9447 unsigned int offset
;
9451 /* Hash function for a dwarf2_offset_and_type. */
9454 offset_and_type_hash (const void *item
)
9456 const struct dwarf2_offset_and_type
*ofs
= item
;
9460 /* Equality function for a dwarf2_offset_and_type. */
9463 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9465 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9466 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9467 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9470 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9471 table if necessary. */
9474 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9476 struct dwarf2_offset_and_type
**slot
, ofs
;
9480 if (cu
->per_cu
== NULL
)
9483 if (cu
->per_cu
->type_hash
== NULL
)
9484 cu
->per_cu
->type_hash
9485 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9486 offset_and_type_hash
,
9489 &cu
->objfile
->objfile_obstack
,
9490 hashtab_obstack_allocate
,
9491 dummy_obstack_deallocate
);
9493 ofs
.offset
= die
->offset
;
9495 slot
= (struct dwarf2_offset_and_type
**)
9496 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9497 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9501 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9502 have a saved type. */
9504 static struct type
*
9505 get_die_type (struct die_info
*die
, htab_t type_hash
)
9507 struct dwarf2_offset_and_type
*slot
, ofs
;
9509 ofs
.offset
= die
->offset
;
9510 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9517 /* Restore the types of the DIE tree starting at START_DIE from the hash
9518 table saved in CU. */
9521 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9523 struct die_info
*die
;
9525 if (cu
->per_cu
->type_hash
== NULL
)
9528 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9530 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9531 if (die
->child
!= NULL
)
9532 reset_die_and_siblings_types (die
->child
, cu
);
9536 /* Set the mark field in CU and in every other compilation unit in the
9537 cache that we must keep because we are keeping CU. */
9539 /* Add a dependence relationship from CU to REF_PER_CU. */
9542 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9543 struct dwarf2_per_cu_data
*ref_per_cu
)
9547 if (cu
->dependencies
== NULL
)
9549 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9550 NULL
, &cu
->comp_unit_obstack
,
9551 hashtab_obstack_allocate
,
9552 dummy_obstack_deallocate
);
9554 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9559 /* Set the mark field in CU and in every other compilation unit in the
9560 cache that we must keep because we are keeping CU. */
9563 dwarf2_mark_helper (void **slot
, void *data
)
9565 struct dwarf2_per_cu_data
*per_cu
;
9567 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9568 if (per_cu
->cu
->mark
)
9570 per_cu
->cu
->mark
= 1;
9572 if (per_cu
->cu
->dependencies
!= NULL
)
9573 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9579 dwarf2_mark (struct dwarf2_cu
*cu
)
9584 if (cu
->dependencies
!= NULL
)
9585 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9589 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9593 per_cu
->cu
->mark
= 0;
9594 per_cu
= per_cu
->cu
->read_in_chain
;
9598 /* Allocation function for the libiberty hash table which uses an
9602 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
9604 unsigned int total
= size
* count
;
9605 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
9606 memset (ptr
, 0, total
);
9610 /* Trivial deallocation function for the libiberty splay tree and hash
9611 table - don't deallocate anything. Rely on later deletion of the
9615 dummy_obstack_deallocate (void *object
, void *data
)
9620 /* Trivial hash function for partial_die_info: the hash value of a DIE
9621 is its offset in .debug_info for this objfile. */
9624 partial_die_hash (const void *item
)
9626 const struct partial_die_info
*part_die
= item
;
9627 return part_die
->offset
;
9630 /* Trivial comparison function for partial_die_info structures: two DIEs
9631 are equal if they have the same offset. */
9634 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9636 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9637 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9638 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9641 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9642 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9645 set_dwarf2_cmd (char *args
, int from_tty
)
9647 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9651 show_dwarf2_cmd (char *args
, int from_tty
)
9653 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9656 void _initialize_dwarf2_read (void);
9659 _initialize_dwarf2_read (void)
9661 dwarf2_objfile_data_key
= register_objfile_data ();
9663 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9664 Set DWARF 2 specific variables.\n\
9665 Configure DWARF 2 variables such as the cache size"),
9666 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9667 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9669 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9670 Show DWARF 2 specific variables\n\
9671 Show DWARF 2 variables such as the cache size"),
9672 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9673 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9675 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9676 &dwarf2_max_cache_age
, _("\
9677 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9678 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9679 A higher limit means that cached compilation units will be stored\n\
9680 in memory longer, and more total memory will be used. Zero disables\n\
9681 caching, which can slow down startup."),
9683 show_dwarf2_max_cache_age
,
9684 &set_dwarf2_cmdlist
,
9685 &show_dwarf2_cmdlist
);