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: decode_locdesc sets these variables to describe the location
584 to the caller. These ought to be a structure or something. If
585 none of the flags are set, the object lives at the address returned
586 by decode_locdesc. */
588 static int isreg
; /* Object lives in register.
589 decode_locdesc's return value is
590 the register number. */
592 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
593 but this would require a corresponding change in unpack_field_as_long
595 static int bits_per_byte
= 8;
597 /* The routines that read and process dies for a C struct or C++ class
598 pass lists of data member fields and lists of member function fields
599 in an instance of a field_info structure, as defined below. */
602 /* List of data member and baseclasses fields. */
605 struct nextfield
*next
;
612 /* Number of fields. */
615 /* Number of baseclasses. */
618 /* Set if the accesibility of one of the fields is not public. */
619 int non_public_fields
;
621 /* Member function fields array, entries are allocated in the order they
622 are encountered in the object file. */
625 struct nextfnfield
*next
;
626 struct fn_field fnfield
;
630 /* Member function fieldlist array, contains name of possibly overloaded
631 member function, number of overloaded member functions and a pointer
632 to the head of the member function field chain. */
637 struct nextfnfield
*head
;
641 /* Number of entries in the fnfieldlists array. */
645 /* One item on the queue of compilation units to read in full symbols
647 struct dwarf2_queue_item
649 struct dwarf2_per_cu_data
*per_cu
;
650 struct dwarf2_queue_item
*next
;
653 /* The current queue. */
654 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
656 /* Loaded secondary compilation units are kept in memory until they
657 have not been referenced for the processing of this many
658 compilation units. Set this to zero to disable caching. Cache
659 sizes of up to at least twenty will improve startup time for
660 typical inter-CU-reference binaries, at an obvious memory cost. */
661 static int dwarf2_max_cache_age
= 5;
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 if (comp_unit_die
.has_stmt_list
)
1538 /* Get the list of files included in the current compilation unit,
1539 and build a psymtab for each of them. */
1540 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1543 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1544 + cu
.header
.initial_length_size
;
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
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1636 &cu_header
, &bytes_read
);
1638 /* Save the compilation unit for later lookup. */
1639 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1640 sizeof (struct dwarf2_per_cu_data
));
1641 memset (this_cu
, 0, sizeof (*this_cu
));
1642 this_cu
->offset
= offset
;
1643 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1645 if (n_comp_units
== n_allocated
)
1648 all_comp_units
= xrealloc (all_comp_units
,
1650 * sizeof (struct dwarf2_per_cu_data
*));
1652 all_comp_units
[n_comp_units
++] = this_cu
;
1654 info_ptr
= info_ptr
+ this_cu
->length
;
1657 dwarf2_per_objfile
->all_comp_units
1658 = obstack_alloc (&objfile
->objfile_obstack
,
1659 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1660 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1661 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1662 xfree (all_comp_units
);
1663 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1666 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1667 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1671 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1672 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1674 struct objfile
*objfile
= cu
->objfile
;
1675 bfd
*abfd
= objfile
->obfd
;
1676 struct partial_die_info
*pdi
;
1678 /* Now, march along the PDI's, descending into ones which have
1679 interesting children but skipping the children of the other ones,
1680 until we reach the end of the compilation unit. */
1686 fixup_partial_die (pdi
, cu
);
1688 /* Anonymous namespaces have no name but have interesting
1689 children, so we need to look at them. Ditto for anonymous
1692 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1693 || pdi
->tag
== DW_TAG_enumeration_type
)
1697 case DW_TAG_subprogram
:
1698 if (pdi
->has_pc_info
)
1700 if (pdi
->lowpc
< *lowpc
)
1702 *lowpc
= pdi
->lowpc
;
1704 if (pdi
->highpc
> *highpc
)
1706 *highpc
= pdi
->highpc
;
1708 if (!pdi
->is_declaration
)
1710 add_partial_symbol (pdi
, cu
);
1714 case DW_TAG_variable
:
1715 case DW_TAG_typedef
:
1716 case DW_TAG_union_type
:
1717 if (!pdi
->is_declaration
)
1719 add_partial_symbol (pdi
, cu
);
1722 case DW_TAG_class_type
:
1723 case DW_TAG_structure_type
:
1724 if (!pdi
->is_declaration
)
1726 add_partial_symbol (pdi
, cu
);
1729 case DW_TAG_enumeration_type
:
1730 if (!pdi
->is_declaration
)
1731 add_partial_enumeration (pdi
, cu
);
1733 case DW_TAG_base_type
:
1734 case DW_TAG_subrange_type
:
1735 /* File scope base type definitions are added to the partial
1737 add_partial_symbol (pdi
, cu
);
1739 case DW_TAG_namespace
:
1740 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1747 /* If the die has a sibling, skip to the sibling. */
1749 pdi
= pdi
->die_sibling
;
1753 /* Functions used to compute the fully scoped name of a partial DIE.
1755 Normally, this is simple. For C++, the parent DIE's fully scoped
1756 name is concatenated with "::" and the partial DIE's name. For
1757 Java, the same thing occurs except that "." is used instead of "::".
1758 Enumerators are an exception; they use the scope of their parent
1759 enumeration type, i.e. the name of the enumeration type is not
1760 prepended to the enumerator.
1762 There are two complexities. One is DW_AT_specification; in this
1763 case "parent" means the parent of the target of the specification,
1764 instead of the direct parent of the DIE. The other is compilers
1765 which do not emit DW_TAG_namespace; in this case we try to guess
1766 the fully qualified name of structure types from their members'
1767 linkage names. This must be done using the DIE's children rather
1768 than the children of any DW_AT_specification target. We only need
1769 to do this for structures at the top level, i.e. if the target of
1770 any DW_AT_specification (if any; otherwise the DIE itself) does not
1773 /* Compute the scope prefix associated with PDI's parent, in
1774 compilation unit CU. The result will be allocated on CU's
1775 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1776 field. NULL is returned if no prefix is necessary. */
1778 partial_die_parent_scope (struct partial_die_info
*pdi
,
1779 struct dwarf2_cu
*cu
)
1781 char *grandparent_scope
;
1782 struct partial_die_info
*parent
, *real_pdi
;
1784 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1785 then this means the parent of the specification DIE. */
1788 while (real_pdi
->has_specification
)
1789 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1791 parent
= real_pdi
->die_parent
;
1795 if (parent
->scope_set
)
1796 return parent
->scope
;
1798 fixup_partial_die (parent
, cu
);
1800 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1802 if (parent
->tag
== DW_TAG_namespace
1803 || parent
->tag
== DW_TAG_structure_type
1804 || parent
->tag
== DW_TAG_class_type
1805 || parent
->tag
== DW_TAG_union_type
)
1807 if (grandparent_scope
== NULL
)
1808 parent
->scope
= parent
->name
;
1810 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1813 else if (parent
->tag
== DW_TAG_enumeration_type
)
1814 /* Enumerators should not get the name of the enumeration as a prefix. */
1815 parent
->scope
= grandparent_scope
;
1818 /* FIXME drow/2004-04-01: What should we be doing with
1819 function-local names? For partial symbols, we should probably be
1821 complaint (&symfile_complaints
,
1822 _("unhandled containing DIE tag %d for DIE at %d"),
1823 parent
->tag
, pdi
->offset
);
1824 parent
->scope
= grandparent_scope
;
1827 parent
->scope_set
= 1;
1828 return parent
->scope
;
1831 /* Return the fully scoped name associated with PDI, from compilation unit
1832 CU. The result will be allocated with malloc. */
1834 partial_die_full_name (struct partial_die_info
*pdi
,
1835 struct dwarf2_cu
*cu
)
1839 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1840 if (parent_scope
== NULL
)
1843 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1847 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1849 struct objfile
*objfile
= cu
->objfile
;
1852 const char *my_prefix
;
1853 const struct partial_symbol
*psym
= NULL
;
1855 int built_actual_name
= 0;
1857 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1861 if (pdi_needs_namespace (pdi
->tag
))
1863 actual_name
= partial_die_full_name (pdi
, cu
);
1865 built_actual_name
= 1;
1868 if (actual_name
== NULL
)
1869 actual_name
= pdi
->name
;
1873 case DW_TAG_subprogram
:
1874 if (pdi
->is_external
)
1876 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1877 mst_text, objfile); */
1878 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1879 VAR_DOMAIN
, LOC_BLOCK
,
1880 &objfile
->global_psymbols
,
1881 0, pdi
->lowpc
+ baseaddr
,
1882 cu
->language
, objfile
);
1886 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1887 mst_file_text, objfile); */
1888 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1889 VAR_DOMAIN
, LOC_BLOCK
,
1890 &objfile
->static_psymbols
,
1891 0, pdi
->lowpc
+ baseaddr
,
1892 cu
->language
, objfile
);
1895 case DW_TAG_variable
:
1896 if (pdi
->is_external
)
1899 Don't enter into the minimal symbol tables as there is
1900 a minimal symbol table entry from the ELF symbols already.
1901 Enter into partial symbol table if it has a location
1902 descriptor or a type.
1903 If the location descriptor is missing, new_symbol will create
1904 a LOC_UNRESOLVED symbol, the address of the variable will then
1905 be determined from the minimal symbol table whenever the variable
1907 The address for the partial symbol table entry is not
1908 used by GDB, but it comes in handy for debugging partial symbol
1912 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1913 if (pdi
->locdesc
|| pdi
->has_type
)
1914 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1915 VAR_DOMAIN
, LOC_STATIC
,
1916 &objfile
->global_psymbols
,
1918 cu
->language
, objfile
);
1922 /* Static Variable. Skip symbols without location descriptors. */
1923 if (pdi
->locdesc
== NULL
)
1925 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1926 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1927 mst_file_data, objfile); */
1928 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1929 VAR_DOMAIN
, LOC_STATIC
,
1930 &objfile
->static_psymbols
,
1932 cu
->language
, objfile
);
1935 case DW_TAG_typedef
:
1936 case DW_TAG_base_type
:
1937 case DW_TAG_subrange_type
:
1938 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1939 VAR_DOMAIN
, LOC_TYPEDEF
,
1940 &objfile
->static_psymbols
,
1941 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1943 case DW_TAG_namespace
:
1944 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1945 VAR_DOMAIN
, LOC_TYPEDEF
,
1946 &objfile
->global_psymbols
,
1947 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1949 case DW_TAG_class_type
:
1950 case DW_TAG_structure_type
:
1951 case DW_TAG_union_type
:
1952 case DW_TAG_enumeration_type
:
1953 /* Skip aggregate types without children, these are external
1955 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1956 static vs. global. */
1957 if (pdi
->has_children
== 0)
1959 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1960 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1961 (cu
->language
== language_cplus
1962 || cu
->language
== language_java
)
1963 ? &objfile
->global_psymbols
1964 : &objfile
->static_psymbols
,
1965 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1967 if (cu
->language
== language_cplus
1968 || cu
->language
== language_java
)
1970 /* For C++ and Java, these implicitly act as typedefs as well. */
1971 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1972 VAR_DOMAIN
, LOC_TYPEDEF
,
1973 &objfile
->global_psymbols
,
1974 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1977 case DW_TAG_enumerator
:
1978 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1979 VAR_DOMAIN
, LOC_CONST
,
1980 (cu
->language
== language_cplus
1981 || cu
->language
== language_java
)
1982 ? &objfile
->global_psymbols
1983 : &objfile
->static_psymbols
,
1984 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1990 /* Check to see if we should scan the name for possible namespace
1991 info. Only do this if this is C++, if we don't have namespace
1992 debugging info in the file, if the psym is of an appropriate type
1993 (otherwise we'll have psym == NULL), and if we actually had a
1994 mangled name to begin with. */
1996 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
1997 cases which do not set PSYM above? */
1999 if (cu
->language
== language_cplus
2000 && cu
->has_namespace_info
== 0
2002 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2003 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2006 if (built_actual_name
)
2007 xfree (actual_name
);
2010 /* Determine whether a die of type TAG living in a C++ class or
2011 namespace needs to have the name of the scope prepended to the
2012 name listed in the die. */
2015 pdi_needs_namespace (enum dwarf_tag tag
)
2019 case DW_TAG_namespace
:
2020 case DW_TAG_typedef
:
2021 case DW_TAG_class_type
:
2022 case DW_TAG_structure_type
:
2023 case DW_TAG_union_type
:
2024 case DW_TAG_enumeration_type
:
2025 case DW_TAG_enumerator
:
2032 /* Read a partial die corresponding to a namespace; also, add a symbol
2033 corresponding to that namespace to the symbol table. NAMESPACE is
2034 the name of the enclosing namespace. */
2037 add_partial_namespace (struct partial_die_info
*pdi
,
2038 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2039 struct dwarf2_cu
*cu
)
2041 struct objfile
*objfile
= cu
->objfile
;
2043 /* Add a symbol for the namespace. */
2045 add_partial_symbol (pdi
, cu
);
2047 /* Now scan partial symbols in that namespace. */
2049 if (pdi
->has_children
)
2050 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2053 /* See if we can figure out if the class lives in a namespace. We do
2054 this by looking for a member function; its demangled name will
2055 contain namespace info, if there is any. */
2058 guess_structure_name (struct partial_die_info
*struct_pdi
,
2059 struct dwarf2_cu
*cu
)
2061 if ((cu
->language
== language_cplus
2062 || cu
->language
== language_java
)
2063 && cu
->has_namespace_info
== 0
2064 && struct_pdi
->has_children
)
2066 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2067 what template types look like, because the demangler
2068 frequently doesn't give the same name as the debug info. We
2069 could fix this by only using the demangled name to get the
2070 prefix (but see comment in read_structure_type). */
2072 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2073 struct partial_die_info
*real_pdi
;
2075 /* If this DIE (this DIE's specification, if any) has a parent, then
2076 we should not do this. We'll prepend the parent's fully qualified
2077 name when we create the partial symbol. */
2079 real_pdi
= struct_pdi
;
2080 while (real_pdi
->has_specification
)
2081 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2083 if (real_pdi
->die_parent
!= NULL
)
2086 while (child_pdi
!= NULL
)
2088 if (child_pdi
->tag
== DW_TAG_subprogram
)
2090 char *actual_class_name
2091 = language_class_name_from_physname (cu
->language_defn
,
2093 if (actual_class_name
!= NULL
)
2096 = obsavestring (actual_class_name
,
2097 strlen (actual_class_name
),
2098 &cu
->comp_unit_obstack
);
2099 xfree (actual_class_name
);
2104 child_pdi
= child_pdi
->die_sibling
;
2109 /* Read a partial die corresponding to an enumeration type. */
2112 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2113 struct dwarf2_cu
*cu
)
2115 struct objfile
*objfile
= cu
->objfile
;
2116 bfd
*abfd
= objfile
->obfd
;
2117 struct partial_die_info
*pdi
;
2119 if (enum_pdi
->name
!= NULL
)
2120 add_partial_symbol (enum_pdi
, cu
);
2122 pdi
= enum_pdi
->die_child
;
2125 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2126 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2128 add_partial_symbol (pdi
, cu
);
2129 pdi
= pdi
->die_sibling
;
2133 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2134 Return the corresponding abbrev, or NULL if the number is zero (indicating
2135 an empty DIE). In either case *BYTES_READ will be set to the length of
2136 the initial number. */
2138 static struct abbrev_info
*
2139 peek_die_abbrev (char *info_ptr
, int *bytes_read
, struct dwarf2_cu
*cu
)
2141 bfd
*abfd
= cu
->objfile
->obfd
;
2142 unsigned int abbrev_number
;
2143 struct abbrev_info
*abbrev
;
2145 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2147 if (abbrev_number
== 0)
2150 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2153 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2154 bfd_get_filename (abfd
));
2160 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2161 pointer to the end of a series of DIEs, terminated by an empty
2162 DIE. Any children of the skipped DIEs will also be skipped. */
2165 skip_children (char *info_ptr
, struct dwarf2_cu
*cu
)
2167 struct abbrev_info
*abbrev
;
2168 unsigned int bytes_read
;
2172 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2174 return info_ptr
+ bytes_read
;
2176 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2180 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2181 should point just after the initial uleb128 of a DIE, and the
2182 abbrev corresponding to that skipped uleb128 should be passed in
2183 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2187 skip_one_die (char *info_ptr
, struct abbrev_info
*abbrev
,
2188 struct dwarf2_cu
*cu
)
2190 unsigned int bytes_read
;
2191 struct attribute attr
;
2192 bfd
*abfd
= cu
->objfile
->obfd
;
2193 unsigned int form
, i
;
2195 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2197 /* The only abbrev we care about is DW_AT_sibling. */
2198 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2200 read_attribute (&attr
, &abbrev
->attrs
[i
],
2201 abfd
, info_ptr
, cu
);
2202 if (attr
.form
== DW_FORM_ref_addr
)
2203 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2205 return dwarf2_per_objfile
->info_buffer
2206 + dwarf2_get_ref_die_offset (&attr
, cu
);
2209 /* If it isn't DW_AT_sibling, skip this attribute. */
2210 form
= abbrev
->attrs
[i
].form
;
2215 case DW_FORM_ref_addr
:
2216 info_ptr
+= cu
->header
.addr_size
;
2235 case DW_FORM_string
:
2236 read_string (abfd
, info_ptr
, &bytes_read
);
2237 info_ptr
+= bytes_read
;
2240 info_ptr
+= cu
->header
.offset_size
;
2243 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2244 info_ptr
+= bytes_read
;
2246 case DW_FORM_block1
:
2247 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2249 case DW_FORM_block2
:
2250 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2252 case DW_FORM_block4
:
2253 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2257 case DW_FORM_ref_udata
:
2258 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2260 case DW_FORM_indirect
:
2261 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2262 info_ptr
+= bytes_read
;
2263 /* We need to continue parsing from here, so just go back to
2265 goto skip_attribute
;
2268 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2269 dwarf_form_name (form
),
2270 bfd_get_filename (abfd
));
2274 if (abbrev
->has_children
)
2275 return skip_children (info_ptr
, cu
);
2280 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2281 the next DIE after ORIG_PDI. */
2284 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
2285 bfd
*abfd
, struct dwarf2_cu
*cu
)
2287 /* Do we know the sibling already? */
2289 if (orig_pdi
->sibling
)
2290 return orig_pdi
->sibling
;
2292 /* Are there any children to deal with? */
2294 if (!orig_pdi
->has_children
)
2297 /* Skip the children the long way. */
2299 return skip_children (info_ptr
, cu
);
2302 /* Expand this partial symbol table into a full symbol table. */
2305 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2307 /* FIXME: This is barely more than a stub. */
2312 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2318 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2319 gdb_flush (gdb_stdout
);
2322 /* Restore our global data. */
2323 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2324 dwarf2_objfile_data_key
);
2326 psymtab_to_symtab_1 (pst
);
2328 /* Finish up the debug error message. */
2330 printf_filtered (_("done.\n"));
2335 /* Add PER_CU to the queue. */
2338 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2340 struct dwarf2_queue_item
*item
;
2343 item
= xmalloc (sizeof (*item
));
2344 item
->per_cu
= per_cu
;
2347 if (dwarf2_queue
== NULL
)
2348 dwarf2_queue
= item
;
2350 dwarf2_queue_tail
->next
= item
;
2352 dwarf2_queue_tail
= item
;
2355 /* Process the queue. */
2358 process_queue (struct objfile
*objfile
)
2360 struct dwarf2_queue_item
*item
, *next_item
;
2362 /* Initially, there is just one item on the queue. Load its DIEs,
2363 and the DIEs of any other compilation units it requires,
2366 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2368 /* Read in this compilation unit. This may add new items to
2369 the end of the queue. */
2370 load_full_comp_unit (item
->per_cu
);
2372 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2373 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2375 /* If this compilation unit has already had full symbols created,
2376 reset the TYPE fields in each DIE. */
2377 if (item
->per_cu
->psymtab
->readin
)
2378 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2382 /* Now everything left on the queue needs to be read in. Process
2383 them, one at a time, removing from the queue as we finish. */
2384 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2386 if (!item
->per_cu
->psymtab
->readin
)
2387 process_full_comp_unit (item
->per_cu
);
2389 item
->per_cu
->queued
= 0;
2390 next_item
= item
->next
;
2394 dwarf2_queue_tail
= NULL
;
2397 /* Free all allocated queue entries. This function only releases anything if
2398 an error was thrown; if the queue was processed then it would have been
2399 freed as we went along. */
2402 dwarf2_release_queue (void *dummy
)
2404 struct dwarf2_queue_item
*item
, *last
;
2406 item
= dwarf2_queue
;
2409 /* Anything still marked queued is likely to be in an
2410 inconsistent state, so discard it. */
2411 if (item
->per_cu
->queued
)
2413 if (item
->per_cu
->cu
!= NULL
)
2414 free_one_cached_comp_unit (item
->per_cu
->cu
);
2415 item
->per_cu
->queued
= 0;
2423 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2426 /* Read in full symbols for PST, and anything it depends on. */
2429 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2431 struct dwarf2_per_cu_data
*per_cu
;
2432 struct cleanup
*back_to
;
2435 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2436 if (!pst
->dependencies
[i
]->readin
)
2438 /* Inform about additional files that need to be read in. */
2441 /* FIXME: i18n: Need to make this a single string. */
2442 fputs_filtered (" ", gdb_stdout
);
2444 fputs_filtered ("and ", gdb_stdout
);
2446 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2447 wrap_here (""); /* Flush output */
2448 gdb_flush (gdb_stdout
);
2450 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2453 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2457 /* It's an include file, no symbols to read for it.
2458 Everything is in the parent symtab. */
2463 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2465 queue_comp_unit (per_cu
);
2467 process_queue (pst
->objfile
);
2469 /* Age the cache, releasing compilation units that have not
2470 been used recently. */
2471 age_cached_comp_units ();
2473 do_cleanups (back_to
);
2476 /* Load the DIEs associated with PST and PER_CU into memory. */
2478 static struct dwarf2_cu
*
2479 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2481 struct partial_symtab
*pst
= per_cu
->psymtab
;
2482 bfd
*abfd
= pst
->objfile
->obfd
;
2483 struct dwarf2_cu
*cu
;
2484 unsigned long offset
;
2486 struct cleanup
*back_to
, *free_cu_cleanup
;
2487 struct attribute
*attr
;
2490 /* Set local variables from the partial symbol table info. */
2491 offset
= per_cu
->offset
;
2493 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2495 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2496 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2498 /* If an error occurs while loading, release our storage. */
2499 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2501 cu
->objfile
= pst
->objfile
;
2503 /* read in the comp_unit header */
2504 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2506 /* Read the abbrevs for this compilation unit */
2507 dwarf2_read_abbrevs (abfd
, cu
);
2508 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2510 cu
->header
.offset
= offset
;
2512 cu
->per_cu
= per_cu
;
2515 /* We use this obstack for block values in dwarf_alloc_block. */
2516 obstack_init (&cu
->comp_unit_obstack
);
2518 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2520 /* We try not to read any attributes in this function, because not
2521 all objfiles needed for references have been loaded yet, and symbol
2522 table processing isn't initialized. But we have to set the CU language,
2523 or we won't be able to build types correctly. */
2524 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2526 set_cu_language (DW_UNSND (attr
), cu
);
2528 set_cu_language (language_minimal
, cu
);
2530 do_cleanups (back_to
);
2532 /* We've successfully allocated this compilation unit. Let our caller
2533 clean it up when finished with it. */
2534 discard_cleanups (free_cu_cleanup
);
2539 /* Generate full symbol information for PST and CU, whose DIEs have
2540 already been loaded into memory. */
2543 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2545 struct partial_symtab
*pst
= per_cu
->psymtab
;
2546 struct dwarf2_cu
*cu
= per_cu
->cu
;
2547 struct objfile
*objfile
= pst
->objfile
;
2548 bfd
*abfd
= objfile
->obfd
;
2549 CORE_ADDR lowpc
, highpc
;
2550 struct symtab
*symtab
;
2551 struct cleanup
*back_to
;
2552 struct attribute
*attr
;
2555 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2557 /* We're in the global namespace. */
2558 processing_current_prefix
= "";
2561 back_to
= make_cleanup (really_free_pendings
, NULL
);
2563 cu
->list_in_scope
= &file_symbols
;
2565 /* Find the base address of the compilation unit for range lists and
2566 location lists. It will normally be specified by DW_AT_low_pc.
2567 In DWARF-3 draft 4, the base address could be overridden by
2568 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2569 compilation units with discontinuous ranges. */
2571 cu
->header
.base_known
= 0;
2572 cu
->header
.base_address
= 0;
2574 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2577 cu
->header
.base_address
= DW_ADDR (attr
);
2578 cu
->header
.base_known
= 1;
2582 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2585 cu
->header
.base_address
= DW_ADDR (attr
);
2586 cu
->header
.base_known
= 1;
2590 /* Do line number decoding in read_file_scope () */
2591 process_die (cu
->dies
, cu
);
2593 /* Some compilers don't define a DW_AT_high_pc attribute for the
2594 compilation unit. If the DW_AT_high_pc is missing, synthesize
2595 it, by scanning the DIE's below the compilation unit. */
2596 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2598 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2600 /* Set symtab language to language from DW_AT_language.
2601 If the compilation is from a C file generated by language preprocessors,
2602 do not set the language if it was already deduced by start_subfile. */
2604 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2606 symtab
->language
= cu
->language
;
2608 pst
->symtab
= symtab
;
2611 do_cleanups (back_to
);
2614 /* Process a die and its children. */
2617 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2621 case DW_TAG_padding
:
2623 case DW_TAG_compile_unit
:
2624 read_file_scope (die
, cu
);
2626 case DW_TAG_subprogram
:
2627 read_subroutine_type (die
, cu
);
2628 read_func_scope (die
, cu
);
2630 case DW_TAG_inlined_subroutine
:
2631 /* FIXME: These are ignored for now.
2632 They could be used to set breakpoints on all inlined instances
2633 of a function and make GDB `next' properly over inlined functions. */
2635 case DW_TAG_lexical_block
:
2636 case DW_TAG_try_block
:
2637 case DW_TAG_catch_block
:
2638 read_lexical_block_scope (die
, cu
);
2640 case DW_TAG_class_type
:
2641 case DW_TAG_structure_type
:
2642 case DW_TAG_union_type
:
2643 read_structure_type (die
, cu
);
2644 process_structure_scope (die
, cu
);
2646 case DW_TAG_enumeration_type
:
2647 read_enumeration_type (die
, cu
);
2648 process_enumeration_scope (die
, cu
);
2651 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2652 a symbol or process any children. Therefore it doesn't do anything
2653 that won't be done on-demand by read_type_die. */
2654 case DW_TAG_subroutine_type
:
2655 read_subroutine_type (die
, cu
);
2657 case DW_TAG_array_type
:
2658 read_array_type (die
, cu
);
2660 case DW_TAG_pointer_type
:
2661 read_tag_pointer_type (die
, cu
);
2663 case DW_TAG_ptr_to_member_type
:
2664 read_tag_ptr_to_member_type (die
, cu
);
2666 case DW_TAG_reference_type
:
2667 read_tag_reference_type (die
, cu
);
2669 case DW_TAG_string_type
:
2670 read_tag_string_type (die
, cu
);
2674 case DW_TAG_base_type
:
2675 read_base_type (die
, cu
);
2676 /* Add a typedef symbol for the type definition, if it has a
2678 new_symbol (die
, die
->type
, cu
);
2680 case DW_TAG_subrange_type
:
2681 read_subrange_type (die
, cu
);
2682 /* Add a typedef symbol for the type definition, if it has a
2684 new_symbol (die
, die
->type
, cu
);
2686 case DW_TAG_common_block
:
2687 read_common_block (die
, cu
);
2689 case DW_TAG_common_inclusion
:
2691 case DW_TAG_namespace
:
2692 processing_has_namespace_info
= 1;
2693 read_namespace (die
, cu
);
2695 case DW_TAG_imported_declaration
:
2696 case DW_TAG_imported_module
:
2697 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2698 information contained in these. DW_TAG_imported_declaration
2699 dies shouldn't have children; DW_TAG_imported_module dies
2700 shouldn't in the C++ case, but conceivably could in the
2701 Fortran case, so we'll have to replace this gdb_assert if
2702 Fortran compilers start generating that info. */
2703 processing_has_namespace_info
= 1;
2704 gdb_assert (die
->child
== NULL
);
2707 new_symbol (die
, NULL
, cu
);
2713 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2715 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2719 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2721 struct objfile
*objfile
= cu
->objfile
;
2722 struct comp_unit_head
*cu_header
= &cu
->header
;
2723 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2724 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2725 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2726 struct attribute
*attr
;
2727 char *name
= "<unknown>";
2728 char *comp_dir
= NULL
;
2729 struct die_info
*child_die
;
2730 bfd
*abfd
= objfile
->obfd
;
2731 struct line_header
*line_header
= 0;
2734 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2736 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2738 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2739 from finish_block. */
2740 if (lowpc
== ((CORE_ADDR
) -1))
2745 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2748 name
= DW_STRING (attr
);
2750 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2753 comp_dir
= DW_STRING (attr
);
2756 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2757 directory, get rid of it. */
2758 char *cp
= strchr (comp_dir
, ':');
2760 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2765 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2768 set_cu_language (DW_UNSND (attr
), cu
);
2771 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2773 cu
->producer
= DW_STRING (attr
);
2775 /* We assume that we're processing GCC output. */
2776 processing_gcc_compilation
= 2;
2778 /* FIXME:Do something here. */
2779 if (dip
->at_producer
!= NULL
)
2781 handle_producer (dip
->at_producer
);
2785 /* The compilation unit may be in a different language or objfile,
2786 zero out all remembered fundamental types. */
2787 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2789 start_symtab (name
, comp_dir
, lowpc
);
2790 record_debugformat ("DWARF 2");
2792 initialize_cu_func_list (cu
);
2794 /* Process all dies in compilation unit. */
2795 if (die
->child
!= NULL
)
2797 child_die
= die
->child
;
2798 while (child_die
&& child_die
->tag
)
2800 process_die (child_die
, cu
);
2801 child_die
= sibling_die (child_die
);
2805 /* Decode line number information if present. */
2806 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2809 unsigned int line_offset
= DW_UNSND (attr
);
2810 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2813 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2814 (void *) line_header
);
2815 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2819 /* Decode macro information, if present. Dwarf 2 macro information
2820 refers to information in the line number info statement program
2821 header, so we can only read it if we've read the header
2823 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2824 if (attr
&& line_header
)
2826 unsigned int macro_offset
= DW_UNSND (attr
);
2827 dwarf_decode_macros (line_header
, macro_offset
,
2828 comp_dir
, abfd
, cu
);
2830 do_cleanups (back_to
);
2834 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2835 struct dwarf2_cu
*cu
)
2837 struct function_range
*thisfn
;
2839 thisfn
= (struct function_range
*)
2840 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2841 thisfn
->name
= name
;
2842 thisfn
->lowpc
= lowpc
;
2843 thisfn
->highpc
= highpc
;
2844 thisfn
->seen_line
= 0;
2845 thisfn
->next
= NULL
;
2847 if (cu
->last_fn
== NULL
)
2848 cu
->first_fn
= thisfn
;
2850 cu
->last_fn
->next
= thisfn
;
2852 cu
->last_fn
= thisfn
;
2856 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2858 struct objfile
*objfile
= cu
->objfile
;
2859 struct context_stack
*new;
2862 struct die_info
*child_die
;
2863 struct attribute
*attr
;
2865 const char *previous_prefix
= processing_current_prefix
;
2866 struct cleanup
*back_to
= NULL
;
2869 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2871 name
= dwarf2_linkage_name (die
, cu
);
2873 /* Ignore functions with missing or empty names and functions with
2874 missing or invalid low and high pc attributes. */
2875 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2878 if (cu
->language
== language_cplus
2879 || cu
->language
== language_java
)
2881 struct die_info
*spec_die
= die_specification (die
, cu
);
2883 /* NOTE: carlton/2004-01-23: We have to be careful in the
2884 presence of DW_AT_specification. For example, with GCC 3.4,
2889 // Definition of N::foo.
2893 then we'll have a tree of DIEs like this:
2895 1: DW_TAG_compile_unit
2896 2: DW_TAG_namespace // N
2897 3: DW_TAG_subprogram // declaration of N::foo
2898 4: DW_TAG_subprogram // definition of N::foo
2899 DW_AT_specification // refers to die #3
2901 Thus, when processing die #4, we have to pretend that we're
2902 in the context of its DW_AT_specification, namely the contex
2905 if (spec_die
!= NULL
)
2907 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2908 processing_current_prefix
= specification_prefix
;
2909 back_to
= make_cleanup (xfree
, specification_prefix
);
2916 /* Record the function range for dwarf_decode_lines. */
2917 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2919 new = push_context (0, lowpc
);
2920 new->name
= new_symbol (die
, die
->type
, cu
);
2922 /* If there is a location expression for DW_AT_frame_base, record
2924 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2926 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2927 expression is being recorded directly in the function's symbol
2928 and not in a separate frame-base object. I guess this hack is
2929 to avoid adding some sort of frame-base adjunct/annex to the
2930 function's symbol :-(. The problem with doing this is that it
2931 results in a function symbol with a location expression that
2932 has nothing to do with the location of the function, ouch! The
2933 relationship should be: a function's symbol has-a frame base; a
2934 frame-base has-a location expression. */
2935 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2937 cu
->list_in_scope
= &local_symbols
;
2939 if (die
->child
!= NULL
)
2941 child_die
= die
->child
;
2942 while (child_die
&& child_die
->tag
)
2944 process_die (child_die
, cu
);
2945 child_die
= sibling_die (child_die
);
2949 new = pop_context ();
2950 /* Make a block for the local symbols within. */
2951 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2952 lowpc
, highpc
, objfile
);
2954 /* In C++, we can have functions nested inside functions (e.g., when
2955 a function declares a class that has methods). This means that
2956 when we finish processing a function scope, we may need to go
2957 back to building a containing block's symbol lists. */
2958 local_symbols
= new->locals
;
2959 param_symbols
= new->params
;
2961 /* If we've finished processing a top-level function, subsequent
2962 symbols go in the file symbol list. */
2963 if (outermost_context_p ())
2964 cu
->list_in_scope
= &file_symbols
;
2966 processing_current_prefix
= previous_prefix
;
2967 if (back_to
!= NULL
)
2968 do_cleanups (back_to
);
2971 /* Process all the DIES contained within a lexical block scope. Start
2972 a new scope, process the dies, and then close the scope. */
2975 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2977 struct objfile
*objfile
= cu
->objfile
;
2978 struct context_stack
*new;
2979 CORE_ADDR lowpc
, highpc
;
2980 struct die_info
*child_die
;
2983 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2985 /* Ignore blocks with missing or invalid low and high pc attributes. */
2986 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2987 as multiple lexical blocks? Handling children in a sane way would
2988 be nasty. Might be easier to properly extend generic blocks to
2990 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2995 push_context (0, lowpc
);
2996 if (die
->child
!= NULL
)
2998 child_die
= die
->child
;
2999 while (child_die
&& child_die
->tag
)
3001 process_die (child_die
, cu
);
3002 child_die
= sibling_die (child_die
);
3005 new = pop_context ();
3007 if (local_symbols
!= NULL
)
3009 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3012 local_symbols
= new->locals
;
3015 /* Get low and high pc attributes from a die. Return 1 if the attributes
3016 are present and valid, otherwise, return 0. Return -1 if the range is
3017 discontinuous, i.e. derived from DW_AT_ranges information. */
3019 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3020 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3022 struct objfile
*objfile
= cu
->objfile
;
3023 struct comp_unit_head
*cu_header
= &cu
->header
;
3024 struct attribute
*attr
;
3025 bfd
*obfd
= objfile
->obfd
;
3030 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3033 high
= DW_ADDR (attr
);
3034 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3036 low
= DW_ADDR (attr
);
3038 /* Found high w/o low attribute. */
3041 /* Found consecutive range of addresses. */
3046 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3049 unsigned int addr_size
= cu_header
->addr_size
;
3050 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3051 /* Value of the DW_AT_ranges attribute is the offset in the
3052 .debug_ranges section. */
3053 unsigned int offset
= DW_UNSND (attr
);
3054 /* Base address selection entry. */
3062 found_base
= cu_header
->base_known
;
3063 base
= cu_header
->base_address
;
3065 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3067 complaint (&symfile_complaints
,
3068 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3072 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3074 /* Read in the largest possible address. */
3075 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3076 if ((marker
& mask
) == mask
)
3078 /* If we found the largest possible address, then
3079 read the base address. */
3080 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3081 buffer
+= 2 * addr_size
;
3082 offset
+= 2 * addr_size
;
3090 CORE_ADDR range_beginning
, range_end
;
3092 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3093 buffer
+= addr_size
;
3094 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3095 buffer
+= addr_size
;
3096 offset
+= 2 * addr_size
;
3098 /* An end of list marker is a pair of zero addresses. */
3099 if (range_beginning
== 0 && range_end
== 0)
3100 /* Found the end of list entry. */
3103 /* Each base address selection entry is a pair of 2 values.
3104 The first is the largest possible address, the second is
3105 the base address. Check for a base address here. */
3106 if ((range_beginning
& mask
) == mask
)
3108 /* If we found the largest possible address, then
3109 read the base address. */
3110 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3117 /* We have no valid base address for the ranges
3119 complaint (&symfile_complaints
,
3120 _("Invalid .debug_ranges data (no base address)"));
3124 range_beginning
+= base
;
3127 /* FIXME: This is recording everything as a low-high
3128 segment of consecutive addresses. We should have a
3129 data structure for discontiguous block ranges
3133 low
= range_beginning
;
3139 if (range_beginning
< low
)
3140 low
= range_beginning
;
3141 if (range_end
> high
)
3147 /* If the first entry is an end-of-list marker, the range
3148 describes an empty scope, i.e. no instructions. */
3158 /* When using the GNU linker, .gnu.linkonce. sections are used to
3159 eliminate duplicate copies of functions and vtables and such.
3160 The linker will arbitrarily choose one and discard the others.
3161 The AT_*_pc values for such functions refer to local labels in
3162 these sections. If the section from that file was discarded, the
3163 labels are not in the output, so the relocs get a value of 0.
3164 If this is a discarded function, mark the pc bounds as invalid,
3165 so that GDB will ignore it. */
3166 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
3174 /* Get the low and high pc's represented by the scope DIE, and store
3175 them in *LOWPC and *HIGHPC. If the correct values can't be
3176 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3179 get_scope_pc_bounds (struct die_info
*die
,
3180 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3181 struct dwarf2_cu
*cu
)
3183 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3184 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3185 CORE_ADDR current_low
, current_high
;
3187 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3189 best_low
= current_low
;
3190 best_high
= current_high
;
3194 struct die_info
*child
= die
->child
;
3196 while (child
&& child
->tag
)
3198 switch (child
->tag
) {
3199 case DW_TAG_subprogram
:
3200 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3202 best_low
= min (best_low
, current_low
);
3203 best_high
= max (best_high
, current_high
);
3206 case DW_TAG_namespace
:
3207 /* FIXME: carlton/2004-01-16: Should we do this for
3208 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3209 that current GCC's always emit the DIEs corresponding
3210 to definitions of methods of classes as children of a
3211 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3212 the DIEs giving the declarations, which could be
3213 anywhere). But I don't see any reason why the
3214 standards says that they have to be there. */
3215 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3217 if (current_low
!= ((CORE_ADDR
) -1))
3219 best_low
= min (best_low
, current_low
);
3220 best_high
= max (best_high
, current_high
);
3228 child
= sibling_die (child
);
3233 *highpc
= best_high
;
3236 /* Add an aggregate field to the field list. */
3239 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3240 struct dwarf2_cu
*cu
)
3242 struct objfile
*objfile
= cu
->objfile
;
3243 struct nextfield
*new_field
;
3244 struct attribute
*attr
;
3246 char *fieldname
= "";
3248 /* Allocate a new field list entry and link it in. */
3249 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3250 make_cleanup (xfree
, new_field
);
3251 memset (new_field
, 0, sizeof (struct nextfield
));
3252 new_field
->next
= fip
->fields
;
3253 fip
->fields
= new_field
;
3256 /* Handle accessibility and virtuality of field.
3257 The default accessibility for members is public, the default
3258 accessibility for inheritance is private. */
3259 if (die
->tag
!= DW_TAG_inheritance
)
3260 new_field
->accessibility
= DW_ACCESS_public
;
3262 new_field
->accessibility
= DW_ACCESS_private
;
3263 new_field
->virtuality
= DW_VIRTUALITY_none
;
3265 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3267 new_field
->accessibility
= DW_UNSND (attr
);
3268 if (new_field
->accessibility
!= DW_ACCESS_public
)
3269 fip
->non_public_fields
= 1;
3270 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3272 new_field
->virtuality
= DW_UNSND (attr
);
3274 fp
= &new_field
->field
;
3276 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3278 /* Data member other than a C++ static data member. */
3280 /* Get type of field. */
3281 fp
->type
= die_type (die
, cu
);
3283 FIELD_STATIC_KIND (*fp
) = 0;
3285 /* Get bit size of field (zero if none). */
3286 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3289 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3293 FIELD_BITSIZE (*fp
) = 0;
3296 /* Get bit offset of field. */
3297 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3300 FIELD_BITPOS (*fp
) =
3301 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3304 FIELD_BITPOS (*fp
) = 0;
3305 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3308 if (BITS_BIG_ENDIAN
)
3310 /* For big endian bits, the DW_AT_bit_offset gives the
3311 additional bit offset from the MSB of the containing
3312 anonymous object to the MSB of the field. We don't
3313 have to do anything special since we don't need to
3314 know the size of the anonymous object. */
3315 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3319 /* For little endian bits, compute the bit offset to the
3320 MSB of the anonymous object, subtract off the number of
3321 bits from the MSB of the field to the MSB of the
3322 object, and then subtract off the number of bits of
3323 the field itself. The result is the bit offset of
3324 the LSB of the field. */
3326 int bit_offset
= DW_UNSND (attr
);
3328 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3331 /* The size of the anonymous object containing
3332 the bit field is explicit, so use the
3333 indicated size (in bytes). */
3334 anonymous_size
= DW_UNSND (attr
);
3338 /* The size of the anonymous object containing
3339 the bit field must be inferred from the type
3340 attribute of the data member containing the
3342 anonymous_size
= TYPE_LENGTH (fp
->type
);
3344 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3345 - bit_offset
- FIELD_BITSIZE (*fp
);
3349 /* Get name of field. */
3350 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3351 if (attr
&& DW_STRING (attr
))
3352 fieldname
= DW_STRING (attr
);
3354 /* The name is already allocated along with this objfile, so we don't
3355 need to duplicate it for the type. */
3356 fp
->name
= fieldname
;
3358 /* Change accessibility for artificial fields (e.g. virtual table
3359 pointer or virtual base class pointer) to private. */
3360 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3362 new_field
->accessibility
= DW_ACCESS_private
;
3363 fip
->non_public_fields
= 1;
3366 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3368 /* C++ static member. */
3370 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3371 is a declaration, but all versions of G++ as of this writing
3372 (so through at least 3.2.1) incorrectly generate
3373 DW_TAG_variable tags. */
3377 /* Get name of field. */
3378 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3379 if (attr
&& DW_STRING (attr
))
3380 fieldname
= DW_STRING (attr
);
3384 /* Get physical name. */
3385 physname
= dwarf2_linkage_name (die
, cu
);
3387 /* The name is already allocated along with this objfile, so we don't
3388 need to duplicate it for the type. */
3389 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3390 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3391 FIELD_NAME (*fp
) = fieldname
;
3393 else if (die
->tag
== DW_TAG_inheritance
)
3395 /* C++ base class field. */
3396 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3398 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3400 FIELD_BITSIZE (*fp
) = 0;
3401 FIELD_STATIC_KIND (*fp
) = 0;
3402 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3403 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3404 fip
->nbaseclasses
++;
3408 /* Create the vector of fields, and attach it to the type. */
3411 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3412 struct dwarf2_cu
*cu
)
3414 int nfields
= fip
->nfields
;
3416 /* Record the field count, allocate space for the array of fields,
3417 and create blank accessibility bitfields if necessary. */
3418 TYPE_NFIELDS (type
) = nfields
;
3419 TYPE_FIELDS (type
) = (struct field
*)
3420 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3421 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3423 if (fip
->non_public_fields
)
3425 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3427 TYPE_FIELD_PRIVATE_BITS (type
) =
3428 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3429 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3431 TYPE_FIELD_PROTECTED_BITS (type
) =
3432 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3433 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3435 TYPE_FIELD_IGNORE_BITS (type
) =
3436 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3437 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3440 /* If the type has baseclasses, allocate and clear a bit vector for
3441 TYPE_FIELD_VIRTUAL_BITS. */
3442 if (fip
->nbaseclasses
)
3444 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3447 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3448 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3449 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3450 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3451 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3454 /* Copy the saved-up fields into the field vector. Start from the head
3455 of the list, adding to the tail of the field array, so that they end
3456 up in the same order in the array in which they were added to the list. */
3457 while (nfields
-- > 0)
3459 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3460 switch (fip
->fields
->accessibility
)
3462 case DW_ACCESS_private
:
3463 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3466 case DW_ACCESS_protected
:
3467 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3470 case DW_ACCESS_public
:
3474 /* Unknown accessibility. Complain and treat it as public. */
3476 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3477 fip
->fields
->accessibility
);
3481 if (nfields
< fip
->nbaseclasses
)
3483 switch (fip
->fields
->virtuality
)
3485 case DW_VIRTUALITY_virtual
:
3486 case DW_VIRTUALITY_pure_virtual
:
3487 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3491 fip
->fields
= fip
->fields
->next
;
3495 /* Add a member function to the proper fieldlist. */
3498 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3499 struct type
*type
, struct dwarf2_cu
*cu
)
3501 struct objfile
*objfile
= cu
->objfile
;
3502 struct attribute
*attr
;
3503 struct fnfieldlist
*flp
;
3505 struct fn_field
*fnp
;
3508 struct nextfnfield
*new_fnfield
;
3510 /* Get name of member function. */
3511 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3512 if (attr
&& DW_STRING (attr
))
3513 fieldname
= DW_STRING (attr
);
3517 /* Get the mangled name. */
3518 physname
= dwarf2_linkage_name (die
, cu
);
3520 /* Look up member function name in fieldlist. */
3521 for (i
= 0; i
< fip
->nfnfields
; i
++)
3523 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3527 /* Create new list element if necessary. */
3528 if (i
< fip
->nfnfields
)
3529 flp
= &fip
->fnfieldlists
[i
];
3532 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3534 fip
->fnfieldlists
= (struct fnfieldlist
*)
3535 xrealloc (fip
->fnfieldlists
,
3536 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3537 * sizeof (struct fnfieldlist
));
3538 if (fip
->nfnfields
== 0)
3539 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3541 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3542 flp
->name
= fieldname
;
3548 /* Create a new member function field and chain it to the field list
3550 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3551 make_cleanup (xfree
, new_fnfield
);
3552 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3553 new_fnfield
->next
= flp
->head
;
3554 flp
->head
= new_fnfield
;
3557 /* Fill in the member function field info. */
3558 fnp
= &new_fnfield
->fnfield
;
3559 /* The name is already allocated along with this objfile, so we don't
3560 need to duplicate it for the type. */
3561 fnp
->physname
= physname
? physname
: "";
3562 fnp
->type
= alloc_type (objfile
);
3563 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3565 int nparams
= TYPE_NFIELDS (die
->type
);
3567 /* TYPE is the domain of this method, and DIE->TYPE is the type
3568 of the method itself (TYPE_CODE_METHOD). */
3569 smash_to_method_type (fnp
->type
, type
,
3570 TYPE_TARGET_TYPE (die
->type
),
3571 TYPE_FIELDS (die
->type
),
3572 TYPE_NFIELDS (die
->type
),
3573 TYPE_VARARGS (die
->type
));
3575 /* Handle static member functions.
3576 Dwarf2 has no clean way to discern C++ static and non-static
3577 member functions. G++ helps GDB by marking the first
3578 parameter for non-static member functions (which is the
3579 this pointer) as artificial. We obtain this information
3580 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3581 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3582 fnp
->voffset
= VOFFSET_STATIC
;
3585 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3588 /* Get fcontext from DW_AT_containing_type if present. */
3589 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3590 fnp
->fcontext
= die_containing_type (die
, cu
);
3592 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3593 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3595 /* Get accessibility. */
3596 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3599 switch (DW_UNSND (attr
))
3601 case DW_ACCESS_private
:
3602 fnp
->is_private
= 1;
3604 case DW_ACCESS_protected
:
3605 fnp
->is_protected
= 1;
3610 /* Check for artificial methods. */
3611 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3612 if (attr
&& DW_UNSND (attr
) != 0)
3613 fnp
->is_artificial
= 1;
3615 /* Get index in virtual function table if it is a virtual member function. */
3616 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3619 /* Support the .debug_loc offsets */
3620 if (attr_form_is_block (attr
))
3622 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3624 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3626 dwarf2_complex_location_expr_complaint ();
3630 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3636 /* Create the vector of member function fields, and attach it to the type. */
3639 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3640 struct dwarf2_cu
*cu
)
3642 struct fnfieldlist
*flp
;
3643 int total_length
= 0;
3646 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3647 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3648 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3650 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3652 struct nextfnfield
*nfp
= flp
->head
;
3653 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3656 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3657 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3658 fn_flp
->fn_fields
= (struct fn_field
*)
3659 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3660 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3661 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3663 total_length
+= flp
->length
;
3666 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3667 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3671 /* Returns non-zero if NAME is the name of a vtable member in CU's
3672 language, zero otherwise. */
3674 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3676 static const char vptr
[] = "_vptr";
3677 static const char vtable
[] = "vtable";
3679 /* Look for the C++ and Java forms of the vtable. */
3680 if ((cu
->language
== language_java
3681 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3682 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3683 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3690 /* Called when we find the DIE that starts a structure or union scope
3691 (definition) to process all dies that define the members of the
3694 NOTE: we need to call struct_type regardless of whether or not the
3695 DIE has an at_name attribute, since it might be an anonymous
3696 structure or union. This gets the type entered into our set of
3699 However, if the structure is incomplete (an opaque struct/union)
3700 then suppress creating a symbol table entry for it since gdb only
3701 wants to find the one with the complete definition. Note that if
3702 it is complete, we just call new_symbol, which does it's own
3703 checking about whether the struct/union is anonymous or not (and
3704 suppresses creating a symbol table entry itself). */
3707 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3709 struct objfile
*objfile
= cu
->objfile
;
3711 struct attribute
*attr
;
3712 const char *previous_prefix
= processing_current_prefix
;
3713 struct cleanup
*back_to
= NULL
;
3718 type
= alloc_type (objfile
);
3720 INIT_CPLUS_SPECIFIC (type
);
3721 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3722 if (attr
&& DW_STRING (attr
))
3724 if (cu
->language
== language_cplus
3725 || cu
->language
== language_java
)
3727 char *new_prefix
= determine_class_name (die
, cu
);
3728 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3729 strlen (new_prefix
),
3730 &objfile
->objfile_obstack
);
3731 back_to
= make_cleanup (xfree
, new_prefix
);
3732 processing_current_prefix
= new_prefix
;
3736 /* The name is already allocated along with this objfile, so
3737 we don't need to duplicate it for the type. */
3738 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3742 if (die
->tag
== DW_TAG_structure_type
)
3744 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3746 else if (die
->tag
== DW_TAG_union_type
)
3748 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3752 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3754 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3757 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3760 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3764 TYPE_LENGTH (type
) = 0;
3767 if (die_is_declaration (die
, cu
))
3768 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3770 /* We need to add the type field to the die immediately so we don't
3771 infinitely recurse when dealing with pointers to the structure
3772 type within the structure itself. */
3773 set_die_type (die
, type
, cu
);
3775 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3777 struct field_info fi
;
3778 struct die_info
*child_die
;
3779 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3781 memset (&fi
, 0, sizeof (struct field_info
));
3783 child_die
= die
->child
;
3785 while (child_die
&& child_die
->tag
)
3787 if (child_die
->tag
== DW_TAG_member
3788 || child_die
->tag
== DW_TAG_variable
)
3790 /* NOTE: carlton/2002-11-05: A C++ static data member
3791 should be a DW_TAG_member that is a declaration, but
3792 all versions of G++ as of this writing (so through at
3793 least 3.2.1) incorrectly generate DW_TAG_variable
3794 tags for them instead. */
3795 dwarf2_add_field (&fi
, child_die
, cu
);
3797 else if (child_die
->tag
== DW_TAG_subprogram
)
3799 /* C++ member function. */
3800 read_type_die (child_die
, cu
);
3801 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3803 else if (child_die
->tag
== DW_TAG_inheritance
)
3805 /* C++ base class field. */
3806 dwarf2_add_field (&fi
, child_die
, cu
);
3808 child_die
= sibling_die (child_die
);
3811 /* Attach fields and member functions to the type. */
3813 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3816 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3818 /* Get the type which refers to the base class (possibly this
3819 class itself) which contains the vtable pointer for the current
3820 class from the DW_AT_containing_type attribute. */
3822 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3824 struct type
*t
= die_containing_type (die
, cu
);
3826 TYPE_VPTR_BASETYPE (type
) = t
;
3831 /* Our own class provides vtbl ptr. */
3832 for (i
= TYPE_NFIELDS (t
) - 1;
3833 i
>= TYPE_N_BASECLASSES (t
);
3836 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3838 if (is_vtable_name (fieldname
, cu
))
3840 TYPE_VPTR_FIELDNO (type
) = i
;
3845 /* Complain if virtual function table field not found. */
3846 if (i
< TYPE_N_BASECLASSES (t
))
3847 complaint (&symfile_complaints
,
3848 _("virtual function table pointer not found when defining class '%s'"),
3849 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3854 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3859 do_cleanups (back_to
);
3862 processing_current_prefix
= previous_prefix
;
3863 if (back_to
!= NULL
)
3864 do_cleanups (back_to
);
3868 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3870 struct objfile
*objfile
= cu
->objfile
;
3871 const char *previous_prefix
= processing_current_prefix
;
3872 struct die_info
*child_die
= die
->child
;
3874 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3875 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3877 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3878 snapshots) has been known to create a die giving a declaration
3879 for a class that has, as a child, a die giving a definition for a
3880 nested class. So we have to process our children even if the
3881 current die is a declaration. Normally, of course, a declaration
3882 won't have any children at all. */
3884 while (child_die
!= NULL
&& child_die
->tag
)
3886 if (child_die
->tag
== DW_TAG_member
3887 || child_die
->tag
== DW_TAG_variable
3888 || child_die
->tag
== DW_TAG_inheritance
)
3893 process_die (child_die
, cu
);
3895 child_die
= sibling_die (child_die
);
3898 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3899 new_symbol (die
, die
->type
, cu
);
3901 processing_current_prefix
= previous_prefix
;
3904 /* Given a DW_AT_enumeration_type die, set its type. We do not
3905 complete the type's fields yet, or create any symbols. */
3908 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3910 struct objfile
*objfile
= cu
->objfile
;
3912 struct attribute
*attr
;
3917 type
= alloc_type (objfile
);
3919 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3920 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3921 if (attr
&& DW_STRING (attr
))
3923 char *name
= DW_STRING (attr
);
3925 if (processing_has_namespace_info
)
3927 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
3928 processing_current_prefix
,
3933 /* The name is already allocated along with this objfile, so
3934 we don't need to duplicate it for the type. */
3935 TYPE_TAG_NAME (type
) = name
;
3939 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3942 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3946 TYPE_LENGTH (type
) = 0;
3949 set_die_type (die
, type
, cu
);
3952 /* Determine the name of the type represented by DIE, which should be
3953 a named C++ or Java compound type. Return the name in question; the caller
3954 is responsible for xfree()'ing it. */
3957 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3959 struct cleanup
*back_to
= NULL
;
3960 struct die_info
*spec_die
= die_specification (die
, cu
);
3961 char *new_prefix
= NULL
;
3963 /* If this is the definition of a class that is declared by another
3964 die, then processing_current_prefix may not be accurate; see
3965 read_func_scope for a similar example. */
3966 if (spec_die
!= NULL
)
3968 char *specification_prefix
= determine_prefix (spec_die
, cu
);
3969 processing_current_prefix
= specification_prefix
;
3970 back_to
= make_cleanup (xfree
, specification_prefix
);
3973 /* If we don't have namespace debug info, guess the name by trying
3974 to demangle the names of members, just like we did in
3975 guess_structure_name. */
3976 if (!processing_has_namespace_info
)
3978 struct die_info
*child
;
3980 for (child
= die
->child
;
3981 child
!= NULL
&& child
->tag
!= 0;
3982 child
= sibling_die (child
))
3984 if (child
->tag
== DW_TAG_subprogram
)
3987 = language_class_name_from_physname (cu
->language_defn
,
3991 if (new_prefix
!= NULL
)
3997 if (new_prefix
== NULL
)
3999 const char *name
= dwarf2_name (die
, cu
);
4000 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4001 name
? name
: "<<anonymous>>",
4005 if (back_to
!= NULL
)
4006 do_cleanups (back_to
);
4011 /* Given a pointer to a die which begins an enumeration, process all
4012 the dies that define the members of the enumeration, and create the
4013 symbol for the enumeration type.
4015 NOTE: We reverse the order of the element list. */
4018 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4020 struct objfile
*objfile
= cu
->objfile
;
4021 struct die_info
*child_die
;
4022 struct field
*fields
;
4023 struct attribute
*attr
;
4026 int unsigned_enum
= 1;
4030 if (die
->child
!= NULL
)
4032 child_die
= die
->child
;
4033 while (child_die
&& child_die
->tag
)
4035 if (child_die
->tag
!= DW_TAG_enumerator
)
4037 process_die (child_die
, cu
);
4041 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4044 sym
= new_symbol (child_die
, die
->type
, cu
);
4045 if (SYMBOL_VALUE (sym
) < 0)
4048 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4050 fields
= (struct field
*)
4052 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4053 * sizeof (struct field
));
4056 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4057 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4058 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4059 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4060 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4066 child_die
= sibling_die (child_die
);
4071 TYPE_NFIELDS (die
->type
) = num_fields
;
4072 TYPE_FIELDS (die
->type
) = (struct field
*)
4073 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4074 memcpy (TYPE_FIELDS (die
->type
), fields
,
4075 sizeof (struct field
) * num_fields
);
4079 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4082 new_symbol (die
, die
->type
, cu
);
4085 /* Extract all information from a DW_TAG_array_type DIE and put it in
4086 the DIE's type field. For now, this only handles one dimensional
4090 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4092 struct objfile
*objfile
= cu
->objfile
;
4093 struct die_info
*child_die
;
4094 struct type
*type
= NULL
;
4095 struct type
*element_type
, *range_type
, *index_type
;
4096 struct type
**range_types
= NULL
;
4097 struct attribute
*attr
;
4099 struct cleanup
*back_to
;
4101 /* Return if we've already decoded this type. */
4107 element_type
= die_type (die
, cu
);
4109 /* Irix 6.2 native cc creates array types without children for
4110 arrays with unspecified length. */
4111 if (die
->child
== NULL
)
4113 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4114 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4115 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4120 back_to
= make_cleanup (null_cleanup
, NULL
);
4121 child_die
= die
->child
;
4122 while (child_die
&& child_die
->tag
)
4124 if (child_die
->tag
== DW_TAG_subrange_type
)
4126 read_subrange_type (child_die
, cu
);
4128 if (child_die
->type
!= NULL
)
4130 /* The range type was succesfully read. Save it for
4131 the array type creation. */
4132 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4134 range_types
= (struct type
**)
4135 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4136 * sizeof (struct type
*));
4138 make_cleanup (free_current_contents
, &range_types
);
4140 range_types
[ndim
++] = child_die
->type
;
4143 child_die
= sibling_die (child_die
);
4146 /* Dwarf2 dimensions are output from left to right, create the
4147 necessary array types in backwards order. */
4149 type
= element_type
;
4151 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4155 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4160 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4163 /* Understand Dwarf2 support for vector types (like they occur on
4164 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4165 array type. This is not part of the Dwarf2/3 standard yet, but a
4166 custom vendor extension. The main difference between a regular
4167 array and the vector variant is that vectors are passed by value
4169 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4171 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4173 do_cleanups (back_to
);
4175 /* Install the type in the die. */
4176 set_die_type (die
, type
, cu
);
4179 static enum dwarf_array_dim_ordering
4180 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4182 struct attribute
*attr
;
4184 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4186 if (attr
) return DW_SND (attr
);
4189 GNU F77 is a special case, as at 08/2004 array type info is the
4190 opposite order to the dwarf2 specification, but data is still
4191 laid out as per normal fortran.
4193 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4197 if (cu
->language
== language_fortran
&&
4198 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4200 return DW_ORD_row_major
;
4203 switch (cu
->language_defn
->la_array_ordering
)
4205 case array_column_major
:
4206 return DW_ORD_col_major
;
4207 case array_row_major
:
4209 return DW_ORD_row_major
;
4214 /* First cut: install each common block member as a global variable. */
4217 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4219 struct die_info
*child_die
;
4220 struct attribute
*attr
;
4222 CORE_ADDR base
= (CORE_ADDR
) 0;
4224 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4227 /* Support the .debug_loc offsets */
4228 if (attr_form_is_block (attr
))
4230 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4232 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4234 dwarf2_complex_location_expr_complaint ();
4238 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4239 "common block member");
4242 if (die
->child
!= NULL
)
4244 child_die
= die
->child
;
4245 while (child_die
&& child_die
->tag
)
4247 sym
= new_symbol (child_die
, NULL
, cu
);
4248 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4251 SYMBOL_VALUE_ADDRESS (sym
) =
4252 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4253 add_symbol_to_list (sym
, &global_symbols
);
4255 child_die
= sibling_die (child_die
);
4260 /* Read a C++ namespace. */
4263 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4265 struct objfile
*objfile
= cu
->objfile
;
4266 const char *previous_prefix
= processing_current_prefix
;
4269 struct die_info
*current_die
;
4270 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4272 name
= namespace_name (die
, &is_anonymous
, cu
);
4274 /* Now build the name of the current namespace. */
4276 if (previous_prefix
[0] == '\0')
4278 processing_current_prefix
= name
;
4282 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4283 make_cleanup (xfree
, temp_name
);
4284 processing_current_prefix
= temp_name
;
4287 /* Add a symbol associated to this if we haven't seen the namespace
4288 before. Also, add a using directive if it's an anonymous
4291 if (dwarf2_extension (die
, cu
) == NULL
)
4295 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4296 this cast will hopefully become unnecessary. */
4297 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4298 (char *) processing_current_prefix
,
4300 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4302 new_symbol (die
, type
, cu
);
4303 set_die_type (die
, type
, cu
);
4306 cp_add_using_directive (processing_current_prefix
,
4307 strlen (previous_prefix
),
4308 strlen (processing_current_prefix
));
4311 if (die
->child
!= NULL
)
4313 struct die_info
*child_die
= die
->child
;
4315 while (child_die
&& child_die
->tag
)
4317 process_die (child_die
, cu
);
4318 child_die
= sibling_die (child_die
);
4322 processing_current_prefix
= previous_prefix
;
4323 do_cleanups (back_to
);
4326 /* Return the name of the namespace represented by DIE. Set
4327 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4331 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4333 struct die_info
*current_die
;
4334 const char *name
= NULL
;
4336 /* Loop through the extensions until we find a name. */
4338 for (current_die
= die
;
4339 current_die
!= NULL
;
4340 current_die
= dwarf2_extension (die
, cu
))
4342 name
= dwarf2_name (current_die
, cu
);
4347 /* Is it an anonymous namespace? */
4349 *is_anonymous
= (name
== NULL
);
4351 name
= "(anonymous namespace)";
4356 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4357 the user defined type vector. */
4360 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4362 struct comp_unit_head
*cu_header
= &cu
->header
;
4364 struct attribute
*attr_byte_size
;
4365 struct attribute
*attr_address_class
;
4366 int byte_size
, addr_class
;
4373 type
= lookup_pointer_type (die_type (die
, cu
));
4375 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4377 byte_size
= DW_UNSND (attr_byte_size
);
4379 byte_size
= cu_header
->addr_size
;
4381 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4382 if (attr_address_class
)
4383 addr_class
= DW_UNSND (attr_address_class
);
4385 addr_class
= DW_ADDR_none
;
4387 /* If the pointer size or address class is different than the
4388 default, create a type variant marked as such and set the
4389 length accordingly. */
4390 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4392 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4396 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4397 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4398 type
= make_type_with_address_space (type
, type_flags
);
4400 else if (TYPE_LENGTH (type
) != byte_size
)
4402 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4405 /* Should we also complain about unhandled address classes? */
4409 TYPE_LENGTH (type
) = byte_size
;
4410 set_die_type (die
, type
, cu
);
4413 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4414 the user defined type vector. */
4417 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4419 struct objfile
*objfile
= cu
->objfile
;
4421 struct type
*to_type
;
4422 struct type
*domain
;
4429 type
= alloc_type (objfile
);
4430 to_type
= die_type (die
, cu
);
4431 domain
= die_containing_type (die
, cu
);
4432 smash_to_member_type (type
, domain
, to_type
);
4434 set_die_type (die
, type
, cu
);
4437 /* Extract all information from a DW_TAG_reference_type DIE and add to
4438 the user defined type vector. */
4441 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4443 struct comp_unit_head
*cu_header
= &cu
->header
;
4445 struct attribute
*attr
;
4452 type
= lookup_reference_type (die_type (die
, cu
));
4453 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4456 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4460 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4462 set_die_type (die
, type
, cu
);
4466 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4468 struct type
*base_type
;
4475 base_type
= die_type (die
, cu
);
4476 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4481 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4483 struct type
*base_type
;
4490 base_type
= die_type (die
, cu
);
4491 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4495 /* Extract all information from a DW_TAG_string_type DIE and add to
4496 the user defined type vector. It isn't really a user defined type,
4497 but it behaves like one, with other DIE's using an AT_user_def_type
4498 attribute to reference it. */
4501 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4503 struct objfile
*objfile
= cu
->objfile
;
4504 struct type
*type
, *range_type
, *index_type
, *char_type
;
4505 struct attribute
*attr
;
4506 unsigned int length
;
4513 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4516 length
= DW_UNSND (attr
);
4520 /* check for the DW_AT_byte_size attribute */
4521 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4524 length
= DW_UNSND (attr
);
4531 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4532 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4533 if (cu
->language
== language_fortran
)
4535 /* Need to create a unique string type for bounds
4537 type
= create_string_type (0, range_type
);
4541 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4542 type
= create_string_type (char_type
, range_type
);
4544 set_die_type (die
, type
, cu
);
4547 /* Handle DIES due to C code like:
4551 int (*funcp)(int a, long l);
4555 ('funcp' generates a DW_TAG_subroutine_type DIE)
4559 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4561 struct type
*type
; /* Type that this function returns */
4562 struct type
*ftype
; /* Function that returns above type */
4563 struct attribute
*attr
;
4565 /* Decode the type that this subroutine returns */
4570 type
= die_type (die
, cu
);
4571 ftype
= make_function_type (type
, (struct type
**) 0);
4573 /* All functions in C++ and Java have prototypes. */
4574 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4575 if ((attr
&& (DW_UNSND (attr
) != 0))
4576 || cu
->language
== language_cplus
4577 || cu
->language
== language_java
)
4578 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4580 if (die
->child
!= NULL
)
4582 struct die_info
*child_die
;
4586 /* Count the number of parameters.
4587 FIXME: GDB currently ignores vararg functions, but knows about
4588 vararg member functions. */
4589 child_die
= die
->child
;
4590 while (child_die
&& child_die
->tag
)
4592 if (child_die
->tag
== DW_TAG_formal_parameter
)
4594 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4595 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4596 child_die
= sibling_die (child_die
);
4599 /* Allocate storage for parameters and fill them in. */
4600 TYPE_NFIELDS (ftype
) = nparams
;
4601 TYPE_FIELDS (ftype
) = (struct field
*)
4602 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
4604 child_die
= die
->child
;
4605 while (child_die
&& child_die
->tag
)
4607 if (child_die
->tag
== DW_TAG_formal_parameter
)
4609 /* Dwarf2 has no clean way to discern C++ static and non-static
4610 member functions. G++ helps GDB by marking the first
4611 parameter for non-static member functions (which is the
4612 this pointer) as artificial. We pass this information
4613 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4614 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4616 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4618 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4619 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4622 child_die
= sibling_die (child_die
);
4626 set_die_type (die
, ftype
, cu
);
4630 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4632 struct objfile
*objfile
= cu
->objfile
;
4633 struct attribute
*attr
;
4638 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4639 if (attr
&& DW_STRING (attr
))
4641 name
= DW_STRING (attr
);
4643 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4644 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4646 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4650 /* Find a representation of a given base type and install
4651 it in the TYPE field of the die. */
4654 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4656 struct objfile
*objfile
= cu
->objfile
;
4658 struct attribute
*attr
;
4659 int encoding
= 0, size
= 0;
4661 /* If we've already decoded this die, this is a no-op. */
4667 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4670 encoding
= DW_UNSND (attr
);
4672 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4675 size
= DW_UNSND (attr
);
4677 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4678 if (attr
&& DW_STRING (attr
))
4680 enum type_code code
= TYPE_CODE_INT
;
4685 case DW_ATE_address
:
4686 /* Turn DW_ATE_address into a void * pointer. */
4687 code
= TYPE_CODE_PTR
;
4688 type_flags
|= TYPE_FLAG_UNSIGNED
;
4690 case DW_ATE_boolean
:
4691 code
= TYPE_CODE_BOOL
;
4692 type_flags
|= TYPE_FLAG_UNSIGNED
;
4694 case DW_ATE_complex_float
:
4695 code
= TYPE_CODE_COMPLEX
;
4698 code
= TYPE_CODE_FLT
;
4701 case DW_ATE_signed_char
:
4703 case DW_ATE_unsigned
:
4704 case DW_ATE_unsigned_char
:
4705 type_flags
|= TYPE_FLAG_UNSIGNED
;
4708 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4709 dwarf_type_encoding_name (encoding
));
4712 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4713 if (encoding
== DW_ATE_address
)
4714 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4716 else if (encoding
== DW_ATE_complex_float
)
4719 TYPE_TARGET_TYPE (type
)
4720 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4721 else if (size
== 16)
4722 TYPE_TARGET_TYPE (type
)
4723 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4725 TYPE_TARGET_TYPE (type
)
4726 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4731 type
= dwarf_base_type (encoding
, size
, cu
);
4733 set_die_type (die
, type
, cu
);
4736 /* Read the given DW_AT_subrange DIE. */
4739 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4741 struct type
*base_type
;
4742 struct type
*range_type
;
4743 struct attribute
*attr
;
4747 /* If we have already decoded this die, then nothing more to do. */
4751 base_type
= die_type (die
, cu
);
4752 if (base_type
== NULL
)
4754 complaint (&symfile_complaints
,
4755 _("DW_AT_type missing from DW_TAG_subrange_type"));
4759 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4760 base_type
= alloc_type (NULL
);
4762 if (cu
->language
== language_fortran
)
4764 /* FORTRAN implies a lower bound of 1, if not given. */
4768 /* FIXME: For variable sized arrays either of these could be
4769 a variable rather than a constant value. We'll allow it,
4770 but we don't know how to handle it. */
4771 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4773 low
= dwarf2_get_attr_constant_value (attr
, 0);
4775 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4778 if (attr
->form
== DW_FORM_block1
)
4780 /* GCC encodes arrays with unspecified or dynamic length
4781 with a DW_FORM_block1 attribute.
4782 FIXME: GDB does not yet know how to handle dynamic
4783 arrays properly, treat them as arrays with unspecified
4786 FIXME: jimb/2003-09-22: GDB does not really know
4787 how to handle arrays of unspecified length
4788 either; we just represent them as zero-length
4789 arrays. Choose an appropriate upper bound given
4790 the lower bound we've computed above. */
4794 high
= dwarf2_get_attr_constant_value (attr
, 1);
4797 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4799 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4800 if (attr
&& DW_STRING (attr
))
4801 TYPE_NAME (range_type
) = DW_STRING (attr
);
4803 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4805 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4807 set_die_type (die
, range_type
, cu
);
4811 /* Read a whole compilation unit into a linked list of dies. */
4813 static struct die_info
*
4814 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4816 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4819 /* Read a single die and all its descendents. Set the die's sibling
4820 field to NULL; set other fields in the die correctly, and set all
4821 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4822 location of the info_ptr after reading all of those dies. PARENT
4823 is the parent of the die in question. */
4825 static struct die_info
*
4826 read_die_and_children (char *info_ptr
, bfd
*abfd
,
4827 struct dwarf2_cu
*cu
,
4828 char **new_info_ptr
,
4829 struct die_info
*parent
)
4831 struct die_info
*die
;
4835 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4836 store_in_ref_table (die
->offset
, die
, cu
);
4840 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4846 *new_info_ptr
= cur_ptr
;
4849 die
->sibling
= NULL
;
4850 die
->parent
= parent
;
4854 /* Read a die, all of its descendents, and all of its siblings; set
4855 all of the fields of all of the dies correctly. Arguments are as
4856 in read_die_and_children. */
4858 static struct die_info
*
4859 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
4860 struct dwarf2_cu
*cu
,
4861 char **new_info_ptr
,
4862 struct die_info
*parent
)
4864 struct die_info
*first_die
, *last_sibling
;
4868 first_die
= last_sibling
= NULL
;
4872 struct die_info
*die
4873 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4881 last_sibling
->sibling
= die
;
4886 *new_info_ptr
= cur_ptr
;
4896 /* Free a linked list of dies. */
4899 free_die_list (struct die_info
*dies
)
4901 struct die_info
*die
, *next
;
4906 if (die
->child
!= NULL
)
4907 free_die_list (die
->child
);
4908 next
= die
->sibling
;
4915 /* Read the contents of the section at OFFSET and of size SIZE from the
4916 object file specified by OBJFILE into the objfile_obstack and return it. */
4919 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4921 bfd
*abfd
= objfile
->obfd
;
4923 bfd_size_type size
= bfd_get_section_size (sectp
);
4928 buf
= (char *) obstack_alloc (&objfile
->objfile_obstack
, size
);
4930 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
4934 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4935 || bfd_bread (buf
, size
, abfd
) != size
)
4936 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
4937 bfd_get_filename (abfd
));
4942 /* In DWARF version 2, the description of the debugging information is
4943 stored in a separate .debug_abbrev section. Before we read any
4944 dies from a section we read in all abbreviations and install them
4945 in a hash table. This function also sets flags in CU describing
4946 the data found in the abbrev table. */
4949 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4951 struct comp_unit_head
*cu_header
= &cu
->header
;
4953 struct abbrev_info
*cur_abbrev
;
4954 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4955 unsigned int abbrev_form
, hash_number
;
4956 struct attr_abbrev
*cur_attrs
;
4957 unsigned int allocated_attrs
;
4959 /* Initialize dwarf2 abbrevs */
4960 obstack_init (&cu
->abbrev_obstack
);
4961 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
4963 * sizeof (struct abbrev_info
*)));
4964 memset (cu
->dwarf2_abbrevs
, 0,
4965 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
4967 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
4968 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4969 abbrev_ptr
+= bytes_read
;
4971 allocated_attrs
= ATTR_ALLOC_CHUNK
;
4972 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
4974 /* loop until we reach an abbrev number of 0 */
4975 while (abbrev_number
)
4977 cur_abbrev
= dwarf_alloc_abbrev (cu
);
4979 /* read in abbrev header */
4980 cur_abbrev
->number
= abbrev_number
;
4981 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4982 abbrev_ptr
+= bytes_read
;
4983 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
4986 if (cur_abbrev
->tag
== DW_TAG_namespace
)
4987 cu
->has_namespace_info
= 1;
4989 /* now read in declarations */
4990 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4991 abbrev_ptr
+= bytes_read
;
4992 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4993 abbrev_ptr
+= bytes_read
;
4996 if (cur_abbrev
->num_attrs
== allocated_attrs
)
4998 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5000 = xrealloc (cur_attrs
, (allocated_attrs
5001 * sizeof (struct attr_abbrev
)));
5004 /* Record whether this compilation unit might have
5005 inter-compilation-unit references. If we don't know what form
5006 this attribute will have, then it might potentially be a
5007 DW_FORM_ref_addr, so we conservatively expect inter-CU
5010 if (abbrev_form
== DW_FORM_ref_addr
5011 || abbrev_form
== DW_FORM_indirect
)
5012 cu
->has_form_ref_addr
= 1;
5014 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5015 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5016 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5017 abbrev_ptr
+= bytes_read
;
5018 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5019 abbrev_ptr
+= bytes_read
;
5022 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5023 (cur_abbrev
->num_attrs
5024 * sizeof (struct attr_abbrev
)));
5025 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5026 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5028 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5029 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5030 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5032 /* Get next abbreviation.
5033 Under Irix6 the abbreviations for a compilation unit are not
5034 always properly terminated with an abbrev number of 0.
5035 Exit loop if we encounter an abbreviation which we have
5036 already read (which means we are about to read the abbreviations
5037 for the next compile unit) or if the end of the abbreviation
5038 table is reached. */
5039 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5040 >= dwarf2_per_objfile
->abbrev_size
)
5042 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5043 abbrev_ptr
+= bytes_read
;
5044 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5051 /* Release the memory used by the abbrev table for a compilation unit. */
5054 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5056 struct dwarf2_cu
*cu
= ptr_to_cu
;
5058 obstack_free (&cu
->abbrev_obstack
, NULL
);
5059 cu
->dwarf2_abbrevs
= NULL
;
5062 /* Lookup an abbrev_info structure in the abbrev hash table. */
5064 static struct abbrev_info
*
5065 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5067 unsigned int hash_number
;
5068 struct abbrev_info
*abbrev
;
5070 hash_number
= number
% ABBREV_HASH_SIZE
;
5071 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5075 if (abbrev
->number
== number
)
5078 abbrev
= abbrev
->next
;
5083 /* Returns nonzero if TAG represents a type that we might generate a partial
5087 is_type_tag_for_partial (int tag
)
5092 /* Some types that would be reasonable to generate partial symbols for,
5093 that we don't at present. */
5094 case DW_TAG_array_type
:
5095 case DW_TAG_file_type
:
5096 case DW_TAG_ptr_to_member_type
:
5097 case DW_TAG_set_type
:
5098 case DW_TAG_string_type
:
5099 case DW_TAG_subroutine_type
:
5101 case DW_TAG_base_type
:
5102 case DW_TAG_class_type
:
5103 case DW_TAG_enumeration_type
:
5104 case DW_TAG_structure_type
:
5105 case DW_TAG_subrange_type
:
5106 case DW_TAG_typedef
:
5107 case DW_TAG_union_type
:
5114 /* Load all DIEs that are interesting for partial symbols into memory. */
5116 static struct partial_die_info
*
5117 load_partial_dies (bfd
*abfd
, char *info_ptr
, int building_psymtab
,
5118 struct dwarf2_cu
*cu
)
5120 struct partial_die_info
*part_die
;
5121 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5122 struct abbrev_info
*abbrev
;
5123 unsigned int bytes_read
;
5125 int nesting_level
= 1;
5131 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5135 &cu
->comp_unit_obstack
,
5136 hashtab_obstack_allocate
,
5137 dummy_obstack_deallocate
);
5139 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5140 sizeof (struct partial_die_info
));
5144 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5146 /* A NULL abbrev means the end of a series of children. */
5149 if (--nesting_level
== 0)
5151 /* PART_DIE was probably the last thing allocated on the
5152 comp_unit_obstack, so we could call obstack_free
5153 here. We don't do that because the waste is small,
5154 and will be cleaned up when we're done with this
5155 compilation unit. This way, we're also more robust
5156 against other users of the comp_unit_obstack. */
5159 info_ptr
+= bytes_read
;
5160 last_die
= parent_die
;
5161 parent_die
= parent_die
->die_parent
;
5165 /* Check whether this DIE is interesting enough to save. */
5166 if (!is_type_tag_for_partial (abbrev
->tag
)
5167 && abbrev
->tag
!= DW_TAG_enumerator
5168 && abbrev
->tag
!= DW_TAG_subprogram
5169 && abbrev
->tag
!= DW_TAG_variable
5170 && abbrev
->tag
!= DW_TAG_namespace
)
5172 /* Otherwise we skip to the next sibling, if any. */
5173 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5177 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5178 abfd
, info_ptr
, cu
);
5180 /* This two-pass algorithm for processing partial symbols has a
5181 high cost in cache pressure. Thus, handle some simple cases
5182 here which cover the majority of C partial symbols. DIEs
5183 which neither have specification tags in them, nor could have
5184 specification tags elsewhere pointing at them, can simply be
5185 processed and discarded.
5187 This segment is also optional; scan_partial_symbols and
5188 add_partial_symbol will handle these DIEs if we chain
5189 them in normally. When compilers which do not emit large
5190 quantities of duplicate debug information are more common,
5191 this code can probably be removed. */
5193 /* Any complete simple types at the top level (pretty much all
5194 of them, for a language without namespaces), can be processed
5196 if (parent_die
== NULL
5197 && part_die
->has_specification
== 0
5198 && part_die
->is_declaration
== 0
5199 && (part_die
->tag
== DW_TAG_typedef
5200 || part_die
->tag
== DW_TAG_base_type
5201 || part_die
->tag
== DW_TAG_subrange_type
))
5203 if (building_psymtab
&& part_die
->name
!= NULL
)
5204 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5205 VAR_DOMAIN
, LOC_TYPEDEF
,
5206 &cu
->objfile
->static_psymbols
,
5207 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5208 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5212 /* If we're at the second level, and we're an enumerator, and
5213 our parent has no specification (meaning possibly lives in a
5214 namespace elsewhere), then we can add the partial symbol now
5215 instead of queueing it. */
5216 if (part_die
->tag
== DW_TAG_enumerator
5217 && parent_die
!= NULL
5218 && parent_die
->die_parent
== NULL
5219 && parent_die
->tag
== DW_TAG_enumeration_type
5220 && parent_die
->has_specification
== 0)
5222 if (part_die
->name
== NULL
)
5223 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5224 else if (building_psymtab
)
5225 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5226 VAR_DOMAIN
, LOC_CONST
,
5227 (cu
->language
== language_cplus
5228 || cu
->language
== language_java
)
5229 ? &cu
->objfile
->global_psymbols
5230 : &cu
->objfile
->static_psymbols
,
5231 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5233 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5237 /* We'll save this DIE so link it in. */
5238 part_die
->die_parent
= parent_die
;
5239 part_die
->die_sibling
= NULL
;
5240 part_die
->die_child
= NULL
;
5242 if (last_die
&& last_die
== parent_die
)
5243 last_die
->die_child
= part_die
;
5245 last_die
->die_sibling
= part_die
;
5247 last_die
= part_die
;
5249 if (first_die
== NULL
)
5250 first_die
= part_die
;
5252 /* Maybe add the DIE to the hash table. Not all DIEs that we
5253 find interesting need to be in the hash table, because we
5254 also have the parent/sibling/child chains; only those that we
5255 might refer to by offset later during partial symbol reading.
5257 For now this means things that might have be the target of a
5258 DW_AT_specification, DW_AT_abstract_origin, or
5259 DW_AT_extension. DW_AT_extension will refer only to
5260 namespaces; DW_AT_abstract_origin refers to functions (and
5261 many things under the function DIE, but we do not recurse
5262 into function DIEs during partial symbol reading) and
5263 possibly variables as well; DW_AT_specification refers to
5264 declarations. Declarations ought to have the DW_AT_declaration
5265 flag. It happens that GCC forgets to put it in sometimes, but
5266 only for functions, not for types.
5268 Adding more things than necessary to the hash table is harmless
5269 except for the performance cost. Adding too few will result in
5270 internal errors in find_partial_die. */
5272 if (abbrev
->tag
== DW_TAG_subprogram
5273 || abbrev
->tag
== DW_TAG_variable
5274 || abbrev
->tag
== DW_TAG_namespace
5275 || part_die
->is_declaration
)
5279 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5280 part_die
->offset
, INSERT
);
5284 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5285 sizeof (struct partial_die_info
));
5287 /* For some DIEs we want to follow their children (if any). For C
5288 we have no reason to follow the children of structures; for other
5289 languages we have to, both so that we can get at method physnames
5290 to infer fully qualified class names, and for DW_AT_specification. */
5291 if (last_die
->has_children
5292 && (last_die
->tag
== DW_TAG_namespace
5293 || last_die
->tag
== DW_TAG_enumeration_type
5294 || (cu
->language
!= language_c
5295 && (last_die
->tag
== DW_TAG_class_type
5296 || last_die
->tag
== DW_TAG_structure_type
5297 || last_die
->tag
== DW_TAG_union_type
))))
5300 parent_die
= last_die
;
5304 /* Otherwise we skip to the next sibling, if any. */
5305 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5307 /* Back to the top, do it again. */
5311 /* Read a minimal amount of information into the minimal die structure. */
5314 read_partial_die (struct partial_die_info
*part_die
,
5315 struct abbrev_info
*abbrev
,
5316 unsigned int abbrev_len
, bfd
*abfd
,
5317 char *info_ptr
, struct dwarf2_cu
*cu
)
5319 unsigned int bytes_read
, i
;
5320 struct attribute attr
;
5321 int has_low_pc_attr
= 0;
5322 int has_high_pc_attr
= 0;
5324 memset (part_die
, 0, sizeof (struct partial_die_info
));
5326 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5328 info_ptr
+= abbrev_len
;
5333 part_die
->tag
= abbrev
->tag
;
5334 part_die
->has_children
= abbrev
->has_children
;
5336 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5338 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5340 /* Store the data if it is of an attribute we want to keep in a
5341 partial symbol table. */
5346 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5347 if (part_die
->name
== NULL
)
5348 part_die
->name
= DW_STRING (&attr
);
5350 case DW_AT_comp_dir
:
5351 if (part_die
->dirname
== NULL
)
5352 part_die
->dirname
= DW_STRING (&attr
);
5354 case DW_AT_MIPS_linkage_name
:
5355 part_die
->name
= DW_STRING (&attr
);
5358 has_low_pc_attr
= 1;
5359 part_die
->lowpc
= DW_ADDR (&attr
);
5362 has_high_pc_attr
= 1;
5363 part_die
->highpc
= DW_ADDR (&attr
);
5365 case DW_AT_location
:
5366 /* Support the .debug_loc offsets */
5367 if (attr_form_is_block (&attr
))
5369 part_die
->locdesc
= DW_BLOCK (&attr
);
5371 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5373 dwarf2_complex_location_expr_complaint ();
5377 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5378 "partial symbol information");
5381 case DW_AT_language
:
5382 part_die
->language
= DW_UNSND (&attr
);
5384 case DW_AT_external
:
5385 part_die
->is_external
= DW_UNSND (&attr
);
5387 case DW_AT_declaration
:
5388 part_die
->is_declaration
= DW_UNSND (&attr
);
5391 part_die
->has_type
= 1;
5393 case DW_AT_abstract_origin
:
5394 case DW_AT_specification
:
5395 case DW_AT_extension
:
5396 part_die
->has_specification
= 1;
5397 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5400 /* Ignore absolute siblings, they might point outside of
5401 the current compile unit. */
5402 if (attr
.form
== DW_FORM_ref_addr
)
5403 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5405 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5406 + dwarf2_get_ref_die_offset (&attr
, cu
);
5408 case DW_AT_stmt_list
:
5409 part_die
->has_stmt_list
= 1;
5410 part_die
->line_offset
= DW_UNSND (&attr
);
5417 /* When using the GNU linker, .gnu.linkonce. sections are used to
5418 eliminate duplicate copies of functions and vtables and such.
5419 The linker will arbitrarily choose one and discard the others.
5420 The AT_*_pc values for such functions refer to local labels in
5421 these sections. If the section from that file was discarded, the
5422 labels are not in the output, so the relocs get a value of 0.
5423 If this is a discarded function, mark the pc bounds as invalid,
5424 so that GDB will ignore it. */
5425 if (has_low_pc_attr
&& has_high_pc_attr
5426 && part_die
->lowpc
< part_die
->highpc
5427 && (part_die
->lowpc
!= 0
5428 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5429 part_die
->has_pc_info
= 1;
5433 /* Find a cached partial DIE at OFFSET in CU. */
5435 static struct partial_die_info
*
5436 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5438 struct partial_die_info
*lookup_die
= NULL
;
5439 struct partial_die_info part_die
;
5441 part_die
.offset
= offset
;
5442 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5444 if (lookup_die
== NULL
)
5445 internal_error (__FILE__
, __LINE__
,
5446 _("could not find partial DIE in cache\n"));
5451 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5453 static struct partial_die_info
*
5454 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5456 struct dwarf2_per_cu_data
*per_cu
;
5458 if (offset
>= cu
->header
.offset
5459 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5460 return find_partial_die_in_comp_unit (offset
, cu
);
5462 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5464 if (per_cu
->cu
== NULL
)
5466 load_comp_unit (per_cu
, cu
->objfile
);
5467 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5468 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5471 per_cu
->cu
->last_used
= 0;
5472 return find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5475 /* Adjust PART_DIE before generating a symbol for it. This function
5476 may set the is_external flag or change the DIE's name. */
5479 fixup_partial_die (struct partial_die_info
*part_die
,
5480 struct dwarf2_cu
*cu
)
5482 /* If we found a reference attribute and the DIE has no name, try
5483 to find a name in the referred to DIE. */
5485 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5487 struct partial_die_info
*spec_die
;
5489 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5491 fixup_partial_die (spec_die
, cu
);
5495 part_die
->name
= spec_die
->name
;
5497 /* Copy DW_AT_external attribute if it is set. */
5498 if (spec_die
->is_external
)
5499 part_die
->is_external
= spec_die
->is_external
;
5503 /* Set default names for some unnamed DIEs. */
5504 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5505 || part_die
->tag
== DW_TAG_class_type
))
5506 part_die
->name
= "(anonymous class)";
5508 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5509 part_die
->name
= "(anonymous namespace)";
5511 if (part_die
->tag
== DW_TAG_structure_type
5512 || part_die
->tag
== DW_TAG_class_type
5513 || part_die
->tag
== DW_TAG_union_type
)
5514 guess_structure_name (part_die
, cu
);
5517 /* Read the die from the .debug_info section buffer. Set DIEP to
5518 point to a newly allocated die with its information, except for its
5519 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5520 whether the die has children or not. */
5523 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
5524 struct dwarf2_cu
*cu
, int *has_children
)
5526 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5527 struct abbrev_info
*abbrev
;
5528 struct die_info
*die
;
5530 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5531 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5532 info_ptr
+= bytes_read
;
5535 die
= dwarf_alloc_die ();
5537 die
->abbrev
= abbrev_number
;
5544 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5547 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5549 bfd_get_filename (abfd
));
5551 die
= dwarf_alloc_die ();
5552 die
->offset
= offset
;
5553 die
->tag
= abbrev
->tag
;
5554 die
->abbrev
= abbrev_number
;
5557 die
->num_attrs
= abbrev
->num_attrs
;
5558 die
->attrs
= (struct attribute
*)
5559 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5561 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5563 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5564 abfd
, info_ptr
, cu
);
5566 /* If this attribute is an absolute reference to a different
5567 compilation unit, make sure that compilation unit is loaded
5569 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5570 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5571 || (DW_ADDR (&die
->attrs
[i
])
5572 >= cu
->header
.offset
+ cu
->header
.length
)))
5574 struct dwarf2_per_cu_data
*per_cu
;
5575 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5578 /* Mark the dependence relation so that we don't flush PER_CU
5580 dwarf2_add_dependence (cu
, per_cu
);
5582 /* If it's already on the queue, we have nothing to do. */
5586 /* If the compilation unit is already loaded, just mark it as
5588 if (per_cu
->cu
!= NULL
)
5590 per_cu
->cu
->last_used
= 0;
5594 /* Add it to the queue. */
5595 queue_comp_unit (per_cu
);
5600 *has_children
= abbrev
->has_children
;
5604 /* Read an attribute value described by an attribute form. */
5607 read_attribute_value (struct attribute
*attr
, unsigned form
,
5608 bfd
*abfd
, char *info_ptr
,
5609 struct dwarf2_cu
*cu
)
5611 struct comp_unit_head
*cu_header
= &cu
->header
;
5612 unsigned int bytes_read
;
5613 struct dwarf_block
*blk
;
5619 case DW_FORM_ref_addr
:
5620 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5621 info_ptr
+= bytes_read
;
5623 case DW_FORM_block2
:
5624 blk
= dwarf_alloc_block (cu
);
5625 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5627 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5628 info_ptr
+= blk
->size
;
5629 DW_BLOCK (attr
) = blk
;
5631 case DW_FORM_block4
:
5632 blk
= dwarf_alloc_block (cu
);
5633 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5635 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5636 info_ptr
+= blk
->size
;
5637 DW_BLOCK (attr
) = blk
;
5640 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5644 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5648 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5651 case DW_FORM_string
:
5652 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5653 info_ptr
+= bytes_read
;
5656 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5658 info_ptr
+= bytes_read
;
5661 blk
= dwarf_alloc_block (cu
);
5662 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5663 info_ptr
+= bytes_read
;
5664 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5665 info_ptr
+= blk
->size
;
5666 DW_BLOCK (attr
) = blk
;
5668 case DW_FORM_block1
:
5669 blk
= dwarf_alloc_block (cu
);
5670 blk
->size
= read_1_byte (abfd
, info_ptr
);
5672 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5673 info_ptr
+= blk
->size
;
5674 DW_BLOCK (attr
) = blk
;
5677 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5681 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5685 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5686 info_ptr
+= bytes_read
;
5689 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5690 info_ptr
+= bytes_read
;
5693 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5697 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5701 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5705 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5708 case DW_FORM_ref_udata
:
5709 DW_ADDR (attr
) = (cu
->header
.offset
5710 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5711 info_ptr
+= bytes_read
;
5713 case DW_FORM_indirect
:
5714 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5715 info_ptr
+= bytes_read
;
5716 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5719 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5720 dwarf_form_name (form
),
5721 bfd_get_filename (abfd
));
5726 /* Read an attribute described by an abbreviated attribute. */
5729 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5730 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
5732 attr
->name
= abbrev
->name
;
5733 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5736 /* read dwarf information from a buffer */
5739 read_1_byte (bfd
*abfd
, char *buf
)
5741 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
5745 read_1_signed_byte (bfd
*abfd
, char *buf
)
5747 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
5751 read_2_bytes (bfd
*abfd
, char *buf
)
5753 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5757 read_2_signed_bytes (bfd
*abfd
, char *buf
)
5759 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5763 read_4_bytes (bfd
*abfd
, char *buf
)
5765 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5769 read_4_signed_bytes (bfd
*abfd
, char *buf
)
5771 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5774 static unsigned long
5775 read_8_bytes (bfd
*abfd
, char *buf
)
5777 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5781 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
5783 struct comp_unit_head
*cu_header
= &cu
->header
;
5784 CORE_ADDR retval
= 0;
5786 if (cu_header
->signed_addr_p
)
5788 switch (cu_header
->addr_size
)
5791 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5794 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5797 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
5800 internal_error (__FILE__
, __LINE__
,
5801 _("read_address: bad switch, signed [in module %s]"),
5802 bfd_get_filename (abfd
));
5807 switch (cu_header
->addr_size
)
5810 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5813 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5816 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5819 internal_error (__FILE__
, __LINE__
,
5820 _("read_address: bad switch, unsigned [in module %s]"),
5821 bfd_get_filename (abfd
));
5825 *bytes_read
= cu_header
->addr_size
;
5829 /* Read the initial length from a section. The (draft) DWARF 3
5830 specification allows the initial length to take up either 4 bytes
5831 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5832 bytes describe the length and all offsets will be 8 bytes in length
5835 An older, non-standard 64-bit format is also handled by this
5836 function. The older format in question stores the initial length
5837 as an 8-byte quantity without an escape value. Lengths greater
5838 than 2^32 aren't very common which means that the initial 4 bytes
5839 is almost always zero. Since a length value of zero doesn't make
5840 sense for the 32-bit format, this initial zero can be considered to
5841 be an escape value which indicates the presence of the older 64-bit
5842 format. As written, the code can't detect (old format) lengths
5843 greater than 4GB. If it becomes necessary to handle lengths
5844 somewhat larger than 4GB, we could allow other small values (such
5845 as the non-sensical values of 1, 2, and 3) to also be used as
5846 escape values indicating the presence of the old format.
5848 The value returned via bytes_read should be used to increment the
5849 relevant pointer after calling read_initial_length().
5851 As a side effect, this function sets the fields initial_length_size
5852 and offset_size in cu_header to the values appropriate for the
5853 length field. (The format of the initial length field determines
5854 the width of file offsets to be fetched later with fetch_offset().)
5856 [ Note: read_initial_length() and read_offset() are based on the
5857 document entitled "DWARF Debugging Information Format", revision
5858 3, draft 8, dated November 19, 2001. This document was obtained
5861 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5863 This document is only a draft and is subject to change. (So beware.)
5865 Details regarding the older, non-standard 64-bit format were
5866 determined empirically by examining 64-bit ELF files produced by
5867 the SGI toolchain on an IRIX 6.5 machine.
5869 - Kevin, July 16, 2002
5873 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
5878 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5880 if (retval
== 0xffffffff)
5882 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
5884 if (cu_header
!= NULL
)
5886 cu_header
->initial_length_size
= 12;
5887 cu_header
->offset_size
= 8;
5890 else if (retval
== 0)
5892 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
5894 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5896 if (cu_header
!= NULL
)
5898 cu_header
->initial_length_size
= 8;
5899 cu_header
->offset_size
= 8;
5905 if (cu_header
!= NULL
)
5907 cu_header
->initial_length_size
= 4;
5908 cu_header
->offset_size
= 4;
5915 /* Read an offset from the data stream. The size of the offset is
5916 given by cu_header->offset_size. */
5919 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
5924 switch (cu_header
->offset_size
)
5927 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5931 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5935 internal_error (__FILE__
, __LINE__
,
5936 _("read_offset: bad switch [in module %s]"),
5937 bfd_get_filename (abfd
));
5944 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
5946 /* If the size of a host char is 8 bits, we can return a pointer
5947 to the buffer, otherwise we have to copy the data to a buffer
5948 allocated on the temporary obstack. */
5949 gdb_assert (HOST_CHAR_BIT
== 8);
5954 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5956 /* If the size of a host char is 8 bits, we can return a pointer
5957 to the string, otherwise we have to copy the string to a buffer
5958 allocated on the temporary obstack. */
5959 gdb_assert (HOST_CHAR_BIT
== 8);
5962 *bytes_read_ptr
= 1;
5965 *bytes_read_ptr
= strlen (buf
) + 1;
5970 read_indirect_string (bfd
*abfd
, char *buf
,
5971 const struct comp_unit_head
*cu_header
,
5972 unsigned int *bytes_read_ptr
)
5974 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
5975 (int *) bytes_read_ptr
);
5977 if (dwarf2_per_objfile
->str_buffer
== NULL
)
5979 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
5980 bfd_get_filename (abfd
));
5983 if (str_offset
>= dwarf2_per_objfile
->str_size
)
5985 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
5986 bfd_get_filename (abfd
));
5989 gdb_assert (HOST_CHAR_BIT
== 8);
5990 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
5992 return dwarf2_per_objfile
->str_buffer
+ str_offset
;
5995 static unsigned long
5996 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5998 unsigned long result
;
5999 unsigned int num_read
;
6009 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6012 result
|= ((unsigned long)(byte
& 127) << shift
);
6013 if ((byte
& 128) == 0)
6019 *bytes_read_ptr
= num_read
;
6024 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
6027 int i
, shift
, size
, num_read
;
6037 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6040 result
|= ((long)(byte
& 127) << shift
);
6042 if ((byte
& 128) == 0)
6047 if ((shift
< size
) && (byte
& 0x40))
6049 result
|= -(1 << shift
);
6051 *bytes_read_ptr
= num_read
;
6055 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6058 skip_leb128 (bfd
*abfd
, char *buf
)
6064 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6066 if ((byte
& 128) == 0)
6072 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6078 cu
->language
= language_c
;
6080 case DW_LANG_C_plus_plus
:
6081 cu
->language
= language_cplus
;
6083 case DW_LANG_Fortran77
:
6084 case DW_LANG_Fortran90
:
6085 case DW_LANG_Fortran95
:
6086 cu
->language
= language_fortran
;
6088 case DW_LANG_Mips_Assembler
:
6089 cu
->language
= language_asm
;
6092 cu
->language
= language_java
;
6096 cu
->language
= language_ada
;
6098 case DW_LANG_Cobol74
:
6099 case DW_LANG_Cobol85
:
6100 case DW_LANG_Pascal83
:
6101 case DW_LANG_Modula2
:
6103 cu
->language
= language_minimal
;
6106 cu
->language_defn
= language_def (cu
->language
);
6109 /* Return the named attribute or NULL if not there. */
6111 static struct attribute
*
6112 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6115 struct attribute
*spec
= NULL
;
6117 for (i
= 0; i
< die
->num_attrs
; ++i
)
6119 if (die
->attrs
[i
].name
== name
)
6120 return &die
->attrs
[i
];
6121 if (die
->attrs
[i
].name
== DW_AT_specification
6122 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6123 spec
= &die
->attrs
[i
];
6127 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6132 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6133 and holds a non-zero value. This function should only be used for
6134 DW_FORM_flag attributes. */
6137 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6139 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6141 return (attr
&& DW_UNSND (attr
));
6145 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6147 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6148 which value is non-zero. However, we have to be careful with
6149 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6150 (via dwarf2_flag_true_p) follows this attribute. So we may
6151 end up accidently finding a declaration attribute that belongs
6152 to a different DIE referenced by the specification attribute,
6153 even though the given DIE does not have a declaration attribute. */
6154 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6155 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6158 /* Return the die giving the specification for DIE, if there is
6161 static struct die_info
*
6162 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6164 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6166 if (spec_attr
== NULL
)
6169 return follow_die_ref (die
, spec_attr
, cu
);
6172 /* Free the line_header structure *LH, and any arrays and strings it
6175 free_line_header (struct line_header
*lh
)
6177 if (lh
->standard_opcode_lengths
)
6178 xfree (lh
->standard_opcode_lengths
);
6180 /* Remember that all the lh->file_names[i].name pointers are
6181 pointers into debug_line_buffer, and don't need to be freed. */
6183 xfree (lh
->file_names
);
6185 /* Similarly for the include directory names. */
6186 if (lh
->include_dirs
)
6187 xfree (lh
->include_dirs
);
6193 /* Add an entry to LH's include directory table. */
6195 add_include_dir (struct line_header
*lh
, char *include_dir
)
6197 /* Grow the array if necessary. */
6198 if (lh
->include_dirs_size
== 0)
6200 lh
->include_dirs_size
= 1; /* for testing */
6201 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6202 * sizeof (*lh
->include_dirs
));
6204 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6206 lh
->include_dirs_size
*= 2;
6207 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6208 (lh
->include_dirs_size
6209 * sizeof (*lh
->include_dirs
)));
6212 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6216 /* Add an entry to LH's file name table. */
6218 add_file_name (struct line_header
*lh
,
6220 unsigned int dir_index
,
6221 unsigned int mod_time
,
6222 unsigned int length
)
6224 struct file_entry
*fe
;
6226 /* Grow the array if necessary. */
6227 if (lh
->file_names_size
== 0)
6229 lh
->file_names_size
= 1; /* for testing */
6230 lh
->file_names
= xmalloc (lh
->file_names_size
6231 * sizeof (*lh
->file_names
));
6233 else if (lh
->num_file_names
>= lh
->file_names_size
)
6235 lh
->file_names_size
*= 2;
6236 lh
->file_names
= xrealloc (lh
->file_names
,
6237 (lh
->file_names_size
6238 * sizeof (*lh
->file_names
)));
6241 fe
= &lh
->file_names
[lh
->num_file_names
++];
6243 fe
->dir_index
= dir_index
;
6244 fe
->mod_time
= mod_time
;
6245 fe
->length
= length
;
6250 /* Read the statement program header starting at OFFSET in
6251 .debug_line, according to the endianness of ABFD. Return a pointer
6252 to a struct line_header, allocated using xmalloc.
6254 NOTE: the strings in the include directory and file name tables of
6255 the returned object point into debug_line_buffer, and must not be
6257 static struct line_header
*
6258 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6259 struct dwarf2_cu
*cu
)
6261 struct cleanup
*back_to
;
6262 struct line_header
*lh
;
6266 char *cur_dir
, *cur_file
;
6268 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6270 complaint (&symfile_complaints
, _("missing .debug_line section"));
6274 /* Make sure that at least there's room for the total_length field.
6275 That could be 12 bytes long, but we're just going to fudge that. */
6276 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6278 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6282 lh
= xmalloc (sizeof (*lh
));
6283 memset (lh
, 0, sizeof (*lh
));
6284 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6287 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6289 /* Read in the header. */
6290 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
6291 line_ptr
+= bytes_read
;
6292 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6293 + dwarf2_per_objfile
->line_size
))
6295 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6298 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6299 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6301 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6302 line_ptr
+= bytes_read
;
6303 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6305 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6307 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6309 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6311 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6313 lh
->standard_opcode_lengths
6314 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
6316 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6317 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6319 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6323 /* Read directory table. */
6324 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6326 line_ptr
+= bytes_read
;
6327 add_include_dir (lh
, cur_dir
);
6329 line_ptr
+= bytes_read
;
6331 /* Read file name table. */
6332 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6334 unsigned int dir_index
, mod_time
, length
;
6336 line_ptr
+= bytes_read
;
6337 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6338 line_ptr
+= bytes_read
;
6339 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6340 line_ptr
+= bytes_read
;
6341 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6342 line_ptr
+= bytes_read
;
6344 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6346 line_ptr
+= bytes_read
;
6347 lh
->statement_program_start
= line_ptr
;
6349 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6350 + dwarf2_per_objfile
->line_size
))
6351 complaint (&symfile_complaints
,
6352 _("line number info header doesn't fit in `.debug_line' section"));
6354 discard_cleanups (back_to
);
6358 /* This function exists to work around a bug in certain compilers
6359 (particularly GCC 2.95), in which the first line number marker of a
6360 function does not show up until after the prologue, right before
6361 the second line number marker. This function shifts ADDRESS down
6362 to the beginning of the function if necessary, and is called on
6363 addresses passed to record_line. */
6366 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6368 struct function_range
*fn
;
6370 /* Find the function_range containing address. */
6375 cu
->cached_fn
= cu
->first_fn
;
6379 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6385 while (fn
&& fn
!= cu
->cached_fn
)
6386 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6396 if (address
!= fn
->lowpc
)
6397 complaint (&symfile_complaints
,
6398 _("misplaced first line number at 0x%lx for '%s'"),
6399 (unsigned long) address
, fn
->name
);
6404 /* Decode the Line Number Program (LNP) for the given line_header
6405 structure and CU. The actual information extracted and the type
6406 of structures created from the LNP depends on the value of PST.
6408 1. If PST is NULL, then this procedure uses the data from the program
6409 to create all necessary symbol tables, and their linetables.
6410 The compilation directory of the file is passed in COMP_DIR,
6411 and must not be NULL.
6413 2. If PST is not NULL, this procedure reads the program to determine
6414 the list of files included by the unit represented by PST, and
6415 builds all the associated partial symbol tables. In this case,
6416 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6417 is not used to compute the full name of the symtab, and therefore
6418 omitting it when building the partial symtab does not introduce
6419 the potential for inconsistency - a partial symtab and its associated
6420 symbtab having a different fullname -). */
6423 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6424 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6428 unsigned int bytes_read
;
6429 unsigned char op_code
, extended_op
, adj_opcode
;
6431 struct objfile
*objfile
= cu
->objfile
;
6432 const int decode_for_pst_p
= (pst
!= NULL
);
6434 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6436 line_ptr
= lh
->statement_program_start
;
6437 line_end
= lh
->statement_program_end
;
6439 /* Read the statement sequences until there's nothing left. */
6440 while (line_ptr
< line_end
)
6442 /* state machine registers */
6443 CORE_ADDR address
= 0;
6444 unsigned int file
= 1;
6445 unsigned int line
= 1;
6446 unsigned int column
= 0;
6447 int is_stmt
= lh
->default_is_stmt
;
6448 int basic_block
= 0;
6449 int end_sequence
= 0;
6451 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6453 /* Start a subfile for the current file of the state machine. */
6454 /* lh->include_dirs and lh->file_names are 0-based, but the
6455 directory and file name numbers in the statement program
6457 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6461 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6464 dwarf2_start_subfile (fe
->name
, dir
);
6467 /* Decode the table. */
6468 while (!end_sequence
)
6470 op_code
= read_1_byte (abfd
, line_ptr
);
6473 if (op_code
>= lh
->opcode_base
)
6475 /* Special operand. */
6476 adj_opcode
= op_code
- lh
->opcode_base
;
6477 address
+= (adj_opcode
/ lh
->line_range
)
6478 * lh
->minimum_instruction_length
;
6479 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6480 lh
->file_names
[file
- 1].included_p
= 1;
6481 if (!decode_for_pst_p
)
6483 /* Append row to matrix using current values. */
6484 record_line (current_subfile
, line
,
6485 check_cu_functions (address
, cu
));
6489 else switch (op_code
)
6491 case DW_LNS_extended_op
:
6492 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6493 line_ptr
+= bytes_read
;
6494 extended_op
= read_1_byte (abfd
, line_ptr
);
6496 switch (extended_op
)
6498 case DW_LNE_end_sequence
:
6500 lh
->file_names
[file
- 1].included_p
= 1;
6501 if (!decode_for_pst_p
)
6502 record_line (current_subfile
, 0, address
);
6504 case DW_LNE_set_address
:
6505 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6506 line_ptr
+= bytes_read
;
6507 address
+= baseaddr
;
6509 case DW_LNE_define_file
:
6512 unsigned int dir_index
, mod_time
, length
;
6514 cur_file
= read_string (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
;
6523 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6524 line_ptr
+= bytes_read
;
6525 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6529 complaint (&symfile_complaints
,
6530 _("mangled .debug_line section"));
6535 lh
->file_names
[file
- 1].included_p
= 1;
6536 if (!decode_for_pst_p
)
6537 record_line (current_subfile
, line
,
6538 check_cu_functions (address
, cu
));
6541 case DW_LNS_advance_pc
:
6542 address
+= lh
->minimum_instruction_length
6543 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6544 line_ptr
+= bytes_read
;
6546 case DW_LNS_advance_line
:
6547 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6548 line_ptr
+= bytes_read
;
6550 case DW_LNS_set_file
:
6552 /* The arrays lh->include_dirs and lh->file_names are
6553 0-based, but the directory and file name numbers in
6554 the statement program are 1-based. */
6555 struct file_entry
*fe
;
6558 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6559 line_ptr
+= bytes_read
;
6560 fe
= &lh
->file_names
[file
- 1];
6562 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6565 if (!decode_for_pst_p
)
6566 dwarf2_start_subfile (fe
->name
, dir
);
6569 case DW_LNS_set_column
:
6570 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6571 line_ptr
+= bytes_read
;
6573 case DW_LNS_negate_stmt
:
6574 is_stmt
= (!is_stmt
);
6576 case DW_LNS_set_basic_block
:
6579 /* Add to the address register of the state machine the
6580 address increment value corresponding to special opcode
6581 255. I.e., this value is scaled by the minimum
6582 instruction length since special opcode 255 would have
6583 scaled the the increment. */
6584 case DW_LNS_const_add_pc
:
6585 address
+= (lh
->minimum_instruction_length
6586 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6588 case DW_LNS_fixed_advance_pc
:
6589 address
+= read_2_bytes (abfd
, line_ptr
);
6594 /* Unknown standard opcode, ignore it. */
6597 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6599 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6600 line_ptr
+= bytes_read
;
6607 if (decode_for_pst_p
)
6611 /* Now that we're done scanning the Line Header Program, we can
6612 create the psymtab of each included file. */
6613 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6614 if (lh
->file_names
[file_index
].included_p
== 1)
6616 char *include_name
= lh
->file_names
[file_index
].name
;
6618 if (strcmp (include_name
, pst
->filename
) != 0)
6619 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6624 /* Start a subfile for DWARF. FILENAME is the name of the file and
6625 DIRNAME the name of the source directory which contains FILENAME
6626 or NULL if not known.
6627 This routine tries to keep line numbers from identical absolute and
6628 relative file names in a common subfile.
6630 Using the `list' example from the GDB testsuite, which resides in
6631 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6632 of /srcdir/list0.c yields the following debugging information for list0.c:
6634 DW_AT_name: /srcdir/list0.c
6635 DW_AT_comp_dir: /compdir
6636 files.files[0].name: list0.h
6637 files.files[0].dir: /srcdir
6638 files.files[1].name: list0.c
6639 files.files[1].dir: /srcdir
6641 The line number information for list0.c has to end up in a single
6642 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6645 dwarf2_start_subfile (char *filename
, char *dirname
)
6647 /* If the filename isn't absolute, try to match an existing subfile
6648 with the full pathname. */
6650 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6652 struct subfile
*subfile
;
6653 char *fullname
= concat (dirname
, "/", filename
, NULL
);
6655 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
6657 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
6659 current_subfile
= subfile
;
6666 start_subfile (filename
, dirname
);
6670 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6671 struct dwarf2_cu
*cu
)
6673 struct objfile
*objfile
= cu
->objfile
;
6674 struct comp_unit_head
*cu_header
= &cu
->header
;
6676 /* NOTE drow/2003-01-30: There used to be a comment and some special
6677 code here to turn a symbol with DW_AT_external and a
6678 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6679 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6680 with some versions of binutils) where shared libraries could have
6681 relocations against symbols in their debug information - the
6682 minimal symbol would have the right address, but the debug info
6683 would not. It's no longer necessary, because we will explicitly
6684 apply relocations when we read in the debug information now. */
6686 /* A DW_AT_location attribute with no contents indicates that a
6687 variable has been optimized away. */
6688 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6690 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6694 /* Handle one degenerate form of location expression specially, to
6695 preserve GDB's previous behavior when section offsets are
6696 specified. If this is just a DW_OP_addr then mark this symbol
6699 if (attr_form_is_block (attr
)
6700 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6701 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6705 SYMBOL_VALUE_ADDRESS (sym
) =
6706 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6707 fixup_symbol_section (sym
, objfile
);
6708 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6709 SYMBOL_SECTION (sym
));
6710 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6714 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6715 expression evaluator, and use LOC_COMPUTED only when necessary
6716 (i.e. when the value of a register or memory location is
6717 referenced, or a thread-local block, etc.). Then again, it might
6718 not be worthwhile. I'm assuming that it isn't unless performance
6719 or memory numbers show me otherwise. */
6721 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6722 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6725 /* Given a pointer to a DWARF information entry, figure out if we need
6726 to make a symbol table entry for it, and if so, create a new entry
6727 and return a pointer to it.
6728 If TYPE is NULL, determine symbol type from the die, otherwise
6729 used the passed type. */
6731 static struct symbol
*
6732 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6734 struct objfile
*objfile
= cu
->objfile
;
6735 struct symbol
*sym
= NULL
;
6737 struct attribute
*attr
= NULL
;
6738 struct attribute
*attr2
= NULL
;
6741 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6743 if (die
->tag
!= DW_TAG_namespace
)
6744 name
= dwarf2_linkage_name (die
, cu
);
6746 name
= TYPE_NAME (type
);
6750 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6751 sizeof (struct symbol
));
6752 OBJSTAT (objfile
, n_syms
++);
6753 memset (sym
, 0, sizeof (struct symbol
));
6755 /* Cache this symbol's name and the name's demangled form (if any). */
6756 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6757 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6759 /* Default assumptions.
6760 Use the passed type or decode it from the die. */
6761 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6762 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6764 SYMBOL_TYPE (sym
) = type
;
6766 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6767 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6770 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6775 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6778 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6780 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6782 case DW_TAG_subprogram
:
6783 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6785 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6786 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6787 if (attr2
&& (DW_UNSND (attr2
) != 0))
6789 add_symbol_to_list (sym
, &global_symbols
);
6793 add_symbol_to_list (sym
, cu
->list_in_scope
);
6796 case DW_TAG_variable
:
6797 /* Compilation with minimal debug info may result in variables
6798 with missing type entries. Change the misleading `void' type
6799 to something sensible. */
6800 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6801 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6802 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6803 "<variable, no debug info>",
6805 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6808 dwarf2_const_value (attr
, sym
, cu
);
6809 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6810 if (attr2
&& (DW_UNSND (attr2
) != 0))
6811 add_symbol_to_list (sym
, &global_symbols
);
6813 add_symbol_to_list (sym
, cu
->list_in_scope
);
6816 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6819 var_decode_location (attr
, sym
, cu
);
6820 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6821 if (attr2
&& (DW_UNSND (attr2
) != 0))
6822 add_symbol_to_list (sym
, &global_symbols
);
6824 add_symbol_to_list (sym
, cu
->list_in_scope
);
6828 /* We do not know the address of this symbol.
6829 If it is an external symbol and we have type information
6830 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6831 The address of the variable will then be determined from
6832 the minimal symbol table whenever the variable is
6834 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6835 if (attr2
&& (DW_UNSND (attr2
) != 0)
6836 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6838 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6839 add_symbol_to_list (sym
, &global_symbols
);
6843 case DW_TAG_formal_parameter
:
6844 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6847 var_decode_location (attr
, sym
, cu
);
6848 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6849 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6850 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6852 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6855 dwarf2_const_value (attr
, sym
, cu
);
6857 add_symbol_to_list (sym
, cu
->list_in_scope
);
6859 case DW_TAG_unspecified_parameters
:
6860 /* From varargs functions; gdb doesn't seem to have any
6861 interest in this information, so just ignore it for now.
6864 case DW_TAG_class_type
:
6865 case DW_TAG_structure_type
:
6866 case DW_TAG_union_type
:
6867 case DW_TAG_enumeration_type
:
6868 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6869 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6871 /* Make sure that the symbol includes appropriate enclosing
6872 classes/namespaces in its name. These are calculated in
6873 read_structure_type, and the correct name is saved in
6876 if (cu
->language
== language_cplus
6877 || cu
->language
== language_java
)
6879 struct type
*type
= SYMBOL_TYPE (sym
);
6881 if (TYPE_TAG_NAME (type
) != NULL
)
6883 /* FIXME: carlton/2003-11-10: Should this use
6884 SYMBOL_SET_NAMES instead? (The same problem also
6885 arises further down in this function.) */
6886 /* The type's name is already allocated along with
6887 this objfile, so we don't need to duplicate it
6889 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
6894 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6895 really ever be static objects: otherwise, if you try
6896 to, say, break of a class's method and you're in a file
6897 which doesn't mention that class, it won't work unless
6898 the check for all static symbols in lookup_symbol_aux
6899 saves you. See the OtherFileClass tests in
6900 gdb.c++/namespace.exp. */
6902 struct pending
**list_to_add
;
6904 list_to_add
= (cu
->list_in_scope
== &file_symbols
6905 && (cu
->language
== language_cplus
6906 || cu
->language
== language_java
)
6907 ? &global_symbols
: cu
->list_in_scope
);
6909 add_symbol_to_list (sym
, list_to_add
);
6911 /* The semantics of C++ state that "struct foo { ... }" also
6912 defines a typedef for "foo". A Java class declaration also
6913 defines a typedef for the class. Synthesize a typedef symbol
6914 so that "ptype foo" works as expected. */
6915 if (cu
->language
== language_cplus
6916 || cu
->language
== language_java
)
6918 struct symbol
*typedef_sym
= (struct symbol
*)
6919 obstack_alloc (&objfile
->objfile_obstack
,
6920 sizeof (struct symbol
));
6921 *typedef_sym
= *sym
;
6922 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
6923 /* The symbol's name is already allocated along with
6924 this objfile, so we don't need to duplicate it for
6926 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
6927 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NATURAL_NAME (sym
);
6928 add_symbol_to_list (typedef_sym
, list_to_add
);
6932 case DW_TAG_typedef
:
6933 if (processing_has_namespace_info
6934 && processing_current_prefix
[0] != '\0')
6936 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6937 processing_current_prefix
,
6940 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6941 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6942 add_symbol_to_list (sym
, cu
->list_in_scope
);
6944 case DW_TAG_base_type
:
6945 case DW_TAG_subrange_type
:
6946 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6947 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6948 add_symbol_to_list (sym
, cu
->list_in_scope
);
6950 case DW_TAG_enumerator
:
6951 if (processing_has_namespace_info
6952 && processing_current_prefix
[0] != '\0')
6954 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6955 processing_current_prefix
,
6958 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6961 dwarf2_const_value (attr
, sym
, cu
);
6964 /* NOTE: carlton/2003-11-10: See comment above in the
6965 DW_TAG_class_type, etc. block. */
6967 struct pending
**list_to_add
;
6969 list_to_add
= (cu
->list_in_scope
== &file_symbols
6970 && (cu
->language
== language_cplus
6971 || cu
->language
== language_java
)
6972 ? &global_symbols
: cu
->list_in_scope
);
6974 add_symbol_to_list (sym
, list_to_add
);
6977 case DW_TAG_namespace
:
6978 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6979 add_symbol_to_list (sym
, &global_symbols
);
6982 /* Not a tag we recognize. Hopefully we aren't processing
6983 trash data, but since we must specifically ignore things
6984 we don't recognize, there is nothing else we should do at
6986 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
6987 dwarf_tag_name (die
->tag
));
6994 /* Copy constant value from an attribute to a symbol. */
6997 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
6998 struct dwarf2_cu
*cu
)
7000 struct objfile
*objfile
= cu
->objfile
;
7001 struct comp_unit_head
*cu_header
= &cu
->header
;
7002 struct dwarf_block
*blk
;
7007 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7008 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7009 cu_header
->addr_size
,
7010 TYPE_LENGTH (SYMBOL_TYPE
7012 SYMBOL_VALUE_BYTES (sym
) = (char *)
7013 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7014 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7015 it's body - store_unsigned_integer. */
7016 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7018 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7020 case DW_FORM_block1
:
7021 case DW_FORM_block2
:
7022 case DW_FORM_block4
:
7024 blk
= DW_BLOCK (attr
);
7025 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7026 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7028 TYPE_LENGTH (SYMBOL_TYPE
7030 SYMBOL_VALUE_BYTES (sym
) = (char *)
7031 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7032 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7033 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7036 /* The DW_AT_const_value attributes are supposed to carry the
7037 symbol's value "represented as it would be on the target
7038 architecture." By the time we get here, it's already been
7039 converted to host endianness, so we just need to sign- or
7040 zero-extend it as appropriate. */
7042 dwarf2_const_value_data (attr
, sym
, 8);
7045 dwarf2_const_value_data (attr
, sym
, 16);
7048 dwarf2_const_value_data (attr
, sym
, 32);
7051 dwarf2_const_value_data (attr
, sym
, 64);
7055 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7056 SYMBOL_CLASS (sym
) = LOC_CONST
;
7060 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7061 SYMBOL_CLASS (sym
) = LOC_CONST
;
7065 complaint (&symfile_complaints
,
7066 _("unsupported const value attribute form: '%s'"),
7067 dwarf_form_name (attr
->form
));
7068 SYMBOL_VALUE (sym
) = 0;
7069 SYMBOL_CLASS (sym
) = LOC_CONST
;
7075 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7076 or zero-extend it as appropriate for the symbol's type. */
7078 dwarf2_const_value_data (struct attribute
*attr
,
7082 LONGEST l
= DW_UNSND (attr
);
7084 if (bits
< sizeof (l
) * 8)
7086 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7087 l
&= ((LONGEST
) 1 << bits
) - 1;
7089 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7092 SYMBOL_VALUE (sym
) = l
;
7093 SYMBOL_CLASS (sym
) = LOC_CONST
;
7097 /* Return the type of the die in question using its DW_AT_type attribute. */
7099 static struct type
*
7100 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7103 struct attribute
*type_attr
;
7104 struct die_info
*type_die
;
7106 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7109 /* A missing DW_AT_type represents a void type. */
7110 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7113 type_die
= follow_die_ref (die
, type_attr
, cu
);
7115 type
= tag_type_to_type (type_die
, cu
);
7118 dump_die (type_die
);
7119 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7125 /* Return the containing type of the die in question using its
7126 DW_AT_containing_type attribute. */
7128 static struct type
*
7129 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7131 struct type
*type
= NULL
;
7132 struct attribute
*type_attr
;
7133 struct die_info
*type_die
= NULL
;
7135 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7138 type_die
= follow_die_ref (die
, type_attr
, cu
);
7139 type
= tag_type_to_type (type_die
, cu
);
7144 dump_die (type_die
);
7145 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7151 static struct type
*
7152 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7160 read_type_die (die
, cu
);
7164 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7172 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7174 char *prefix
= determine_prefix (die
, cu
);
7175 const char *old_prefix
= processing_current_prefix
;
7176 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7177 processing_current_prefix
= prefix
;
7181 case DW_TAG_class_type
:
7182 case DW_TAG_structure_type
:
7183 case DW_TAG_union_type
:
7184 read_structure_type (die
, cu
);
7186 case DW_TAG_enumeration_type
:
7187 read_enumeration_type (die
, cu
);
7189 case DW_TAG_subprogram
:
7190 case DW_TAG_subroutine_type
:
7191 read_subroutine_type (die
, cu
);
7193 case DW_TAG_array_type
:
7194 read_array_type (die
, cu
);
7196 case DW_TAG_pointer_type
:
7197 read_tag_pointer_type (die
, cu
);
7199 case DW_TAG_ptr_to_member_type
:
7200 read_tag_ptr_to_member_type (die
, cu
);
7202 case DW_TAG_reference_type
:
7203 read_tag_reference_type (die
, cu
);
7205 case DW_TAG_const_type
:
7206 read_tag_const_type (die
, cu
);
7208 case DW_TAG_volatile_type
:
7209 read_tag_volatile_type (die
, cu
);
7211 case DW_TAG_string_type
:
7212 read_tag_string_type (die
, cu
);
7214 case DW_TAG_typedef
:
7215 read_typedef (die
, cu
);
7217 case DW_TAG_subrange_type
:
7218 read_subrange_type (die
, cu
);
7220 case DW_TAG_base_type
:
7221 read_base_type (die
, cu
);
7224 complaint (&symfile_complaints
, _("unexepected tag in read_type_die: '%s'"),
7225 dwarf_tag_name (die
->tag
));
7229 processing_current_prefix
= old_prefix
;
7230 do_cleanups (back_to
);
7233 /* Return the name of the namespace/class that DIE is defined within,
7234 or "" if we can't tell. The caller should xfree the result. */
7236 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7237 therein) for an example of how to use this function to deal with
7238 DW_AT_specification. */
7241 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7243 struct die_info
*parent
;
7245 if (cu
->language
!= language_cplus
7246 && cu
->language
!= language_java
)
7249 parent
= die
->parent
;
7253 return xstrdup ("");
7257 switch (parent
->tag
) {
7258 case DW_TAG_namespace
:
7260 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7261 before doing this check? */
7262 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7264 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7269 char *parent_prefix
= determine_prefix (parent
, cu
);
7270 char *retval
= typename_concat (NULL
, parent_prefix
,
7271 namespace_name (parent
, &dummy
,
7274 xfree (parent_prefix
);
7279 case DW_TAG_class_type
:
7280 case DW_TAG_structure_type
:
7282 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7284 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7288 const char *old_prefix
= processing_current_prefix
;
7289 char *new_prefix
= determine_prefix (parent
, cu
);
7292 processing_current_prefix
= new_prefix
;
7293 retval
= determine_class_name (parent
, cu
);
7294 processing_current_prefix
= old_prefix
;
7301 return determine_prefix (parent
, cu
);
7306 /* Return a newly-allocated string formed by concatenating PREFIX and
7307 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7308 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7309 perform an obconcat, otherwise allocate storage for the result. The CU argument
7310 is used to determine the language and hence, the appropriate separator. */
7312 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7315 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7316 struct dwarf2_cu
*cu
)
7320 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7322 else if (cu
->language
== language_java
)
7329 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7334 strcpy (retval
, prefix
);
7335 strcat (retval
, sep
);
7338 strcat (retval
, suffix
);
7344 /* We have an obstack. */
7345 return obconcat (obs
, prefix
, sep
, suffix
);
7349 static struct type
*
7350 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7352 struct objfile
*objfile
= cu
->objfile
;
7354 /* FIXME - this should not produce a new (struct type *)
7355 every time. It should cache base types. */
7359 case DW_ATE_address
:
7360 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7362 case DW_ATE_boolean
:
7363 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7365 case DW_ATE_complex_float
:
7368 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7372 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7378 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7382 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7389 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7392 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7396 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7400 case DW_ATE_signed_char
:
7401 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7403 case DW_ATE_unsigned
:
7407 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7410 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7414 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7418 case DW_ATE_unsigned_char
:
7419 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7422 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7429 copy_die (struct die_info
*old_die
)
7431 struct die_info
*new_die
;
7434 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7435 memset (new_die
, 0, sizeof (struct die_info
));
7437 new_die
->tag
= old_die
->tag
;
7438 new_die
->has_children
= old_die
->has_children
;
7439 new_die
->abbrev
= old_die
->abbrev
;
7440 new_die
->offset
= old_die
->offset
;
7441 new_die
->type
= NULL
;
7443 num_attrs
= old_die
->num_attrs
;
7444 new_die
->num_attrs
= num_attrs
;
7445 new_die
->attrs
= (struct attribute
*)
7446 xmalloc (num_attrs
* sizeof (struct attribute
));
7448 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7450 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7451 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7452 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7455 new_die
->next
= NULL
;
7460 /* Return sibling of die, NULL if no sibling. */
7462 static struct die_info
*
7463 sibling_die (struct die_info
*die
)
7465 return die
->sibling
;
7468 /* Get linkage name of a die, return NULL if not found. */
7471 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7473 struct attribute
*attr
;
7475 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7476 if (attr
&& DW_STRING (attr
))
7477 return DW_STRING (attr
);
7478 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7479 if (attr
&& DW_STRING (attr
))
7480 return DW_STRING (attr
);
7484 /* Get name of a die, return NULL if not found. */
7487 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7489 struct attribute
*attr
;
7491 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7492 if (attr
&& DW_STRING (attr
))
7493 return DW_STRING (attr
);
7497 /* Return the die that this die in an extension of, or NULL if there
7500 static struct die_info
*
7501 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7503 struct attribute
*attr
;
7505 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7509 return follow_die_ref (die
, attr
, cu
);
7512 /* Convert a DIE tag into its string name. */
7515 dwarf_tag_name (unsigned tag
)
7519 case DW_TAG_padding
:
7520 return "DW_TAG_padding";
7521 case DW_TAG_array_type
:
7522 return "DW_TAG_array_type";
7523 case DW_TAG_class_type
:
7524 return "DW_TAG_class_type";
7525 case DW_TAG_entry_point
:
7526 return "DW_TAG_entry_point";
7527 case DW_TAG_enumeration_type
:
7528 return "DW_TAG_enumeration_type";
7529 case DW_TAG_formal_parameter
:
7530 return "DW_TAG_formal_parameter";
7531 case DW_TAG_imported_declaration
:
7532 return "DW_TAG_imported_declaration";
7534 return "DW_TAG_label";
7535 case DW_TAG_lexical_block
:
7536 return "DW_TAG_lexical_block";
7538 return "DW_TAG_member";
7539 case DW_TAG_pointer_type
:
7540 return "DW_TAG_pointer_type";
7541 case DW_TAG_reference_type
:
7542 return "DW_TAG_reference_type";
7543 case DW_TAG_compile_unit
:
7544 return "DW_TAG_compile_unit";
7545 case DW_TAG_string_type
:
7546 return "DW_TAG_string_type";
7547 case DW_TAG_structure_type
:
7548 return "DW_TAG_structure_type";
7549 case DW_TAG_subroutine_type
:
7550 return "DW_TAG_subroutine_type";
7551 case DW_TAG_typedef
:
7552 return "DW_TAG_typedef";
7553 case DW_TAG_union_type
:
7554 return "DW_TAG_union_type";
7555 case DW_TAG_unspecified_parameters
:
7556 return "DW_TAG_unspecified_parameters";
7557 case DW_TAG_variant
:
7558 return "DW_TAG_variant";
7559 case DW_TAG_common_block
:
7560 return "DW_TAG_common_block";
7561 case DW_TAG_common_inclusion
:
7562 return "DW_TAG_common_inclusion";
7563 case DW_TAG_inheritance
:
7564 return "DW_TAG_inheritance";
7565 case DW_TAG_inlined_subroutine
:
7566 return "DW_TAG_inlined_subroutine";
7568 return "DW_TAG_module";
7569 case DW_TAG_ptr_to_member_type
:
7570 return "DW_TAG_ptr_to_member_type";
7571 case DW_TAG_set_type
:
7572 return "DW_TAG_set_type";
7573 case DW_TAG_subrange_type
:
7574 return "DW_TAG_subrange_type";
7575 case DW_TAG_with_stmt
:
7576 return "DW_TAG_with_stmt";
7577 case DW_TAG_access_declaration
:
7578 return "DW_TAG_access_declaration";
7579 case DW_TAG_base_type
:
7580 return "DW_TAG_base_type";
7581 case DW_TAG_catch_block
:
7582 return "DW_TAG_catch_block";
7583 case DW_TAG_const_type
:
7584 return "DW_TAG_const_type";
7585 case DW_TAG_constant
:
7586 return "DW_TAG_constant";
7587 case DW_TAG_enumerator
:
7588 return "DW_TAG_enumerator";
7589 case DW_TAG_file_type
:
7590 return "DW_TAG_file_type";
7592 return "DW_TAG_friend";
7593 case DW_TAG_namelist
:
7594 return "DW_TAG_namelist";
7595 case DW_TAG_namelist_item
:
7596 return "DW_TAG_namelist_item";
7597 case DW_TAG_packed_type
:
7598 return "DW_TAG_packed_type";
7599 case DW_TAG_subprogram
:
7600 return "DW_TAG_subprogram";
7601 case DW_TAG_template_type_param
:
7602 return "DW_TAG_template_type_param";
7603 case DW_TAG_template_value_param
:
7604 return "DW_TAG_template_value_param";
7605 case DW_TAG_thrown_type
:
7606 return "DW_TAG_thrown_type";
7607 case DW_TAG_try_block
:
7608 return "DW_TAG_try_block";
7609 case DW_TAG_variant_part
:
7610 return "DW_TAG_variant_part";
7611 case DW_TAG_variable
:
7612 return "DW_TAG_variable";
7613 case DW_TAG_volatile_type
:
7614 return "DW_TAG_volatile_type";
7615 case DW_TAG_dwarf_procedure
:
7616 return "DW_TAG_dwarf_procedure";
7617 case DW_TAG_restrict_type
:
7618 return "DW_TAG_restrict_type";
7619 case DW_TAG_interface_type
:
7620 return "DW_TAG_interface_type";
7621 case DW_TAG_namespace
:
7622 return "DW_TAG_namespace";
7623 case DW_TAG_imported_module
:
7624 return "DW_TAG_imported_module";
7625 case DW_TAG_unspecified_type
:
7626 return "DW_TAG_unspecified_type";
7627 case DW_TAG_partial_unit
:
7628 return "DW_TAG_partial_unit";
7629 case DW_TAG_imported_unit
:
7630 return "DW_TAG_imported_unit";
7631 case DW_TAG_MIPS_loop
:
7632 return "DW_TAG_MIPS_loop";
7633 case DW_TAG_format_label
:
7634 return "DW_TAG_format_label";
7635 case DW_TAG_function_template
:
7636 return "DW_TAG_function_template";
7637 case DW_TAG_class_template
:
7638 return "DW_TAG_class_template";
7640 return "DW_TAG_<unknown>";
7644 /* Convert a DWARF attribute code into its string name. */
7647 dwarf_attr_name (unsigned attr
)
7652 return "DW_AT_sibling";
7653 case DW_AT_location
:
7654 return "DW_AT_location";
7656 return "DW_AT_name";
7657 case DW_AT_ordering
:
7658 return "DW_AT_ordering";
7659 case DW_AT_subscr_data
:
7660 return "DW_AT_subscr_data";
7661 case DW_AT_byte_size
:
7662 return "DW_AT_byte_size";
7663 case DW_AT_bit_offset
:
7664 return "DW_AT_bit_offset";
7665 case DW_AT_bit_size
:
7666 return "DW_AT_bit_size";
7667 case DW_AT_element_list
:
7668 return "DW_AT_element_list";
7669 case DW_AT_stmt_list
:
7670 return "DW_AT_stmt_list";
7672 return "DW_AT_low_pc";
7674 return "DW_AT_high_pc";
7675 case DW_AT_language
:
7676 return "DW_AT_language";
7678 return "DW_AT_member";
7680 return "DW_AT_discr";
7681 case DW_AT_discr_value
:
7682 return "DW_AT_discr_value";
7683 case DW_AT_visibility
:
7684 return "DW_AT_visibility";
7686 return "DW_AT_import";
7687 case DW_AT_string_length
:
7688 return "DW_AT_string_length";
7689 case DW_AT_common_reference
:
7690 return "DW_AT_common_reference";
7691 case DW_AT_comp_dir
:
7692 return "DW_AT_comp_dir";
7693 case DW_AT_const_value
:
7694 return "DW_AT_const_value";
7695 case DW_AT_containing_type
:
7696 return "DW_AT_containing_type";
7697 case DW_AT_default_value
:
7698 return "DW_AT_default_value";
7700 return "DW_AT_inline";
7701 case DW_AT_is_optional
:
7702 return "DW_AT_is_optional";
7703 case DW_AT_lower_bound
:
7704 return "DW_AT_lower_bound";
7705 case DW_AT_producer
:
7706 return "DW_AT_producer";
7707 case DW_AT_prototyped
:
7708 return "DW_AT_prototyped";
7709 case DW_AT_return_addr
:
7710 return "DW_AT_return_addr";
7711 case DW_AT_start_scope
:
7712 return "DW_AT_start_scope";
7713 case DW_AT_stride_size
:
7714 return "DW_AT_stride_size";
7715 case DW_AT_upper_bound
:
7716 return "DW_AT_upper_bound";
7717 case DW_AT_abstract_origin
:
7718 return "DW_AT_abstract_origin";
7719 case DW_AT_accessibility
:
7720 return "DW_AT_accessibility";
7721 case DW_AT_address_class
:
7722 return "DW_AT_address_class";
7723 case DW_AT_artificial
:
7724 return "DW_AT_artificial";
7725 case DW_AT_base_types
:
7726 return "DW_AT_base_types";
7727 case DW_AT_calling_convention
:
7728 return "DW_AT_calling_convention";
7730 return "DW_AT_count";
7731 case DW_AT_data_member_location
:
7732 return "DW_AT_data_member_location";
7733 case DW_AT_decl_column
:
7734 return "DW_AT_decl_column";
7735 case DW_AT_decl_file
:
7736 return "DW_AT_decl_file";
7737 case DW_AT_decl_line
:
7738 return "DW_AT_decl_line";
7739 case DW_AT_declaration
:
7740 return "DW_AT_declaration";
7741 case DW_AT_discr_list
:
7742 return "DW_AT_discr_list";
7743 case DW_AT_encoding
:
7744 return "DW_AT_encoding";
7745 case DW_AT_external
:
7746 return "DW_AT_external";
7747 case DW_AT_frame_base
:
7748 return "DW_AT_frame_base";
7750 return "DW_AT_friend";
7751 case DW_AT_identifier_case
:
7752 return "DW_AT_identifier_case";
7753 case DW_AT_macro_info
:
7754 return "DW_AT_macro_info";
7755 case DW_AT_namelist_items
:
7756 return "DW_AT_namelist_items";
7757 case DW_AT_priority
:
7758 return "DW_AT_priority";
7760 return "DW_AT_segment";
7761 case DW_AT_specification
:
7762 return "DW_AT_specification";
7763 case DW_AT_static_link
:
7764 return "DW_AT_static_link";
7766 return "DW_AT_type";
7767 case DW_AT_use_location
:
7768 return "DW_AT_use_location";
7769 case DW_AT_variable_parameter
:
7770 return "DW_AT_variable_parameter";
7771 case DW_AT_virtuality
:
7772 return "DW_AT_virtuality";
7773 case DW_AT_vtable_elem_location
:
7774 return "DW_AT_vtable_elem_location";
7775 case DW_AT_allocated
:
7776 return "DW_AT_allocated";
7777 case DW_AT_associated
:
7778 return "DW_AT_associated";
7779 case DW_AT_data_location
:
7780 return "DW_AT_data_location";
7782 return "DW_AT_stride";
7783 case DW_AT_entry_pc
:
7784 return "DW_AT_entry_pc";
7785 case DW_AT_use_UTF8
:
7786 return "DW_AT_use_UTF8";
7787 case DW_AT_extension
:
7788 return "DW_AT_extension";
7790 return "DW_AT_ranges";
7791 case DW_AT_trampoline
:
7792 return "DW_AT_trampoline";
7793 case DW_AT_call_column
:
7794 return "DW_AT_call_column";
7795 case DW_AT_call_file
:
7796 return "DW_AT_call_file";
7797 case DW_AT_call_line
:
7798 return "DW_AT_call_line";
7800 case DW_AT_MIPS_fde
:
7801 return "DW_AT_MIPS_fde";
7802 case DW_AT_MIPS_loop_begin
:
7803 return "DW_AT_MIPS_loop_begin";
7804 case DW_AT_MIPS_tail_loop_begin
:
7805 return "DW_AT_MIPS_tail_loop_begin";
7806 case DW_AT_MIPS_epilog_begin
:
7807 return "DW_AT_MIPS_epilog_begin";
7808 case DW_AT_MIPS_loop_unroll_factor
:
7809 return "DW_AT_MIPS_loop_unroll_factor";
7810 case DW_AT_MIPS_software_pipeline_depth
:
7811 return "DW_AT_MIPS_software_pipeline_depth";
7813 case DW_AT_MIPS_linkage_name
:
7814 return "DW_AT_MIPS_linkage_name";
7816 case DW_AT_sf_names
:
7817 return "DW_AT_sf_names";
7818 case DW_AT_src_info
:
7819 return "DW_AT_src_info";
7820 case DW_AT_mac_info
:
7821 return "DW_AT_mac_info";
7822 case DW_AT_src_coords
:
7823 return "DW_AT_src_coords";
7824 case DW_AT_body_begin
:
7825 return "DW_AT_body_begin";
7826 case DW_AT_body_end
:
7827 return "DW_AT_body_end";
7828 case DW_AT_GNU_vector
:
7829 return "DW_AT_GNU_vector";
7831 return "DW_AT_<unknown>";
7835 /* Convert a DWARF value form code into its string name. */
7838 dwarf_form_name (unsigned form
)
7843 return "DW_FORM_addr";
7844 case DW_FORM_block2
:
7845 return "DW_FORM_block2";
7846 case DW_FORM_block4
:
7847 return "DW_FORM_block4";
7849 return "DW_FORM_data2";
7851 return "DW_FORM_data4";
7853 return "DW_FORM_data8";
7854 case DW_FORM_string
:
7855 return "DW_FORM_string";
7857 return "DW_FORM_block";
7858 case DW_FORM_block1
:
7859 return "DW_FORM_block1";
7861 return "DW_FORM_data1";
7863 return "DW_FORM_flag";
7865 return "DW_FORM_sdata";
7867 return "DW_FORM_strp";
7869 return "DW_FORM_udata";
7870 case DW_FORM_ref_addr
:
7871 return "DW_FORM_ref_addr";
7873 return "DW_FORM_ref1";
7875 return "DW_FORM_ref2";
7877 return "DW_FORM_ref4";
7879 return "DW_FORM_ref8";
7880 case DW_FORM_ref_udata
:
7881 return "DW_FORM_ref_udata";
7882 case DW_FORM_indirect
:
7883 return "DW_FORM_indirect";
7885 return "DW_FORM_<unknown>";
7889 /* Convert a DWARF stack opcode into its string name. */
7892 dwarf_stack_op_name (unsigned op
)
7897 return "DW_OP_addr";
7899 return "DW_OP_deref";
7901 return "DW_OP_const1u";
7903 return "DW_OP_const1s";
7905 return "DW_OP_const2u";
7907 return "DW_OP_const2s";
7909 return "DW_OP_const4u";
7911 return "DW_OP_const4s";
7913 return "DW_OP_const8u";
7915 return "DW_OP_const8s";
7917 return "DW_OP_constu";
7919 return "DW_OP_consts";
7923 return "DW_OP_drop";
7925 return "DW_OP_over";
7927 return "DW_OP_pick";
7929 return "DW_OP_swap";
7933 return "DW_OP_xderef";
7941 return "DW_OP_minus";
7953 return "DW_OP_plus";
7954 case DW_OP_plus_uconst
:
7955 return "DW_OP_plus_uconst";
7961 return "DW_OP_shra";
7979 return "DW_OP_skip";
7981 return "DW_OP_lit0";
7983 return "DW_OP_lit1";
7985 return "DW_OP_lit2";
7987 return "DW_OP_lit3";
7989 return "DW_OP_lit4";
7991 return "DW_OP_lit5";
7993 return "DW_OP_lit6";
7995 return "DW_OP_lit7";
7997 return "DW_OP_lit8";
7999 return "DW_OP_lit9";
8001 return "DW_OP_lit10";
8003 return "DW_OP_lit11";
8005 return "DW_OP_lit12";
8007 return "DW_OP_lit13";
8009 return "DW_OP_lit14";
8011 return "DW_OP_lit15";
8013 return "DW_OP_lit16";
8015 return "DW_OP_lit17";
8017 return "DW_OP_lit18";
8019 return "DW_OP_lit19";
8021 return "DW_OP_lit20";
8023 return "DW_OP_lit21";
8025 return "DW_OP_lit22";
8027 return "DW_OP_lit23";
8029 return "DW_OP_lit24";
8031 return "DW_OP_lit25";
8033 return "DW_OP_lit26";
8035 return "DW_OP_lit27";
8037 return "DW_OP_lit28";
8039 return "DW_OP_lit29";
8041 return "DW_OP_lit30";
8043 return "DW_OP_lit31";
8045 return "DW_OP_reg0";
8047 return "DW_OP_reg1";
8049 return "DW_OP_reg2";
8051 return "DW_OP_reg3";
8053 return "DW_OP_reg4";
8055 return "DW_OP_reg5";
8057 return "DW_OP_reg6";
8059 return "DW_OP_reg7";
8061 return "DW_OP_reg8";
8063 return "DW_OP_reg9";
8065 return "DW_OP_reg10";
8067 return "DW_OP_reg11";
8069 return "DW_OP_reg12";
8071 return "DW_OP_reg13";
8073 return "DW_OP_reg14";
8075 return "DW_OP_reg15";
8077 return "DW_OP_reg16";
8079 return "DW_OP_reg17";
8081 return "DW_OP_reg18";
8083 return "DW_OP_reg19";
8085 return "DW_OP_reg20";
8087 return "DW_OP_reg21";
8089 return "DW_OP_reg22";
8091 return "DW_OP_reg23";
8093 return "DW_OP_reg24";
8095 return "DW_OP_reg25";
8097 return "DW_OP_reg26";
8099 return "DW_OP_reg27";
8101 return "DW_OP_reg28";
8103 return "DW_OP_reg29";
8105 return "DW_OP_reg30";
8107 return "DW_OP_reg31";
8109 return "DW_OP_breg0";
8111 return "DW_OP_breg1";
8113 return "DW_OP_breg2";
8115 return "DW_OP_breg3";
8117 return "DW_OP_breg4";
8119 return "DW_OP_breg5";
8121 return "DW_OP_breg6";
8123 return "DW_OP_breg7";
8125 return "DW_OP_breg8";
8127 return "DW_OP_breg9";
8129 return "DW_OP_breg10";
8131 return "DW_OP_breg11";
8133 return "DW_OP_breg12";
8135 return "DW_OP_breg13";
8137 return "DW_OP_breg14";
8139 return "DW_OP_breg15";
8141 return "DW_OP_breg16";
8143 return "DW_OP_breg17";
8145 return "DW_OP_breg18";
8147 return "DW_OP_breg19";
8149 return "DW_OP_breg20";
8151 return "DW_OP_breg21";
8153 return "DW_OP_breg22";
8155 return "DW_OP_breg23";
8157 return "DW_OP_breg24";
8159 return "DW_OP_breg25";
8161 return "DW_OP_breg26";
8163 return "DW_OP_breg27";
8165 return "DW_OP_breg28";
8167 return "DW_OP_breg29";
8169 return "DW_OP_breg30";
8171 return "DW_OP_breg31";
8173 return "DW_OP_regx";
8175 return "DW_OP_fbreg";
8177 return "DW_OP_bregx";
8179 return "DW_OP_piece";
8180 case DW_OP_deref_size
:
8181 return "DW_OP_deref_size";
8182 case DW_OP_xderef_size
:
8183 return "DW_OP_xderef_size";
8186 /* DWARF 3 extensions. */
8187 case DW_OP_push_object_address
:
8188 return "DW_OP_push_object_address";
8190 return "DW_OP_call2";
8192 return "DW_OP_call4";
8193 case DW_OP_call_ref
:
8194 return "DW_OP_call_ref";
8195 /* GNU extensions. */
8196 case DW_OP_GNU_push_tls_address
:
8197 return "DW_OP_GNU_push_tls_address";
8199 return "OP_<unknown>";
8204 dwarf_bool_name (unsigned mybool
)
8212 /* Convert a DWARF type code into its string name. */
8215 dwarf_type_encoding_name (unsigned enc
)
8219 case DW_ATE_address
:
8220 return "DW_ATE_address";
8221 case DW_ATE_boolean
:
8222 return "DW_ATE_boolean";
8223 case DW_ATE_complex_float
:
8224 return "DW_ATE_complex_float";
8226 return "DW_ATE_float";
8228 return "DW_ATE_signed";
8229 case DW_ATE_signed_char
:
8230 return "DW_ATE_signed_char";
8231 case DW_ATE_unsigned
:
8232 return "DW_ATE_unsigned";
8233 case DW_ATE_unsigned_char
:
8234 return "DW_ATE_unsigned_char";
8235 case DW_ATE_imaginary_float
:
8236 return "DW_ATE_imaginary_float";
8238 return "DW_ATE_<unknown>";
8242 /* Convert a DWARF call frame info operation to its string name. */
8246 dwarf_cfi_name (unsigned cfi_opc
)
8250 case DW_CFA_advance_loc
:
8251 return "DW_CFA_advance_loc";
8253 return "DW_CFA_offset";
8254 case DW_CFA_restore
:
8255 return "DW_CFA_restore";
8257 return "DW_CFA_nop";
8258 case DW_CFA_set_loc
:
8259 return "DW_CFA_set_loc";
8260 case DW_CFA_advance_loc1
:
8261 return "DW_CFA_advance_loc1";
8262 case DW_CFA_advance_loc2
:
8263 return "DW_CFA_advance_loc2";
8264 case DW_CFA_advance_loc4
:
8265 return "DW_CFA_advance_loc4";
8266 case DW_CFA_offset_extended
:
8267 return "DW_CFA_offset_extended";
8268 case DW_CFA_restore_extended
:
8269 return "DW_CFA_restore_extended";
8270 case DW_CFA_undefined
:
8271 return "DW_CFA_undefined";
8272 case DW_CFA_same_value
:
8273 return "DW_CFA_same_value";
8274 case DW_CFA_register
:
8275 return "DW_CFA_register";
8276 case DW_CFA_remember_state
:
8277 return "DW_CFA_remember_state";
8278 case DW_CFA_restore_state
:
8279 return "DW_CFA_restore_state";
8280 case DW_CFA_def_cfa
:
8281 return "DW_CFA_def_cfa";
8282 case DW_CFA_def_cfa_register
:
8283 return "DW_CFA_def_cfa_register";
8284 case DW_CFA_def_cfa_offset
:
8285 return "DW_CFA_def_cfa_offset";
8288 case DW_CFA_def_cfa_expression
:
8289 return "DW_CFA_def_cfa_expression";
8290 case DW_CFA_expression
:
8291 return "DW_CFA_expression";
8292 case DW_CFA_offset_extended_sf
:
8293 return "DW_CFA_offset_extended_sf";
8294 case DW_CFA_def_cfa_sf
:
8295 return "DW_CFA_def_cfa_sf";
8296 case DW_CFA_def_cfa_offset_sf
:
8297 return "DW_CFA_def_cfa_offset_sf";
8299 /* SGI/MIPS specific */
8300 case DW_CFA_MIPS_advance_loc8
:
8301 return "DW_CFA_MIPS_advance_loc8";
8303 /* GNU extensions */
8304 case DW_CFA_GNU_window_save
:
8305 return "DW_CFA_GNU_window_save";
8306 case DW_CFA_GNU_args_size
:
8307 return "DW_CFA_GNU_args_size";
8308 case DW_CFA_GNU_negative_offset_extended
:
8309 return "DW_CFA_GNU_negative_offset_extended";
8312 return "DW_CFA_<unknown>";
8318 dump_die (struct die_info
*die
)
8322 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8323 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8324 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8325 dwarf_bool_name (die
->child
!= NULL
));
8327 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8328 for (i
= 0; i
< die
->num_attrs
; ++i
)
8330 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8331 dwarf_attr_name (die
->attrs
[i
].name
),
8332 dwarf_form_name (die
->attrs
[i
].form
));
8333 switch (die
->attrs
[i
].form
)
8335 case DW_FORM_ref_addr
:
8337 fprintf_unfiltered (gdb_stderr
, "address: ");
8338 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8340 case DW_FORM_block2
:
8341 case DW_FORM_block4
:
8343 case DW_FORM_block1
:
8344 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8349 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8350 (long) (DW_ADDR (&die
->attrs
[i
])));
8358 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8360 case DW_FORM_string
:
8362 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8363 DW_STRING (&die
->attrs
[i
])
8364 ? DW_STRING (&die
->attrs
[i
]) : "");
8367 if (DW_UNSND (&die
->attrs
[i
]))
8368 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8370 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8372 case DW_FORM_indirect
:
8373 /* the reader will have reduced the indirect form to
8374 the "base form" so this form should not occur */
8375 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8378 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8379 die
->attrs
[i
].form
);
8381 fprintf_unfiltered (gdb_stderr
, "\n");
8386 dump_die_list (struct die_info
*die
)
8391 if (die
->child
!= NULL
)
8392 dump_die_list (die
->child
);
8393 if (die
->sibling
!= NULL
)
8394 dump_die_list (die
->sibling
);
8399 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8400 struct dwarf2_cu
*cu
)
8403 struct die_info
*old
;
8405 h
= (offset
% REF_HASH_SIZE
);
8406 old
= cu
->die_ref_table
[h
];
8407 die
->next_ref
= old
;
8408 cu
->die_ref_table
[h
] = die
;
8412 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8414 unsigned int result
= 0;
8418 case DW_FORM_ref_addr
:
8423 case DW_FORM_ref_udata
:
8424 result
= DW_ADDR (attr
);
8427 complaint (&symfile_complaints
,
8428 _("unsupported die ref attribute form: '%s'"),
8429 dwarf_form_name (attr
->form
));
8434 /* Return the constant value held by the given attribute. Return -1
8435 if the value held by the attribute is not constant. */
8438 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8440 if (attr
->form
== DW_FORM_sdata
)
8441 return DW_SND (attr
);
8442 else if (attr
->form
== DW_FORM_udata
8443 || attr
->form
== DW_FORM_data1
8444 || attr
->form
== DW_FORM_data2
8445 || attr
->form
== DW_FORM_data4
8446 || attr
->form
== DW_FORM_data8
)
8447 return DW_UNSND (attr
);
8450 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8451 dwarf_form_name (attr
->form
));
8452 return default_value
;
8456 static struct die_info
*
8457 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8458 struct dwarf2_cu
*cu
)
8460 struct die_info
*die
;
8461 unsigned int offset
;
8463 struct die_info temp_die
;
8464 struct dwarf2_cu
*target_cu
;
8466 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8468 if (DW_ADDR (attr
) < cu
->header
.offset
8469 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8471 struct dwarf2_per_cu_data
*per_cu
;
8472 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8474 target_cu
= per_cu
->cu
;
8479 h
= (offset
% REF_HASH_SIZE
);
8480 die
= target_cu
->die_ref_table
[h
];
8483 if (die
->offset
== offset
)
8485 die
= die
->next_ref
;
8488 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8489 "at 0x%lx [in module %s]"),
8490 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8495 static struct type
*
8496 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8497 struct dwarf2_cu
*cu
)
8499 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8501 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8502 typeid, objfile
->name
);
8505 /* Look for this particular type in the fundamental type vector. If
8506 one is not found, create and install one appropriate for the
8507 current language and the current target machine. */
8509 if (cu
->ftypes
[typeid] == NULL
)
8511 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8514 return (cu
->ftypes
[typeid]);
8517 /* Decode simple location descriptions.
8518 Given a pointer to a dwarf block that defines a location, compute
8519 the location and return the value.
8521 NOTE drow/2003-11-18: This function is called in two situations
8522 now: for the address of static or global variables (partial symbols
8523 only) and for offsets into structures which are expected to be
8524 (more or less) constant. The partial symbol case should go away,
8525 and only the constant case should remain. That will let this
8526 function complain more accurately. A few special modes are allowed
8527 without complaint for global variables (for instance, global
8528 register values and thread-local values).
8530 A location description containing no operations indicates that the
8531 object is optimized out. The return value is 0 for that case.
8532 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8533 callers will only want a very basic result and this can become a
8536 When the result is a register number, the global isreg flag is set,
8537 otherwise it is cleared.
8539 Note that stack[0] is unused except as a default error return.
8540 Note that stack overflow is not yet handled. */
8543 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8545 struct objfile
*objfile
= cu
->objfile
;
8546 struct comp_unit_head
*cu_header
= &cu
->header
;
8548 int size
= blk
->size
;
8549 char *data
= blk
->data
;
8550 CORE_ADDR stack
[64];
8552 unsigned int bytes_read
, unsnd
;
8597 stack
[++stacki
] = op
- DW_OP_lit0
;
8633 stack
[++stacki
] = op
- DW_OP_reg0
;
8635 dwarf2_complex_location_expr_complaint ();
8640 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8642 stack
[++stacki
] = unsnd
;
8644 dwarf2_complex_location_expr_complaint ();
8648 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8654 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8659 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8664 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8669 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8674 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8679 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8684 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8690 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8695 stack
[stacki
+ 1] = stack
[stacki
];
8700 stack
[stacki
- 1] += stack
[stacki
];
8704 case DW_OP_plus_uconst
:
8705 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8710 stack
[stacki
- 1] -= stack
[stacki
];
8715 /* If we're not the last op, then we definitely can't encode
8716 this using GDB's address_class enum. This is valid for partial
8717 global symbols, although the variable's address will be bogus
8720 dwarf2_complex_location_expr_complaint ();
8723 case DW_OP_GNU_push_tls_address
:
8724 /* The top of the stack has the offset from the beginning
8725 of the thread control block at which the variable is located. */
8726 /* Nothing should follow this operator, so the top of stack would
8728 /* This is valid for partial global symbols, but the variable's
8729 address will be bogus in the psymtab. */
8731 dwarf2_complex_location_expr_complaint ();
8735 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8736 dwarf_stack_op_name (op
));
8737 return (stack
[stacki
]);
8740 return (stack
[stacki
]);
8743 /* memory allocation interface */
8745 static struct dwarf_block
*
8746 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8748 struct dwarf_block
*blk
;
8750 blk
= (struct dwarf_block
*)
8751 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8755 static struct abbrev_info
*
8756 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8758 struct abbrev_info
*abbrev
;
8760 abbrev
= (struct abbrev_info
*)
8761 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8762 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8766 static struct die_info
*
8767 dwarf_alloc_die (void)
8769 struct die_info
*die
;
8771 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8772 memset (die
, 0, sizeof (struct die_info
));
8777 /* Macro support. */
8780 /* Return the full name of file number I in *LH's file name table.
8781 Use COMP_DIR as the name of the current directory of the
8782 compilation. The result is allocated using xmalloc; the caller is
8783 responsible for freeing it. */
8785 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8787 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8789 if (IS_ABSOLUTE_PATH (fe
->name
))
8790 return xstrdup (fe
->name
);
8798 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8804 dir_len
= strlen (dir
);
8805 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8806 strcpy (full_name
, dir
);
8807 full_name
[dir_len
] = '/';
8808 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8812 return xstrdup (fe
->name
);
8817 static struct macro_source_file
*
8818 macro_start_file (int file
, int line
,
8819 struct macro_source_file
*current_file
,
8820 const char *comp_dir
,
8821 struct line_header
*lh
, struct objfile
*objfile
)
8823 /* The full name of this source file. */
8824 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8826 /* We don't create a macro table for this compilation unit
8827 at all until we actually get a filename. */
8828 if (! pending_macros
)
8829 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8830 objfile
->macro_cache
);
8833 /* If we have no current file, then this must be the start_file
8834 directive for the compilation unit's main source file. */
8835 current_file
= macro_set_main (pending_macros
, full_name
);
8837 current_file
= macro_include (current_file
, line
, full_name
);
8841 return current_file
;
8845 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8846 followed by a null byte. */
8848 copy_string (const char *buf
, int len
)
8850 char *s
= xmalloc (len
+ 1);
8851 memcpy (s
, buf
, len
);
8859 consume_improper_spaces (const char *p
, const char *body
)
8863 complaint (&symfile_complaints
,
8864 _("macro definition contains spaces in formal argument list:\n`%s'"),
8876 parse_macro_definition (struct macro_source_file
*file
, int line
,
8881 /* The body string takes one of two forms. For object-like macro
8882 definitions, it should be:
8884 <macro name> " " <definition>
8886 For function-like macro definitions, it should be:
8888 <macro name> "() " <definition>
8890 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8892 Spaces may appear only where explicitly indicated, and in the
8895 The Dwarf 2 spec says that an object-like macro's name is always
8896 followed by a space, but versions of GCC around March 2002 omit
8897 the space when the macro's definition is the empty string.
8899 The Dwarf 2 spec says that there should be no spaces between the
8900 formal arguments in a function-like macro's formal argument list,
8901 but versions of GCC around March 2002 include spaces after the
8905 /* Find the extent of the macro name. The macro name is terminated
8906 by either a space or null character (for an object-like macro) or
8907 an opening paren (for a function-like macro). */
8908 for (p
= body
; *p
; p
++)
8909 if (*p
== ' ' || *p
== '(')
8912 if (*p
== ' ' || *p
== '\0')
8914 /* It's an object-like macro. */
8915 int name_len
= p
- body
;
8916 char *name
= copy_string (body
, name_len
);
8917 const char *replacement
;
8920 replacement
= body
+ name_len
+ 1;
8923 dwarf2_macro_malformed_definition_complaint (body
);
8924 replacement
= body
+ name_len
;
8927 macro_define_object (file
, line
, name
, replacement
);
8933 /* It's a function-like macro. */
8934 char *name
= copy_string (body
, p
- body
);
8937 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
8941 p
= consume_improper_spaces (p
, body
);
8943 /* Parse the formal argument list. */
8944 while (*p
&& *p
!= ')')
8946 /* Find the extent of the current argument name. */
8947 const char *arg_start
= p
;
8949 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
8952 if (! *p
|| p
== arg_start
)
8953 dwarf2_macro_malformed_definition_complaint (body
);
8956 /* Make sure argv has room for the new argument. */
8957 if (argc
>= argv_size
)
8960 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
8963 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
8966 p
= consume_improper_spaces (p
, body
);
8968 /* Consume the comma, if present. */
8973 p
= consume_improper_spaces (p
, body
);
8982 /* Perfectly formed definition, no complaints. */
8983 macro_define_function (file
, line
, name
,
8984 argc
, (const char **) argv
,
8986 else if (*p
== '\0')
8988 /* Complain, but do define it. */
8989 dwarf2_macro_malformed_definition_complaint (body
);
8990 macro_define_function (file
, line
, name
,
8991 argc
, (const char **) argv
,
8995 /* Just complain. */
8996 dwarf2_macro_malformed_definition_complaint (body
);
8999 /* Just complain. */
9000 dwarf2_macro_malformed_definition_complaint (body
);
9006 for (i
= 0; i
< argc
; i
++)
9012 dwarf2_macro_malformed_definition_complaint (body
);
9017 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9018 char *comp_dir
, bfd
*abfd
,
9019 struct dwarf2_cu
*cu
)
9021 char *mac_ptr
, *mac_end
;
9022 struct macro_source_file
*current_file
= 0;
9024 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9026 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9030 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9031 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9032 + dwarf2_per_objfile
->macinfo_size
;
9036 enum dwarf_macinfo_record_type macinfo_type
;
9038 /* Do we at least have room for a macinfo type byte? */
9039 if (mac_ptr
>= mac_end
)
9041 dwarf2_macros_too_long_complaint ();
9045 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9048 switch (macinfo_type
)
9050 /* A zero macinfo type indicates the end of the macro
9055 case DW_MACINFO_define
:
9056 case DW_MACINFO_undef
:
9062 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9063 mac_ptr
+= bytes_read
;
9064 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9065 mac_ptr
+= bytes_read
;
9068 complaint (&symfile_complaints
,
9069 _("debug info gives macro %s outside of any file: %s"),
9071 DW_MACINFO_define
? "definition" : macinfo_type
==
9072 DW_MACINFO_undef
? "undefinition" :
9073 "something-or-other", body
);
9076 if (macinfo_type
== DW_MACINFO_define
)
9077 parse_macro_definition (current_file
, line
, body
);
9078 else if (macinfo_type
== DW_MACINFO_undef
)
9079 macro_undef (current_file
, line
, body
);
9084 case DW_MACINFO_start_file
:
9089 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9090 mac_ptr
+= bytes_read
;
9091 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9092 mac_ptr
+= bytes_read
;
9094 current_file
= macro_start_file (file
, line
,
9095 current_file
, comp_dir
,
9100 case DW_MACINFO_end_file
:
9102 complaint (&symfile_complaints
,
9103 _("macro debug info has an unmatched `close_file' directive"));
9106 current_file
= current_file
->included_by
;
9109 enum dwarf_macinfo_record_type next_type
;
9111 /* GCC circa March 2002 doesn't produce the zero
9112 type byte marking the end of the compilation
9113 unit. Complain if it's not there, but exit no
9116 /* Do we at least have room for a macinfo type byte? */
9117 if (mac_ptr
>= mac_end
)
9119 dwarf2_macros_too_long_complaint ();
9123 /* We don't increment mac_ptr here, so this is just
9125 next_type
= read_1_byte (abfd
, mac_ptr
);
9127 complaint (&symfile_complaints
,
9128 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9135 case DW_MACINFO_vendor_ext
:
9141 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9142 mac_ptr
+= bytes_read
;
9143 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9144 mac_ptr
+= bytes_read
;
9146 /* We don't recognize any vendor extensions. */
9153 /* Check if the attribute's form is a DW_FORM_block*
9154 if so return true else false. */
9156 attr_form_is_block (struct attribute
*attr
)
9158 return (attr
== NULL
? 0 :
9159 attr
->form
== DW_FORM_block1
9160 || attr
->form
== DW_FORM_block2
9161 || attr
->form
== DW_FORM_block4
9162 || attr
->form
== DW_FORM_block
);
9166 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9167 struct dwarf2_cu
*cu
)
9169 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9171 struct dwarf2_loclist_baton
*baton
;
9173 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9174 sizeof (struct dwarf2_loclist_baton
));
9175 baton
->objfile
= cu
->objfile
;
9177 /* We don't know how long the location list is, but make sure we
9178 don't run off the edge of the section. */
9179 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9180 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9181 baton
->base_address
= cu
->header
.base_address
;
9182 if (cu
->header
.base_known
== 0)
9183 complaint (&symfile_complaints
,
9184 _("Location list used without specifying the CU base address."));
9186 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9187 SYMBOL_LOCATION_BATON (sym
) = baton
;
9191 struct dwarf2_locexpr_baton
*baton
;
9193 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9194 sizeof (struct dwarf2_locexpr_baton
));
9195 baton
->objfile
= cu
->objfile
;
9197 if (attr_form_is_block (attr
))
9199 /* Note that we're just copying the block's data pointer
9200 here, not the actual data. We're still pointing into the
9201 info_buffer for SYM's objfile; right now we never release
9202 that buffer, but when we do clean up properly this may
9204 baton
->size
= DW_BLOCK (attr
)->size
;
9205 baton
->data
= DW_BLOCK (attr
)->data
;
9209 dwarf2_invalid_attrib_class_complaint ("location description",
9210 SYMBOL_NATURAL_NAME (sym
));
9215 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9216 SYMBOL_LOCATION_BATON (sym
) = baton
;
9220 /* Locate the compilation unit from CU's objfile which contains the
9221 DIE at OFFSET. Raises an error on failure. */
9223 static struct dwarf2_per_cu_data
*
9224 dwarf2_find_containing_comp_unit (unsigned long offset
,
9225 struct objfile
*objfile
)
9227 struct dwarf2_per_cu_data
*this_cu
;
9231 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9234 int mid
= low
+ (high
- low
) / 2;
9235 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9240 gdb_assert (low
== high
);
9241 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9244 error (_("Dwarf Error: could not find partial DIE containing "
9245 "offset 0x%lx [in module %s]"),
9246 (long) offset
, bfd_get_filename (objfile
->obfd
));
9248 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9249 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9253 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9254 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9255 && offset
>= this_cu
->offset
+ this_cu
->length
)
9256 error (_("invalid dwarf2 offset %ld"), offset
);
9257 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9262 /* Locate the compilation unit from OBJFILE which is located at exactly
9263 OFFSET. Raises an error on failure. */
9265 static struct dwarf2_per_cu_data
*
9266 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9268 struct dwarf2_per_cu_data
*this_cu
;
9269 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9270 if (this_cu
->offset
!= offset
)
9271 error (_("no compilation unit with offset %ld."), offset
);
9275 /* Release one cached compilation unit, CU. We unlink it from the tree
9276 of compilation units, but we don't remove it from the read_in_chain;
9277 the caller is responsible for that. */
9280 free_one_comp_unit (void *data
)
9282 struct dwarf2_cu
*cu
= data
;
9284 if (cu
->per_cu
!= NULL
)
9285 cu
->per_cu
->cu
= NULL
;
9288 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9290 free_die_list (cu
->dies
);
9295 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9296 when we're finished with it. We can't free the pointer itself, but be
9297 sure to unlink it from the cache. Also release any associated storage
9298 and perform cache maintenance.
9300 Only used during partial symbol parsing. */
9303 free_stack_comp_unit (void *data
)
9305 struct dwarf2_cu
*cu
= data
;
9307 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9308 cu
->partial_dies
= NULL
;
9310 if (cu
->per_cu
!= NULL
)
9312 /* This compilation unit is on the stack in our caller, so we
9313 should not xfree it. Just unlink it. */
9314 cu
->per_cu
->cu
= NULL
;
9317 /* If we had a per-cu pointer, then we may have other compilation
9318 units loaded, so age them now. */
9319 age_cached_comp_units ();
9323 /* Free all cached compilation units. */
9326 free_cached_comp_units (void *data
)
9328 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9330 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9331 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9332 while (per_cu
!= NULL
)
9334 struct dwarf2_per_cu_data
*next_cu
;
9336 next_cu
= per_cu
->cu
->read_in_chain
;
9338 free_one_comp_unit (per_cu
->cu
);
9339 *last_chain
= next_cu
;
9345 /* Increase the age counter on each cached compilation unit, and free
9346 any that are too old. */
9349 age_cached_comp_units (void)
9351 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9353 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9354 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9355 while (per_cu
!= NULL
)
9357 per_cu
->cu
->last_used
++;
9358 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9359 dwarf2_mark (per_cu
->cu
);
9360 per_cu
= per_cu
->cu
->read_in_chain
;
9363 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9364 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9365 while (per_cu
!= NULL
)
9367 struct dwarf2_per_cu_data
*next_cu
;
9369 next_cu
= per_cu
->cu
->read_in_chain
;
9371 if (!per_cu
->cu
->mark
)
9373 free_one_comp_unit (per_cu
->cu
);
9374 *last_chain
= next_cu
;
9377 last_chain
= &per_cu
->cu
->read_in_chain
;
9383 /* Remove a single compilation unit from the cache. */
9386 free_one_cached_comp_unit (void *target_cu
)
9388 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9390 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9391 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9392 while (per_cu
!= NULL
)
9394 struct dwarf2_per_cu_data
*next_cu
;
9396 next_cu
= per_cu
->cu
->read_in_chain
;
9398 if (per_cu
->cu
== target_cu
)
9400 free_one_comp_unit (per_cu
->cu
);
9401 *last_chain
= next_cu
;
9405 last_chain
= &per_cu
->cu
->read_in_chain
;
9411 /* A pair of DIE offset and GDB type pointer. We store these
9412 in a hash table separate from the DIEs, and preserve them
9413 when the DIEs are flushed out of cache. */
9415 struct dwarf2_offset_and_type
9417 unsigned int offset
;
9421 /* Hash function for a dwarf2_offset_and_type. */
9424 offset_and_type_hash (const void *item
)
9426 const struct dwarf2_offset_and_type
*ofs
= item
;
9430 /* Equality function for a dwarf2_offset_and_type. */
9433 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9435 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9436 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9437 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9440 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9441 table if necessary. */
9444 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9446 struct dwarf2_offset_and_type
**slot
, ofs
;
9450 if (cu
->per_cu
== NULL
)
9453 if (cu
->per_cu
->type_hash
== NULL
)
9454 cu
->per_cu
->type_hash
9455 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9456 offset_and_type_hash
,
9459 &cu
->objfile
->objfile_obstack
,
9460 hashtab_obstack_allocate
,
9461 dummy_obstack_deallocate
);
9463 ofs
.offset
= die
->offset
;
9465 slot
= (struct dwarf2_offset_and_type
**)
9466 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9467 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9471 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9472 have a saved type. */
9474 static struct type
*
9475 get_die_type (struct die_info
*die
, htab_t type_hash
)
9477 struct dwarf2_offset_and_type
*slot
, ofs
;
9479 ofs
.offset
= die
->offset
;
9480 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9487 /* Restore the types of the DIE tree starting at START_DIE from the hash
9488 table saved in CU. */
9491 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9493 struct die_info
*die
;
9495 if (cu
->per_cu
->type_hash
== NULL
)
9498 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9500 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9501 if (die
->child
!= NULL
)
9502 reset_die_and_siblings_types (die
->child
, cu
);
9506 /* Set the mark field in CU and in every other compilation unit in the
9507 cache that we must keep because we are keeping CU. */
9509 /* Add a dependence relationship from CU to REF_PER_CU. */
9512 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9513 struct dwarf2_per_cu_data
*ref_per_cu
)
9517 if (cu
->dependencies
== NULL
)
9519 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9520 NULL
, &cu
->comp_unit_obstack
,
9521 hashtab_obstack_allocate
,
9522 dummy_obstack_deallocate
);
9524 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9529 /* Set the mark field in CU and in every other compilation unit in the
9530 cache that we must keep because we are keeping CU. */
9533 dwarf2_mark_helper (void **slot
, void *data
)
9535 struct dwarf2_per_cu_data
*per_cu
;
9537 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9538 if (per_cu
->cu
->mark
)
9540 per_cu
->cu
->mark
= 1;
9542 if (per_cu
->cu
->dependencies
!= NULL
)
9543 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9549 dwarf2_mark (struct dwarf2_cu
*cu
)
9554 if (cu
->dependencies
!= NULL
)
9555 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9559 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9563 per_cu
->cu
->mark
= 0;
9564 per_cu
= per_cu
->cu
->read_in_chain
;
9568 /* Allocation function for the libiberty hash table which uses an
9572 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
9574 unsigned int total
= size
* count
;
9575 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
9576 memset (ptr
, 0, total
);
9580 /* Trivial deallocation function for the libiberty splay tree and hash
9581 table - don't deallocate anything. Rely on later deletion of the
9585 dummy_obstack_deallocate (void *object
, void *data
)
9590 /* Trivial hash function for partial_die_info: the hash value of a DIE
9591 is its offset in .debug_info for this objfile. */
9594 partial_die_hash (const void *item
)
9596 const struct partial_die_info
*part_die
= item
;
9597 return part_die
->offset
;
9600 /* Trivial comparison function for partial_die_info structures: two DIEs
9601 are equal if they have the same offset. */
9604 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9606 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9607 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9608 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9611 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9612 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9615 set_dwarf2_cmd (char *args
, int from_tty
)
9617 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9621 show_dwarf2_cmd (char *args
, int from_tty
)
9623 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9626 void _initialize_dwarf2_read (void);
9629 _initialize_dwarf2_read (void)
9631 dwarf2_objfile_data_key
= register_objfile_data ();
9633 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
,
9634 "Set DWARF 2 specific variables.\n"
9635 "Configure DWARF 2 variables such as the cache size",
9636 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9637 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9639 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
,
9640 "Show DWARF 2 specific variables\n"
9641 "Show DWARF 2 variables such as the cache size",
9642 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9643 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9645 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9646 &dwarf2_max_cache_age
,
9647 "Set the upper bound on the age of cached "
9648 "dwarf2 compilation units.",
9649 "Show the upper bound on the age of cached "
9650 "dwarf2 compilation units.",
9651 "A higher limit means that cached "
9652 "compilation units will be stored\n"
9653 "in memory longer, and more total memory will "
9654 "be used. Zero disables\n"
9655 "caching, which can slow down startup.",
9656 NULL
, /* PRINT: The upper bound on the age of cached dwarf2 compilation units is %d. */
9657 NULL
, NULL
, &set_dwarf2_cmdlist
,
9658 &show_dwarf2_cmdlist
);