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 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
664 struct cmd_list_element
*c
, const char *value
)
666 fprintf_filtered (file
, _("\
667 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
672 /* Various complaints about symbol reading that don't abort the process */
675 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
677 complaint (&symfile_complaints
,
678 _("statement list doesn't fit in .debug_line section"));
682 dwarf2_complex_location_expr_complaint (void)
684 complaint (&symfile_complaints
, _("location expression too complex"));
688 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
691 complaint (&symfile_complaints
,
692 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
697 dwarf2_macros_too_long_complaint (void)
699 complaint (&symfile_complaints
,
700 _("macro info runs off end of `.debug_macinfo' section"));
704 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
706 complaint (&symfile_complaints
,
707 _("macro debug info contains a malformed macro definition:\n`%s'"),
712 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
714 complaint (&symfile_complaints
,
715 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
718 /* local function prototypes */
720 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
723 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
726 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
729 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
730 struct partial_die_info
*,
731 struct partial_symtab
*);
733 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
735 static void scan_partial_symbols (struct partial_die_info
*,
736 CORE_ADDR
*, CORE_ADDR
*,
739 static void add_partial_symbol (struct partial_die_info
*,
742 static int pdi_needs_namespace (enum dwarf_tag tag
);
744 static void add_partial_namespace (struct partial_die_info
*pdi
,
745 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
746 struct dwarf2_cu
*cu
);
748 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
749 struct dwarf2_cu
*cu
);
751 static char *locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
754 struct dwarf2_cu
*cu
);
756 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
758 static void psymtab_to_symtab_1 (struct partial_symtab
*);
760 char *dwarf2_read_section (struct objfile
*, asection
*);
762 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
764 static void dwarf2_free_abbrev_table (void *);
766 static struct abbrev_info
*peek_die_abbrev (char *, int *, struct dwarf2_cu
*);
768 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
771 static struct partial_die_info
*load_partial_dies (bfd
*, char *, int,
774 static char *read_partial_die (struct partial_die_info
*,
775 struct abbrev_info
*abbrev
, unsigned int,
776 bfd
*, char *, struct dwarf2_cu
*);
778 static struct partial_die_info
*find_partial_die (unsigned long,
781 static void fixup_partial_die (struct partial_die_info
*,
784 static char *read_full_die (struct die_info
**, bfd
*, char *,
785 struct dwarf2_cu
*, int *);
787 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
788 bfd
*, char *, struct dwarf2_cu
*);
790 static char *read_attribute_value (struct attribute
*, unsigned,
791 bfd
*, char *, struct dwarf2_cu
*);
793 static unsigned int read_1_byte (bfd
*, char *);
795 static int read_1_signed_byte (bfd
*, char *);
797 static unsigned int read_2_bytes (bfd
*, char *);
799 static unsigned int read_4_bytes (bfd
*, char *);
801 static unsigned long read_8_bytes (bfd
*, char *);
803 static CORE_ADDR
read_address (bfd
*, char *ptr
, struct dwarf2_cu
*,
806 static LONGEST
read_initial_length (bfd
*, char *,
807 struct comp_unit_head
*, int *bytes_read
);
809 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
812 static char *read_n_bytes (bfd
*, char *, unsigned int);
814 static char *read_string (bfd
*, char *, unsigned int *);
816 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
819 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
821 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
823 static char *skip_leb128 (bfd
*, char *);
825 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
827 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
830 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
831 struct dwarf2_cu
*cu
);
833 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
835 static struct die_info
*die_specification (struct die_info
*die
,
838 static void free_line_header (struct line_header
*lh
);
840 static void add_file_name (struct line_header
*, char *, unsigned int,
841 unsigned int, unsigned int);
843 static struct line_header
*(dwarf_decode_line_header
844 (unsigned int offset
,
845 bfd
*abfd
, struct dwarf2_cu
*cu
));
847 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
848 struct dwarf2_cu
*, struct partial_symtab
*);
850 static void dwarf2_start_subfile (char *, char *);
852 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
855 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
858 static void dwarf2_const_value_data (struct attribute
*attr
,
862 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
864 static struct type
*die_containing_type (struct die_info
*,
867 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
869 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
871 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
873 static char *typename_concat (struct obstack
*, const char *prefix
, const char *suffix
,
876 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
878 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
880 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
882 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
884 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
886 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
888 static int dwarf2_get_pc_bounds (struct die_info
*,
889 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
891 static void get_scope_pc_bounds (struct die_info
*,
892 CORE_ADDR
*, CORE_ADDR
*,
895 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
898 static void dwarf2_attach_fields_to_type (struct field_info
*,
899 struct type
*, struct dwarf2_cu
*);
901 static void dwarf2_add_member_fn (struct field_info
*,
902 struct die_info
*, struct type
*,
905 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
906 struct type
*, struct dwarf2_cu
*);
908 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
910 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
912 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
914 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
916 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
918 static const char *namespace_name (struct die_info
*die
,
919 int *is_anonymous
, struct dwarf2_cu
*);
921 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
923 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
925 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
927 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
929 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
931 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
934 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
936 static void read_tag_ptr_to_member_type (struct die_info
*,
939 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
941 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
943 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
945 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
947 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
949 static struct die_info
*read_comp_unit (char *, bfd
*, struct dwarf2_cu
*);
951 static struct die_info
*read_die_and_children (char *info_ptr
, bfd
*abfd
,
954 struct die_info
*parent
);
956 static struct die_info
*read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
959 struct die_info
*parent
);
961 static void free_die_list (struct die_info
*);
963 static void process_die (struct die_info
*, struct dwarf2_cu
*);
965 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
967 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
969 static struct die_info
*dwarf2_extension (struct die_info
*die
,
972 static char *dwarf_tag_name (unsigned int);
974 static char *dwarf_attr_name (unsigned int);
976 static char *dwarf_form_name (unsigned int);
978 static char *dwarf_stack_op_name (unsigned int);
980 static char *dwarf_bool_name (unsigned int);
982 static char *dwarf_type_encoding_name (unsigned int);
985 static char *dwarf_cfi_name (unsigned int);
987 struct die_info
*copy_die (struct die_info
*);
990 static struct die_info
*sibling_die (struct die_info
*);
992 static void dump_die (struct die_info
*);
994 static void dump_die_list (struct die_info
*);
996 static void store_in_ref_table (unsigned int, struct die_info
*,
999 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
1000 struct dwarf2_cu
*);
1002 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
1004 static struct die_info
*follow_die_ref (struct die_info
*,
1006 struct dwarf2_cu
*);
1008 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
1009 struct dwarf2_cu
*);
1011 /* memory allocation interface */
1013 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1015 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1017 static struct die_info
*dwarf_alloc_die (void);
1019 static void initialize_cu_func_list (struct dwarf2_cu
*);
1021 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1022 struct dwarf2_cu
*);
1024 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1025 char *, bfd
*, struct dwarf2_cu
*);
1027 static int attr_form_is_block (struct attribute
*);
1030 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
1031 struct dwarf2_cu
*cu
);
1033 static char *skip_one_die (char *info_ptr
, struct abbrev_info
*abbrev
,
1034 struct dwarf2_cu
*cu
);
1036 static void free_stack_comp_unit (void *);
1038 static void *hashtab_obstack_allocate (void *data
, size_t size
, size_t count
);
1040 static void dummy_obstack_deallocate (void *object
, void *data
);
1042 static hashval_t
partial_die_hash (const void *item
);
1044 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1046 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1047 (unsigned long offset
, struct objfile
*objfile
);
1049 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1050 (unsigned long offset
, struct objfile
*objfile
);
1052 static void free_one_comp_unit (void *);
1054 static void free_cached_comp_units (void *);
1056 static void age_cached_comp_units (void);
1058 static void free_one_cached_comp_unit (void *);
1060 static void set_die_type (struct die_info
*, struct type
*,
1061 struct dwarf2_cu
*);
1063 static void reset_die_and_siblings_types (struct die_info
*,
1064 struct dwarf2_cu
*);
1066 static void create_all_comp_units (struct objfile
*);
1068 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*);
1070 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1072 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1073 struct dwarf2_per_cu_data
*);
1075 static void dwarf2_mark (struct dwarf2_cu
*);
1077 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1079 /* Try to locate the sections we need for DWARF 2 debugging
1080 information and return true if we have enough to do something. */
1083 dwarf2_has_info (struct objfile
*objfile
)
1085 struct dwarf2_per_objfile
*data
;
1087 /* Initialize per-objfile state. */
1088 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1089 memset (data
, 0, sizeof (*data
));
1090 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1091 dwarf2_per_objfile
= data
;
1093 dwarf_info_section
= 0;
1094 dwarf_abbrev_section
= 0;
1095 dwarf_line_section
= 0;
1096 dwarf_str_section
= 0;
1097 dwarf_macinfo_section
= 0;
1098 dwarf_frame_section
= 0;
1099 dwarf_eh_frame_section
= 0;
1100 dwarf_ranges_section
= 0;
1101 dwarf_loc_section
= 0;
1103 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1104 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1107 /* This function is mapped across the sections and remembers the
1108 offset and size of each of the debugging sections we are interested
1112 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
1114 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1116 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1117 dwarf_info_section
= sectp
;
1119 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1121 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1122 dwarf_abbrev_section
= sectp
;
1124 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1126 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1127 dwarf_line_section
= sectp
;
1129 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1131 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1132 dwarf_pubnames_section
= sectp
;
1134 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1136 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1137 dwarf_aranges_section
= sectp
;
1139 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1141 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1142 dwarf_loc_section
= sectp
;
1144 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1146 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1147 dwarf_macinfo_section
= sectp
;
1149 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1151 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1152 dwarf_str_section
= sectp
;
1154 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1156 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1157 dwarf_frame_section
= sectp
;
1159 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1161 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1162 if (aflag
& SEC_HAS_CONTENTS
)
1164 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1165 dwarf_eh_frame_section
= sectp
;
1168 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1170 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1171 dwarf_ranges_section
= sectp
;
1175 /* Build a partial symbol table. */
1178 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1180 /* We definitely need the .debug_info and .debug_abbrev sections */
1182 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1183 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1185 if (dwarf_line_section
)
1186 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1188 dwarf2_per_objfile
->line_buffer
= NULL
;
1190 if (dwarf_str_section
)
1191 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1193 dwarf2_per_objfile
->str_buffer
= NULL
;
1195 if (dwarf_macinfo_section
)
1196 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1197 dwarf_macinfo_section
);
1199 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1201 if (dwarf_ranges_section
)
1202 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1204 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1206 if (dwarf_loc_section
)
1207 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1209 dwarf2_per_objfile
->loc_buffer
= NULL
;
1212 || (objfile
->global_psymbols
.size
== 0
1213 && objfile
->static_psymbols
.size
== 0))
1215 init_psymbol_list (objfile
, 1024);
1219 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1221 /* Things are significantly easier if we have .debug_aranges and
1222 .debug_pubnames sections */
1224 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1228 /* only test this case for now */
1230 /* In this case we have to work a bit harder */
1231 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1236 /* Build the partial symbol table from the information in the
1237 .debug_pubnames and .debug_aranges sections. */
1240 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1242 bfd
*abfd
= objfile
->obfd
;
1243 char *aranges_buffer
, *pubnames_buffer
;
1244 char *aranges_ptr
, *pubnames_ptr
;
1245 unsigned int entry_length
, version
, info_offset
, info_size
;
1247 pubnames_buffer
= dwarf2_read_section (objfile
,
1248 dwarf_pubnames_section
);
1249 pubnames_ptr
= pubnames_buffer
;
1250 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1252 struct comp_unit_head cu_header
;
1255 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1257 pubnames_ptr
+= bytes_read
;
1258 version
= read_1_byte (abfd
, pubnames_ptr
);
1260 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1262 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1266 aranges_buffer
= dwarf2_read_section (objfile
,
1267 dwarf_aranges_section
);
1272 /* Read in the comp unit header information from the debug_info at
1276 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1277 char *info_ptr
, bfd
*abfd
)
1281 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1283 info_ptr
+= bytes_read
;
1284 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1286 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1288 info_ptr
+= bytes_read
;
1289 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1291 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1292 if (signed_addr
< 0)
1293 internal_error (__FILE__
, __LINE__
,
1294 _("read_comp_unit_head: dwarf from non elf file"));
1295 cu_header
->signed_addr_p
= signed_addr
;
1300 partial_read_comp_unit_head (struct comp_unit_head
*header
, char *info_ptr
,
1303 char *beg_of_comp_unit
= info_ptr
;
1305 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1307 if (header
->version
!= 2)
1308 error (_("Dwarf Error: wrong version in compilation unit header "
1309 "(is %d, should be %d) [in module %s]"), header
->version
,
1310 2, bfd_get_filename (abfd
));
1312 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1313 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1314 "(offset 0x%lx + 6) [in module %s]"),
1315 (long) header
->abbrev_offset
,
1316 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1317 bfd_get_filename (abfd
));
1319 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1320 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1321 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1322 "(offset 0x%lx + 0) [in module %s]"),
1323 (long) header
->length
,
1324 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1325 bfd_get_filename (abfd
));
1330 /* Allocate a new partial symtab for file named NAME and mark this new
1331 partial symtab as being an include of PST. */
1334 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1335 struct objfile
*objfile
)
1337 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1339 subpst
->section_offsets
= pst
->section_offsets
;
1340 subpst
->textlow
= 0;
1341 subpst
->texthigh
= 0;
1343 subpst
->dependencies
= (struct partial_symtab
**)
1344 obstack_alloc (&objfile
->objfile_obstack
,
1345 sizeof (struct partial_symtab
*));
1346 subpst
->dependencies
[0] = pst
;
1347 subpst
->number_of_dependencies
= 1;
1349 subpst
->globals_offset
= 0;
1350 subpst
->n_global_syms
= 0;
1351 subpst
->statics_offset
= 0;
1352 subpst
->n_static_syms
= 0;
1353 subpst
->symtab
= NULL
;
1354 subpst
->read_symtab
= pst
->read_symtab
;
1357 /* No private part is necessary for include psymtabs. This property
1358 can be used to differentiate between such include psymtabs and
1359 the regular ones. */
1360 subpst
->read_symtab_private
= NULL
;
1363 /* Read the Line Number Program data and extract the list of files
1364 included by the source file represented by PST. Build an include
1365 partial symtab for each of these included files.
1367 This procedure assumes that there *is* a Line Number Program in
1368 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1369 before calling this procedure. */
1372 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1373 struct partial_die_info
*pdi
,
1374 struct partial_symtab
*pst
)
1376 struct objfile
*objfile
= cu
->objfile
;
1377 bfd
*abfd
= objfile
->obfd
;
1378 struct line_header
*lh
;
1380 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1382 return; /* No linetable, so no includes. */
1384 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1386 free_line_header (lh
);
1390 /* Build the partial symbol table by doing a quick pass through the
1391 .debug_info and .debug_abbrev sections. */
1394 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1396 /* Instead of reading this into a big buffer, we should probably use
1397 mmap() on architectures that support it. (FIXME) */
1398 bfd
*abfd
= objfile
->obfd
;
1400 char *beg_of_comp_unit
;
1401 struct partial_die_info comp_unit_die
;
1402 struct partial_symtab
*pst
;
1403 struct cleanup
*back_to
;
1404 CORE_ADDR lowpc
, highpc
, baseaddr
;
1406 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1408 /* Any cached compilation units will be linked by the per-objfile
1409 read_in_chain. Make sure to free them when we're done. */
1410 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1412 create_all_comp_units (objfile
);
1414 /* Since the objects we're extracting from .debug_info vary in
1415 length, only the individual functions to extract them (like
1416 read_comp_unit_head and load_partial_die) can really know whether
1417 the buffer is large enough to hold another complete object.
1419 At the moment, they don't actually check that. If .debug_info
1420 holds just one extra byte after the last compilation unit's dies,
1421 then read_comp_unit_head will happily read off the end of the
1422 buffer. read_partial_die is similarly casual. Those functions
1425 For this loop condition, simply checking whether there's any data
1426 left at all should be sufficient. */
1427 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1428 + dwarf2_per_objfile
->info_size
))
1430 struct cleanup
*back_to_inner
;
1431 struct dwarf2_cu cu
;
1432 struct abbrev_info
*abbrev
;
1433 unsigned int bytes_read
;
1434 struct dwarf2_per_cu_data
*this_cu
;
1436 beg_of_comp_unit
= info_ptr
;
1438 memset (&cu
, 0, sizeof (cu
));
1440 obstack_init (&cu
.comp_unit_obstack
);
1442 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1444 cu
.objfile
= objfile
;
1445 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1447 /* Complete the cu_header */
1448 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1449 cu
.header
.first_die_ptr
= info_ptr
;
1450 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1452 cu
.list_in_scope
= &file_symbols
;
1454 /* Read the abbrevs for this compilation unit into a table */
1455 dwarf2_read_abbrevs (abfd
, &cu
);
1456 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1458 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1460 /* Read the compilation unit die */
1461 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1462 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1463 abfd
, info_ptr
, &cu
);
1465 /* Set the language we're debugging */
1466 set_cu_language (comp_unit_die
.language
, &cu
);
1468 /* Allocate a new partial symbol table structure */
1469 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1470 comp_unit_die
.name
? comp_unit_die
.name
: "",
1471 comp_unit_die
.lowpc
,
1472 objfile
->global_psymbols
.next
,
1473 objfile
->static_psymbols
.next
);
1475 if (comp_unit_die
.dirname
)
1476 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1478 pst
->read_symtab_private
= (char *) this_cu
;
1480 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1482 /* Store the function that reads in the rest of the symbol table */
1483 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1485 /* If this compilation unit was already read in, free the
1486 cached copy in order to read it in again. This is
1487 necessary because we skipped some symbols when we first
1488 read in the compilation unit (see load_partial_dies).
1489 This problem could be avoided, but the benefit is
1491 if (this_cu
->cu
!= NULL
)
1492 free_one_cached_comp_unit (this_cu
->cu
);
1494 cu
.per_cu
= this_cu
;
1496 /* Note that this is a pointer to our stack frame, being
1497 added to a global data structure. It will be cleaned up
1498 in free_stack_comp_unit when we finish with this
1499 compilation unit. */
1502 this_cu
->psymtab
= pst
;
1504 /* Check if comp unit has_children.
1505 If so, read the rest of the partial symbols from this comp unit.
1506 If not, there's no more debug_info for this comp unit. */
1507 if (comp_unit_die
.has_children
)
1509 struct partial_die_info
*first_die
;
1511 lowpc
= ((CORE_ADDR
) -1);
1512 highpc
= ((CORE_ADDR
) 0);
1514 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1516 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1518 /* If we didn't find a lowpc, set it to highpc to avoid
1519 complaints from `maint check'. */
1520 if (lowpc
== ((CORE_ADDR
) -1))
1523 /* If the compilation unit didn't have an explicit address range,
1524 then use the information extracted from its child dies. */
1525 if (! comp_unit_die
.has_pc_info
)
1527 comp_unit_die
.lowpc
= lowpc
;
1528 comp_unit_die
.highpc
= highpc
;
1531 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1532 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1534 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1535 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1536 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1537 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1538 sort_pst_symbols (pst
);
1540 /* If there is already a psymtab or symtab for a file of this
1541 name, remove it. (If there is a symtab, more drastic things
1542 also happen.) This happens in VxWorks. */
1543 free_named_symtabs (pst
->filename
);
1545 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1546 + cu
.header
.initial_length_size
;
1548 if (comp_unit_die
.has_stmt_list
)
1550 /* Get the list of files included in the current compilation unit,
1551 and build a psymtab for each of them. */
1552 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1555 do_cleanups (back_to_inner
);
1557 do_cleanups (back_to
);
1560 /* Load the DIEs for a secondary CU into memory. */
1563 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1565 bfd
*abfd
= objfile
->obfd
;
1566 char *info_ptr
, *beg_of_comp_unit
;
1567 struct partial_die_info comp_unit_die
;
1568 struct dwarf2_cu
*cu
;
1569 struct abbrev_info
*abbrev
;
1570 unsigned int bytes_read
;
1571 struct cleanup
*back_to
;
1573 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1574 beg_of_comp_unit
= info_ptr
;
1576 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1577 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1579 obstack_init (&cu
->comp_unit_obstack
);
1581 cu
->objfile
= objfile
;
1582 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1584 /* Complete the cu_header. */
1585 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1586 cu
->header
.first_die_ptr
= info_ptr
;
1587 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1589 /* Read the abbrevs for this compilation unit into a table. */
1590 dwarf2_read_abbrevs (abfd
, cu
);
1591 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1593 /* Read the compilation unit die. */
1594 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1595 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1596 abfd
, info_ptr
, cu
);
1598 /* Set the language we're debugging. */
1599 set_cu_language (comp_unit_die
.language
, cu
);
1601 /* Link this compilation unit into the compilation unit tree. */
1603 cu
->per_cu
= this_cu
;
1605 /* Check if comp unit has_children.
1606 If so, read the rest of the partial symbols from this comp unit.
1607 If not, there's no more debug_info for this comp unit. */
1608 if (comp_unit_die
.has_children
)
1609 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1611 do_cleanups (back_to
);
1614 /* Create a list of all compilation units in OBJFILE. We do this only
1615 if an inter-comp-unit reference is found; presumably if there is one,
1616 there will be many, and one will occur early in the .debug_info section.
1617 So there's no point in building this list incrementally. */
1620 create_all_comp_units (struct objfile
*objfile
)
1624 struct dwarf2_per_cu_data
**all_comp_units
;
1625 char *info_ptr
= dwarf2_per_objfile
->info_buffer
;
1629 all_comp_units
= xmalloc (n_allocated
1630 * sizeof (struct dwarf2_per_cu_data
*));
1632 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1634 struct comp_unit_head cu_header
;
1635 char *beg_of_comp_unit
;
1636 struct dwarf2_per_cu_data
*this_cu
;
1637 unsigned long offset
;
1640 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1642 /* Read just enough information to find out where the next
1643 compilation unit is. */
1644 cu_header
.initial_length_size
= 0;
1645 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1646 &cu_header
, &bytes_read
);
1648 /* Save the compilation unit for later lookup. */
1649 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1650 sizeof (struct dwarf2_per_cu_data
));
1651 memset (this_cu
, 0, sizeof (*this_cu
));
1652 this_cu
->offset
= offset
;
1653 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1655 if (n_comp_units
== n_allocated
)
1658 all_comp_units
= xrealloc (all_comp_units
,
1660 * sizeof (struct dwarf2_per_cu_data
*));
1662 all_comp_units
[n_comp_units
++] = this_cu
;
1664 info_ptr
= info_ptr
+ this_cu
->length
;
1667 dwarf2_per_objfile
->all_comp_units
1668 = obstack_alloc (&objfile
->objfile_obstack
,
1669 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1670 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1671 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1672 xfree (all_comp_units
);
1673 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1676 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1677 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1681 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1682 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1684 struct objfile
*objfile
= cu
->objfile
;
1685 bfd
*abfd
= objfile
->obfd
;
1686 struct partial_die_info
*pdi
;
1688 /* Now, march along the PDI's, descending into ones which have
1689 interesting children but skipping the children of the other ones,
1690 until we reach the end of the compilation unit. */
1696 fixup_partial_die (pdi
, cu
);
1698 /* Anonymous namespaces have no name but have interesting
1699 children, so we need to look at them. Ditto for anonymous
1702 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1703 || pdi
->tag
== DW_TAG_enumeration_type
)
1707 case DW_TAG_subprogram
:
1708 if (pdi
->has_pc_info
)
1710 if (pdi
->lowpc
< *lowpc
)
1712 *lowpc
= pdi
->lowpc
;
1714 if (pdi
->highpc
> *highpc
)
1716 *highpc
= pdi
->highpc
;
1718 if (!pdi
->is_declaration
)
1720 add_partial_symbol (pdi
, cu
);
1724 case DW_TAG_variable
:
1725 case DW_TAG_typedef
:
1726 case DW_TAG_union_type
:
1727 if (!pdi
->is_declaration
)
1729 add_partial_symbol (pdi
, cu
);
1732 case DW_TAG_class_type
:
1733 case DW_TAG_structure_type
:
1734 if (!pdi
->is_declaration
)
1736 add_partial_symbol (pdi
, cu
);
1739 case DW_TAG_enumeration_type
:
1740 if (!pdi
->is_declaration
)
1741 add_partial_enumeration (pdi
, cu
);
1743 case DW_TAG_base_type
:
1744 case DW_TAG_subrange_type
:
1745 /* File scope base type definitions are added to the partial
1747 add_partial_symbol (pdi
, cu
);
1749 case DW_TAG_namespace
:
1750 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1757 /* If the die has a sibling, skip to the sibling. */
1759 pdi
= pdi
->die_sibling
;
1763 /* Functions used to compute the fully scoped name of a partial DIE.
1765 Normally, this is simple. For C++, the parent DIE's fully scoped
1766 name is concatenated with "::" and the partial DIE's name. For
1767 Java, the same thing occurs except that "." is used instead of "::".
1768 Enumerators are an exception; they use the scope of their parent
1769 enumeration type, i.e. the name of the enumeration type is not
1770 prepended to the enumerator.
1772 There are two complexities. One is DW_AT_specification; in this
1773 case "parent" means the parent of the target of the specification,
1774 instead of the direct parent of the DIE. The other is compilers
1775 which do not emit DW_TAG_namespace; in this case we try to guess
1776 the fully qualified name of structure types from their members'
1777 linkage names. This must be done using the DIE's children rather
1778 than the children of any DW_AT_specification target. We only need
1779 to do this for structures at the top level, i.e. if the target of
1780 any DW_AT_specification (if any; otherwise the DIE itself) does not
1783 /* Compute the scope prefix associated with PDI's parent, in
1784 compilation unit CU. The result will be allocated on CU's
1785 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1786 field. NULL is returned if no prefix is necessary. */
1788 partial_die_parent_scope (struct partial_die_info
*pdi
,
1789 struct dwarf2_cu
*cu
)
1791 char *grandparent_scope
;
1792 struct partial_die_info
*parent
, *real_pdi
;
1794 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1795 then this means the parent of the specification DIE. */
1798 while (real_pdi
->has_specification
)
1799 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1801 parent
= real_pdi
->die_parent
;
1805 if (parent
->scope_set
)
1806 return parent
->scope
;
1808 fixup_partial_die (parent
, cu
);
1810 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1812 if (parent
->tag
== DW_TAG_namespace
1813 || parent
->tag
== DW_TAG_structure_type
1814 || parent
->tag
== DW_TAG_class_type
1815 || parent
->tag
== DW_TAG_union_type
)
1817 if (grandparent_scope
== NULL
)
1818 parent
->scope
= parent
->name
;
1820 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1823 else if (parent
->tag
== DW_TAG_enumeration_type
)
1824 /* Enumerators should not get the name of the enumeration as a prefix. */
1825 parent
->scope
= grandparent_scope
;
1828 /* FIXME drow/2004-04-01: What should we be doing with
1829 function-local names? For partial symbols, we should probably be
1831 complaint (&symfile_complaints
,
1832 _("unhandled containing DIE tag %d for DIE at %d"),
1833 parent
->tag
, pdi
->offset
);
1834 parent
->scope
= grandparent_scope
;
1837 parent
->scope_set
= 1;
1838 return parent
->scope
;
1841 /* Return the fully scoped name associated with PDI, from compilation unit
1842 CU. The result will be allocated with malloc. */
1844 partial_die_full_name (struct partial_die_info
*pdi
,
1845 struct dwarf2_cu
*cu
)
1849 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1850 if (parent_scope
== NULL
)
1853 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1857 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1859 struct objfile
*objfile
= cu
->objfile
;
1862 const char *my_prefix
;
1863 const struct partial_symbol
*psym
= NULL
;
1865 int built_actual_name
= 0;
1867 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1871 if (pdi_needs_namespace (pdi
->tag
))
1873 actual_name
= partial_die_full_name (pdi
, cu
);
1875 built_actual_name
= 1;
1878 if (actual_name
== NULL
)
1879 actual_name
= pdi
->name
;
1883 case DW_TAG_subprogram
:
1884 if (pdi
->is_external
)
1886 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1887 mst_text, objfile); */
1888 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1889 VAR_DOMAIN
, LOC_BLOCK
,
1890 &objfile
->global_psymbols
,
1891 0, pdi
->lowpc
+ baseaddr
,
1892 cu
->language
, objfile
);
1896 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1897 mst_file_text, objfile); */
1898 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1899 VAR_DOMAIN
, LOC_BLOCK
,
1900 &objfile
->static_psymbols
,
1901 0, pdi
->lowpc
+ baseaddr
,
1902 cu
->language
, objfile
);
1905 case DW_TAG_variable
:
1906 if (pdi
->is_external
)
1909 Don't enter into the minimal symbol tables as there is
1910 a minimal symbol table entry from the ELF symbols already.
1911 Enter into partial symbol table if it has a location
1912 descriptor or a type.
1913 If the location descriptor is missing, new_symbol will create
1914 a LOC_UNRESOLVED symbol, the address of the variable will then
1915 be determined from the minimal symbol table whenever the variable
1917 The address for the partial symbol table entry is not
1918 used by GDB, but it comes in handy for debugging partial symbol
1922 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1923 if (pdi
->locdesc
|| pdi
->has_type
)
1924 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1925 VAR_DOMAIN
, LOC_STATIC
,
1926 &objfile
->global_psymbols
,
1928 cu
->language
, objfile
);
1932 /* Static Variable. Skip symbols without location descriptors. */
1933 if (pdi
->locdesc
== NULL
)
1935 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1936 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1937 mst_file_data, objfile); */
1938 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1939 VAR_DOMAIN
, LOC_STATIC
,
1940 &objfile
->static_psymbols
,
1942 cu
->language
, objfile
);
1945 case DW_TAG_typedef
:
1946 case DW_TAG_base_type
:
1947 case DW_TAG_subrange_type
:
1948 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1949 VAR_DOMAIN
, LOC_TYPEDEF
,
1950 &objfile
->static_psymbols
,
1951 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1953 case DW_TAG_namespace
:
1954 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1955 VAR_DOMAIN
, LOC_TYPEDEF
,
1956 &objfile
->global_psymbols
,
1957 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1959 case DW_TAG_class_type
:
1960 case DW_TAG_structure_type
:
1961 case DW_TAG_union_type
:
1962 case DW_TAG_enumeration_type
:
1963 /* Skip aggregate types without children, these are external
1965 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1966 static vs. global. */
1967 if (pdi
->has_children
== 0)
1969 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1970 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1971 (cu
->language
== language_cplus
1972 || cu
->language
== language_java
)
1973 ? &objfile
->global_psymbols
1974 : &objfile
->static_psymbols
,
1975 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1977 if (cu
->language
== language_cplus
1978 || cu
->language
== language_java
)
1980 /* For C++ and Java, these implicitly act as typedefs as well. */
1981 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1982 VAR_DOMAIN
, LOC_TYPEDEF
,
1983 &objfile
->global_psymbols
,
1984 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1987 case DW_TAG_enumerator
:
1988 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1989 VAR_DOMAIN
, LOC_CONST
,
1990 (cu
->language
== language_cplus
1991 || cu
->language
== language_java
)
1992 ? &objfile
->global_psymbols
1993 : &objfile
->static_psymbols
,
1994 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2000 /* Check to see if we should scan the name for possible namespace
2001 info. Only do this if this is C++, if we don't have namespace
2002 debugging info in the file, if the psym is of an appropriate type
2003 (otherwise we'll have psym == NULL), and if we actually had a
2004 mangled name to begin with. */
2006 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2007 cases which do not set PSYM above? */
2009 if (cu
->language
== language_cplus
2010 && cu
->has_namespace_info
== 0
2012 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2013 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2016 if (built_actual_name
)
2017 xfree (actual_name
);
2020 /* Determine whether a die of type TAG living in a C++ class or
2021 namespace needs to have the name of the scope prepended to the
2022 name listed in the die. */
2025 pdi_needs_namespace (enum dwarf_tag tag
)
2029 case DW_TAG_namespace
:
2030 case DW_TAG_typedef
:
2031 case DW_TAG_class_type
:
2032 case DW_TAG_structure_type
:
2033 case DW_TAG_union_type
:
2034 case DW_TAG_enumeration_type
:
2035 case DW_TAG_enumerator
:
2042 /* Read a partial die corresponding to a namespace; also, add a symbol
2043 corresponding to that namespace to the symbol table. NAMESPACE is
2044 the name of the enclosing namespace. */
2047 add_partial_namespace (struct partial_die_info
*pdi
,
2048 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2049 struct dwarf2_cu
*cu
)
2051 struct objfile
*objfile
= cu
->objfile
;
2053 /* Add a symbol for the namespace. */
2055 add_partial_symbol (pdi
, cu
);
2057 /* Now scan partial symbols in that namespace. */
2059 if (pdi
->has_children
)
2060 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2063 /* See if we can figure out if the class lives in a namespace. We do
2064 this by looking for a member function; its demangled name will
2065 contain namespace info, if there is any. */
2068 guess_structure_name (struct partial_die_info
*struct_pdi
,
2069 struct dwarf2_cu
*cu
)
2071 if ((cu
->language
== language_cplus
2072 || cu
->language
== language_java
)
2073 && cu
->has_namespace_info
== 0
2074 && struct_pdi
->has_children
)
2076 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2077 what template types look like, because the demangler
2078 frequently doesn't give the same name as the debug info. We
2079 could fix this by only using the demangled name to get the
2080 prefix (but see comment in read_structure_type). */
2082 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2083 struct partial_die_info
*real_pdi
;
2085 /* If this DIE (this DIE's specification, if any) has a parent, then
2086 we should not do this. We'll prepend the parent's fully qualified
2087 name when we create the partial symbol. */
2089 real_pdi
= struct_pdi
;
2090 while (real_pdi
->has_specification
)
2091 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2093 if (real_pdi
->die_parent
!= NULL
)
2096 while (child_pdi
!= NULL
)
2098 if (child_pdi
->tag
== DW_TAG_subprogram
)
2100 char *actual_class_name
2101 = language_class_name_from_physname (cu
->language_defn
,
2103 if (actual_class_name
!= NULL
)
2106 = obsavestring (actual_class_name
,
2107 strlen (actual_class_name
),
2108 &cu
->comp_unit_obstack
);
2109 xfree (actual_class_name
);
2114 child_pdi
= child_pdi
->die_sibling
;
2119 /* Read a partial die corresponding to an enumeration type. */
2122 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2123 struct dwarf2_cu
*cu
)
2125 struct objfile
*objfile
= cu
->objfile
;
2126 bfd
*abfd
= objfile
->obfd
;
2127 struct partial_die_info
*pdi
;
2129 if (enum_pdi
->name
!= NULL
)
2130 add_partial_symbol (enum_pdi
, cu
);
2132 pdi
= enum_pdi
->die_child
;
2135 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2136 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2138 add_partial_symbol (pdi
, cu
);
2139 pdi
= pdi
->die_sibling
;
2143 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2144 Return the corresponding abbrev, or NULL if the number is zero (indicating
2145 an empty DIE). In either case *BYTES_READ will be set to the length of
2146 the initial number. */
2148 static struct abbrev_info
*
2149 peek_die_abbrev (char *info_ptr
, int *bytes_read
, struct dwarf2_cu
*cu
)
2151 bfd
*abfd
= cu
->objfile
->obfd
;
2152 unsigned int abbrev_number
;
2153 struct abbrev_info
*abbrev
;
2155 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2157 if (abbrev_number
== 0)
2160 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2163 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2164 bfd_get_filename (abfd
));
2170 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2171 pointer to the end of a series of DIEs, terminated by an empty
2172 DIE. Any children of the skipped DIEs will also be skipped. */
2175 skip_children (char *info_ptr
, struct dwarf2_cu
*cu
)
2177 struct abbrev_info
*abbrev
;
2178 unsigned int bytes_read
;
2182 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2184 return info_ptr
+ bytes_read
;
2186 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2190 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2191 should point just after the initial uleb128 of a DIE, and the
2192 abbrev corresponding to that skipped uleb128 should be passed in
2193 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2197 skip_one_die (char *info_ptr
, struct abbrev_info
*abbrev
,
2198 struct dwarf2_cu
*cu
)
2200 unsigned int bytes_read
;
2201 struct attribute attr
;
2202 bfd
*abfd
= cu
->objfile
->obfd
;
2203 unsigned int form
, i
;
2205 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2207 /* The only abbrev we care about is DW_AT_sibling. */
2208 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2210 read_attribute (&attr
, &abbrev
->attrs
[i
],
2211 abfd
, info_ptr
, cu
);
2212 if (attr
.form
== DW_FORM_ref_addr
)
2213 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2215 return dwarf2_per_objfile
->info_buffer
2216 + dwarf2_get_ref_die_offset (&attr
, cu
);
2219 /* If it isn't DW_AT_sibling, skip this attribute. */
2220 form
= abbrev
->attrs
[i
].form
;
2225 case DW_FORM_ref_addr
:
2226 info_ptr
+= cu
->header
.addr_size
;
2245 case DW_FORM_string
:
2246 read_string (abfd
, info_ptr
, &bytes_read
);
2247 info_ptr
+= bytes_read
;
2250 info_ptr
+= cu
->header
.offset_size
;
2253 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2254 info_ptr
+= bytes_read
;
2256 case DW_FORM_block1
:
2257 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2259 case DW_FORM_block2
:
2260 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2262 case DW_FORM_block4
:
2263 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2267 case DW_FORM_ref_udata
:
2268 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2270 case DW_FORM_indirect
:
2271 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2272 info_ptr
+= bytes_read
;
2273 /* We need to continue parsing from here, so just go back to
2275 goto skip_attribute
;
2278 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2279 dwarf_form_name (form
),
2280 bfd_get_filename (abfd
));
2284 if (abbrev
->has_children
)
2285 return skip_children (info_ptr
, cu
);
2290 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2291 the next DIE after ORIG_PDI. */
2294 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
2295 bfd
*abfd
, struct dwarf2_cu
*cu
)
2297 /* Do we know the sibling already? */
2299 if (orig_pdi
->sibling
)
2300 return orig_pdi
->sibling
;
2302 /* Are there any children to deal with? */
2304 if (!orig_pdi
->has_children
)
2307 /* Skip the children the long way. */
2309 return skip_children (info_ptr
, cu
);
2312 /* Expand this partial symbol table into a full symbol table. */
2315 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2317 /* FIXME: This is barely more than a stub. */
2322 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2328 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2329 gdb_flush (gdb_stdout
);
2332 /* Restore our global data. */
2333 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2334 dwarf2_objfile_data_key
);
2336 psymtab_to_symtab_1 (pst
);
2338 /* Finish up the debug error message. */
2340 printf_filtered (_("done.\n"));
2345 /* Add PER_CU to the queue. */
2348 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2350 struct dwarf2_queue_item
*item
;
2353 item
= xmalloc (sizeof (*item
));
2354 item
->per_cu
= per_cu
;
2357 if (dwarf2_queue
== NULL
)
2358 dwarf2_queue
= item
;
2360 dwarf2_queue_tail
->next
= item
;
2362 dwarf2_queue_tail
= item
;
2365 /* Process the queue. */
2368 process_queue (struct objfile
*objfile
)
2370 struct dwarf2_queue_item
*item
, *next_item
;
2372 /* Initially, there is just one item on the queue. Load its DIEs,
2373 and the DIEs of any other compilation units it requires,
2376 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2378 /* Read in this compilation unit. This may add new items to
2379 the end of the queue. */
2380 load_full_comp_unit (item
->per_cu
);
2382 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2383 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2385 /* If this compilation unit has already had full symbols created,
2386 reset the TYPE fields in each DIE. */
2387 if (item
->per_cu
->psymtab
->readin
)
2388 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2392 /* Now everything left on the queue needs to be read in. Process
2393 them, one at a time, removing from the queue as we finish. */
2394 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2396 if (!item
->per_cu
->psymtab
->readin
)
2397 process_full_comp_unit (item
->per_cu
);
2399 item
->per_cu
->queued
= 0;
2400 next_item
= item
->next
;
2404 dwarf2_queue_tail
= NULL
;
2407 /* Free all allocated queue entries. This function only releases anything if
2408 an error was thrown; if the queue was processed then it would have been
2409 freed as we went along. */
2412 dwarf2_release_queue (void *dummy
)
2414 struct dwarf2_queue_item
*item
, *last
;
2416 item
= dwarf2_queue
;
2419 /* Anything still marked queued is likely to be in an
2420 inconsistent state, so discard it. */
2421 if (item
->per_cu
->queued
)
2423 if (item
->per_cu
->cu
!= NULL
)
2424 free_one_cached_comp_unit (item
->per_cu
->cu
);
2425 item
->per_cu
->queued
= 0;
2433 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2436 /* Read in full symbols for PST, and anything it depends on. */
2439 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2441 struct dwarf2_per_cu_data
*per_cu
;
2442 struct cleanup
*back_to
;
2445 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2446 if (!pst
->dependencies
[i
]->readin
)
2448 /* Inform about additional files that need to be read in. */
2451 /* FIXME: i18n: Need to make this a single string. */
2452 fputs_filtered (" ", gdb_stdout
);
2454 fputs_filtered ("and ", gdb_stdout
);
2456 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2457 wrap_here (""); /* Flush output */
2458 gdb_flush (gdb_stdout
);
2460 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2463 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2467 /* It's an include file, no symbols to read for it.
2468 Everything is in the parent symtab. */
2473 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2475 queue_comp_unit (per_cu
);
2477 process_queue (pst
->objfile
);
2479 /* Age the cache, releasing compilation units that have not
2480 been used recently. */
2481 age_cached_comp_units ();
2483 do_cleanups (back_to
);
2486 /* Load the DIEs associated with PST and PER_CU into memory. */
2488 static struct dwarf2_cu
*
2489 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2491 struct partial_symtab
*pst
= per_cu
->psymtab
;
2492 bfd
*abfd
= pst
->objfile
->obfd
;
2493 struct dwarf2_cu
*cu
;
2494 unsigned long offset
;
2496 struct cleanup
*back_to
, *free_cu_cleanup
;
2497 struct attribute
*attr
;
2500 /* Set local variables from the partial symbol table info. */
2501 offset
= per_cu
->offset
;
2503 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2505 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2506 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2508 /* If an error occurs while loading, release our storage. */
2509 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2511 cu
->objfile
= pst
->objfile
;
2513 /* read in the comp_unit header */
2514 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2516 /* Read the abbrevs for this compilation unit */
2517 dwarf2_read_abbrevs (abfd
, cu
);
2518 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2520 cu
->header
.offset
= offset
;
2522 cu
->per_cu
= per_cu
;
2525 /* We use this obstack for block values in dwarf_alloc_block. */
2526 obstack_init (&cu
->comp_unit_obstack
);
2528 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2530 /* We try not to read any attributes in this function, because not
2531 all objfiles needed for references have been loaded yet, and symbol
2532 table processing isn't initialized. But we have to set the CU language,
2533 or we won't be able to build types correctly. */
2534 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2536 set_cu_language (DW_UNSND (attr
), cu
);
2538 set_cu_language (language_minimal
, cu
);
2540 do_cleanups (back_to
);
2542 /* We've successfully allocated this compilation unit. Let our caller
2543 clean it up when finished with it. */
2544 discard_cleanups (free_cu_cleanup
);
2549 /* Generate full symbol information for PST and CU, whose DIEs have
2550 already been loaded into memory. */
2553 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2555 struct partial_symtab
*pst
= per_cu
->psymtab
;
2556 struct dwarf2_cu
*cu
= per_cu
->cu
;
2557 struct objfile
*objfile
= pst
->objfile
;
2558 bfd
*abfd
= objfile
->obfd
;
2559 CORE_ADDR lowpc
, highpc
;
2560 struct symtab
*symtab
;
2561 struct cleanup
*back_to
;
2562 struct attribute
*attr
;
2565 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2567 /* We're in the global namespace. */
2568 processing_current_prefix
= "";
2571 back_to
= make_cleanup (really_free_pendings
, NULL
);
2573 cu
->list_in_scope
= &file_symbols
;
2575 /* Find the base address of the compilation unit for range lists and
2576 location lists. It will normally be specified by DW_AT_low_pc.
2577 In DWARF-3 draft 4, the base address could be overridden by
2578 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2579 compilation units with discontinuous ranges. */
2581 cu
->header
.base_known
= 0;
2582 cu
->header
.base_address
= 0;
2584 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2587 cu
->header
.base_address
= DW_ADDR (attr
);
2588 cu
->header
.base_known
= 1;
2592 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2595 cu
->header
.base_address
= DW_ADDR (attr
);
2596 cu
->header
.base_known
= 1;
2600 /* Do line number decoding in read_file_scope () */
2601 process_die (cu
->dies
, cu
);
2603 /* Some compilers don't define a DW_AT_high_pc attribute for the
2604 compilation unit. If the DW_AT_high_pc is missing, synthesize
2605 it, by scanning the DIE's below the compilation unit. */
2606 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2608 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2610 /* Set symtab language to language from DW_AT_language.
2611 If the compilation is from a C file generated by language preprocessors,
2612 do not set the language if it was already deduced by start_subfile. */
2614 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2616 symtab
->language
= cu
->language
;
2618 pst
->symtab
= symtab
;
2621 do_cleanups (back_to
);
2624 /* Process a die and its children. */
2627 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2631 case DW_TAG_padding
:
2633 case DW_TAG_compile_unit
:
2634 read_file_scope (die
, cu
);
2636 case DW_TAG_subprogram
:
2637 read_subroutine_type (die
, cu
);
2638 read_func_scope (die
, cu
);
2640 case DW_TAG_inlined_subroutine
:
2641 /* FIXME: These are ignored for now.
2642 They could be used to set breakpoints on all inlined instances
2643 of a function and make GDB `next' properly over inlined functions. */
2645 case DW_TAG_lexical_block
:
2646 case DW_TAG_try_block
:
2647 case DW_TAG_catch_block
:
2648 read_lexical_block_scope (die
, cu
);
2650 case DW_TAG_class_type
:
2651 case DW_TAG_structure_type
:
2652 case DW_TAG_union_type
:
2653 read_structure_type (die
, cu
);
2654 process_structure_scope (die
, cu
);
2656 case DW_TAG_enumeration_type
:
2657 read_enumeration_type (die
, cu
);
2658 process_enumeration_scope (die
, cu
);
2661 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2662 a symbol or process any children. Therefore it doesn't do anything
2663 that won't be done on-demand by read_type_die. */
2664 case DW_TAG_subroutine_type
:
2665 read_subroutine_type (die
, cu
);
2667 case DW_TAG_array_type
:
2668 read_array_type (die
, cu
);
2670 case DW_TAG_pointer_type
:
2671 read_tag_pointer_type (die
, cu
);
2673 case DW_TAG_ptr_to_member_type
:
2674 read_tag_ptr_to_member_type (die
, cu
);
2676 case DW_TAG_reference_type
:
2677 read_tag_reference_type (die
, cu
);
2679 case DW_TAG_string_type
:
2680 read_tag_string_type (die
, cu
);
2684 case DW_TAG_base_type
:
2685 read_base_type (die
, cu
);
2686 /* Add a typedef symbol for the type definition, if it has a
2688 new_symbol (die
, die
->type
, cu
);
2690 case DW_TAG_subrange_type
:
2691 read_subrange_type (die
, cu
);
2692 /* Add a typedef symbol for the type definition, if it has a
2694 new_symbol (die
, die
->type
, cu
);
2696 case DW_TAG_common_block
:
2697 read_common_block (die
, cu
);
2699 case DW_TAG_common_inclusion
:
2701 case DW_TAG_namespace
:
2702 processing_has_namespace_info
= 1;
2703 read_namespace (die
, cu
);
2705 case DW_TAG_imported_declaration
:
2706 case DW_TAG_imported_module
:
2707 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2708 information contained in these. DW_TAG_imported_declaration
2709 dies shouldn't have children; DW_TAG_imported_module dies
2710 shouldn't in the C++ case, but conceivably could in the
2711 Fortran case, so we'll have to replace this gdb_assert if
2712 Fortran compilers start generating that info. */
2713 processing_has_namespace_info
= 1;
2714 gdb_assert (die
->child
== NULL
);
2717 new_symbol (die
, NULL
, cu
);
2723 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2725 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2729 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2731 struct objfile
*objfile
= cu
->objfile
;
2732 struct comp_unit_head
*cu_header
= &cu
->header
;
2733 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2734 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2735 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2736 struct attribute
*attr
;
2737 char *name
= "<unknown>";
2738 char *comp_dir
= NULL
;
2739 struct die_info
*child_die
;
2740 bfd
*abfd
= objfile
->obfd
;
2741 struct line_header
*line_header
= 0;
2744 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2746 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2748 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2749 from finish_block. */
2750 if (lowpc
== ((CORE_ADDR
) -1))
2755 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2758 name
= DW_STRING (attr
);
2760 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2763 comp_dir
= DW_STRING (attr
);
2766 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2767 directory, get rid of it. */
2768 char *cp
= strchr (comp_dir
, ':');
2770 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2775 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2778 set_cu_language (DW_UNSND (attr
), cu
);
2781 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2783 cu
->producer
= DW_STRING (attr
);
2785 /* We assume that we're processing GCC output. */
2786 processing_gcc_compilation
= 2;
2788 /* FIXME:Do something here. */
2789 if (dip
->at_producer
!= NULL
)
2791 handle_producer (dip
->at_producer
);
2795 /* The compilation unit may be in a different language or objfile,
2796 zero out all remembered fundamental types. */
2797 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2799 start_symtab (name
, comp_dir
, lowpc
);
2800 record_debugformat ("DWARF 2");
2802 initialize_cu_func_list (cu
);
2804 /* Process all dies in compilation unit. */
2805 if (die
->child
!= NULL
)
2807 child_die
= die
->child
;
2808 while (child_die
&& child_die
->tag
)
2810 process_die (child_die
, cu
);
2811 child_die
= sibling_die (child_die
);
2815 /* Decode line number information if present. */
2816 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2819 unsigned int line_offset
= DW_UNSND (attr
);
2820 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2823 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2824 (void *) line_header
);
2825 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2829 /* Decode macro information, if present. Dwarf 2 macro information
2830 refers to information in the line number info statement program
2831 header, so we can only read it if we've read the header
2833 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2834 if (attr
&& line_header
)
2836 unsigned int macro_offset
= DW_UNSND (attr
);
2837 dwarf_decode_macros (line_header
, macro_offset
,
2838 comp_dir
, abfd
, cu
);
2840 do_cleanups (back_to
);
2844 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2845 struct dwarf2_cu
*cu
)
2847 struct function_range
*thisfn
;
2849 thisfn
= (struct function_range
*)
2850 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2851 thisfn
->name
= name
;
2852 thisfn
->lowpc
= lowpc
;
2853 thisfn
->highpc
= highpc
;
2854 thisfn
->seen_line
= 0;
2855 thisfn
->next
= NULL
;
2857 if (cu
->last_fn
== NULL
)
2858 cu
->first_fn
= thisfn
;
2860 cu
->last_fn
->next
= thisfn
;
2862 cu
->last_fn
= thisfn
;
2866 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2868 struct objfile
*objfile
= cu
->objfile
;
2869 struct context_stack
*new;
2872 struct die_info
*child_die
;
2873 struct attribute
*attr
;
2875 const char *previous_prefix
= processing_current_prefix
;
2876 struct cleanup
*back_to
= NULL
;
2879 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2881 name
= dwarf2_linkage_name (die
, cu
);
2883 /* Ignore functions with missing or empty names and functions with
2884 missing or invalid low and high pc attributes. */
2885 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2888 if (cu
->language
== language_cplus
2889 || cu
->language
== language_java
)
2891 struct die_info
*spec_die
= die_specification (die
, cu
);
2893 /* NOTE: carlton/2004-01-23: We have to be careful in the
2894 presence of DW_AT_specification. For example, with GCC 3.4,
2899 // Definition of N::foo.
2903 then we'll have a tree of DIEs like this:
2905 1: DW_TAG_compile_unit
2906 2: DW_TAG_namespace // N
2907 3: DW_TAG_subprogram // declaration of N::foo
2908 4: DW_TAG_subprogram // definition of N::foo
2909 DW_AT_specification // refers to die #3
2911 Thus, when processing die #4, we have to pretend that we're
2912 in the context of its DW_AT_specification, namely the contex
2915 if (spec_die
!= NULL
)
2917 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2918 processing_current_prefix
= specification_prefix
;
2919 back_to
= make_cleanup (xfree
, specification_prefix
);
2926 /* Record the function range for dwarf_decode_lines. */
2927 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2929 new = push_context (0, lowpc
);
2930 new->name
= new_symbol (die
, die
->type
, cu
);
2932 /* If there is a location expression for DW_AT_frame_base, record
2934 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2936 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2937 expression is being recorded directly in the function's symbol
2938 and not in a separate frame-base object. I guess this hack is
2939 to avoid adding some sort of frame-base adjunct/annex to the
2940 function's symbol :-(. The problem with doing this is that it
2941 results in a function symbol with a location expression that
2942 has nothing to do with the location of the function, ouch! The
2943 relationship should be: a function's symbol has-a frame base; a
2944 frame-base has-a location expression. */
2945 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2947 cu
->list_in_scope
= &local_symbols
;
2949 if (die
->child
!= NULL
)
2951 child_die
= die
->child
;
2952 while (child_die
&& child_die
->tag
)
2954 process_die (child_die
, cu
);
2955 child_die
= sibling_die (child_die
);
2959 new = pop_context ();
2960 /* Make a block for the local symbols within. */
2961 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2962 lowpc
, highpc
, objfile
);
2964 /* In C++, we can have functions nested inside functions (e.g., when
2965 a function declares a class that has methods). This means that
2966 when we finish processing a function scope, we may need to go
2967 back to building a containing block's symbol lists. */
2968 local_symbols
= new->locals
;
2969 param_symbols
= new->params
;
2971 /* If we've finished processing a top-level function, subsequent
2972 symbols go in the file symbol list. */
2973 if (outermost_context_p ())
2974 cu
->list_in_scope
= &file_symbols
;
2976 processing_current_prefix
= previous_prefix
;
2977 if (back_to
!= NULL
)
2978 do_cleanups (back_to
);
2981 /* Process all the DIES contained within a lexical block scope. Start
2982 a new scope, process the dies, and then close the scope. */
2985 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2987 struct objfile
*objfile
= cu
->objfile
;
2988 struct context_stack
*new;
2989 CORE_ADDR lowpc
, highpc
;
2990 struct die_info
*child_die
;
2993 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2995 /* Ignore blocks with missing or invalid low and high pc attributes. */
2996 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2997 as multiple lexical blocks? Handling children in a sane way would
2998 be nasty. Might be easier to properly extend generic blocks to
3000 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3005 push_context (0, lowpc
);
3006 if (die
->child
!= NULL
)
3008 child_die
= die
->child
;
3009 while (child_die
&& child_die
->tag
)
3011 process_die (child_die
, cu
);
3012 child_die
= sibling_die (child_die
);
3015 new = pop_context ();
3017 if (local_symbols
!= NULL
)
3019 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3022 local_symbols
= new->locals
;
3025 /* Get low and high pc attributes from a die. Return 1 if the attributes
3026 are present and valid, otherwise, return 0. Return -1 if the range is
3027 discontinuous, i.e. derived from DW_AT_ranges information. */
3029 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3030 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3032 struct objfile
*objfile
= cu
->objfile
;
3033 struct comp_unit_head
*cu_header
= &cu
->header
;
3034 struct attribute
*attr
;
3035 bfd
*obfd
= objfile
->obfd
;
3040 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3043 high
= DW_ADDR (attr
);
3044 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3046 low
= DW_ADDR (attr
);
3048 /* Found high w/o low attribute. */
3051 /* Found consecutive range of addresses. */
3056 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3059 unsigned int addr_size
= cu_header
->addr_size
;
3060 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3061 /* Value of the DW_AT_ranges attribute is the offset in the
3062 .debug_ranges section. */
3063 unsigned int offset
= DW_UNSND (attr
);
3064 /* Base address selection entry. */
3072 found_base
= cu_header
->base_known
;
3073 base
= cu_header
->base_address
;
3075 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3077 complaint (&symfile_complaints
,
3078 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3082 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3084 /* Read in the largest possible address. */
3085 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3086 if ((marker
& mask
) == mask
)
3088 /* If we found the largest possible address, then
3089 read the base address. */
3090 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3091 buffer
+= 2 * addr_size
;
3092 offset
+= 2 * addr_size
;
3100 CORE_ADDR range_beginning
, range_end
;
3102 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3103 buffer
+= addr_size
;
3104 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3105 buffer
+= addr_size
;
3106 offset
+= 2 * addr_size
;
3108 /* An end of list marker is a pair of zero addresses. */
3109 if (range_beginning
== 0 && range_end
== 0)
3110 /* Found the end of list entry. */
3113 /* Each base address selection entry is a pair of 2 values.
3114 The first is the largest possible address, the second is
3115 the base address. Check for a base address here. */
3116 if ((range_beginning
& mask
) == mask
)
3118 /* If we found the largest possible address, then
3119 read the base address. */
3120 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3127 /* We have no valid base address for the ranges
3129 complaint (&symfile_complaints
,
3130 _("Invalid .debug_ranges data (no base address)"));
3134 range_beginning
+= base
;
3137 /* FIXME: This is recording everything as a low-high
3138 segment of consecutive addresses. We should have a
3139 data structure for discontiguous block ranges
3143 low
= range_beginning
;
3149 if (range_beginning
< low
)
3150 low
= range_beginning
;
3151 if (range_end
> high
)
3157 /* If the first entry is an end-of-list marker, the range
3158 describes an empty scope, i.e. no instructions. */
3168 /* When using the GNU linker, .gnu.linkonce. sections are used to
3169 eliminate duplicate copies of functions and vtables and such.
3170 The linker will arbitrarily choose one and discard the others.
3171 The AT_*_pc values for such functions refer to local labels in
3172 these sections. If the section from that file was discarded, the
3173 labels are not in the output, so the relocs get a value of 0.
3174 If this is a discarded function, mark the pc bounds as invalid,
3175 so that GDB will ignore it. */
3176 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
3184 /* Get the low and high pc's represented by the scope DIE, and store
3185 them in *LOWPC and *HIGHPC. If the correct values can't be
3186 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3189 get_scope_pc_bounds (struct die_info
*die
,
3190 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3191 struct dwarf2_cu
*cu
)
3193 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3194 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3195 CORE_ADDR current_low
, current_high
;
3197 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3199 best_low
= current_low
;
3200 best_high
= current_high
;
3204 struct die_info
*child
= die
->child
;
3206 while (child
&& child
->tag
)
3208 switch (child
->tag
) {
3209 case DW_TAG_subprogram
:
3210 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3212 best_low
= min (best_low
, current_low
);
3213 best_high
= max (best_high
, current_high
);
3216 case DW_TAG_namespace
:
3217 /* FIXME: carlton/2004-01-16: Should we do this for
3218 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3219 that current GCC's always emit the DIEs corresponding
3220 to definitions of methods of classes as children of a
3221 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3222 the DIEs giving the declarations, which could be
3223 anywhere). But I don't see any reason why the
3224 standards says that they have to be there. */
3225 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3227 if (current_low
!= ((CORE_ADDR
) -1))
3229 best_low
= min (best_low
, current_low
);
3230 best_high
= max (best_high
, current_high
);
3238 child
= sibling_die (child
);
3243 *highpc
= best_high
;
3246 /* Add an aggregate field to the field list. */
3249 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3250 struct dwarf2_cu
*cu
)
3252 struct objfile
*objfile
= cu
->objfile
;
3253 struct nextfield
*new_field
;
3254 struct attribute
*attr
;
3256 char *fieldname
= "";
3258 /* Allocate a new field list entry and link it in. */
3259 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3260 make_cleanup (xfree
, new_field
);
3261 memset (new_field
, 0, sizeof (struct nextfield
));
3262 new_field
->next
= fip
->fields
;
3263 fip
->fields
= new_field
;
3266 /* Handle accessibility and virtuality of field.
3267 The default accessibility for members is public, the default
3268 accessibility for inheritance is private. */
3269 if (die
->tag
!= DW_TAG_inheritance
)
3270 new_field
->accessibility
= DW_ACCESS_public
;
3272 new_field
->accessibility
= DW_ACCESS_private
;
3273 new_field
->virtuality
= DW_VIRTUALITY_none
;
3275 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3277 new_field
->accessibility
= DW_UNSND (attr
);
3278 if (new_field
->accessibility
!= DW_ACCESS_public
)
3279 fip
->non_public_fields
= 1;
3280 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3282 new_field
->virtuality
= DW_UNSND (attr
);
3284 fp
= &new_field
->field
;
3286 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3288 /* Data member other than a C++ static data member. */
3290 /* Get type of field. */
3291 fp
->type
= die_type (die
, cu
);
3293 FIELD_STATIC_KIND (*fp
) = 0;
3295 /* Get bit size of field (zero if none). */
3296 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3299 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3303 FIELD_BITSIZE (*fp
) = 0;
3306 /* Get bit offset of field. */
3307 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3310 FIELD_BITPOS (*fp
) =
3311 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3314 FIELD_BITPOS (*fp
) = 0;
3315 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3318 if (BITS_BIG_ENDIAN
)
3320 /* For big endian bits, the DW_AT_bit_offset gives the
3321 additional bit offset from the MSB of the containing
3322 anonymous object to the MSB of the field. We don't
3323 have to do anything special since we don't need to
3324 know the size of the anonymous object. */
3325 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3329 /* For little endian bits, compute the bit offset to the
3330 MSB of the anonymous object, subtract off the number of
3331 bits from the MSB of the field to the MSB of the
3332 object, and then subtract off the number of bits of
3333 the field itself. The result is the bit offset of
3334 the LSB of the field. */
3336 int bit_offset
= DW_UNSND (attr
);
3338 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3341 /* The size of the anonymous object containing
3342 the bit field is explicit, so use the
3343 indicated size (in bytes). */
3344 anonymous_size
= DW_UNSND (attr
);
3348 /* The size of the anonymous object containing
3349 the bit field must be inferred from the type
3350 attribute of the data member containing the
3352 anonymous_size
= TYPE_LENGTH (fp
->type
);
3354 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3355 - bit_offset
- FIELD_BITSIZE (*fp
);
3359 /* Get name of field. */
3360 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3361 if (attr
&& DW_STRING (attr
))
3362 fieldname
= DW_STRING (attr
);
3364 /* The name is already allocated along with this objfile, so we don't
3365 need to duplicate it for the type. */
3366 fp
->name
= fieldname
;
3368 /* Change accessibility for artificial fields (e.g. virtual table
3369 pointer or virtual base class pointer) to private. */
3370 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3372 new_field
->accessibility
= DW_ACCESS_private
;
3373 fip
->non_public_fields
= 1;
3376 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3378 /* C++ static member. */
3380 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3381 is a declaration, but all versions of G++ as of this writing
3382 (so through at least 3.2.1) incorrectly generate
3383 DW_TAG_variable tags. */
3387 /* Get name of field. */
3388 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3389 if (attr
&& DW_STRING (attr
))
3390 fieldname
= DW_STRING (attr
);
3394 /* Get physical name. */
3395 physname
= dwarf2_linkage_name (die
, cu
);
3397 /* The name is already allocated along with this objfile, so we don't
3398 need to duplicate it for the type. */
3399 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3400 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3401 FIELD_NAME (*fp
) = fieldname
;
3403 else if (die
->tag
== DW_TAG_inheritance
)
3405 /* C++ base class field. */
3406 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3408 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3410 FIELD_BITSIZE (*fp
) = 0;
3411 FIELD_STATIC_KIND (*fp
) = 0;
3412 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3413 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3414 fip
->nbaseclasses
++;
3418 /* Create the vector of fields, and attach it to the type. */
3421 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3422 struct dwarf2_cu
*cu
)
3424 int nfields
= fip
->nfields
;
3426 /* Record the field count, allocate space for the array of fields,
3427 and create blank accessibility bitfields if necessary. */
3428 TYPE_NFIELDS (type
) = nfields
;
3429 TYPE_FIELDS (type
) = (struct field
*)
3430 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3431 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3433 if (fip
->non_public_fields
)
3435 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3437 TYPE_FIELD_PRIVATE_BITS (type
) =
3438 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3439 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3441 TYPE_FIELD_PROTECTED_BITS (type
) =
3442 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3443 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3445 TYPE_FIELD_IGNORE_BITS (type
) =
3446 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3447 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3450 /* If the type has baseclasses, allocate and clear a bit vector for
3451 TYPE_FIELD_VIRTUAL_BITS. */
3452 if (fip
->nbaseclasses
)
3454 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3457 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3458 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3459 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3460 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3461 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3464 /* Copy the saved-up fields into the field vector. Start from the head
3465 of the list, adding to the tail of the field array, so that they end
3466 up in the same order in the array in which they were added to the list. */
3467 while (nfields
-- > 0)
3469 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3470 switch (fip
->fields
->accessibility
)
3472 case DW_ACCESS_private
:
3473 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3476 case DW_ACCESS_protected
:
3477 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3480 case DW_ACCESS_public
:
3484 /* Unknown accessibility. Complain and treat it as public. */
3486 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3487 fip
->fields
->accessibility
);
3491 if (nfields
< fip
->nbaseclasses
)
3493 switch (fip
->fields
->virtuality
)
3495 case DW_VIRTUALITY_virtual
:
3496 case DW_VIRTUALITY_pure_virtual
:
3497 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3501 fip
->fields
= fip
->fields
->next
;
3505 /* Add a member function to the proper fieldlist. */
3508 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3509 struct type
*type
, struct dwarf2_cu
*cu
)
3511 struct objfile
*objfile
= cu
->objfile
;
3512 struct attribute
*attr
;
3513 struct fnfieldlist
*flp
;
3515 struct fn_field
*fnp
;
3518 struct nextfnfield
*new_fnfield
;
3520 /* Get name of member function. */
3521 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3522 if (attr
&& DW_STRING (attr
))
3523 fieldname
= DW_STRING (attr
);
3527 /* Get the mangled name. */
3528 physname
= dwarf2_linkage_name (die
, cu
);
3530 /* Look up member function name in fieldlist. */
3531 for (i
= 0; i
< fip
->nfnfields
; i
++)
3533 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3537 /* Create new list element if necessary. */
3538 if (i
< fip
->nfnfields
)
3539 flp
= &fip
->fnfieldlists
[i
];
3542 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3544 fip
->fnfieldlists
= (struct fnfieldlist
*)
3545 xrealloc (fip
->fnfieldlists
,
3546 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3547 * sizeof (struct fnfieldlist
));
3548 if (fip
->nfnfields
== 0)
3549 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3551 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3552 flp
->name
= fieldname
;
3558 /* Create a new member function field and chain it to the field list
3560 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3561 make_cleanup (xfree
, new_fnfield
);
3562 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3563 new_fnfield
->next
= flp
->head
;
3564 flp
->head
= new_fnfield
;
3567 /* Fill in the member function field info. */
3568 fnp
= &new_fnfield
->fnfield
;
3569 /* The name is already allocated along with this objfile, so we don't
3570 need to duplicate it for the type. */
3571 fnp
->physname
= physname
? physname
: "";
3572 fnp
->type
= alloc_type (objfile
);
3573 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3575 int nparams
= TYPE_NFIELDS (die
->type
);
3577 /* TYPE is the domain of this method, and DIE->TYPE is the type
3578 of the method itself (TYPE_CODE_METHOD). */
3579 smash_to_method_type (fnp
->type
, type
,
3580 TYPE_TARGET_TYPE (die
->type
),
3581 TYPE_FIELDS (die
->type
),
3582 TYPE_NFIELDS (die
->type
),
3583 TYPE_VARARGS (die
->type
));
3585 /* Handle static member functions.
3586 Dwarf2 has no clean way to discern C++ static and non-static
3587 member functions. G++ helps GDB by marking the first
3588 parameter for non-static member functions (which is the
3589 this pointer) as artificial. We obtain this information
3590 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3591 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3592 fnp
->voffset
= VOFFSET_STATIC
;
3595 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3598 /* Get fcontext from DW_AT_containing_type if present. */
3599 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3600 fnp
->fcontext
= die_containing_type (die
, cu
);
3602 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3603 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3605 /* Get accessibility. */
3606 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3609 switch (DW_UNSND (attr
))
3611 case DW_ACCESS_private
:
3612 fnp
->is_private
= 1;
3614 case DW_ACCESS_protected
:
3615 fnp
->is_protected
= 1;
3620 /* Check for artificial methods. */
3621 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3622 if (attr
&& DW_UNSND (attr
) != 0)
3623 fnp
->is_artificial
= 1;
3625 /* Get index in virtual function table if it is a virtual member function. */
3626 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3629 /* Support the .debug_loc offsets */
3630 if (attr_form_is_block (attr
))
3632 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3634 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3636 dwarf2_complex_location_expr_complaint ();
3640 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3646 /* Create the vector of member function fields, and attach it to the type. */
3649 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3650 struct dwarf2_cu
*cu
)
3652 struct fnfieldlist
*flp
;
3653 int total_length
= 0;
3656 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3657 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3658 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3660 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3662 struct nextfnfield
*nfp
= flp
->head
;
3663 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3666 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3667 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3668 fn_flp
->fn_fields
= (struct fn_field
*)
3669 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3670 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3671 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3673 total_length
+= flp
->length
;
3676 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3677 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3681 /* Returns non-zero if NAME is the name of a vtable member in CU's
3682 language, zero otherwise. */
3684 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3686 static const char vptr
[] = "_vptr";
3687 static const char vtable
[] = "vtable";
3689 /* Look for the C++ and Java forms of the vtable. */
3690 if ((cu
->language
== language_java
3691 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3692 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3693 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3700 /* Called when we find the DIE that starts a structure or union scope
3701 (definition) to process all dies that define the members of the
3704 NOTE: we need to call struct_type regardless of whether or not the
3705 DIE has an at_name attribute, since it might be an anonymous
3706 structure or union. This gets the type entered into our set of
3709 However, if the structure is incomplete (an opaque struct/union)
3710 then suppress creating a symbol table entry for it since gdb only
3711 wants to find the one with the complete definition. Note that if
3712 it is complete, we just call new_symbol, which does it's own
3713 checking about whether the struct/union is anonymous or not (and
3714 suppresses creating a symbol table entry itself). */
3717 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3719 struct objfile
*objfile
= cu
->objfile
;
3721 struct attribute
*attr
;
3722 const char *previous_prefix
= processing_current_prefix
;
3723 struct cleanup
*back_to
= NULL
;
3728 type
= alloc_type (objfile
);
3730 INIT_CPLUS_SPECIFIC (type
);
3731 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3732 if (attr
&& DW_STRING (attr
))
3734 if (cu
->language
== language_cplus
3735 || cu
->language
== language_java
)
3737 char *new_prefix
= determine_class_name (die
, cu
);
3738 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3739 strlen (new_prefix
),
3740 &objfile
->objfile_obstack
);
3741 back_to
= make_cleanup (xfree
, new_prefix
);
3742 processing_current_prefix
= new_prefix
;
3746 /* The name is already allocated along with this objfile, so
3747 we don't need to duplicate it for the type. */
3748 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3752 if (die
->tag
== DW_TAG_structure_type
)
3754 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3756 else if (die
->tag
== DW_TAG_union_type
)
3758 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3762 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3764 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3767 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3770 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3774 TYPE_LENGTH (type
) = 0;
3777 if (die_is_declaration (die
, cu
))
3778 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3780 /* We need to add the type field to the die immediately so we don't
3781 infinitely recurse when dealing with pointers to the structure
3782 type within the structure itself. */
3783 set_die_type (die
, type
, cu
);
3785 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3787 struct field_info fi
;
3788 struct die_info
*child_die
;
3789 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3791 memset (&fi
, 0, sizeof (struct field_info
));
3793 child_die
= die
->child
;
3795 while (child_die
&& child_die
->tag
)
3797 if (child_die
->tag
== DW_TAG_member
3798 || child_die
->tag
== DW_TAG_variable
)
3800 /* NOTE: carlton/2002-11-05: A C++ static data member
3801 should be a DW_TAG_member that is a declaration, but
3802 all versions of G++ as of this writing (so through at
3803 least 3.2.1) incorrectly generate DW_TAG_variable
3804 tags for them instead. */
3805 dwarf2_add_field (&fi
, child_die
, cu
);
3807 else if (child_die
->tag
== DW_TAG_subprogram
)
3809 /* C++ member function. */
3810 read_type_die (child_die
, cu
);
3811 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3813 else if (child_die
->tag
== DW_TAG_inheritance
)
3815 /* C++ base class field. */
3816 dwarf2_add_field (&fi
, child_die
, cu
);
3818 child_die
= sibling_die (child_die
);
3821 /* Attach fields and member functions to the type. */
3823 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3826 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3828 /* Get the type which refers to the base class (possibly this
3829 class itself) which contains the vtable pointer for the current
3830 class from the DW_AT_containing_type attribute. */
3832 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3834 struct type
*t
= die_containing_type (die
, cu
);
3836 TYPE_VPTR_BASETYPE (type
) = t
;
3841 /* Our own class provides vtbl ptr. */
3842 for (i
= TYPE_NFIELDS (t
) - 1;
3843 i
>= TYPE_N_BASECLASSES (t
);
3846 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3848 if (is_vtable_name (fieldname
, cu
))
3850 TYPE_VPTR_FIELDNO (type
) = i
;
3855 /* Complain if virtual function table field not found. */
3856 if (i
< TYPE_N_BASECLASSES (t
))
3857 complaint (&symfile_complaints
,
3858 _("virtual function table pointer not found when defining class '%s'"),
3859 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3864 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3869 do_cleanups (back_to
);
3872 processing_current_prefix
= previous_prefix
;
3873 if (back_to
!= NULL
)
3874 do_cleanups (back_to
);
3878 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3880 struct objfile
*objfile
= cu
->objfile
;
3881 const char *previous_prefix
= processing_current_prefix
;
3882 struct die_info
*child_die
= die
->child
;
3884 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3885 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3887 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3888 snapshots) has been known to create a die giving a declaration
3889 for a class that has, as a child, a die giving a definition for a
3890 nested class. So we have to process our children even if the
3891 current die is a declaration. Normally, of course, a declaration
3892 won't have any children at all. */
3894 while (child_die
!= NULL
&& child_die
->tag
)
3896 if (child_die
->tag
== DW_TAG_member
3897 || child_die
->tag
== DW_TAG_variable
3898 || child_die
->tag
== DW_TAG_inheritance
)
3903 process_die (child_die
, cu
);
3905 child_die
= sibling_die (child_die
);
3908 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3909 new_symbol (die
, die
->type
, cu
);
3911 processing_current_prefix
= previous_prefix
;
3914 /* Given a DW_AT_enumeration_type die, set its type. We do not
3915 complete the type's fields yet, or create any symbols. */
3918 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3920 struct objfile
*objfile
= cu
->objfile
;
3922 struct attribute
*attr
;
3927 type
= alloc_type (objfile
);
3929 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3930 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3931 if (attr
&& DW_STRING (attr
))
3933 char *name
= DW_STRING (attr
);
3935 if (processing_has_namespace_info
)
3937 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
3938 processing_current_prefix
,
3943 /* The name is already allocated along with this objfile, so
3944 we don't need to duplicate it for the type. */
3945 TYPE_TAG_NAME (type
) = name
;
3949 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3952 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3956 TYPE_LENGTH (type
) = 0;
3959 set_die_type (die
, type
, cu
);
3962 /* Determine the name of the type represented by DIE, which should be
3963 a named C++ or Java compound type. Return the name in question; the caller
3964 is responsible for xfree()'ing it. */
3967 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3969 struct cleanup
*back_to
= NULL
;
3970 struct die_info
*spec_die
= die_specification (die
, cu
);
3971 char *new_prefix
= NULL
;
3973 /* If this is the definition of a class that is declared by another
3974 die, then processing_current_prefix may not be accurate; see
3975 read_func_scope for a similar example. */
3976 if (spec_die
!= NULL
)
3978 char *specification_prefix
= determine_prefix (spec_die
, cu
);
3979 processing_current_prefix
= specification_prefix
;
3980 back_to
= make_cleanup (xfree
, specification_prefix
);
3983 /* If we don't have namespace debug info, guess the name by trying
3984 to demangle the names of members, just like we did in
3985 guess_structure_name. */
3986 if (!processing_has_namespace_info
)
3988 struct die_info
*child
;
3990 for (child
= die
->child
;
3991 child
!= NULL
&& child
->tag
!= 0;
3992 child
= sibling_die (child
))
3994 if (child
->tag
== DW_TAG_subprogram
)
3997 = language_class_name_from_physname (cu
->language_defn
,
4001 if (new_prefix
!= NULL
)
4007 if (new_prefix
== NULL
)
4009 const char *name
= dwarf2_name (die
, cu
);
4010 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4011 name
? name
: "<<anonymous>>",
4015 if (back_to
!= NULL
)
4016 do_cleanups (back_to
);
4021 /* Given a pointer to a die which begins an enumeration, process all
4022 the dies that define the members of the enumeration, and create the
4023 symbol for the enumeration type.
4025 NOTE: We reverse the order of the element list. */
4028 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4030 struct objfile
*objfile
= cu
->objfile
;
4031 struct die_info
*child_die
;
4032 struct field
*fields
;
4033 struct attribute
*attr
;
4036 int unsigned_enum
= 1;
4040 if (die
->child
!= NULL
)
4042 child_die
= die
->child
;
4043 while (child_die
&& child_die
->tag
)
4045 if (child_die
->tag
!= DW_TAG_enumerator
)
4047 process_die (child_die
, cu
);
4051 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4054 sym
= new_symbol (child_die
, die
->type
, cu
);
4055 if (SYMBOL_VALUE (sym
) < 0)
4058 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4060 fields
= (struct field
*)
4062 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4063 * sizeof (struct field
));
4066 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4067 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4068 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4069 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4070 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4076 child_die
= sibling_die (child_die
);
4081 TYPE_NFIELDS (die
->type
) = num_fields
;
4082 TYPE_FIELDS (die
->type
) = (struct field
*)
4083 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4084 memcpy (TYPE_FIELDS (die
->type
), fields
,
4085 sizeof (struct field
) * num_fields
);
4089 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4092 new_symbol (die
, die
->type
, cu
);
4095 /* Extract all information from a DW_TAG_array_type DIE and put it in
4096 the DIE's type field. For now, this only handles one dimensional
4100 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4102 struct objfile
*objfile
= cu
->objfile
;
4103 struct die_info
*child_die
;
4104 struct type
*type
= NULL
;
4105 struct type
*element_type
, *range_type
, *index_type
;
4106 struct type
**range_types
= NULL
;
4107 struct attribute
*attr
;
4109 struct cleanup
*back_to
;
4111 /* Return if we've already decoded this type. */
4117 element_type
= die_type (die
, cu
);
4119 /* Irix 6.2 native cc creates array types without children for
4120 arrays with unspecified length. */
4121 if (die
->child
== NULL
)
4123 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4124 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4125 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4130 back_to
= make_cleanup (null_cleanup
, NULL
);
4131 child_die
= die
->child
;
4132 while (child_die
&& child_die
->tag
)
4134 if (child_die
->tag
== DW_TAG_subrange_type
)
4136 read_subrange_type (child_die
, cu
);
4138 if (child_die
->type
!= NULL
)
4140 /* The range type was succesfully read. Save it for
4141 the array type creation. */
4142 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4144 range_types
= (struct type
**)
4145 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4146 * sizeof (struct type
*));
4148 make_cleanup (free_current_contents
, &range_types
);
4150 range_types
[ndim
++] = child_die
->type
;
4153 child_die
= sibling_die (child_die
);
4156 /* Dwarf2 dimensions are output from left to right, create the
4157 necessary array types in backwards order. */
4159 type
= element_type
;
4161 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4165 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4170 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4173 /* Understand Dwarf2 support for vector types (like they occur on
4174 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4175 array type. This is not part of the Dwarf2/3 standard yet, but a
4176 custom vendor extension. The main difference between a regular
4177 array and the vector variant is that vectors are passed by value
4179 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4181 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4183 do_cleanups (back_to
);
4185 /* Install the type in the die. */
4186 set_die_type (die
, type
, cu
);
4189 static enum dwarf_array_dim_ordering
4190 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4192 struct attribute
*attr
;
4194 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4196 if (attr
) return DW_SND (attr
);
4199 GNU F77 is a special case, as at 08/2004 array type info is the
4200 opposite order to the dwarf2 specification, but data is still
4201 laid out as per normal fortran.
4203 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4207 if (cu
->language
== language_fortran
&&
4208 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4210 return DW_ORD_row_major
;
4213 switch (cu
->language_defn
->la_array_ordering
)
4215 case array_column_major
:
4216 return DW_ORD_col_major
;
4217 case array_row_major
:
4219 return DW_ORD_row_major
;
4224 /* First cut: install each common block member as a global variable. */
4227 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4229 struct die_info
*child_die
;
4230 struct attribute
*attr
;
4232 CORE_ADDR base
= (CORE_ADDR
) 0;
4234 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4237 /* Support the .debug_loc offsets */
4238 if (attr_form_is_block (attr
))
4240 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4242 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4244 dwarf2_complex_location_expr_complaint ();
4248 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4249 "common block member");
4252 if (die
->child
!= NULL
)
4254 child_die
= die
->child
;
4255 while (child_die
&& child_die
->tag
)
4257 sym
= new_symbol (child_die
, NULL
, cu
);
4258 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4261 SYMBOL_VALUE_ADDRESS (sym
) =
4262 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4263 add_symbol_to_list (sym
, &global_symbols
);
4265 child_die
= sibling_die (child_die
);
4270 /* Read a C++ namespace. */
4273 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4275 struct objfile
*objfile
= cu
->objfile
;
4276 const char *previous_prefix
= processing_current_prefix
;
4279 struct die_info
*current_die
;
4280 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4282 name
= namespace_name (die
, &is_anonymous
, cu
);
4284 /* Now build the name of the current namespace. */
4286 if (previous_prefix
[0] == '\0')
4288 processing_current_prefix
= name
;
4292 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4293 make_cleanup (xfree
, temp_name
);
4294 processing_current_prefix
= temp_name
;
4297 /* Add a symbol associated to this if we haven't seen the namespace
4298 before. Also, add a using directive if it's an anonymous
4301 if (dwarf2_extension (die
, cu
) == NULL
)
4305 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4306 this cast will hopefully become unnecessary. */
4307 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4308 (char *) processing_current_prefix
,
4310 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4312 new_symbol (die
, type
, cu
);
4313 set_die_type (die
, type
, cu
);
4316 cp_add_using_directive (processing_current_prefix
,
4317 strlen (previous_prefix
),
4318 strlen (processing_current_prefix
));
4321 if (die
->child
!= NULL
)
4323 struct die_info
*child_die
= die
->child
;
4325 while (child_die
&& child_die
->tag
)
4327 process_die (child_die
, cu
);
4328 child_die
= sibling_die (child_die
);
4332 processing_current_prefix
= previous_prefix
;
4333 do_cleanups (back_to
);
4336 /* Return the name of the namespace represented by DIE. Set
4337 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4341 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4343 struct die_info
*current_die
;
4344 const char *name
= NULL
;
4346 /* Loop through the extensions until we find a name. */
4348 for (current_die
= die
;
4349 current_die
!= NULL
;
4350 current_die
= dwarf2_extension (die
, cu
))
4352 name
= dwarf2_name (current_die
, cu
);
4357 /* Is it an anonymous namespace? */
4359 *is_anonymous
= (name
== NULL
);
4361 name
= "(anonymous namespace)";
4366 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4367 the user defined type vector. */
4370 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4372 struct comp_unit_head
*cu_header
= &cu
->header
;
4374 struct attribute
*attr_byte_size
;
4375 struct attribute
*attr_address_class
;
4376 int byte_size
, addr_class
;
4383 type
= lookup_pointer_type (die_type (die
, cu
));
4385 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4387 byte_size
= DW_UNSND (attr_byte_size
);
4389 byte_size
= cu_header
->addr_size
;
4391 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4392 if (attr_address_class
)
4393 addr_class
= DW_UNSND (attr_address_class
);
4395 addr_class
= DW_ADDR_none
;
4397 /* If the pointer size or address class is different than the
4398 default, create a type variant marked as such and set the
4399 length accordingly. */
4400 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4402 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4406 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4407 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4408 type
= make_type_with_address_space (type
, type_flags
);
4410 else if (TYPE_LENGTH (type
) != byte_size
)
4412 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4415 /* Should we also complain about unhandled address classes? */
4419 TYPE_LENGTH (type
) = byte_size
;
4420 set_die_type (die
, type
, cu
);
4423 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4424 the user defined type vector. */
4427 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4429 struct objfile
*objfile
= cu
->objfile
;
4431 struct type
*to_type
;
4432 struct type
*domain
;
4439 type
= alloc_type (objfile
);
4440 to_type
= die_type (die
, cu
);
4441 domain
= die_containing_type (die
, cu
);
4442 smash_to_member_type (type
, domain
, to_type
);
4444 set_die_type (die
, type
, cu
);
4447 /* Extract all information from a DW_TAG_reference_type DIE and add to
4448 the user defined type vector. */
4451 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4453 struct comp_unit_head
*cu_header
= &cu
->header
;
4455 struct attribute
*attr
;
4462 type
= lookup_reference_type (die_type (die
, cu
));
4463 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4466 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4470 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4472 set_die_type (die
, type
, cu
);
4476 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4478 struct type
*base_type
;
4485 base_type
= die_type (die
, cu
);
4486 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4491 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4493 struct type
*base_type
;
4500 base_type
= die_type (die
, cu
);
4501 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4505 /* Extract all information from a DW_TAG_string_type DIE and add to
4506 the user defined type vector. It isn't really a user defined type,
4507 but it behaves like one, with other DIE's using an AT_user_def_type
4508 attribute to reference it. */
4511 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4513 struct objfile
*objfile
= cu
->objfile
;
4514 struct type
*type
, *range_type
, *index_type
, *char_type
;
4515 struct attribute
*attr
;
4516 unsigned int length
;
4523 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4526 length
= DW_UNSND (attr
);
4530 /* check for the DW_AT_byte_size attribute */
4531 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4534 length
= DW_UNSND (attr
);
4541 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4542 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4543 if (cu
->language
== language_fortran
)
4545 /* Need to create a unique string type for bounds
4547 type
= create_string_type (0, range_type
);
4551 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4552 type
= create_string_type (char_type
, range_type
);
4554 set_die_type (die
, type
, cu
);
4557 /* Handle DIES due to C code like:
4561 int (*funcp)(int a, long l);
4565 ('funcp' generates a DW_TAG_subroutine_type DIE)
4569 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4571 struct type
*type
; /* Type that this function returns */
4572 struct type
*ftype
; /* Function that returns above type */
4573 struct attribute
*attr
;
4575 /* Decode the type that this subroutine returns */
4580 type
= die_type (die
, cu
);
4581 ftype
= make_function_type (type
, (struct type
**) 0);
4583 /* All functions in C++ and Java have prototypes. */
4584 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4585 if ((attr
&& (DW_UNSND (attr
) != 0))
4586 || cu
->language
== language_cplus
4587 || cu
->language
== language_java
)
4588 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4590 if (die
->child
!= NULL
)
4592 struct die_info
*child_die
;
4596 /* Count the number of parameters.
4597 FIXME: GDB currently ignores vararg functions, but knows about
4598 vararg member functions. */
4599 child_die
= die
->child
;
4600 while (child_die
&& child_die
->tag
)
4602 if (child_die
->tag
== DW_TAG_formal_parameter
)
4604 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4605 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4606 child_die
= sibling_die (child_die
);
4609 /* Allocate storage for parameters and fill them in. */
4610 TYPE_NFIELDS (ftype
) = nparams
;
4611 TYPE_FIELDS (ftype
) = (struct field
*)
4612 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
4614 child_die
= die
->child
;
4615 while (child_die
&& child_die
->tag
)
4617 if (child_die
->tag
== DW_TAG_formal_parameter
)
4619 /* Dwarf2 has no clean way to discern C++ static and non-static
4620 member functions. G++ helps GDB by marking the first
4621 parameter for non-static member functions (which is the
4622 this pointer) as artificial. We pass this information
4623 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4624 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4626 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4628 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4629 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4632 child_die
= sibling_die (child_die
);
4636 set_die_type (die
, ftype
, cu
);
4640 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4642 struct objfile
*objfile
= cu
->objfile
;
4643 struct attribute
*attr
;
4648 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4649 if (attr
&& DW_STRING (attr
))
4651 name
= DW_STRING (attr
);
4653 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4654 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4656 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4660 /* Find a representation of a given base type and install
4661 it in the TYPE field of the die. */
4664 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4666 struct objfile
*objfile
= cu
->objfile
;
4668 struct attribute
*attr
;
4669 int encoding
= 0, size
= 0;
4671 /* If we've already decoded this die, this is a no-op. */
4677 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4680 encoding
= DW_UNSND (attr
);
4682 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4685 size
= DW_UNSND (attr
);
4687 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4688 if (attr
&& DW_STRING (attr
))
4690 enum type_code code
= TYPE_CODE_INT
;
4695 case DW_ATE_address
:
4696 /* Turn DW_ATE_address into a void * pointer. */
4697 code
= TYPE_CODE_PTR
;
4698 type_flags
|= TYPE_FLAG_UNSIGNED
;
4700 case DW_ATE_boolean
:
4701 code
= TYPE_CODE_BOOL
;
4702 type_flags
|= TYPE_FLAG_UNSIGNED
;
4704 case DW_ATE_complex_float
:
4705 code
= TYPE_CODE_COMPLEX
;
4708 code
= TYPE_CODE_FLT
;
4711 case DW_ATE_signed_char
:
4713 case DW_ATE_unsigned
:
4714 case DW_ATE_unsigned_char
:
4715 type_flags
|= TYPE_FLAG_UNSIGNED
;
4718 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4719 dwarf_type_encoding_name (encoding
));
4722 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4723 if (encoding
== DW_ATE_address
)
4724 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4726 else if (encoding
== DW_ATE_complex_float
)
4729 TYPE_TARGET_TYPE (type
)
4730 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4731 else if (size
== 16)
4732 TYPE_TARGET_TYPE (type
)
4733 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4735 TYPE_TARGET_TYPE (type
)
4736 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4741 type
= dwarf_base_type (encoding
, size
, cu
);
4743 set_die_type (die
, type
, cu
);
4746 /* Read the given DW_AT_subrange DIE. */
4749 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4751 struct type
*base_type
;
4752 struct type
*range_type
;
4753 struct attribute
*attr
;
4757 /* If we have already decoded this die, then nothing more to do. */
4761 base_type
= die_type (die
, cu
);
4762 if (base_type
== NULL
)
4764 complaint (&symfile_complaints
,
4765 _("DW_AT_type missing from DW_TAG_subrange_type"));
4769 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4770 base_type
= alloc_type (NULL
);
4772 if (cu
->language
== language_fortran
)
4774 /* FORTRAN implies a lower bound of 1, if not given. */
4778 /* FIXME: For variable sized arrays either of these could be
4779 a variable rather than a constant value. We'll allow it,
4780 but we don't know how to handle it. */
4781 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4783 low
= dwarf2_get_attr_constant_value (attr
, 0);
4785 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4788 if (attr
->form
== DW_FORM_block1
)
4790 /* GCC encodes arrays with unspecified or dynamic length
4791 with a DW_FORM_block1 attribute.
4792 FIXME: GDB does not yet know how to handle dynamic
4793 arrays properly, treat them as arrays with unspecified
4796 FIXME: jimb/2003-09-22: GDB does not really know
4797 how to handle arrays of unspecified length
4798 either; we just represent them as zero-length
4799 arrays. Choose an appropriate upper bound given
4800 the lower bound we've computed above. */
4804 high
= dwarf2_get_attr_constant_value (attr
, 1);
4807 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4809 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4810 if (attr
&& DW_STRING (attr
))
4811 TYPE_NAME (range_type
) = DW_STRING (attr
);
4813 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4815 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4817 set_die_type (die
, range_type
, cu
);
4821 /* Read a whole compilation unit into a linked list of dies. */
4823 static struct die_info
*
4824 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4826 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4829 /* Read a single die and all its descendents. Set the die's sibling
4830 field to NULL; set other fields in the die correctly, and set all
4831 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4832 location of the info_ptr after reading all of those dies. PARENT
4833 is the parent of the die in question. */
4835 static struct die_info
*
4836 read_die_and_children (char *info_ptr
, bfd
*abfd
,
4837 struct dwarf2_cu
*cu
,
4838 char **new_info_ptr
,
4839 struct die_info
*parent
)
4841 struct die_info
*die
;
4845 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4846 store_in_ref_table (die
->offset
, die
, cu
);
4850 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4856 *new_info_ptr
= cur_ptr
;
4859 die
->sibling
= NULL
;
4860 die
->parent
= parent
;
4864 /* Read a die, all of its descendents, and all of its siblings; set
4865 all of the fields of all of the dies correctly. Arguments are as
4866 in read_die_and_children. */
4868 static struct die_info
*
4869 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
4870 struct dwarf2_cu
*cu
,
4871 char **new_info_ptr
,
4872 struct die_info
*parent
)
4874 struct die_info
*first_die
, *last_sibling
;
4878 first_die
= last_sibling
= NULL
;
4882 struct die_info
*die
4883 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4891 last_sibling
->sibling
= die
;
4896 *new_info_ptr
= cur_ptr
;
4906 /* Free a linked list of dies. */
4909 free_die_list (struct die_info
*dies
)
4911 struct die_info
*die
, *next
;
4916 if (die
->child
!= NULL
)
4917 free_die_list (die
->child
);
4918 next
= die
->sibling
;
4925 /* Read the contents of the section at OFFSET and of size SIZE from the
4926 object file specified by OBJFILE into the objfile_obstack and return it. */
4929 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4931 bfd
*abfd
= objfile
->obfd
;
4933 bfd_size_type size
= bfd_get_section_size (sectp
);
4938 buf
= (char *) obstack_alloc (&objfile
->objfile_obstack
, size
);
4940 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
4944 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4945 || bfd_bread (buf
, size
, abfd
) != size
)
4946 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
4947 bfd_get_filename (abfd
));
4952 /* In DWARF version 2, the description of the debugging information is
4953 stored in a separate .debug_abbrev section. Before we read any
4954 dies from a section we read in all abbreviations and install them
4955 in a hash table. This function also sets flags in CU describing
4956 the data found in the abbrev table. */
4959 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4961 struct comp_unit_head
*cu_header
= &cu
->header
;
4963 struct abbrev_info
*cur_abbrev
;
4964 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4965 unsigned int abbrev_form
, hash_number
;
4966 struct attr_abbrev
*cur_attrs
;
4967 unsigned int allocated_attrs
;
4969 /* Initialize dwarf2 abbrevs */
4970 obstack_init (&cu
->abbrev_obstack
);
4971 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
4973 * sizeof (struct abbrev_info
*)));
4974 memset (cu
->dwarf2_abbrevs
, 0,
4975 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
4977 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
4978 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4979 abbrev_ptr
+= bytes_read
;
4981 allocated_attrs
= ATTR_ALLOC_CHUNK
;
4982 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
4984 /* loop until we reach an abbrev number of 0 */
4985 while (abbrev_number
)
4987 cur_abbrev
= dwarf_alloc_abbrev (cu
);
4989 /* read in abbrev header */
4990 cur_abbrev
->number
= abbrev_number
;
4991 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4992 abbrev_ptr
+= bytes_read
;
4993 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
4996 if (cur_abbrev
->tag
== DW_TAG_namespace
)
4997 cu
->has_namespace_info
= 1;
4999 /* now read in declarations */
5000 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5001 abbrev_ptr
+= bytes_read
;
5002 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5003 abbrev_ptr
+= bytes_read
;
5006 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5008 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5010 = xrealloc (cur_attrs
, (allocated_attrs
5011 * sizeof (struct attr_abbrev
)));
5014 /* Record whether this compilation unit might have
5015 inter-compilation-unit references. If we don't know what form
5016 this attribute will have, then it might potentially be a
5017 DW_FORM_ref_addr, so we conservatively expect inter-CU
5020 if (abbrev_form
== DW_FORM_ref_addr
5021 || abbrev_form
== DW_FORM_indirect
)
5022 cu
->has_form_ref_addr
= 1;
5024 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5025 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5026 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5027 abbrev_ptr
+= bytes_read
;
5028 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5029 abbrev_ptr
+= bytes_read
;
5032 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5033 (cur_abbrev
->num_attrs
5034 * sizeof (struct attr_abbrev
)));
5035 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5036 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5038 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5039 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5040 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5042 /* Get next abbreviation.
5043 Under Irix6 the abbreviations for a compilation unit are not
5044 always properly terminated with an abbrev number of 0.
5045 Exit loop if we encounter an abbreviation which we have
5046 already read (which means we are about to read the abbreviations
5047 for the next compile unit) or if the end of the abbreviation
5048 table is reached. */
5049 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5050 >= dwarf2_per_objfile
->abbrev_size
)
5052 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5053 abbrev_ptr
+= bytes_read
;
5054 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5061 /* Release the memory used by the abbrev table for a compilation unit. */
5064 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5066 struct dwarf2_cu
*cu
= ptr_to_cu
;
5068 obstack_free (&cu
->abbrev_obstack
, NULL
);
5069 cu
->dwarf2_abbrevs
= NULL
;
5072 /* Lookup an abbrev_info structure in the abbrev hash table. */
5074 static struct abbrev_info
*
5075 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5077 unsigned int hash_number
;
5078 struct abbrev_info
*abbrev
;
5080 hash_number
= number
% ABBREV_HASH_SIZE
;
5081 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5085 if (abbrev
->number
== number
)
5088 abbrev
= abbrev
->next
;
5093 /* Returns nonzero if TAG represents a type that we might generate a partial
5097 is_type_tag_for_partial (int tag
)
5102 /* Some types that would be reasonable to generate partial symbols for,
5103 that we don't at present. */
5104 case DW_TAG_array_type
:
5105 case DW_TAG_file_type
:
5106 case DW_TAG_ptr_to_member_type
:
5107 case DW_TAG_set_type
:
5108 case DW_TAG_string_type
:
5109 case DW_TAG_subroutine_type
:
5111 case DW_TAG_base_type
:
5112 case DW_TAG_class_type
:
5113 case DW_TAG_enumeration_type
:
5114 case DW_TAG_structure_type
:
5115 case DW_TAG_subrange_type
:
5116 case DW_TAG_typedef
:
5117 case DW_TAG_union_type
:
5124 /* Load all DIEs that are interesting for partial symbols into memory. */
5126 static struct partial_die_info
*
5127 load_partial_dies (bfd
*abfd
, char *info_ptr
, int building_psymtab
,
5128 struct dwarf2_cu
*cu
)
5130 struct partial_die_info
*part_die
;
5131 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5132 struct abbrev_info
*abbrev
;
5133 unsigned int bytes_read
;
5135 int nesting_level
= 1;
5141 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5145 &cu
->comp_unit_obstack
,
5146 hashtab_obstack_allocate
,
5147 dummy_obstack_deallocate
);
5149 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5150 sizeof (struct partial_die_info
));
5154 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5156 /* A NULL abbrev means the end of a series of children. */
5159 if (--nesting_level
== 0)
5161 /* PART_DIE was probably the last thing allocated on the
5162 comp_unit_obstack, so we could call obstack_free
5163 here. We don't do that because the waste is small,
5164 and will be cleaned up when we're done with this
5165 compilation unit. This way, we're also more robust
5166 against other users of the comp_unit_obstack. */
5169 info_ptr
+= bytes_read
;
5170 last_die
= parent_die
;
5171 parent_die
= parent_die
->die_parent
;
5175 /* Check whether this DIE is interesting enough to save. */
5176 if (!is_type_tag_for_partial (abbrev
->tag
)
5177 && abbrev
->tag
!= DW_TAG_enumerator
5178 && abbrev
->tag
!= DW_TAG_subprogram
5179 && abbrev
->tag
!= DW_TAG_variable
5180 && abbrev
->tag
!= DW_TAG_namespace
)
5182 /* Otherwise we skip to the next sibling, if any. */
5183 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5187 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5188 abfd
, info_ptr
, cu
);
5190 /* This two-pass algorithm for processing partial symbols has a
5191 high cost in cache pressure. Thus, handle some simple cases
5192 here which cover the majority of C partial symbols. DIEs
5193 which neither have specification tags in them, nor could have
5194 specification tags elsewhere pointing at them, can simply be
5195 processed and discarded.
5197 This segment is also optional; scan_partial_symbols and
5198 add_partial_symbol will handle these DIEs if we chain
5199 them in normally. When compilers which do not emit large
5200 quantities of duplicate debug information are more common,
5201 this code can probably be removed. */
5203 /* Any complete simple types at the top level (pretty much all
5204 of them, for a language without namespaces), can be processed
5206 if (parent_die
== NULL
5207 && part_die
->has_specification
== 0
5208 && part_die
->is_declaration
== 0
5209 && (part_die
->tag
== DW_TAG_typedef
5210 || part_die
->tag
== DW_TAG_base_type
5211 || part_die
->tag
== DW_TAG_subrange_type
))
5213 if (building_psymtab
&& part_die
->name
!= NULL
)
5214 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5215 VAR_DOMAIN
, LOC_TYPEDEF
,
5216 &cu
->objfile
->static_psymbols
,
5217 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5218 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5222 /* If we're at the second level, and we're an enumerator, and
5223 our parent has no specification (meaning possibly lives in a
5224 namespace elsewhere), then we can add the partial symbol now
5225 instead of queueing it. */
5226 if (part_die
->tag
== DW_TAG_enumerator
5227 && parent_die
!= NULL
5228 && parent_die
->die_parent
== NULL
5229 && parent_die
->tag
== DW_TAG_enumeration_type
5230 && parent_die
->has_specification
== 0)
5232 if (part_die
->name
== NULL
)
5233 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5234 else if (building_psymtab
)
5235 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5236 VAR_DOMAIN
, LOC_CONST
,
5237 (cu
->language
== language_cplus
5238 || cu
->language
== language_java
)
5239 ? &cu
->objfile
->global_psymbols
5240 : &cu
->objfile
->static_psymbols
,
5241 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5243 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5247 /* We'll save this DIE so link it in. */
5248 part_die
->die_parent
= parent_die
;
5249 part_die
->die_sibling
= NULL
;
5250 part_die
->die_child
= NULL
;
5252 if (last_die
&& last_die
== parent_die
)
5253 last_die
->die_child
= part_die
;
5255 last_die
->die_sibling
= part_die
;
5257 last_die
= part_die
;
5259 if (first_die
== NULL
)
5260 first_die
= part_die
;
5262 /* Maybe add the DIE to the hash table. Not all DIEs that we
5263 find interesting need to be in the hash table, because we
5264 also have the parent/sibling/child chains; only those that we
5265 might refer to by offset later during partial symbol reading.
5267 For now this means things that might have be the target of a
5268 DW_AT_specification, DW_AT_abstract_origin, or
5269 DW_AT_extension. DW_AT_extension will refer only to
5270 namespaces; DW_AT_abstract_origin refers to functions (and
5271 many things under the function DIE, but we do not recurse
5272 into function DIEs during partial symbol reading) and
5273 possibly variables as well; DW_AT_specification refers to
5274 declarations. Declarations ought to have the DW_AT_declaration
5275 flag. It happens that GCC forgets to put it in sometimes, but
5276 only for functions, not for types.
5278 Adding more things than necessary to the hash table is harmless
5279 except for the performance cost. Adding too few will result in
5280 internal errors in find_partial_die. */
5282 if (abbrev
->tag
== DW_TAG_subprogram
5283 || abbrev
->tag
== DW_TAG_variable
5284 || abbrev
->tag
== DW_TAG_namespace
5285 || part_die
->is_declaration
)
5289 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5290 part_die
->offset
, INSERT
);
5294 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5295 sizeof (struct partial_die_info
));
5297 /* For some DIEs we want to follow their children (if any). For C
5298 we have no reason to follow the children of structures; for other
5299 languages we have to, both so that we can get at method physnames
5300 to infer fully qualified class names, and for DW_AT_specification. */
5301 if (last_die
->has_children
5302 && (last_die
->tag
== DW_TAG_namespace
5303 || last_die
->tag
== DW_TAG_enumeration_type
5304 || (cu
->language
!= language_c
5305 && (last_die
->tag
== DW_TAG_class_type
5306 || last_die
->tag
== DW_TAG_structure_type
5307 || last_die
->tag
== DW_TAG_union_type
))))
5310 parent_die
= last_die
;
5314 /* Otherwise we skip to the next sibling, if any. */
5315 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5317 /* Back to the top, do it again. */
5321 /* Read a minimal amount of information into the minimal die structure. */
5324 read_partial_die (struct partial_die_info
*part_die
,
5325 struct abbrev_info
*abbrev
,
5326 unsigned int abbrev_len
, bfd
*abfd
,
5327 char *info_ptr
, struct dwarf2_cu
*cu
)
5329 unsigned int bytes_read
, i
;
5330 struct attribute attr
;
5331 int has_low_pc_attr
= 0;
5332 int has_high_pc_attr
= 0;
5334 memset (part_die
, 0, sizeof (struct partial_die_info
));
5336 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5338 info_ptr
+= abbrev_len
;
5343 part_die
->tag
= abbrev
->tag
;
5344 part_die
->has_children
= abbrev
->has_children
;
5346 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5348 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5350 /* Store the data if it is of an attribute we want to keep in a
5351 partial symbol table. */
5356 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5357 if (part_die
->name
== NULL
)
5358 part_die
->name
= DW_STRING (&attr
);
5360 case DW_AT_comp_dir
:
5361 if (part_die
->dirname
== NULL
)
5362 part_die
->dirname
= DW_STRING (&attr
);
5364 case DW_AT_MIPS_linkage_name
:
5365 part_die
->name
= DW_STRING (&attr
);
5368 has_low_pc_attr
= 1;
5369 part_die
->lowpc
= DW_ADDR (&attr
);
5372 has_high_pc_attr
= 1;
5373 part_die
->highpc
= DW_ADDR (&attr
);
5375 case DW_AT_location
:
5376 /* Support the .debug_loc offsets */
5377 if (attr_form_is_block (&attr
))
5379 part_die
->locdesc
= DW_BLOCK (&attr
);
5381 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5383 dwarf2_complex_location_expr_complaint ();
5387 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5388 "partial symbol information");
5391 case DW_AT_language
:
5392 part_die
->language
= DW_UNSND (&attr
);
5394 case DW_AT_external
:
5395 part_die
->is_external
= DW_UNSND (&attr
);
5397 case DW_AT_declaration
:
5398 part_die
->is_declaration
= DW_UNSND (&attr
);
5401 part_die
->has_type
= 1;
5403 case DW_AT_abstract_origin
:
5404 case DW_AT_specification
:
5405 case DW_AT_extension
:
5406 part_die
->has_specification
= 1;
5407 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5410 /* Ignore absolute siblings, they might point outside of
5411 the current compile unit. */
5412 if (attr
.form
== DW_FORM_ref_addr
)
5413 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5415 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5416 + dwarf2_get_ref_die_offset (&attr
, cu
);
5418 case DW_AT_stmt_list
:
5419 part_die
->has_stmt_list
= 1;
5420 part_die
->line_offset
= DW_UNSND (&attr
);
5427 /* When using the GNU linker, .gnu.linkonce. sections are used to
5428 eliminate duplicate copies of functions and vtables and such.
5429 The linker will arbitrarily choose one and discard the others.
5430 The AT_*_pc values for such functions refer to local labels in
5431 these sections. If the section from that file was discarded, the
5432 labels are not in the output, so the relocs get a value of 0.
5433 If this is a discarded function, mark the pc bounds as invalid,
5434 so that GDB will ignore it. */
5435 if (has_low_pc_attr
&& has_high_pc_attr
5436 && part_die
->lowpc
< part_die
->highpc
5437 && (part_die
->lowpc
!= 0
5438 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5439 part_die
->has_pc_info
= 1;
5443 /* Find a cached partial DIE at OFFSET in CU. */
5445 static struct partial_die_info
*
5446 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5448 struct partial_die_info
*lookup_die
= NULL
;
5449 struct partial_die_info part_die
;
5451 part_die
.offset
= offset
;
5452 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5454 if (lookup_die
== NULL
)
5455 internal_error (__FILE__
, __LINE__
,
5456 _("could not find partial DIE in cache\n"));
5461 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5463 static struct partial_die_info
*
5464 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5466 struct dwarf2_per_cu_data
*per_cu
;
5468 if (offset
>= cu
->header
.offset
5469 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5470 return find_partial_die_in_comp_unit (offset
, cu
);
5472 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5474 if (per_cu
->cu
== NULL
)
5476 load_comp_unit (per_cu
, cu
->objfile
);
5477 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5478 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5481 per_cu
->cu
->last_used
= 0;
5482 return find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5485 /* Adjust PART_DIE before generating a symbol for it. This function
5486 may set the is_external flag or change the DIE's name. */
5489 fixup_partial_die (struct partial_die_info
*part_die
,
5490 struct dwarf2_cu
*cu
)
5492 /* If we found a reference attribute and the DIE has no name, try
5493 to find a name in the referred to DIE. */
5495 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5497 struct partial_die_info
*spec_die
;
5499 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5501 fixup_partial_die (spec_die
, cu
);
5505 part_die
->name
= spec_die
->name
;
5507 /* Copy DW_AT_external attribute if it is set. */
5508 if (spec_die
->is_external
)
5509 part_die
->is_external
= spec_die
->is_external
;
5513 /* Set default names for some unnamed DIEs. */
5514 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5515 || part_die
->tag
== DW_TAG_class_type
))
5516 part_die
->name
= "(anonymous class)";
5518 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5519 part_die
->name
= "(anonymous namespace)";
5521 if (part_die
->tag
== DW_TAG_structure_type
5522 || part_die
->tag
== DW_TAG_class_type
5523 || part_die
->tag
== DW_TAG_union_type
)
5524 guess_structure_name (part_die
, cu
);
5527 /* Read the die from the .debug_info section buffer. Set DIEP to
5528 point to a newly allocated die with its information, except for its
5529 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5530 whether the die has children or not. */
5533 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
5534 struct dwarf2_cu
*cu
, int *has_children
)
5536 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5537 struct abbrev_info
*abbrev
;
5538 struct die_info
*die
;
5540 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5541 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5542 info_ptr
+= bytes_read
;
5545 die
= dwarf_alloc_die ();
5547 die
->abbrev
= abbrev_number
;
5554 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5557 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5559 bfd_get_filename (abfd
));
5561 die
= dwarf_alloc_die ();
5562 die
->offset
= offset
;
5563 die
->tag
= abbrev
->tag
;
5564 die
->abbrev
= abbrev_number
;
5567 die
->num_attrs
= abbrev
->num_attrs
;
5568 die
->attrs
= (struct attribute
*)
5569 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5571 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5573 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5574 abfd
, info_ptr
, cu
);
5576 /* If this attribute is an absolute reference to a different
5577 compilation unit, make sure that compilation unit is loaded
5579 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5580 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5581 || (DW_ADDR (&die
->attrs
[i
])
5582 >= cu
->header
.offset
+ cu
->header
.length
)))
5584 struct dwarf2_per_cu_data
*per_cu
;
5585 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5588 /* Mark the dependence relation so that we don't flush PER_CU
5590 dwarf2_add_dependence (cu
, per_cu
);
5592 /* If it's already on the queue, we have nothing to do. */
5596 /* If the compilation unit is already loaded, just mark it as
5598 if (per_cu
->cu
!= NULL
)
5600 per_cu
->cu
->last_used
= 0;
5604 /* Add it to the queue. */
5605 queue_comp_unit (per_cu
);
5610 *has_children
= abbrev
->has_children
;
5614 /* Read an attribute value described by an attribute form. */
5617 read_attribute_value (struct attribute
*attr
, unsigned form
,
5618 bfd
*abfd
, char *info_ptr
,
5619 struct dwarf2_cu
*cu
)
5621 struct comp_unit_head
*cu_header
= &cu
->header
;
5622 unsigned int bytes_read
;
5623 struct dwarf_block
*blk
;
5629 case DW_FORM_ref_addr
:
5630 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5631 info_ptr
+= bytes_read
;
5633 case DW_FORM_block2
:
5634 blk
= dwarf_alloc_block (cu
);
5635 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5637 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5638 info_ptr
+= blk
->size
;
5639 DW_BLOCK (attr
) = blk
;
5641 case DW_FORM_block4
:
5642 blk
= dwarf_alloc_block (cu
);
5643 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5645 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5646 info_ptr
+= blk
->size
;
5647 DW_BLOCK (attr
) = blk
;
5650 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5654 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5658 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5661 case DW_FORM_string
:
5662 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5663 info_ptr
+= bytes_read
;
5666 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5668 info_ptr
+= bytes_read
;
5671 blk
= dwarf_alloc_block (cu
);
5672 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5673 info_ptr
+= bytes_read
;
5674 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5675 info_ptr
+= blk
->size
;
5676 DW_BLOCK (attr
) = blk
;
5678 case DW_FORM_block1
:
5679 blk
= dwarf_alloc_block (cu
);
5680 blk
->size
= read_1_byte (abfd
, info_ptr
);
5682 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5683 info_ptr
+= blk
->size
;
5684 DW_BLOCK (attr
) = blk
;
5687 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5691 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5695 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5696 info_ptr
+= bytes_read
;
5699 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5700 info_ptr
+= bytes_read
;
5703 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5707 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5711 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5715 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5718 case DW_FORM_ref_udata
:
5719 DW_ADDR (attr
) = (cu
->header
.offset
5720 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5721 info_ptr
+= bytes_read
;
5723 case DW_FORM_indirect
:
5724 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5725 info_ptr
+= bytes_read
;
5726 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5729 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5730 dwarf_form_name (form
),
5731 bfd_get_filename (abfd
));
5736 /* Read an attribute described by an abbreviated attribute. */
5739 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5740 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
5742 attr
->name
= abbrev
->name
;
5743 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5746 /* read dwarf information from a buffer */
5749 read_1_byte (bfd
*abfd
, char *buf
)
5751 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
5755 read_1_signed_byte (bfd
*abfd
, char *buf
)
5757 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
5761 read_2_bytes (bfd
*abfd
, char *buf
)
5763 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5767 read_2_signed_bytes (bfd
*abfd
, char *buf
)
5769 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5773 read_4_bytes (bfd
*abfd
, char *buf
)
5775 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5779 read_4_signed_bytes (bfd
*abfd
, char *buf
)
5781 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5784 static unsigned long
5785 read_8_bytes (bfd
*abfd
, char *buf
)
5787 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5791 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
5793 struct comp_unit_head
*cu_header
= &cu
->header
;
5794 CORE_ADDR retval
= 0;
5796 if (cu_header
->signed_addr_p
)
5798 switch (cu_header
->addr_size
)
5801 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5804 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5807 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
5810 internal_error (__FILE__
, __LINE__
,
5811 _("read_address: bad switch, signed [in module %s]"),
5812 bfd_get_filename (abfd
));
5817 switch (cu_header
->addr_size
)
5820 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5823 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5826 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5829 internal_error (__FILE__
, __LINE__
,
5830 _("read_address: bad switch, unsigned [in module %s]"),
5831 bfd_get_filename (abfd
));
5835 *bytes_read
= cu_header
->addr_size
;
5839 /* Read the initial length from a section. The (draft) DWARF 3
5840 specification allows the initial length to take up either 4 bytes
5841 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5842 bytes describe the length and all offsets will be 8 bytes in length
5845 An older, non-standard 64-bit format is also handled by this
5846 function. The older format in question stores the initial length
5847 as an 8-byte quantity without an escape value. Lengths greater
5848 than 2^32 aren't very common which means that the initial 4 bytes
5849 is almost always zero. Since a length value of zero doesn't make
5850 sense for the 32-bit format, this initial zero can be considered to
5851 be an escape value which indicates the presence of the older 64-bit
5852 format. As written, the code can't detect (old format) lengths
5853 greater than 4GB. If it becomes necessary to handle lengths
5854 somewhat larger than 4GB, we could allow other small values (such
5855 as the non-sensical values of 1, 2, and 3) to also be used as
5856 escape values indicating the presence of the old format.
5858 The value returned via bytes_read should be used to increment the
5859 relevant pointer after calling read_initial_length().
5861 As a side effect, this function sets the fields initial_length_size
5862 and offset_size in cu_header to the values appropriate for the
5863 length field. (The format of the initial length field determines
5864 the width of file offsets to be fetched later with read_offset().)
5866 [ Note: read_initial_length() and read_offset() are based on the
5867 document entitled "DWARF Debugging Information Format", revision
5868 3, draft 8, dated November 19, 2001. This document was obtained
5871 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5873 This document is only a draft and is subject to change. (So beware.)
5875 Details regarding the older, non-standard 64-bit format were
5876 determined empirically by examining 64-bit ELF files produced by
5877 the SGI toolchain on an IRIX 6.5 machine.
5879 - Kevin, July 16, 2002
5883 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
5886 LONGEST length
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5888 if (length
== 0xffffffff)
5890 length
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
5893 else if (length
== 0)
5895 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
5896 length
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5906 gdb_assert (cu_header
->initial_length_size
== 0
5907 || cu_header
->initial_length_size
== 4
5908 || cu_header
->initial_length_size
== 8
5909 || cu_header
->initial_length_size
== 12);
5911 if (cu_header
->initial_length_size
!= 0
5912 && cu_header
->initial_length_size
!= *bytes_read
)
5913 complaint (&symfile_complaints
,
5914 _("intermixed 32-bit and 64-bit DWARF sections"));
5916 cu_header
->initial_length_size
= *bytes_read
;
5917 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
5923 /* Read an offset from the data stream. The size of the offset is
5924 given by cu_header->offset_size. */
5927 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
5932 switch (cu_header
->offset_size
)
5935 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5939 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5943 internal_error (__FILE__
, __LINE__
,
5944 _("read_offset: bad switch [in module %s]"),
5945 bfd_get_filename (abfd
));
5952 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
5954 /* If the size of a host char is 8 bits, we can return a pointer
5955 to the buffer, otherwise we have to copy the data to a buffer
5956 allocated on the temporary obstack. */
5957 gdb_assert (HOST_CHAR_BIT
== 8);
5962 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5964 /* If the size of a host char is 8 bits, we can return a pointer
5965 to the string, otherwise we have to copy the string to a buffer
5966 allocated on the temporary obstack. */
5967 gdb_assert (HOST_CHAR_BIT
== 8);
5970 *bytes_read_ptr
= 1;
5973 *bytes_read_ptr
= strlen (buf
) + 1;
5978 read_indirect_string (bfd
*abfd
, char *buf
,
5979 const struct comp_unit_head
*cu_header
,
5980 unsigned int *bytes_read_ptr
)
5982 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
5983 (int *) bytes_read_ptr
);
5985 if (dwarf2_per_objfile
->str_buffer
== NULL
)
5987 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
5988 bfd_get_filename (abfd
));
5991 if (str_offset
>= dwarf2_per_objfile
->str_size
)
5993 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
5994 bfd_get_filename (abfd
));
5997 gdb_assert (HOST_CHAR_BIT
== 8);
5998 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6000 return dwarf2_per_objfile
->str_buffer
+ str_offset
;
6003 static unsigned long
6004 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
6006 unsigned long result
;
6007 unsigned int num_read
;
6017 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6020 result
|= ((unsigned long)(byte
& 127) << shift
);
6021 if ((byte
& 128) == 0)
6027 *bytes_read_ptr
= num_read
;
6032 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
6035 int i
, shift
, size
, num_read
;
6045 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6048 result
|= ((long)(byte
& 127) << shift
);
6050 if ((byte
& 128) == 0)
6055 if ((shift
< size
) && (byte
& 0x40))
6057 result
|= -(1 << shift
);
6059 *bytes_read_ptr
= num_read
;
6063 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6066 skip_leb128 (bfd
*abfd
, char *buf
)
6072 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6074 if ((byte
& 128) == 0)
6080 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6086 cu
->language
= language_c
;
6088 case DW_LANG_C_plus_plus
:
6089 cu
->language
= language_cplus
;
6091 case DW_LANG_Fortran77
:
6092 case DW_LANG_Fortran90
:
6093 case DW_LANG_Fortran95
:
6094 cu
->language
= language_fortran
;
6096 case DW_LANG_Mips_Assembler
:
6097 cu
->language
= language_asm
;
6100 cu
->language
= language_java
;
6104 cu
->language
= language_ada
;
6106 case DW_LANG_Cobol74
:
6107 case DW_LANG_Cobol85
:
6108 case DW_LANG_Pascal83
:
6109 case DW_LANG_Modula2
:
6111 cu
->language
= language_minimal
;
6114 cu
->language_defn
= language_def (cu
->language
);
6117 /* Return the named attribute or NULL if not there. */
6119 static struct attribute
*
6120 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6123 struct attribute
*spec
= NULL
;
6125 for (i
= 0; i
< die
->num_attrs
; ++i
)
6127 if (die
->attrs
[i
].name
== name
)
6128 return &die
->attrs
[i
];
6129 if (die
->attrs
[i
].name
== DW_AT_specification
6130 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6131 spec
= &die
->attrs
[i
];
6135 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6140 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6141 and holds a non-zero value. This function should only be used for
6142 DW_FORM_flag attributes. */
6145 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6147 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6149 return (attr
&& DW_UNSND (attr
));
6153 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6155 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6156 which value is non-zero. However, we have to be careful with
6157 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6158 (via dwarf2_flag_true_p) follows this attribute. So we may
6159 end up accidently finding a declaration attribute that belongs
6160 to a different DIE referenced by the specification attribute,
6161 even though the given DIE does not have a declaration attribute. */
6162 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6163 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6166 /* Return the die giving the specification for DIE, if there is
6169 static struct die_info
*
6170 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6172 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6174 if (spec_attr
== NULL
)
6177 return follow_die_ref (die
, spec_attr
, cu
);
6180 /* Free the line_header structure *LH, and any arrays and strings it
6183 free_line_header (struct line_header
*lh
)
6185 if (lh
->standard_opcode_lengths
)
6186 xfree (lh
->standard_opcode_lengths
);
6188 /* Remember that all the lh->file_names[i].name pointers are
6189 pointers into debug_line_buffer, and don't need to be freed. */
6191 xfree (lh
->file_names
);
6193 /* Similarly for the include directory names. */
6194 if (lh
->include_dirs
)
6195 xfree (lh
->include_dirs
);
6201 /* Add an entry to LH's include directory table. */
6203 add_include_dir (struct line_header
*lh
, char *include_dir
)
6205 /* Grow the array if necessary. */
6206 if (lh
->include_dirs_size
== 0)
6208 lh
->include_dirs_size
= 1; /* for testing */
6209 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6210 * sizeof (*lh
->include_dirs
));
6212 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6214 lh
->include_dirs_size
*= 2;
6215 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6216 (lh
->include_dirs_size
6217 * sizeof (*lh
->include_dirs
)));
6220 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6224 /* Add an entry to LH's file name table. */
6226 add_file_name (struct line_header
*lh
,
6228 unsigned int dir_index
,
6229 unsigned int mod_time
,
6230 unsigned int length
)
6232 struct file_entry
*fe
;
6234 /* Grow the array if necessary. */
6235 if (lh
->file_names_size
== 0)
6237 lh
->file_names_size
= 1; /* for testing */
6238 lh
->file_names
= xmalloc (lh
->file_names_size
6239 * sizeof (*lh
->file_names
));
6241 else if (lh
->num_file_names
>= lh
->file_names_size
)
6243 lh
->file_names_size
*= 2;
6244 lh
->file_names
= xrealloc (lh
->file_names
,
6245 (lh
->file_names_size
6246 * sizeof (*lh
->file_names
)));
6249 fe
= &lh
->file_names
[lh
->num_file_names
++];
6251 fe
->dir_index
= dir_index
;
6252 fe
->mod_time
= mod_time
;
6253 fe
->length
= length
;
6258 /* Read the statement program header starting at OFFSET in
6259 .debug_line, according to the endianness of ABFD. Return a pointer
6260 to a struct line_header, allocated using xmalloc.
6262 NOTE: the strings in the include directory and file name tables of
6263 the returned object point into debug_line_buffer, and must not be
6265 static struct line_header
*
6266 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6267 struct dwarf2_cu
*cu
)
6269 struct cleanup
*back_to
;
6270 struct line_header
*lh
;
6274 char *cur_dir
, *cur_file
;
6276 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6278 complaint (&symfile_complaints
, _("missing .debug_line section"));
6282 /* Make sure that at least there's room for the total_length field.
6283 That could be 12 bytes long, but we're just going to fudge that. */
6284 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6286 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6290 lh
= xmalloc (sizeof (*lh
));
6291 memset (lh
, 0, sizeof (*lh
));
6292 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6295 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6297 /* Read in the header. */
6299 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6300 line_ptr
+= bytes_read
;
6301 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6302 + dwarf2_per_objfile
->line_size
))
6304 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6307 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6308 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6310 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6311 line_ptr
+= bytes_read
;
6312 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6314 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6316 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6318 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6320 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6322 lh
->standard_opcode_lengths
6323 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
6325 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6326 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6328 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6332 /* Read directory table. */
6333 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6335 line_ptr
+= bytes_read
;
6336 add_include_dir (lh
, cur_dir
);
6338 line_ptr
+= bytes_read
;
6340 /* Read file name table. */
6341 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6343 unsigned int dir_index
, mod_time
, length
;
6345 line_ptr
+= bytes_read
;
6346 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6347 line_ptr
+= bytes_read
;
6348 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6349 line_ptr
+= bytes_read
;
6350 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6351 line_ptr
+= bytes_read
;
6353 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6355 line_ptr
+= bytes_read
;
6356 lh
->statement_program_start
= line_ptr
;
6358 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6359 + dwarf2_per_objfile
->line_size
))
6360 complaint (&symfile_complaints
,
6361 _("line number info header doesn't fit in `.debug_line' section"));
6363 discard_cleanups (back_to
);
6367 /* This function exists to work around a bug in certain compilers
6368 (particularly GCC 2.95), in which the first line number marker of a
6369 function does not show up until after the prologue, right before
6370 the second line number marker. This function shifts ADDRESS down
6371 to the beginning of the function if necessary, and is called on
6372 addresses passed to record_line. */
6375 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6377 struct function_range
*fn
;
6379 /* Find the function_range containing address. */
6384 cu
->cached_fn
= cu
->first_fn
;
6388 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6394 while (fn
&& fn
!= cu
->cached_fn
)
6395 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6405 if (address
!= fn
->lowpc
)
6406 complaint (&symfile_complaints
,
6407 _("misplaced first line number at 0x%lx for '%s'"),
6408 (unsigned long) address
, fn
->name
);
6413 /* Decode the Line Number Program (LNP) for the given line_header
6414 structure and CU. The actual information extracted and the type
6415 of structures created from the LNP depends on the value of PST.
6417 1. If PST is NULL, then this procedure uses the data from the program
6418 to create all necessary symbol tables, and their linetables.
6419 The compilation directory of the file is passed in COMP_DIR,
6420 and must not be NULL.
6422 2. If PST is not NULL, this procedure reads the program to determine
6423 the list of files included by the unit represented by PST, and
6424 builds all the associated partial symbol tables. In this case,
6425 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6426 is not used to compute the full name of the symtab, and therefore
6427 omitting it when building the partial symtab does not introduce
6428 the potential for inconsistency - a partial symtab and its associated
6429 symbtab having a different fullname -). */
6432 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6433 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6437 unsigned int bytes_read
;
6438 unsigned char op_code
, extended_op
, adj_opcode
;
6440 struct objfile
*objfile
= cu
->objfile
;
6441 const int decode_for_pst_p
= (pst
!= NULL
);
6443 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6445 line_ptr
= lh
->statement_program_start
;
6446 line_end
= lh
->statement_program_end
;
6448 /* Read the statement sequences until there's nothing left. */
6449 while (line_ptr
< line_end
)
6451 /* state machine registers */
6452 CORE_ADDR address
= 0;
6453 unsigned int file
= 1;
6454 unsigned int line
= 1;
6455 unsigned int column
= 0;
6456 int is_stmt
= lh
->default_is_stmt
;
6457 int basic_block
= 0;
6458 int end_sequence
= 0;
6460 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6462 /* Start a subfile for the current file of the state machine. */
6463 /* lh->include_dirs and lh->file_names are 0-based, but the
6464 directory and file name numbers in the statement program
6466 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6470 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6473 dwarf2_start_subfile (fe
->name
, dir
);
6476 /* Decode the table. */
6477 while (!end_sequence
)
6479 op_code
= read_1_byte (abfd
, line_ptr
);
6482 if (op_code
>= lh
->opcode_base
)
6484 /* Special operand. */
6485 adj_opcode
= op_code
- lh
->opcode_base
;
6486 address
+= (adj_opcode
/ lh
->line_range
)
6487 * lh
->minimum_instruction_length
;
6488 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6489 lh
->file_names
[file
- 1].included_p
= 1;
6490 if (!decode_for_pst_p
)
6492 /* Append row to matrix using current values. */
6493 record_line (current_subfile
, line
,
6494 check_cu_functions (address
, cu
));
6498 else switch (op_code
)
6500 case DW_LNS_extended_op
:
6501 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6502 line_ptr
+= bytes_read
;
6503 extended_op
= read_1_byte (abfd
, line_ptr
);
6505 switch (extended_op
)
6507 case DW_LNE_end_sequence
:
6509 lh
->file_names
[file
- 1].included_p
= 1;
6510 if (!decode_for_pst_p
)
6511 record_line (current_subfile
, 0, address
);
6513 case DW_LNE_set_address
:
6514 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6515 line_ptr
+= bytes_read
;
6516 address
+= baseaddr
;
6518 case DW_LNE_define_file
:
6521 unsigned int dir_index
, mod_time
, length
;
6523 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6524 line_ptr
+= bytes_read
;
6526 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6527 line_ptr
+= bytes_read
;
6529 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6530 line_ptr
+= bytes_read
;
6532 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6533 line_ptr
+= bytes_read
;
6534 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6538 complaint (&symfile_complaints
,
6539 _("mangled .debug_line section"));
6544 lh
->file_names
[file
- 1].included_p
= 1;
6545 if (!decode_for_pst_p
)
6546 record_line (current_subfile
, line
,
6547 check_cu_functions (address
, cu
));
6550 case DW_LNS_advance_pc
:
6551 address
+= lh
->minimum_instruction_length
6552 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6553 line_ptr
+= bytes_read
;
6555 case DW_LNS_advance_line
:
6556 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6557 line_ptr
+= bytes_read
;
6559 case DW_LNS_set_file
:
6561 /* The arrays lh->include_dirs and lh->file_names are
6562 0-based, but the directory and file name numbers in
6563 the statement program are 1-based. */
6564 struct file_entry
*fe
;
6567 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6568 line_ptr
+= bytes_read
;
6569 fe
= &lh
->file_names
[file
- 1];
6571 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6574 if (!decode_for_pst_p
)
6575 dwarf2_start_subfile (fe
->name
, dir
);
6578 case DW_LNS_set_column
:
6579 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6580 line_ptr
+= bytes_read
;
6582 case DW_LNS_negate_stmt
:
6583 is_stmt
= (!is_stmt
);
6585 case DW_LNS_set_basic_block
:
6588 /* Add to the address register of the state machine the
6589 address increment value corresponding to special opcode
6590 255. I.e., this value is scaled by the minimum
6591 instruction length since special opcode 255 would have
6592 scaled the the increment. */
6593 case DW_LNS_const_add_pc
:
6594 address
+= (lh
->minimum_instruction_length
6595 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6597 case DW_LNS_fixed_advance_pc
:
6598 address
+= read_2_bytes (abfd
, line_ptr
);
6603 /* Unknown standard opcode, ignore it. */
6606 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6608 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6609 line_ptr
+= bytes_read
;
6616 if (decode_for_pst_p
)
6620 /* Now that we're done scanning the Line Header Program, we can
6621 create the psymtab of each included file. */
6622 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6623 if (lh
->file_names
[file_index
].included_p
== 1)
6625 const struct file_entry fe
= lh
->file_names
[file_index
];
6626 char *include_name
= fe
.name
;
6627 char *dir_name
= NULL
;
6628 char *pst_filename
= pst
->filename
;
6631 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6633 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6636 concat (dir_name
, SLASH_STRING
, include_name
, NULL
);
6637 make_cleanup (xfree
, include_name
);
6640 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6643 concat (pst
->dirname
, SLASH_STRING
, pst_filename
, NULL
);
6644 make_cleanup (xfree
, pst_filename
);
6647 if (strcmp (include_name
, pst_filename
) != 0)
6648 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6653 /* Start a subfile for DWARF. FILENAME is the name of the file and
6654 DIRNAME the name of the source directory which contains FILENAME
6655 or NULL if not known.
6656 This routine tries to keep line numbers from identical absolute and
6657 relative file names in a common subfile.
6659 Using the `list' example from the GDB testsuite, which resides in
6660 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6661 of /srcdir/list0.c yields the following debugging information for list0.c:
6663 DW_AT_name: /srcdir/list0.c
6664 DW_AT_comp_dir: /compdir
6665 files.files[0].name: list0.h
6666 files.files[0].dir: /srcdir
6667 files.files[1].name: list0.c
6668 files.files[1].dir: /srcdir
6670 The line number information for list0.c has to end up in a single
6671 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6674 dwarf2_start_subfile (char *filename
, char *dirname
)
6676 /* If the filename isn't absolute, try to match an existing subfile
6677 with the full pathname. */
6679 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6681 struct subfile
*subfile
;
6682 char *fullname
= concat (dirname
, "/", filename
, NULL
);
6684 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
6686 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
6688 current_subfile
= subfile
;
6695 start_subfile (filename
, dirname
);
6699 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6700 struct dwarf2_cu
*cu
)
6702 struct objfile
*objfile
= cu
->objfile
;
6703 struct comp_unit_head
*cu_header
= &cu
->header
;
6705 /* NOTE drow/2003-01-30: There used to be a comment and some special
6706 code here to turn a symbol with DW_AT_external and a
6707 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6708 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6709 with some versions of binutils) where shared libraries could have
6710 relocations against symbols in their debug information - the
6711 minimal symbol would have the right address, but the debug info
6712 would not. It's no longer necessary, because we will explicitly
6713 apply relocations when we read in the debug information now. */
6715 /* A DW_AT_location attribute with no contents indicates that a
6716 variable has been optimized away. */
6717 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6719 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6723 /* Handle one degenerate form of location expression specially, to
6724 preserve GDB's previous behavior when section offsets are
6725 specified. If this is just a DW_OP_addr then mark this symbol
6728 if (attr_form_is_block (attr
)
6729 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6730 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6734 SYMBOL_VALUE_ADDRESS (sym
) =
6735 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6736 fixup_symbol_section (sym
, objfile
);
6737 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6738 SYMBOL_SECTION (sym
));
6739 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6743 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6744 expression evaluator, and use LOC_COMPUTED only when necessary
6745 (i.e. when the value of a register or memory location is
6746 referenced, or a thread-local block, etc.). Then again, it might
6747 not be worthwhile. I'm assuming that it isn't unless performance
6748 or memory numbers show me otherwise. */
6750 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6751 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6754 /* Given a pointer to a DWARF information entry, figure out if we need
6755 to make a symbol table entry for it, and if so, create a new entry
6756 and return a pointer to it.
6757 If TYPE is NULL, determine symbol type from the die, otherwise
6758 used the passed type. */
6760 static struct symbol
*
6761 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6763 struct objfile
*objfile
= cu
->objfile
;
6764 struct symbol
*sym
= NULL
;
6766 struct attribute
*attr
= NULL
;
6767 struct attribute
*attr2
= NULL
;
6770 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6772 if (die
->tag
!= DW_TAG_namespace
)
6773 name
= dwarf2_linkage_name (die
, cu
);
6775 name
= TYPE_NAME (type
);
6779 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6780 sizeof (struct symbol
));
6781 OBJSTAT (objfile
, n_syms
++);
6782 memset (sym
, 0, sizeof (struct symbol
));
6784 /* Cache this symbol's name and the name's demangled form (if any). */
6785 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6786 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6788 /* Default assumptions.
6789 Use the passed type or decode it from the die. */
6790 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6791 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6793 SYMBOL_TYPE (sym
) = type
;
6795 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6796 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6799 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6804 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6807 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6809 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6811 case DW_TAG_subprogram
:
6812 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6814 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6815 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6816 if (attr2
&& (DW_UNSND (attr2
) != 0))
6818 add_symbol_to_list (sym
, &global_symbols
);
6822 add_symbol_to_list (sym
, cu
->list_in_scope
);
6825 case DW_TAG_variable
:
6826 /* Compilation with minimal debug info may result in variables
6827 with missing type entries. Change the misleading `void' type
6828 to something sensible. */
6829 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6830 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6831 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6832 "<variable, no debug info>",
6834 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6837 dwarf2_const_value (attr
, sym
, cu
);
6838 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6839 if (attr2
&& (DW_UNSND (attr2
) != 0))
6840 add_symbol_to_list (sym
, &global_symbols
);
6842 add_symbol_to_list (sym
, cu
->list_in_scope
);
6845 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6848 var_decode_location (attr
, sym
, cu
);
6849 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6850 if (attr2
&& (DW_UNSND (attr2
) != 0))
6851 add_symbol_to_list (sym
, &global_symbols
);
6853 add_symbol_to_list (sym
, cu
->list_in_scope
);
6857 /* We do not know the address of this symbol.
6858 If it is an external symbol and we have type information
6859 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6860 The address of the variable will then be determined from
6861 the minimal symbol table whenever the variable is
6863 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6864 if (attr2
&& (DW_UNSND (attr2
) != 0)
6865 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6867 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6868 add_symbol_to_list (sym
, &global_symbols
);
6872 case DW_TAG_formal_parameter
:
6873 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6876 var_decode_location (attr
, sym
, cu
);
6877 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6878 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6879 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6881 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6884 dwarf2_const_value (attr
, sym
, cu
);
6886 add_symbol_to_list (sym
, cu
->list_in_scope
);
6888 case DW_TAG_unspecified_parameters
:
6889 /* From varargs functions; gdb doesn't seem to have any
6890 interest in this information, so just ignore it for now.
6893 case DW_TAG_class_type
:
6894 case DW_TAG_structure_type
:
6895 case DW_TAG_union_type
:
6896 case DW_TAG_enumeration_type
:
6897 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6898 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6900 /* Make sure that the symbol includes appropriate enclosing
6901 classes/namespaces in its name. These are calculated in
6902 read_structure_type, and the correct name is saved in
6905 if (cu
->language
== language_cplus
6906 || cu
->language
== language_java
)
6908 struct type
*type
= SYMBOL_TYPE (sym
);
6910 if (TYPE_TAG_NAME (type
) != NULL
)
6912 /* FIXME: carlton/2003-11-10: Should this use
6913 SYMBOL_SET_NAMES instead? (The same problem also
6914 arises further down in this function.) */
6915 /* The type's name is already allocated along with
6916 this objfile, so we don't need to duplicate it
6918 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
6923 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6924 really ever be static objects: otherwise, if you try
6925 to, say, break of a class's method and you're in a file
6926 which doesn't mention that class, it won't work unless
6927 the check for all static symbols in lookup_symbol_aux
6928 saves you. See the OtherFileClass tests in
6929 gdb.c++/namespace.exp. */
6931 struct pending
**list_to_add
;
6933 list_to_add
= (cu
->list_in_scope
== &file_symbols
6934 && (cu
->language
== language_cplus
6935 || cu
->language
== language_java
)
6936 ? &global_symbols
: cu
->list_in_scope
);
6938 add_symbol_to_list (sym
, list_to_add
);
6940 /* The semantics of C++ state that "struct foo { ... }" also
6941 defines a typedef for "foo". A Java class declaration also
6942 defines a typedef for the class. Synthesize a typedef symbol
6943 so that "ptype foo" works as expected. */
6944 if (cu
->language
== language_cplus
6945 || cu
->language
== language_java
)
6947 struct symbol
*typedef_sym
= (struct symbol
*)
6948 obstack_alloc (&objfile
->objfile_obstack
,
6949 sizeof (struct symbol
));
6950 *typedef_sym
= *sym
;
6951 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
6952 /* The symbol's name is already allocated along with
6953 this objfile, so we don't need to duplicate it for
6955 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
6956 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
6957 add_symbol_to_list (typedef_sym
, list_to_add
);
6961 case DW_TAG_typedef
:
6962 if (processing_has_namespace_info
6963 && processing_current_prefix
[0] != '\0')
6965 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6966 processing_current_prefix
,
6969 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6970 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6971 add_symbol_to_list (sym
, cu
->list_in_scope
);
6973 case DW_TAG_base_type
:
6974 case DW_TAG_subrange_type
:
6975 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6976 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6977 add_symbol_to_list (sym
, cu
->list_in_scope
);
6979 case DW_TAG_enumerator
:
6980 if (processing_has_namespace_info
6981 && processing_current_prefix
[0] != '\0')
6983 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6984 processing_current_prefix
,
6987 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6990 dwarf2_const_value (attr
, sym
, cu
);
6993 /* NOTE: carlton/2003-11-10: See comment above in the
6994 DW_TAG_class_type, etc. block. */
6996 struct pending
**list_to_add
;
6998 list_to_add
= (cu
->list_in_scope
== &file_symbols
6999 && (cu
->language
== language_cplus
7000 || cu
->language
== language_java
)
7001 ? &global_symbols
: cu
->list_in_scope
);
7003 add_symbol_to_list (sym
, list_to_add
);
7006 case DW_TAG_namespace
:
7007 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7008 add_symbol_to_list (sym
, &global_symbols
);
7011 /* Not a tag we recognize. Hopefully we aren't processing
7012 trash data, but since we must specifically ignore things
7013 we don't recognize, there is nothing else we should do at
7015 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7016 dwarf_tag_name (die
->tag
));
7023 /* Copy constant value from an attribute to a symbol. */
7026 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7027 struct dwarf2_cu
*cu
)
7029 struct objfile
*objfile
= cu
->objfile
;
7030 struct comp_unit_head
*cu_header
= &cu
->header
;
7031 struct dwarf_block
*blk
;
7036 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7037 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7038 cu_header
->addr_size
,
7039 TYPE_LENGTH (SYMBOL_TYPE
7041 SYMBOL_VALUE_BYTES (sym
) = (char *)
7042 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7043 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7044 it's body - store_unsigned_integer. */
7045 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7047 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7049 case DW_FORM_block1
:
7050 case DW_FORM_block2
:
7051 case DW_FORM_block4
:
7053 blk
= DW_BLOCK (attr
);
7054 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7055 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7057 TYPE_LENGTH (SYMBOL_TYPE
7059 SYMBOL_VALUE_BYTES (sym
) = (char *)
7060 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7061 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7062 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7065 /* The DW_AT_const_value attributes are supposed to carry the
7066 symbol's value "represented as it would be on the target
7067 architecture." By the time we get here, it's already been
7068 converted to host endianness, so we just need to sign- or
7069 zero-extend it as appropriate. */
7071 dwarf2_const_value_data (attr
, sym
, 8);
7074 dwarf2_const_value_data (attr
, sym
, 16);
7077 dwarf2_const_value_data (attr
, sym
, 32);
7080 dwarf2_const_value_data (attr
, sym
, 64);
7084 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7085 SYMBOL_CLASS (sym
) = LOC_CONST
;
7089 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7090 SYMBOL_CLASS (sym
) = LOC_CONST
;
7094 complaint (&symfile_complaints
,
7095 _("unsupported const value attribute form: '%s'"),
7096 dwarf_form_name (attr
->form
));
7097 SYMBOL_VALUE (sym
) = 0;
7098 SYMBOL_CLASS (sym
) = LOC_CONST
;
7104 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7105 or zero-extend it as appropriate for the symbol's type. */
7107 dwarf2_const_value_data (struct attribute
*attr
,
7111 LONGEST l
= DW_UNSND (attr
);
7113 if (bits
< sizeof (l
) * 8)
7115 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7116 l
&= ((LONGEST
) 1 << bits
) - 1;
7118 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7121 SYMBOL_VALUE (sym
) = l
;
7122 SYMBOL_CLASS (sym
) = LOC_CONST
;
7126 /* Return the type of the die in question using its DW_AT_type attribute. */
7128 static struct type
*
7129 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7132 struct attribute
*type_attr
;
7133 struct die_info
*type_die
;
7135 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7138 /* A missing DW_AT_type represents a void type. */
7139 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7142 type_die
= follow_die_ref (die
, type_attr
, cu
);
7144 type
= tag_type_to_type (type_die
, cu
);
7147 dump_die (type_die
);
7148 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7154 /* Return the containing type of the die in question using its
7155 DW_AT_containing_type attribute. */
7157 static struct type
*
7158 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7160 struct type
*type
= NULL
;
7161 struct attribute
*type_attr
;
7162 struct die_info
*type_die
= NULL
;
7164 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7167 type_die
= follow_die_ref (die
, type_attr
, cu
);
7168 type
= tag_type_to_type (type_die
, cu
);
7173 dump_die (type_die
);
7174 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7180 static struct type
*
7181 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7189 read_type_die (die
, cu
);
7193 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7201 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7203 char *prefix
= determine_prefix (die
, cu
);
7204 const char *old_prefix
= processing_current_prefix
;
7205 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7206 processing_current_prefix
= prefix
;
7210 case DW_TAG_class_type
:
7211 case DW_TAG_structure_type
:
7212 case DW_TAG_union_type
:
7213 read_structure_type (die
, cu
);
7215 case DW_TAG_enumeration_type
:
7216 read_enumeration_type (die
, cu
);
7218 case DW_TAG_subprogram
:
7219 case DW_TAG_subroutine_type
:
7220 read_subroutine_type (die
, cu
);
7222 case DW_TAG_array_type
:
7223 read_array_type (die
, cu
);
7225 case DW_TAG_pointer_type
:
7226 read_tag_pointer_type (die
, cu
);
7228 case DW_TAG_ptr_to_member_type
:
7229 read_tag_ptr_to_member_type (die
, cu
);
7231 case DW_TAG_reference_type
:
7232 read_tag_reference_type (die
, cu
);
7234 case DW_TAG_const_type
:
7235 read_tag_const_type (die
, cu
);
7237 case DW_TAG_volatile_type
:
7238 read_tag_volatile_type (die
, cu
);
7240 case DW_TAG_string_type
:
7241 read_tag_string_type (die
, cu
);
7243 case DW_TAG_typedef
:
7244 read_typedef (die
, cu
);
7246 case DW_TAG_subrange_type
:
7247 read_subrange_type (die
, cu
);
7249 case DW_TAG_base_type
:
7250 read_base_type (die
, cu
);
7253 complaint (&symfile_complaints
, _("unexepected tag in read_type_die: '%s'"),
7254 dwarf_tag_name (die
->tag
));
7258 processing_current_prefix
= old_prefix
;
7259 do_cleanups (back_to
);
7262 /* Return the name of the namespace/class that DIE is defined within,
7263 or "" if we can't tell. The caller should xfree the result. */
7265 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7266 therein) for an example of how to use this function to deal with
7267 DW_AT_specification. */
7270 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7272 struct die_info
*parent
;
7274 if (cu
->language
!= language_cplus
7275 && cu
->language
!= language_java
)
7278 parent
= die
->parent
;
7282 return xstrdup ("");
7286 switch (parent
->tag
) {
7287 case DW_TAG_namespace
:
7289 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7290 before doing this check? */
7291 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7293 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7298 char *parent_prefix
= determine_prefix (parent
, cu
);
7299 char *retval
= typename_concat (NULL
, parent_prefix
,
7300 namespace_name (parent
, &dummy
,
7303 xfree (parent_prefix
);
7308 case DW_TAG_class_type
:
7309 case DW_TAG_structure_type
:
7311 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7313 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7317 const char *old_prefix
= processing_current_prefix
;
7318 char *new_prefix
= determine_prefix (parent
, cu
);
7321 processing_current_prefix
= new_prefix
;
7322 retval
= determine_class_name (parent
, cu
);
7323 processing_current_prefix
= old_prefix
;
7330 return determine_prefix (parent
, cu
);
7335 /* Return a newly-allocated string formed by concatenating PREFIX and
7336 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7337 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7338 perform an obconcat, otherwise allocate storage for the result. The CU argument
7339 is used to determine the language and hence, the appropriate separator. */
7341 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7344 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7345 struct dwarf2_cu
*cu
)
7349 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7351 else if (cu
->language
== language_java
)
7358 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7363 strcpy (retval
, prefix
);
7364 strcat (retval
, sep
);
7367 strcat (retval
, suffix
);
7373 /* We have an obstack. */
7374 return obconcat (obs
, prefix
, sep
, suffix
);
7378 static struct type
*
7379 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7381 struct objfile
*objfile
= cu
->objfile
;
7383 /* FIXME - this should not produce a new (struct type *)
7384 every time. It should cache base types. */
7388 case DW_ATE_address
:
7389 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7391 case DW_ATE_boolean
:
7392 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7394 case DW_ATE_complex_float
:
7397 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7401 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7407 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7411 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7418 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7421 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7425 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7429 case DW_ATE_signed_char
:
7430 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7432 case DW_ATE_unsigned
:
7436 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7439 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7443 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7447 case DW_ATE_unsigned_char
:
7448 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7451 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7458 copy_die (struct die_info
*old_die
)
7460 struct die_info
*new_die
;
7463 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7464 memset (new_die
, 0, sizeof (struct die_info
));
7466 new_die
->tag
= old_die
->tag
;
7467 new_die
->has_children
= old_die
->has_children
;
7468 new_die
->abbrev
= old_die
->abbrev
;
7469 new_die
->offset
= old_die
->offset
;
7470 new_die
->type
= NULL
;
7472 num_attrs
= old_die
->num_attrs
;
7473 new_die
->num_attrs
= num_attrs
;
7474 new_die
->attrs
= (struct attribute
*)
7475 xmalloc (num_attrs
* sizeof (struct attribute
));
7477 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7479 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7480 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7481 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7484 new_die
->next
= NULL
;
7489 /* Return sibling of die, NULL if no sibling. */
7491 static struct die_info
*
7492 sibling_die (struct die_info
*die
)
7494 return die
->sibling
;
7497 /* Get linkage name of a die, return NULL if not found. */
7500 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7502 struct attribute
*attr
;
7504 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7505 if (attr
&& DW_STRING (attr
))
7506 return DW_STRING (attr
);
7507 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7508 if (attr
&& DW_STRING (attr
))
7509 return DW_STRING (attr
);
7513 /* Get name of a die, return NULL if not found. */
7516 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7518 struct attribute
*attr
;
7520 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7521 if (attr
&& DW_STRING (attr
))
7522 return DW_STRING (attr
);
7526 /* Return the die that this die in an extension of, or NULL if there
7529 static struct die_info
*
7530 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7532 struct attribute
*attr
;
7534 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7538 return follow_die_ref (die
, attr
, cu
);
7541 /* Convert a DIE tag into its string name. */
7544 dwarf_tag_name (unsigned tag
)
7548 case DW_TAG_padding
:
7549 return "DW_TAG_padding";
7550 case DW_TAG_array_type
:
7551 return "DW_TAG_array_type";
7552 case DW_TAG_class_type
:
7553 return "DW_TAG_class_type";
7554 case DW_TAG_entry_point
:
7555 return "DW_TAG_entry_point";
7556 case DW_TAG_enumeration_type
:
7557 return "DW_TAG_enumeration_type";
7558 case DW_TAG_formal_parameter
:
7559 return "DW_TAG_formal_parameter";
7560 case DW_TAG_imported_declaration
:
7561 return "DW_TAG_imported_declaration";
7563 return "DW_TAG_label";
7564 case DW_TAG_lexical_block
:
7565 return "DW_TAG_lexical_block";
7567 return "DW_TAG_member";
7568 case DW_TAG_pointer_type
:
7569 return "DW_TAG_pointer_type";
7570 case DW_TAG_reference_type
:
7571 return "DW_TAG_reference_type";
7572 case DW_TAG_compile_unit
:
7573 return "DW_TAG_compile_unit";
7574 case DW_TAG_string_type
:
7575 return "DW_TAG_string_type";
7576 case DW_TAG_structure_type
:
7577 return "DW_TAG_structure_type";
7578 case DW_TAG_subroutine_type
:
7579 return "DW_TAG_subroutine_type";
7580 case DW_TAG_typedef
:
7581 return "DW_TAG_typedef";
7582 case DW_TAG_union_type
:
7583 return "DW_TAG_union_type";
7584 case DW_TAG_unspecified_parameters
:
7585 return "DW_TAG_unspecified_parameters";
7586 case DW_TAG_variant
:
7587 return "DW_TAG_variant";
7588 case DW_TAG_common_block
:
7589 return "DW_TAG_common_block";
7590 case DW_TAG_common_inclusion
:
7591 return "DW_TAG_common_inclusion";
7592 case DW_TAG_inheritance
:
7593 return "DW_TAG_inheritance";
7594 case DW_TAG_inlined_subroutine
:
7595 return "DW_TAG_inlined_subroutine";
7597 return "DW_TAG_module";
7598 case DW_TAG_ptr_to_member_type
:
7599 return "DW_TAG_ptr_to_member_type";
7600 case DW_TAG_set_type
:
7601 return "DW_TAG_set_type";
7602 case DW_TAG_subrange_type
:
7603 return "DW_TAG_subrange_type";
7604 case DW_TAG_with_stmt
:
7605 return "DW_TAG_with_stmt";
7606 case DW_TAG_access_declaration
:
7607 return "DW_TAG_access_declaration";
7608 case DW_TAG_base_type
:
7609 return "DW_TAG_base_type";
7610 case DW_TAG_catch_block
:
7611 return "DW_TAG_catch_block";
7612 case DW_TAG_const_type
:
7613 return "DW_TAG_const_type";
7614 case DW_TAG_constant
:
7615 return "DW_TAG_constant";
7616 case DW_TAG_enumerator
:
7617 return "DW_TAG_enumerator";
7618 case DW_TAG_file_type
:
7619 return "DW_TAG_file_type";
7621 return "DW_TAG_friend";
7622 case DW_TAG_namelist
:
7623 return "DW_TAG_namelist";
7624 case DW_TAG_namelist_item
:
7625 return "DW_TAG_namelist_item";
7626 case DW_TAG_packed_type
:
7627 return "DW_TAG_packed_type";
7628 case DW_TAG_subprogram
:
7629 return "DW_TAG_subprogram";
7630 case DW_TAG_template_type_param
:
7631 return "DW_TAG_template_type_param";
7632 case DW_TAG_template_value_param
:
7633 return "DW_TAG_template_value_param";
7634 case DW_TAG_thrown_type
:
7635 return "DW_TAG_thrown_type";
7636 case DW_TAG_try_block
:
7637 return "DW_TAG_try_block";
7638 case DW_TAG_variant_part
:
7639 return "DW_TAG_variant_part";
7640 case DW_TAG_variable
:
7641 return "DW_TAG_variable";
7642 case DW_TAG_volatile_type
:
7643 return "DW_TAG_volatile_type";
7644 case DW_TAG_dwarf_procedure
:
7645 return "DW_TAG_dwarf_procedure";
7646 case DW_TAG_restrict_type
:
7647 return "DW_TAG_restrict_type";
7648 case DW_TAG_interface_type
:
7649 return "DW_TAG_interface_type";
7650 case DW_TAG_namespace
:
7651 return "DW_TAG_namespace";
7652 case DW_TAG_imported_module
:
7653 return "DW_TAG_imported_module";
7654 case DW_TAG_unspecified_type
:
7655 return "DW_TAG_unspecified_type";
7656 case DW_TAG_partial_unit
:
7657 return "DW_TAG_partial_unit";
7658 case DW_TAG_imported_unit
:
7659 return "DW_TAG_imported_unit";
7660 case DW_TAG_MIPS_loop
:
7661 return "DW_TAG_MIPS_loop";
7662 case DW_TAG_format_label
:
7663 return "DW_TAG_format_label";
7664 case DW_TAG_function_template
:
7665 return "DW_TAG_function_template";
7666 case DW_TAG_class_template
:
7667 return "DW_TAG_class_template";
7669 return "DW_TAG_<unknown>";
7673 /* Convert a DWARF attribute code into its string name. */
7676 dwarf_attr_name (unsigned attr
)
7681 return "DW_AT_sibling";
7682 case DW_AT_location
:
7683 return "DW_AT_location";
7685 return "DW_AT_name";
7686 case DW_AT_ordering
:
7687 return "DW_AT_ordering";
7688 case DW_AT_subscr_data
:
7689 return "DW_AT_subscr_data";
7690 case DW_AT_byte_size
:
7691 return "DW_AT_byte_size";
7692 case DW_AT_bit_offset
:
7693 return "DW_AT_bit_offset";
7694 case DW_AT_bit_size
:
7695 return "DW_AT_bit_size";
7696 case DW_AT_element_list
:
7697 return "DW_AT_element_list";
7698 case DW_AT_stmt_list
:
7699 return "DW_AT_stmt_list";
7701 return "DW_AT_low_pc";
7703 return "DW_AT_high_pc";
7704 case DW_AT_language
:
7705 return "DW_AT_language";
7707 return "DW_AT_member";
7709 return "DW_AT_discr";
7710 case DW_AT_discr_value
:
7711 return "DW_AT_discr_value";
7712 case DW_AT_visibility
:
7713 return "DW_AT_visibility";
7715 return "DW_AT_import";
7716 case DW_AT_string_length
:
7717 return "DW_AT_string_length";
7718 case DW_AT_common_reference
:
7719 return "DW_AT_common_reference";
7720 case DW_AT_comp_dir
:
7721 return "DW_AT_comp_dir";
7722 case DW_AT_const_value
:
7723 return "DW_AT_const_value";
7724 case DW_AT_containing_type
:
7725 return "DW_AT_containing_type";
7726 case DW_AT_default_value
:
7727 return "DW_AT_default_value";
7729 return "DW_AT_inline";
7730 case DW_AT_is_optional
:
7731 return "DW_AT_is_optional";
7732 case DW_AT_lower_bound
:
7733 return "DW_AT_lower_bound";
7734 case DW_AT_producer
:
7735 return "DW_AT_producer";
7736 case DW_AT_prototyped
:
7737 return "DW_AT_prototyped";
7738 case DW_AT_return_addr
:
7739 return "DW_AT_return_addr";
7740 case DW_AT_start_scope
:
7741 return "DW_AT_start_scope";
7742 case DW_AT_stride_size
:
7743 return "DW_AT_stride_size";
7744 case DW_AT_upper_bound
:
7745 return "DW_AT_upper_bound";
7746 case DW_AT_abstract_origin
:
7747 return "DW_AT_abstract_origin";
7748 case DW_AT_accessibility
:
7749 return "DW_AT_accessibility";
7750 case DW_AT_address_class
:
7751 return "DW_AT_address_class";
7752 case DW_AT_artificial
:
7753 return "DW_AT_artificial";
7754 case DW_AT_base_types
:
7755 return "DW_AT_base_types";
7756 case DW_AT_calling_convention
:
7757 return "DW_AT_calling_convention";
7759 return "DW_AT_count";
7760 case DW_AT_data_member_location
:
7761 return "DW_AT_data_member_location";
7762 case DW_AT_decl_column
:
7763 return "DW_AT_decl_column";
7764 case DW_AT_decl_file
:
7765 return "DW_AT_decl_file";
7766 case DW_AT_decl_line
:
7767 return "DW_AT_decl_line";
7768 case DW_AT_declaration
:
7769 return "DW_AT_declaration";
7770 case DW_AT_discr_list
:
7771 return "DW_AT_discr_list";
7772 case DW_AT_encoding
:
7773 return "DW_AT_encoding";
7774 case DW_AT_external
:
7775 return "DW_AT_external";
7776 case DW_AT_frame_base
:
7777 return "DW_AT_frame_base";
7779 return "DW_AT_friend";
7780 case DW_AT_identifier_case
:
7781 return "DW_AT_identifier_case";
7782 case DW_AT_macro_info
:
7783 return "DW_AT_macro_info";
7784 case DW_AT_namelist_items
:
7785 return "DW_AT_namelist_items";
7786 case DW_AT_priority
:
7787 return "DW_AT_priority";
7789 return "DW_AT_segment";
7790 case DW_AT_specification
:
7791 return "DW_AT_specification";
7792 case DW_AT_static_link
:
7793 return "DW_AT_static_link";
7795 return "DW_AT_type";
7796 case DW_AT_use_location
:
7797 return "DW_AT_use_location";
7798 case DW_AT_variable_parameter
:
7799 return "DW_AT_variable_parameter";
7800 case DW_AT_virtuality
:
7801 return "DW_AT_virtuality";
7802 case DW_AT_vtable_elem_location
:
7803 return "DW_AT_vtable_elem_location";
7804 case DW_AT_allocated
:
7805 return "DW_AT_allocated";
7806 case DW_AT_associated
:
7807 return "DW_AT_associated";
7808 case DW_AT_data_location
:
7809 return "DW_AT_data_location";
7811 return "DW_AT_stride";
7812 case DW_AT_entry_pc
:
7813 return "DW_AT_entry_pc";
7814 case DW_AT_use_UTF8
:
7815 return "DW_AT_use_UTF8";
7816 case DW_AT_extension
:
7817 return "DW_AT_extension";
7819 return "DW_AT_ranges";
7820 case DW_AT_trampoline
:
7821 return "DW_AT_trampoline";
7822 case DW_AT_call_column
:
7823 return "DW_AT_call_column";
7824 case DW_AT_call_file
:
7825 return "DW_AT_call_file";
7826 case DW_AT_call_line
:
7827 return "DW_AT_call_line";
7829 case DW_AT_MIPS_fde
:
7830 return "DW_AT_MIPS_fde";
7831 case DW_AT_MIPS_loop_begin
:
7832 return "DW_AT_MIPS_loop_begin";
7833 case DW_AT_MIPS_tail_loop_begin
:
7834 return "DW_AT_MIPS_tail_loop_begin";
7835 case DW_AT_MIPS_epilog_begin
:
7836 return "DW_AT_MIPS_epilog_begin";
7837 case DW_AT_MIPS_loop_unroll_factor
:
7838 return "DW_AT_MIPS_loop_unroll_factor";
7839 case DW_AT_MIPS_software_pipeline_depth
:
7840 return "DW_AT_MIPS_software_pipeline_depth";
7842 case DW_AT_MIPS_linkage_name
:
7843 return "DW_AT_MIPS_linkage_name";
7845 case DW_AT_sf_names
:
7846 return "DW_AT_sf_names";
7847 case DW_AT_src_info
:
7848 return "DW_AT_src_info";
7849 case DW_AT_mac_info
:
7850 return "DW_AT_mac_info";
7851 case DW_AT_src_coords
:
7852 return "DW_AT_src_coords";
7853 case DW_AT_body_begin
:
7854 return "DW_AT_body_begin";
7855 case DW_AT_body_end
:
7856 return "DW_AT_body_end";
7857 case DW_AT_GNU_vector
:
7858 return "DW_AT_GNU_vector";
7860 return "DW_AT_<unknown>";
7864 /* Convert a DWARF value form code into its string name. */
7867 dwarf_form_name (unsigned form
)
7872 return "DW_FORM_addr";
7873 case DW_FORM_block2
:
7874 return "DW_FORM_block2";
7875 case DW_FORM_block4
:
7876 return "DW_FORM_block4";
7878 return "DW_FORM_data2";
7880 return "DW_FORM_data4";
7882 return "DW_FORM_data8";
7883 case DW_FORM_string
:
7884 return "DW_FORM_string";
7886 return "DW_FORM_block";
7887 case DW_FORM_block1
:
7888 return "DW_FORM_block1";
7890 return "DW_FORM_data1";
7892 return "DW_FORM_flag";
7894 return "DW_FORM_sdata";
7896 return "DW_FORM_strp";
7898 return "DW_FORM_udata";
7899 case DW_FORM_ref_addr
:
7900 return "DW_FORM_ref_addr";
7902 return "DW_FORM_ref1";
7904 return "DW_FORM_ref2";
7906 return "DW_FORM_ref4";
7908 return "DW_FORM_ref8";
7909 case DW_FORM_ref_udata
:
7910 return "DW_FORM_ref_udata";
7911 case DW_FORM_indirect
:
7912 return "DW_FORM_indirect";
7914 return "DW_FORM_<unknown>";
7918 /* Convert a DWARF stack opcode into its string name. */
7921 dwarf_stack_op_name (unsigned op
)
7926 return "DW_OP_addr";
7928 return "DW_OP_deref";
7930 return "DW_OP_const1u";
7932 return "DW_OP_const1s";
7934 return "DW_OP_const2u";
7936 return "DW_OP_const2s";
7938 return "DW_OP_const4u";
7940 return "DW_OP_const4s";
7942 return "DW_OP_const8u";
7944 return "DW_OP_const8s";
7946 return "DW_OP_constu";
7948 return "DW_OP_consts";
7952 return "DW_OP_drop";
7954 return "DW_OP_over";
7956 return "DW_OP_pick";
7958 return "DW_OP_swap";
7962 return "DW_OP_xderef";
7970 return "DW_OP_minus";
7982 return "DW_OP_plus";
7983 case DW_OP_plus_uconst
:
7984 return "DW_OP_plus_uconst";
7990 return "DW_OP_shra";
8008 return "DW_OP_skip";
8010 return "DW_OP_lit0";
8012 return "DW_OP_lit1";
8014 return "DW_OP_lit2";
8016 return "DW_OP_lit3";
8018 return "DW_OP_lit4";
8020 return "DW_OP_lit5";
8022 return "DW_OP_lit6";
8024 return "DW_OP_lit7";
8026 return "DW_OP_lit8";
8028 return "DW_OP_lit9";
8030 return "DW_OP_lit10";
8032 return "DW_OP_lit11";
8034 return "DW_OP_lit12";
8036 return "DW_OP_lit13";
8038 return "DW_OP_lit14";
8040 return "DW_OP_lit15";
8042 return "DW_OP_lit16";
8044 return "DW_OP_lit17";
8046 return "DW_OP_lit18";
8048 return "DW_OP_lit19";
8050 return "DW_OP_lit20";
8052 return "DW_OP_lit21";
8054 return "DW_OP_lit22";
8056 return "DW_OP_lit23";
8058 return "DW_OP_lit24";
8060 return "DW_OP_lit25";
8062 return "DW_OP_lit26";
8064 return "DW_OP_lit27";
8066 return "DW_OP_lit28";
8068 return "DW_OP_lit29";
8070 return "DW_OP_lit30";
8072 return "DW_OP_lit31";
8074 return "DW_OP_reg0";
8076 return "DW_OP_reg1";
8078 return "DW_OP_reg2";
8080 return "DW_OP_reg3";
8082 return "DW_OP_reg4";
8084 return "DW_OP_reg5";
8086 return "DW_OP_reg6";
8088 return "DW_OP_reg7";
8090 return "DW_OP_reg8";
8092 return "DW_OP_reg9";
8094 return "DW_OP_reg10";
8096 return "DW_OP_reg11";
8098 return "DW_OP_reg12";
8100 return "DW_OP_reg13";
8102 return "DW_OP_reg14";
8104 return "DW_OP_reg15";
8106 return "DW_OP_reg16";
8108 return "DW_OP_reg17";
8110 return "DW_OP_reg18";
8112 return "DW_OP_reg19";
8114 return "DW_OP_reg20";
8116 return "DW_OP_reg21";
8118 return "DW_OP_reg22";
8120 return "DW_OP_reg23";
8122 return "DW_OP_reg24";
8124 return "DW_OP_reg25";
8126 return "DW_OP_reg26";
8128 return "DW_OP_reg27";
8130 return "DW_OP_reg28";
8132 return "DW_OP_reg29";
8134 return "DW_OP_reg30";
8136 return "DW_OP_reg31";
8138 return "DW_OP_breg0";
8140 return "DW_OP_breg1";
8142 return "DW_OP_breg2";
8144 return "DW_OP_breg3";
8146 return "DW_OP_breg4";
8148 return "DW_OP_breg5";
8150 return "DW_OP_breg6";
8152 return "DW_OP_breg7";
8154 return "DW_OP_breg8";
8156 return "DW_OP_breg9";
8158 return "DW_OP_breg10";
8160 return "DW_OP_breg11";
8162 return "DW_OP_breg12";
8164 return "DW_OP_breg13";
8166 return "DW_OP_breg14";
8168 return "DW_OP_breg15";
8170 return "DW_OP_breg16";
8172 return "DW_OP_breg17";
8174 return "DW_OP_breg18";
8176 return "DW_OP_breg19";
8178 return "DW_OP_breg20";
8180 return "DW_OP_breg21";
8182 return "DW_OP_breg22";
8184 return "DW_OP_breg23";
8186 return "DW_OP_breg24";
8188 return "DW_OP_breg25";
8190 return "DW_OP_breg26";
8192 return "DW_OP_breg27";
8194 return "DW_OP_breg28";
8196 return "DW_OP_breg29";
8198 return "DW_OP_breg30";
8200 return "DW_OP_breg31";
8202 return "DW_OP_regx";
8204 return "DW_OP_fbreg";
8206 return "DW_OP_bregx";
8208 return "DW_OP_piece";
8209 case DW_OP_deref_size
:
8210 return "DW_OP_deref_size";
8211 case DW_OP_xderef_size
:
8212 return "DW_OP_xderef_size";
8215 /* DWARF 3 extensions. */
8216 case DW_OP_push_object_address
:
8217 return "DW_OP_push_object_address";
8219 return "DW_OP_call2";
8221 return "DW_OP_call4";
8222 case DW_OP_call_ref
:
8223 return "DW_OP_call_ref";
8224 /* GNU extensions. */
8225 case DW_OP_GNU_push_tls_address
:
8226 return "DW_OP_GNU_push_tls_address";
8228 return "OP_<unknown>";
8233 dwarf_bool_name (unsigned mybool
)
8241 /* Convert a DWARF type code into its string name. */
8244 dwarf_type_encoding_name (unsigned enc
)
8248 case DW_ATE_address
:
8249 return "DW_ATE_address";
8250 case DW_ATE_boolean
:
8251 return "DW_ATE_boolean";
8252 case DW_ATE_complex_float
:
8253 return "DW_ATE_complex_float";
8255 return "DW_ATE_float";
8257 return "DW_ATE_signed";
8258 case DW_ATE_signed_char
:
8259 return "DW_ATE_signed_char";
8260 case DW_ATE_unsigned
:
8261 return "DW_ATE_unsigned";
8262 case DW_ATE_unsigned_char
:
8263 return "DW_ATE_unsigned_char";
8264 case DW_ATE_imaginary_float
:
8265 return "DW_ATE_imaginary_float";
8267 return "DW_ATE_<unknown>";
8271 /* Convert a DWARF call frame info operation to its string name. */
8275 dwarf_cfi_name (unsigned cfi_opc
)
8279 case DW_CFA_advance_loc
:
8280 return "DW_CFA_advance_loc";
8282 return "DW_CFA_offset";
8283 case DW_CFA_restore
:
8284 return "DW_CFA_restore";
8286 return "DW_CFA_nop";
8287 case DW_CFA_set_loc
:
8288 return "DW_CFA_set_loc";
8289 case DW_CFA_advance_loc1
:
8290 return "DW_CFA_advance_loc1";
8291 case DW_CFA_advance_loc2
:
8292 return "DW_CFA_advance_loc2";
8293 case DW_CFA_advance_loc4
:
8294 return "DW_CFA_advance_loc4";
8295 case DW_CFA_offset_extended
:
8296 return "DW_CFA_offset_extended";
8297 case DW_CFA_restore_extended
:
8298 return "DW_CFA_restore_extended";
8299 case DW_CFA_undefined
:
8300 return "DW_CFA_undefined";
8301 case DW_CFA_same_value
:
8302 return "DW_CFA_same_value";
8303 case DW_CFA_register
:
8304 return "DW_CFA_register";
8305 case DW_CFA_remember_state
:
8306 return "DW_CFA_remember_state";
8307 case DW_CFA_restore_state
:
8308 return "DW_CFA_restore_state";
8309 case DW_CFA_def_cfa
:
8310 return "DW_CFA_def_cfa";
8311 case DW_CFA_def_cfa_register
:
8312 return "DW_CFA_def_cfa_register";
8313 case DW_CFA_def_cfa_offset
:
8314 return "DW_CFA_def_cfa_offset";
8317 case DW_CFA_def_cfa_expression
:
8318 return "DW_CFA_def_cfa_expression";
8319 case DW_CFA_expression
:
8320 return "DW_CFA_expression";
8321 case DW_CFA_offset_extended_sf
:
8322 return "DW_CFA_offset_extended_sf";
8323 case DW_CFA_def_cfa_sf
:
8324 return "DW_CFA_def_cfa_sf";
8325 case DW_CFA_def_cfa_offset_sf
:
8326 return "DW_CFA_def_cfa_offset_sf";
8328 /* SGI/MIPS specific */
8329 case DW_CFA_MIPS_advance_loc8
:
8330 return "DW_CFA_MIPS_advance_loc8";
8332 /* GNU extensions */
8333 case DW_CFA_GNU_window_save
:
8334 return "DW_CFA_GNU_window_save";
8335 case DW_CFA_GNU_args_size
:
8336 return "DW_CFA_GNU_args_size";
8337 case DW_CFA_GNU_negative_offset_extended
:
8338 return "DW_CFA_GNU_negative_offset_extended";
8341 return "DW_CFA_<unknown>";
8347 dump_die (struct die_info
*die
)
8351 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8352 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8353 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8354 dwarf_bool_name (die
->child
!= NULL
));
8356 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8357 for (i
= 0; i
< die
->num_attrs
; ++i
)
8359 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8360 dwarf_attr_name (die
->attrs
[i
].name
),
8361 dwarf_form_name (die
->attrs
[i
].form
));
8362 switch (die
->attrs
[i
].form
)
8364 case DW_FORM_ref_addr
:
8366 fprintf_unfiltered (gdb_stderr
, "address: ");
8367 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8369 case DW_FORM_block2
:
8370 case DW_FORM_block4
:
8372 case DW_FORM_block1
:
8373 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8378 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8379 (long) (DW_ADDR (&die
->attrs
[i
])));
8387 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8389 case DW_FORM_string
:
8391 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8392 DW_STRING (&die
->attrs
[i
])
8393 ? DW_STRING (&die
->attrs
[i
]) : "");
8396 if (DW_UNSND (&die
->attrs
[i
]))
8397 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8399 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8401 case DW_FORM_indirect
:
8402 /* the reader will have reduced the indirect form to
8403 the "base form" so this form should not occur */
8404 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8407 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8408 die
->attrs
[i
].form
);
8410 fprintf_unfiltered (gdb_stderr
, "\n");
8415 dump_die_list (struct die_info
*die
)
8420 if (die
->child
!= NULL
)
8421 dump_die_list (die
->child
);
8422 if (die
->sibling
!= NULL
)
8423 dump_die_list (die
->sibling
);
8428 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8429 struct dwarf2_cu
*cu
)
8432 struct die_info
*old
;
8434 h
= (offset
% REF_HASH_SIZE
);
8435 old
= cu
->die_ref_table
[h
];
8436 die
->next_ref
= old
;
8437 cu
->die_ref_table
[h
] = die
;
8441 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8443 unsigned int result
= 0;
8447 case DW_FORM_ref_addr
:
8452 case DW_FORM_ref_udata
:
8453 result
= DW_ADDR (attr
);
8456 complaint (&symfile_complaints
,
8457 _("unsupported die ref attribute form: '%s'"),
8458 dwarf_form_name (attr
->form
));
8463 /* Return the constant value held by the given attribute. Return -1
8464 if the value held by the attribute is not constant. */
8467 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8469 if (attr
->form
== DW_FORM_sdata
)
8470 return DW_SND (attr
);
8471 else if (attr
->form
== DW_FORM_udata
8472 || attr
->form
== DW_FORM_data1
8473 || attr
->form
== DW_FORM_data2
8474 || attr
->form
== DW_FORM_data4
8475 || attr
->form
== DW_FORM_data8
)
8476 return DW_UNSND (attr
);
8479 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8480 dwarf_form_name (attr
->form
));
8481 return default_value
;
8485 static struct die_info
*
8486 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8487 struct dwarf2_cu
*cu
)
8489 struct die_info
*die
;
8490 unsigned int offset
;
8492 struct die_info temp_die
;
8493 struct dwarf2_cu
*target_cu
;
8495 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8497 if (DW_ADDR (attr
) < cu
->header
.offset
8498 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8500 struct dwarf2_per_cu_data
*per_cu
;
8501 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8503 target_cu
= per_cu
->cu
;
8508 h
= (offset
% REF_HASH_SIZE
);
8509 die
= target_cu
->die_ref_table
[h
];
8512 if (die
->offset
== offset
)
8514 die
= die
->next_ref
;
8517 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8518 "at 0x%lx [in module %s]"),
8519 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8524 static struct type
*
8525 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8526 struct dwarf2_cu
*cu
)
8528 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8530 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8531 typeid, objfile
->name
);
8534 /* Look for this particular type in the fundamental type vector. If
8535 one is not found, create and install one appropriate for the
8536 current language and the current target machine. */
8538 if (cu
->ftypes
[typeid] == NULL
)
8540 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8543 return (cu
->ftypes
[typeid]);
8546 /* Decode simple location descriptions.
8547 Given a pointer to a dwarf block that defines a location, compute
8548 the location and return the value.
8550 NOTE drow/2003-11-18: This function is called in two situations
8551 now: for the address of static or global variables (partial symbols
8552 only) and for offsets into structures which are expected to be
8553 (more or less) constant. The partial symbol case should go away,
8554 and only the constant case should remain. That will let this
8555 function complain more accurately. A few special modes are allowed
8556 without complaint for global variables (for instance, global
8557 register values and thread-local values).
8559 A location description containing no operations indicates that the
8560 object is optimized out. The return value is 0 for that case.
8561 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8562 callers will only want a very basic result and this can become a
8565 When the result is a register number, the global isreg flag is set,
8566 otherwise it is cleared.
8568 Note that stack[0] is unused except as a default error return.
8569 Note that stack overflow is not yet handled. */
8572 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8574 struct objfile
*objfile
= cu
->objfile
;
8575 struct comp_unit_head
*cu_header
= &cu
->header
;
8577 int size
= blk
->size
;
8578 char *data
= blk
->data
;
8579 CORE_ADDR stack
[64];
8581 unsigned int bytes_read
, unsnd
;
8626 stack
[++stacki
] = op
- DW_OP_lit0
;
8662 stack
[++stacki
] = op
- DW_OP_reg0
;
8664 dwarf2_complex_location_expr_complaint ();
8669 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8671 stack
[++stacki
] = unsnd
;
8673 dwarf2_complex_location_expr_complaint ();
8677 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8683 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8688 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8693 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8698 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8703 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8708 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8713 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8719 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8724 stack
[stacki
+ 1] = stack
[stacki
];
8729 stack
[stacki
- 1] += stack
[stacki
];
8733 case DW_OP_plus_uconst
:
8734 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8739 stack
[stacki
- 1] -= stack
[stacki
];
8744 /* If we're not the last op, then we definitely can't encode
8745 this using GDB's address_class enum. This is valid for partial
8746 global symbols, although the variable's address will be bogus
8749 dwarf2_complex_location_expr_complaint ();
8752 case DW_OP_GNU_push_tls_address
:
8753 /* The top of the stack has the offset from the beginning
8754 of the thread control block at which the variable is located. */
8755 /* Nothing should follow this operator, so the top of stack would
8757 /* This is valid for partial global symbols, but the variable's
8758 address will be bogus in the psymtab. */
8760 dwarf2_complex_location_expr_complaint ();
8764 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8765 dwarf_stack_op_name (op
));
8766 return (stack
[stacki
]);
8769 return (stack
[stacki
]);
8772 /* memory allocation interface */
8774 static struct dwarf_block
*
8775 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8777 struct dwarf_block
*blk
;
8779 blk
= (struct dwarf_block
*)
8780 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8784 static struct abbrev_info
*
8785 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8787 struct abbrev_info
*abbrev
;
8789 abbrev
= (struct abbrev_info
*)
8790 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8791 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8795 static struct die_info
*
8796 dwarf_alloc_die (void)
8798 struct die_info
*die
;
8800 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8801 memset (die
, 0, sizeof (struct die_info
));
8806 /* Macro support. */
8809 /* Return the full name of file number I in *LH's file name table.
8810 Use COMP_DIR as the name of the current directory of the
8811 compilation. The result is allocated using xmalloc; the caller is
8812 responsible for freeing it. */
8814 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8816 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8818 if (IS_ABSOLUTE_PATH (fe
->name
))
8819 return xstrdup (fe
->name
);
8827 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8833 dir_len
= strlen (dir
);
8834 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8835 strcpy (full_name
, dir
);
8836 full_name
[dir_len
] = '/';
8837 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8841 return xstrdup (fe
->name
);
8846 static struct macro_source_file
*
8847 macro_start_file (int file
, int line
,
8848 struct macro_source_file
*current_file
,
8849 const char *comp_dir
,
8850 struct line_header
*lh
, struct objfile
*objfile
)
8852 /* The full name of this source file. */
8853 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8855 /* We don't create a macro table for this compilation unit
8856 at all until we actually get a filename. */
8857 if (! pending_macros
)
8858 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8859 objfile
->macro_cache
);
8862 /* If we have no current file, then this must be the start_file
8863 directive for the compilation unit's main source file. */
8864 current_file
= macro_set_main (pending_macros
, full_name
);
8866 current_file
= macro_include (current_file
, line
, full_name
);
8870 return current_file
;
8874 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8875 followed by a null byte. */
8877 copy_string (const char *buf
, int len
)
8879 char *s
= xmalloc (len
+ 1);
8880 memcpy (s
, buf
, len
);
8888 consume_improper_spaces (const char *p
, const char *body
)
8892 complaint (&symfile_complaints
,
8893 _("macro definition contains spaces in formal argument list:\n`%s'"),
8905 parse_macro_definition (struct macro_source_file
*file
, int line
,
8910 /* The body string takes one of two forms. For object-like macro
8911 definitions, it should be:
8913 <macro name> " " <definition>
8915 For function-like macro definitions, it should be:
8917 <macro name> "() " <definition>
8919 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8921 Spaces may appear only where explicitly indicated, and in the
8924 The Dwarf 2 spec says that an object-like macro's name is always
8925 followed by a space, but versions of GCC around March 2002 omit
8926 the space when the macro's definition is the empty string.
8928 The Dwarf 2 spec says that there should be no spaces between the
8929 formal arguments in a function-like macro's formal argument list,
8930 but versions of GCC around March 2002 include spaces after the
8934 /* Find the extent of the macro name. The macro name is terminated
8935 by either a space or null character (for an object-like macro) or
8936 an opening paren (for a function-like macro). */
8937 for (p
= body
; *p
; p
++)
8938 if (*p
== ' ' || *p
== '(')
8941 if (*p
== ' ' || *p
== '\0')
8943 /* It's an object-like macro. */
8944 int name_len
= p
- body
;
8945 char *name
= copy_string (body
, name_len
);
8946 const char *replacement
;
8949 replacement
= body
+ name_len
+ 1;
8952 dwarf2_macro_malformed_definition_complaint (body
);
8953 replacement
= body
+ name_len
;
8956 macro_define_object (file
, line
, name
, replacement
);
8962 /* It's a function-like macro. */
8963 char *name
= copy_string (body
, p
- body
);
8966 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
8970 p
= consume_improper_spaces (p
, body
);
8972 /* Parse the formal argument list. */
8973 while (*p
&& *p
!= ')')
8975 /* Find the extent of the current argument name. */
8976 const char *arg_start
= p
;
8978 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
8981 if (! *p
|| p
== arg_start
)
8982 dwarf2_macro_malformed_definition_complaint (body
);
8985 /* Make sure argv has room for the new argument. */
8986 if (argc
>= argv_size
)
8989 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
8992 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
8995 p
= consume_improper_spaces (p
, body
);
8997 /* Consume the comma, if present. */
9002 p
= consume_improper_spaces (p
, body
);
9011 /* Perfectly formed definition, no complaints. */
9012 macro_define_function (file
, line
, name
,
9013 argc
, (const char **) argv
,
9015 else if (*p
== '\0')
9017 /* Complain, but do define it. */
9018 dwarf2_macro_malformed_definition_complaint (body
);
9019 macro_define_function (file
, line
, name
,
9020 argc
, (const char **) argv
,
9024 /* Just complain. */
9025 dwarf2_macro_malformed_definition_complaint (body
);
9028 /* Just complain. */
9029 dwarf2_macro_malformed_definition_complaint (body
);
9035 for (i
= 0; i
< argc
; i
++)
9041 dwarf2_macro_malformed_definition_complaint (body
);
9046 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9047 char *comp_dir
, bfd
*abfd
,
9048 struct dwarf2_cu
*cu
)
9050 char *mac_ptr
, *mac_end
;
9051 struct macro_source_file
*current_file
= 0;
9053 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9055 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9059 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9060 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9061 + dwarf2_per_objfile
->macinfo_size
;
9065 enum dwarf_macinfo_record_type macinfo_type
;
9067 /* Do we at least have room for a macinfo type byte? */
9068 if (mac_ptr
>= mac_end
)
9070 dwarf2_macros_too_long_complaint ();
9074 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9077 switch (macinfo_type
)
9079 /* A zero macinfo type indicates the end of the macro
9084 case DW_MACINFO_define
:
9085 case DW_MACINFO_undef
:
9091 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9092 mac_ptr
+= bytes_read
;
9093 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9094 mac_ptr
+= bytes_read
;
9097 complaint (&symfile_complaints
,
9098 _("debug info gives macro %s outside of any file: %s"),
9100 DW_MACINFO_define
? "definition" : macinfo_type
==
9101 DW_MACINFO_undef
? "undefinition" :
9102 "something-or-other", body
);
9105 if (macinfo_type
== DW_MACINFO_define
)
9106 parse_macro_definition (current_file
, line
, body
);
9107 else if (macinfo_type
== DW_MACINFO_undef
)
9108 macro_undef (current_file
, line
, body
);
9113 case DW_MACINFO_start_file
:
9118 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9119 mac_ptr
+= bytes_read
;
9120 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9121 mac_ptr
+= bytes_read
;
9123 current_file
= macro_start_file (file
, line
,
9124 current_file
, comp_dir
,
9129 case DW_MACINFO_end_file
:
9131 complaint (&symfile_complaints
,
9132 _("macro debug info has an unmatched `close_file' directive"));
9135 current_file
= current_file
->included_by
;
9138 enum dwarf_macinfo_record_type next_type
;
9140 /* GCC circa March 2002 doesn't produce the zero
9141 type byte marking the end of the compilation
9142 unit. Complain if it's not there, but exit no
9145 /* Do we at least have room for a macinfo type byte? */
9146 if (mac_ptr
>= mac_end
)
9148 dwarf2_macros_too_long_complaint ();
9152 /* We don't increment mac_ptr here, so this is just
9154 next_type
= read_1_byte (abfd
, mac_ptr
);
9156 complaint (&symfile_complaints
,
9157 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9164 case DW_MACINFO_vendor_ext
:
9170 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9171 mac_ptr
+= bytes_read
;
9172 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9173 mac_ptr
+= bytes_read
;
9175 /* We don't recognize any vendor extensions. */
9182 /* Check if the attribute's form is a DW_FORM_block*
9183 if so return true else false. */
9185 attr_form_is_block (struct attribute
*attr
)
9187 return (attr
== NULL
? 0 :
9188 attr
->form
== DW_FORM_block1
9189 || attr
->form
== DW_FORM_block2
9190 || attr
->form
== DW_FORM_block4
9191 || attr
->form
== DW_FORM_block
);
9195 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9196 struct dwarf2_cu
*cu
)
9198 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9200 struct dwarf2_loclist_baton
*baton
;
9202 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9203 sizeof (struct dwarf2_loclist_baton
));
9204 baton
->objfile
= cu
->objfile
;
9206 /* We don't know how long the location list is, but make sure we
9207 don't run off the edge of the section. */
9208 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9209 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9210 baton
->base_address
= cu
->header
.base_address
;
9211 if (cu
->header
.base_known
== 0)
9212 complaint (&symfile_complaints
,
9213 _("Location list used without specifying the CU base address."));
9215 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9216 SYMBOL_LOCATION_BATON (sym
) = baton
;
9220 struct dwarf2_locexpr_baton
*baton
;
9222 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9223 sizeof (struct dwarf2_locexpr_baton
));
9224 baton
->objfile
= cu
->objfile
;
9226 if (attr_form_is_block (attr
))
9228 /* Note that we're just copying the block's data pointer
9229 here, not the actual data. We're still pointing into the
9230 info_buffer for SYM's objfile; right now we never release
9231 that buffer, but when we do clean up properly this may
9233 baton
->size
= DW_BLOCK (attr
)->size
;
9234 baton
->data
= DW_BLOCK (attr
)->data
;
9238 dwarf2_invalid_attrib_class_complaint ("location description",
9239 SYMBOL_NATURAL_NAME (sym
));
9244 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9245 SYMBOL_LOCATION_BATON (sym
) = baton
;
9249 /* Locate the compilation unit from CU's objfile which contains the
9250 DIE at OFFSET. Raises an error on failure. */
9252 static struct dwarf2_per_cu_data
*
9253 dwarf2_find_containing_comp_unit (unsigned long offset
,
9254 struct objfile
*objfile
)
9256 struct dwarf2_per_cu_data
*this_cu
;
9260 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9263 int mid
= low
+ (high
- low
) / 2;
9264 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9269 gdb_assert (low
== high
);
9270 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9273 error (_("Dwarf Error: could not find partial DIE containing "
9274 "offset 0x%lx [in module %s]"),
9275 (long) offset
, bfd_get_filename (objfile
->obfd
));
9277 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9278 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9282 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9283 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9284 && offset
>= this_cu
->offset
+ this_cu
->length
)
9285 error (_("invalid dwarf2 offset %ld"), offset
);
9286 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9291 /* Locate the compilation unit from OBJFILE which is located at exactly
9292 OFFSET. Raises an error on failure. */
9294 static struct dwarf2_per_cu_data
*
9295 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9297 struct dwarf2_per_cu_data
*this_cu
;
9298 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9299 if (this_cu
->offset
!= offset
)
9300 error (_("no compilation unit with offset %ld."), offset
);
9304 /* Release one cached compilation unit, CU. We unlink it from the tree
9305 of compilation units, but we don't remove it from the read_in_chain;
9306 the caller is responsible for that. */
9309 free_one_comp_unit (void *data
)
9311 struct dwarf2_cu
*cu
= data
;
9313 if (cu
->per_cu
!= NULL
)
9314 cu
->per_cu
->cu
= NULL
;
9317 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9319 free_die_list (cu
->dies
);
9324 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9325 when we're finished with it. We can't free the pointer itself, but be
9326 sure to unlink it from the cache. Also release any associated storage
9327 and perform cache maintenance.
9329 Only used during partial symbol parsing. */
9332 free_stack_comp_unit (void *data
)
9334 struct dwarf2_cu
*cu
= data
;
9336 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9337 cu
->partial_dies
= NULL
;
9339 if (cu
->per_cu
!= NULL
)
9341 /* This compilation unit is on the stack in our caller, so we
9342 should not xfree it. Just unlink it. */
9343 cu
->per_cu
->cu
= NULL
;
9346 /* If we had a per-cu pointer, then we may have other compilation
9347 units loaded, so age them now. */
9348 age_cached_comp_units ();
9352 /* Free all cached compilation units. */
9355 free_cached_comp_units (void *data
)
9357 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9359 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9360 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9361 while (per_cu
!= NULL
)
9363 struct dwarf2_per_cu_data
*next_cu
;
9365 next_cu
= per_cu
->cu
->read_in_chain
;
9367 free_one_comp_unit (per_cu
->cu
);
9368 *last_chain
= next_cu
;
9374 /* Increase the age counter on each cached compilation unit, and free
9375 any that are too old. */
9378 age_cached_comp_units (void)
9380 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9382 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9383 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9384 while (per_cu
!= NULL
)
9386 per_cu
->cu
->last_used
++;
9387 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9388 dwarf2_mark (per_cu
->cu
);
9389 per_cu
= per_cu
->cu
->read_in_chain
;
9392 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9393 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9394 while (per_cu
!= NULL
)
9396 struct dwarf2_per_cu_data
*next_cu
;
9398 next_cu
= per_cu
->cu
->read_in_chain
;
9400 if (!per_cu
->cu
->mark
)
9402 free_one_comp_unit (per_cu
->cu
);
9403 *last_chain
= next_cu
;
9406 last_chain
= &per_cu
->cu
->read_in_chain
;
9412 /* Remove a single compilation unit from the cache. */
9415 free_one_cached_comp_unit (void *target_cu
)
9417 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9419 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9420 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9421 while (per_cu
!= NULL
)
9423 struct dwarf2_per_cu_data
*next_cu
;
9425 next_cu
= per_cu
->cu
->read_in_chain
;
9427 if (per_cu
->cu
== target_cu
)
9429 free_one_comp_unit (per_cu
->cu
);
9430 *last_chain
= next_cu
;
9434 last_chain
= &per_cu
->cu
->read_in_chain
;
9440 /* A pair of DIE offset and GDB type pointer. We store these
9441 in a hash table separate from the DIEs, and preserve them
9442 when the DIEs are flushed out of cache. */
9444 struct dwarf2_offset_and_type
9446 unsigned int offset
;
9450 /* Hash function for a dwarf2_offset_and_type. */
9453 offset_and_type_hash (const void *item
)
9455 const struct dwarf2_offset_and_type
*ofs
= item
;
9459 /* Equality function for a dwarf2_offset_and_type. */
9462 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9464 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9465 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9466 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9469 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9470 table if necessary. */
9473 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9475 struct dwarf2_offset_and_type
**slot
, ofs
;
9479 if (cu
->per_cu
== NULL
)
9482 if (cu
->per_cu
->type_hash
== NULL
)
9483 cu
->per_cu
->type_hash
9484 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9485 offset_and_type_hash
,
9488 &cu
->objfile
->objfile_obstack
,
9489 hashtab_obstack_allocate
,
9490 dummy_obstack_deallocate
);
9492 ofs
.offset
= die
->offset
;
9494 slot
= (struct dwarf2_offset_and_type
**)
9495 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9496 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9500 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9501 have a saved type. */
9503 static struct type
*
9504 get_die_type (struct die_info
*die
, htab_t type_hash
)
9506 struct dwarf2_offset_and_type
*slot
, ofs
;
9508 ofs
.offset
= die
->offset
;
9509 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9516 /* Restore the types of the DIE tree starting at START_DIE from the hash
9517 table saved in CU. */
9520 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9522 struct die_info
*die
;
9524 if (cu
->per_cu
->type_hash
== NULL
)
9527 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9529 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9530 if (die
->child
!= NULL
)
9531 reset_die_and_siblings_types (die
->child
, cu
);
9535 /* Set the mark field in CU and in every other compilation unit in the
9536 cache that we must keep because we are keeping CU. */
9538 /* Add a dependence relationship from CU to REF_PER_CU. */
9541 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9542 struct dwarf2_per_cu_data
*ref_per_cu
)
9546 if (cu
->dependencies
== NULL
)
9548 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9549 NULL
, &cu
->comp_unit_obstack
,
9550 hashtab_obstack_allocate
,
9551 dummy_obstack_deallocate
);
9553 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9558 /* Set the mark field in CU and in every other compilation unit in the
9559 cache that we must keep because we are keeping CU. */
9562 dwarf2_mark_helper (void **slot
, void *data
)
9564 struct dwarf2_per_cu_data
*per_cu
;
9566 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9567 if (per_cu
->cu
->mark
)
9569 per_cu
->cu
->mark
= 1;
9571 if (per_cu
->cu
->dependencies
!= NULL
)
9572 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9578 dwarf2_mark (struct dwarf2_cu
*cu
)
9583 if (cu
->dependencies
!= NULL
)
9584 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9588 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9592 per_cu
->cu
->mark
= 0;
9593 per_cu
= per_cu
->cu
->read_in_chain
;
9597 /* Allocation function for the libiberty hash table which uses an
9601 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
9603 unsigned int total
= size
* count
;
9604 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
9605 memset (ptr
, 0, total
);
9609 /* Trivial deallocation function for the libiberty splay tree and hash
9610 table - don't deallocate anything. Rely on later deletion of the
9614 dummy_obstack_deallocate (void *object
, void *data
)
9619 /* Trivial hash function for partial_die_info: the hash value of a DIE
9620 is its offset in .debug_info for this objfile. */
9623 partial_die_hash (const void *item
)
9625 const struct partial_die_info
*part_die
= item
;
9626 return part_die
->offset
;
9629 /* Trivial comparison function for partial_die_info structures: two DIEs
9630 are equal if they have the same offset. */
9633 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9635 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9636 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9637 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9640 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9641 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9644 set_dwarf2_cmd (char *args
, int from_tty
)
9646 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9650 show_dwarf2_cmd (char *args
, int from_tty
)
9652 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9655 void _initialize_dwarf2_read (void);
9658 _initialize_dwarf2_read (void)
9660 dwarf2_objfile_data_key
= register_objfile_data ();
9662 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9663 Set DWARF 2 specific variables.\n\
9664 Configure DWARF 2 variables such as the cache size"),
9665 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9666 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9668 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9669 Show DWARF 2 specific variables\n\
9670 Show DWARF 2 variables such as the cache size"),
9671 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9672 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9674 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9675 &dwarf2_max_cache_age
, _("\
9676 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9677 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9678 A higher limit means that cached compilation units will be stored\n\
9679 in memory longer, and more total memory will be used. Zero disables\n\
9680 caching, which can slow down startup."),
9682 show_dwarf2_max_cache_age
,
9683 &set_dwarf2_cmdlist
,
9684 &show_dwarf2_cmdlist
);