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
, num_read
;
6044 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6047 result
|= ((long)(byte
& 127) << shift
);
6049 if ((byte
& 128) == 0)
6054 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6055 result
|= -(((long)1) << shift
);
6056 *bytes_read_ptr
= num_read
;
6060 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6063 skip_leb128 (bfd
*abfd
, char *buf
)
6069 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6071 if ((byte
& 128) == 0)
6077 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6083 cu
->language
= language_c
;
6085 case DW_LANG_C_plus_plus
:
6086 cu
->language
= language_cplus
;
6088 case DW_LANG_Fortran77
:
6089 case DW_LANG_Fortran90
:
6090 case DW_LANG_Fortran95
:
6091 cu
->language
= language_fortran
;
6093 case DW_LANG_Mips_Assembler
:
6094 cu
->language
= language_asm
;
6097 cu
->language
= language_java
;
6101 cu
->language
= language_ada
;
6103 case DW_LANG_Cobol74
:
6104 case DW_LANG_Cobol85
:
6105 case DW_LANG_Pascal83
:
6106 case DW_LANG_Modula2
:
6108 cu
->language
= language_minimal
;
6111 cu
->language_defn
= language_def (cu
->language
);
6114 /* Return the named attribute or NULL if not there. */
6116 static struct attribute
*
6117 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6120 struct attribute
*spec
= NULL
;
6122 for (i
= 0; i
< die
->num_attrs
; ++i
)
6124 if (die
->attrs
[i
].name
== name
)
6125 return &die
->attrs
[i
];
6126 if (die
->attrs
[i
].name
== DW_AT_specification
6127 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6128 spec
= &die
->attrs
[i
];
6132 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6137 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6138 and holds a non-zero value. This function should only be used for
6139 DW_FORM_flag attributes. */
6142 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6144 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6146 return (attr
&& DW_UNSND (attr
));
6150 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6152 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6153 which value is non-zero. However, we have to be careful with
6154 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6155 (via dwarf2_flag_true_p) follows this attribute. So we may
6156 end up accidently finding a declaration attribute that belongs
6157 to a different DIE referenced by the specification attribute,
6158 even though the given DIE does not have a declaration attribute. */
6159 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6160 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6163 /* Return the die giving the specification for DIE, if there is
6166 static struct die_info
*
6167 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6169 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6171 if (spec_attr
== NULL
)
6174 return follow_die_ref (die
, spec_attr
, cu
);
6177 /* Free the line_header structure *LH, and any arrays and strings it
6180 free_line_header (struct line_header
*lh
)
6182 if (lh
->standard_opcode_lengths
)
6183 xfree (lh
->standard_opcode_lengths
);
6185 /* Remember that all the lh->file_names[i].name pointers are
6186 pointers into debug_line_buffer, and don't need to be freed. */
6188 xfree (lh
->file_names
);
6190 /* Similarly for the include directory names. */
6191 if (lh
->include_dirs
)
6192 xfree (lh
->include_dirs
);
6198 /* Add an entry to LH's include directory table. */
6200 add_include_dir (struct line_header
*lh
, char *include_dir
)
6202 /* Grow the array if necessary. */
6203 if (lh
->include_dirs_size
== 0)
6205 lh
->include_dirs_size
= 1; /* for testing */
6206 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6207 * sizeof (*lh
->include_dirs
));
6209 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6211 lh
->include_dirs_size
*= 2;
6212 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6213 (lh
->include_dirs_size
6214 * sizeof (*lh
->include_dirs
)));
6217 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6221 /* Add an entry to LH's file name table. */
6223 add_file_name (struct line_header
*lh
,
6225 unsigned int dir_index
,
6226 unsigned int mod_time
,
6227 unsigned int length
)
6229 struct file_entry
*fe
;
6231 /* Grow the array if necessary. */
6232 if (lh
->file_names_size
== 0)
6234 lh
->file_names_size
= 1; /* for testing */
6235 lh
->file_names
= xmalloc (lh
->file_names_size
6236 * sizeof (*lh
->file_names
));
6238 else if (lh
->num_file_names
>= lh
->file_names_size
)
6240 lh
->file_names_size
*= 2;
6241 lh
->file_names
= xrealloc (lh
->file_names
,
6242 (lh
->file_names_size
6243 * sizeof (*lh
->file_names
)));
6246 fe
= &lh
->file_names
[lh
->num_file_names
++];
6248 fe
->dir_index
= dir_index
;
6249 fe
->mod_time
= mod_time
;
6250 fe
->length
= length
;
6255 /* Read the statement program header starting at OFFSET in
6256 .debug_line, according to the endianness of ABFD. Return a pointer
6257 to a struct line_header, allocated using xmalloc.
6259 NOTE: the strings in the include directory and file name tables of
6260 the returned object point into debug_line_buffer, and must not be
6262 static struct line_header
*
6263 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6264 struct dwarf2_cu
*cu
)
6266 struct cleanup
*back_to
;
6267 struct line_header
*lh
;
6271 char *cur_dir
, *cur_file
;
6273 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6275 complaint (&symfile_complaints
, _("missing .debug_line section"));
6279 /* Make sure that at least there's room for the total_length field.
6280 That could be 12 bytes long, but we're just going to fudge that. */
6281 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6283 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6287 lh
= xmalloc (sizeof (*lh
));
6288 memset (lh
, 0, sizeof (*lh
));
6289 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6292 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6294 /* Read in the header. */
6296 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6297 line_ptr
+= bytes_read
;
6298 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6299 + dwarf2_per_objfile
->line_size
))
6301 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6304 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6305 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6307 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6308 line_ptr
+= bytes_read
;
6309 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6311 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6313 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6315 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6317 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6319 lh
->standard_opcode_lengths
6320 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
6322 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6323 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6325 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6329 /* Read directory table. */
6330 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6332 line_ptr
+= bytes_read
;
6333 add_include_dir (lh
, cur_dir
);
6335 line_ptr
+= bytes_read
;
6337 /* Read file name table. */
6338 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6340 unsigned int dir_index
, mod_time
, length
;
6342 line_ptr
+= bytes_read
;
6343 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6344 line_ptr
+= bytes_read
;
6345 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6346 line_ptr
+= bytes_read
;
6347 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6348 line_ptr
+= bytes_read
;
6350 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6352 line_ptr
+= bytes_read
;
6353 lh
->statement_program_start
= line_ptr
;
6355 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6356 + dwarf2_per_objfile
->line_size
))
6357 complaint (&symfile_complaints
,
6358 _("line number info header doesn't fit in `.debug_line' section"));
6360 discard_cleanups (back_to
);
6364 /* This function exists to work around a bug in certain compilers
6365 (particularly GCC 2.95), in which the first line number marker of a
6366 function does not show up until after the prologue, right before
6367 the second line number marker. This function shifts ADDRESS down
6368 to the beginning of the function if necessary, and is called on
6369 addresses passed to record_line. */
6372 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6374 struct function_range
*fn
;
6376 /* Find the function_range containing address. */
6381 cu
->cached_fn
= cu
->first_fn
;
6385 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6391 while (fn
&& fn
!= cu
->cached_fn
)
6392 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6402 if (address
!= fn
->lowpc
)
6403 complaint (&symfile_complaints
,
6404 _("misplaced first line number at 0x%lx for '%s'"),
6405 (unsigned long) address
, fn
->name
);
6410 /* Decode the Line Number Program (LNP) for the given line_header
6411 structure and CU. The actual information extracted and the type
6412 of structures created from the LNP depends on the value of PST.
6414 1. If PST is NULL, then this procedure uses the data from the program
6415 to create all necessary symbol tables, and their linetables.
6416 The compilation directory of the file is passed in COMP_DIR,
6417 and must not be NULL.
6419 2. If PST is not NULL, this procedure reads the program to determine
6420 the list of files included by the unit represented by PST, and
6421 builds all the associated partial symbol tables. In this case,
6422 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6423 is not used to compute the full name of the symtab, and therefore
6424 omitting it when building the partial symtab does not introduce
6425 the potential for inconsistency - a partial symtab and its associated
6426 symbtab having a different fullname -). */
6429 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6430 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6434 unsigned int bytes_read
;
6435 unsigned char op_code
, extended_op
, adj_opcode
;
6437 struct objfile
*objfile
= cu
->objfile
;
6438 const int decode_for_pst_p
= (pst
!= NULL
);
6440 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6442 line_ptr
= lh
->statement_program_start
;
6443 line_end
= lh
->statement_program_end
;
6445 /* Read the statement sequences until there's nothing left. */
6446 while (line_ptr
< line_end
)
6448 /* state machine registers */
6449 CORE_ADDR address
= 0;
6450 unsigned int file
= 1;
6451 unsigned int line
= 1;
6452 unsigned int column
= 0;
6453 int is_stmt
= lh
->default_is_stmt
;
6454 int basic_block
= 0;
6455 int end_sequence
= 0;
6457 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6459 /* Start a subfile for the current file of the state machine. */
6460 /* lh->include_dirs and lh->file_names are 0-based, but the
6461 directory and file name numbers in the statement program
6463 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6467 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6470 dwarf2_start_subfile (fe
->name
, dir
);
6473 /* Decode the table. */
6474 while (!end_sequence
)
6476 op_code
= read_1_byte (abfd
, line_ptr
);
6479 if (op_code
>= lh
->opcode_base
)
6481 /* Special operand. */
6482 adj_opcode
= op_code
- lh
->opcode_base
;
6483 address
+= (adj_opcode
/ lh
->line_range
)
6484 * lh
->minimum_instruction_length
;
6485 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6486 lh
->file_names
[file
- 1].included_p
= 1;
6487 if (!decode_for_pst_p
)
6489 /* Append row to matrix using current values. */
6490 record_line (current_subfile
, line
,
6491 check_cu_functions (address
, cu
));
6495 else switch (op_code
)
6497 case DW_LNS_extended_op
:
6498 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6499 line_ptr
+= bytes_read
;
6500 extended_op
= read_1_byte (abfd
, line_ptr
);
6502 switch (extended_op
)
6504 case DW_LNE_end_sequence
:
6506 lh
->file_names
[file
- 1].included_p
= 1;
6507 if (!decode_for_pst_p
)
6508 record_line (current_subfile
, 0, address
);
6510 case DW_LNE_set_address
:
6511 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6512 line_ptr
+= bytes_read
;
6513 address
+= baseaddr
;
6515 case DW_LNE_define_file
:
6518 unsigned int dir_index
, mod_time
, length
;
6520 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6521 line_ptr
+= bytes_read
;
6523 read_unsigned_leb128 (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
;
6531 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6535 complaint (&symfile_complaints
,
6536 _("mangled .debug_line section"));
6541 lh
->file_names
[file
- 1].included_p
= 1;
6542 if (!decode_for_pst_p
)
6543 record_line (current_subfile
, line
,
6544 check_cu_functions (address
, cu
));
6547 case DW_LNS_advance_pc
:
6548 address
+= lh
->minimum_instruction_length
6549 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6550 line_ptr
+= bytes_read
;
6552 case DW_LNS_advance_line
:
6553 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6554 line_ptr
+= bytes_read
;
6556 case DW_LNS_set_file
:
6558 /* The arrays lh->include_dirs and lh->file_names are
6559 0-based, but the directory and file name numbers in
6560 the statement program are 1-based. */
6561 struct file_entry
*fe
;
6564 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6565 line_ptr
+= bytes_read
;
6566 fe
= &lh
->file_names
[file
- 1];
6568 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6571 if (!decode_for_pst_p
)
6572 dwarf2_start_subfile (fe
->name
, dir
);
6575 case DW_LNS_set_column
:
6576 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6577 line_ptr
+= bytes_read
;
6579 case DW_LNS_negate_stmt
:
6580 is_stmt
= (!is_stmt
);
6582 case DW_LNS_set_basic_block
:
6585 /* Add to the address register of the state machine the
6586 address increment value corresponding to special opcode
6587 255. I.e., this value is scaled by the minimum
6588 instruction length since special opcode 255 would have
6589 scaled the the increment. */
6590 case DW_LNS_const_add_pc
:
6591 address
+= (lh
->minimum_instruction_length
6592 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6594 case DW_LNS_fixed_advance_pc
:
6595 address
+= read_2_bytes (abfd
, line_ptr
);
6600 /* Unknown standard opcode, ignore it. */
6603 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6605 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6606 line_ptr
+= bytes_read
;
6613 if (decode_for_pst_p
)
6617 /* Now that we're done scanning the Line Header Program, we can
6618 create the psymtab of each included file. */
6619 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6620 if (lh
->file_names
[file_index
].included_p
== 1)
6622 const struct file_entry fe
= lh
->file_names
[file_index
];
6623 char *include_name
= fe
.name
;
6624 char *dir_name
= NULL
;
6625 char *pst_filename
= pst
->filename
;
6628 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6630 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6632 include_name
= concat (dir_name
, SLASH_STRING
,
6633 include_name
, (char *)NULL
);
6634 make_cleanup (xfree
, include_name
);
6637 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6639 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6640 pst_filename
, (char *)NULL
);
6641 make_cleanup (xfree
, pst_filename
);
6644 if (strcmp (include_name
, pst_filename
) != 0)
6645 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6650 /* Start a subfile for DWARF. FILENAME is the name of the file and
6651 DIRNAME the name of the source directory which contains FILENAME
6652 or NULL if not known.
6653 This routine tries to keep line numbers from identical absolute and
6654 relative file names in a common subfile.
6656 Using the `list' example from the GDB testsuite, which resides in
6657 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6658 of /srcdir/list0.c yields the following debugging information for list0.c:
6660 DW_AT_name: /srcdir/list0.c
6661 DW_AT_comp_dir: /compdir
6662 files.files[0].name: list0.h
6663 files.files[0].dir: /srcdir
6664 files.files[1].name: list0.c
6665 files.files[1].dir: /srcdir
6667 The line number information for list0.c has to end up in a single
6668 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6671 dwarf2_start_subfile (char *filename
, char *dirname
)
6673 /* If the filename isn't absolute, try to match an existing subfile
6674 with the full pathname. */
6676 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6678 struct subfile
*subfile
;
6679 char *fullname
= concat (dirname
, "/", filename
, (char *)NULL
);
6681 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
6683 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
6685 current_subfile
= subfile
;
6692 start_subfile (filename
, dirname
);
6696 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6697 struct dwarf2_cu
*cu
)
6699 struct objfile
*objfile
= cu
->objfile
;
6700 struct comp_unit_head
*cu_header
= &cu
->header
;
6702 /* NOTE drow/2003-01-30: There used to be a comment and some special
6703 code here to turn a symbol with DW_AT_external and a
6704 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6705 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6706 with some versions of binutils) where shared libraries could have
6707 relocations against symbols in their debug information - the
6708 minimal symbol would have the right address, but the debug info
6709 would not. It's no longer necessary, because we will explicitly
6710 apply relocations when we read in the debug information now. */
6712 /* A DW_AT_location attribute with no contents indicates that a
6713 variable has been optimized away. */
6714 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6716 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6720 /* Handle one degenerate form of location expression specially, to
6721 preserve GDB's previous behavior when section offsets are
6722 specified. If this is just a DW_OP_addr then mark this symbol
6725 if (attr_form_is_block (attr
)
6726 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6727 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6731 SYMBOL_VALUE_ADDRESS (sym
) =
6732 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6733 fixup_symbol_section (sym
, objfile
);
6734 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6735 SYMBOL_SECTION (sym
));
6736 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6740 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6741 expression evaluator, and use LOC_COMPUTED only when necessary
6742 (i.e. when the value of a register or memory location is
6743 referenced, or a thread-local block, etc.). Then again, it might
6744 not be worthwhile. I'm assuming that it isn't unless performance
6745 or memory numbers show me otherwise. */
6747 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6748 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6751 /* Given a pointer to a DWARF information entry, figure out if we need
6752 to make a symbol table entry for it, and if so, create a new entry
6753 and return a pointer to it.
6754 If TYPE is NULL, determine symbol type from the die, otherwise
6755 used the passed type. */
6757 static struct symbol
*
6758 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6760 struct objfile
*objfile
= cu
->objfile
;
6761 struct symbol
*sym
= NULL
;
6763 struct attribute
*attr
= NULL
;
6764 struct attribute
*attr2
= NULL
;
6767 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6769 if (die
->tag
!= DW_TAG_namespace
)
6770 name
= dwarf2_linkage_name (die
, cu
);
6772 name
= TYPE_NAME (type
);
6776 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6777 sizeof (struct symbol
));
6778 OBJSTAT (objfile
, n_syms
++);
6779 memset (sym
, 0, sizeof (struct symbol
));
6781 /* Cache this symbol's name and the name's demangled form (if any). */
6782 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6783 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6785 /* Default assumptions.
6786 Use the passed type or decode it from the die. */
6787 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6788 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6790 SYMBOL_TYPE (sym
) = type
;
6792 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6793 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6796 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6801 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6804 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6806 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6808 case DW_TAG_subprogram
:
6809 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6811 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6812 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6813 if (attr2
&& (DW_UNSND (attr2
) != 0))
6815 add_symbol_to_list (sym
, &global_symbols
);
6819 add_symbol_to_list (sym
, cu
->list_in_scope
);
6822 case DW_TAG_variable
:
6823 /* Compilation with minimal debug info may result in variables
6824 with missing type entries. Change the misleading `void' type
6825 to something sensible. */
6826 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6827 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6828 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6829 "<variable, no debug info>",
6831 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6834 dwarf2_const_value (attr
, sym
, cu
);
6835 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6836 if (attr2
&& (DW_UNSND (attr2
) != 0))
6837 add_symbol_to_list (sym
, &global_symbols
);
6839 add_symbol_to_list (sym
, cu
->list_in_scope
);
6842 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6845 var_decode_location (attr
, sym
, cu
);
6846 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6847 if (attr2
&& (DW_UNSND (attr2
) != 0))
6848 add_symbol_to_list (sym
, &global_symbols
);
6850 add_symbol_to_list (sym
, cu
->list_in_scope
);
6854 /* We do not know the address of this symbol.
6855 If it is an external symbol and we have type information
6856 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6857 The address of the variable will then be determined from
6858 the minimal symbol table whenever the variable is
6860 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6861 if (attr2
&& (DW_UNSND (attr2
) != 0)
6862 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6864 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6865 add_symbol_to_list (sym
, &global_symbols
);
6869 case DW_TAG_formal_parameter
:
6870 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6873 var_decode_location (attr
, sym
, cu
);
6874 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6875 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6876 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6878 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6881 dwarf2_const_value (attr
, sym
, cu
);
6883 add_symbol_to_list (sym
, cu
->list_in_scope
);
6885 case DW_TAG_unspecified_parameters
:
6886 /* From varargs functions; gdb doesn't seem to have any
6887 interest in this information, so just ignore it for now.
6890 case DW_TAG_class_type
:
6891 case DW_TAG_structure_type
:
6892 case DW_TAG_union_type
:
6893 case DW_TAG_enumeration_type
:
6894 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6895 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6897 /* Make sure that the symbol includes appropriate enclosing
6898 classes/namespaces in its name. These are calculated in
6899 read_structure_type, and the correct name is saved in
6902 if (cu
->language
== language_cplus
6903 || cu
->language
== language_java
)
6905 struct type
*type
= SYMBOL_TYPE (sym
);
6907 if (TYPE_TAG_NAME (type
) != NULL
)
6909 /* FIXME: carlton/2003-11-10: Should this use
6910 SYMBOL_SET_NAMES instead? (The same problem also
6911 arises further down in this function.) */
6912 /* The type's name is already allocated along with
6913 this objfile, so we don't need to duplicate it
6915 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
6920 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6921 really ever be static objects: otherwise, if you try
6922 to, say, break of a class's method and you're in a file
6923 which doesn't mention that class, it won't work unless
6924 the check for all static symbols in lookup_symbol_aux
6925 saves you. See the OtherFileClass tests in
6926 gdb.c++/namespace.exp. */
6928 struct pending
**list_to_add
;
6930 list_to_add
= (cu
->list_in_scope
== &file_symbols
6931 && (cu
->language
== language_cplus
6932 || cu
->language
== language_java
)
6933 ? &global_symbols
: cu
->list_in_scope
);
6935 add_symbol_to_list (sym
, list_to_add
);
6937 /* The semantics of C++ state that "struct foo { ... }" also
6938 defines a typedef for "foo". A Java class declaration also
6939 defines a typedef for the class. Synthesize a typedef symbol
6940 so that "ptype foo" works as expected. */
6941 if (cu
->language
== language_cplus
6942 || cu
->language
== language_java
)
6944 struct symbol
*typedef_sym
= (struct symbol
*)
6945 obstack_alloc (&objfile
->objfile_obstack
,
6946 sizeof (struct symbol
));
6947 *typedef_sym
= *sym
;
6948 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
6949 /* The symbol's name is already allocated along with
6950 this objfile, so we don't need to duplicate it for
6952 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
6953 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
6954 add_symbol_to_list (typedef_sym
, list_to_add
);
6958 case DW_TAG_typedef
:
6959 if (processing_has_namespace_info
6960 && processing_current_prefix
[0] != '\0')
6962 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6963 processing_current_prefix
,
6966 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6967 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6968 add_symbol_to_list (sym
, cu
->list_in_scope
);
6970 case DW_TAG_base_type
:
6971 case DW_TAG_subrange_type
:
6972 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6973 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6974 add_symbol_to_list (sym
, cu
->list_in_scope
);
6976 case DW_TAG_enumerator
:
6977 if (processing_has_namespace_info
6978 && processing_current_prefix
[0] != '\0')
6980 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6981 processing_current_prefix
,
6984 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6987 dwarf2_const_value (attr
, sym
, cu
);
6990 /* NOTE: carlton/2003-11-10: See comment above in the
6991 DW_TAG_class_type, etc. block. */
6993 struct pending
**list_to_add
;
6995 list_to_add
= (cu
->list_in_scope
== &file_symbols
6996 && (cu
->language
== language_cplus
6997 || cu
->language
== language_java
)
6998 ? &global_symbols
: cu
->list_in_scope
);
7000 add_symbol_to_list (sym
, list_to_add
);
7003 case DW_TAG_namespace
:
7004 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7005 add_symbol_to_list (sym
, &global_symbols
);
7008 /* Not a tag we recognize. Hopefully we aren't processing
7009 trash data, but since we must specifically ignore things
7010 we don't recognize, there is nothing else we should do at
7012 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7013 dwarf_tag_name (die
->tag
));
7020 /* Copy constant value from an attribute to a symbol. */
7023 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7024 struct dwarf2_cu
*cu
)
7026 struct objfile
*objfile
= cu
->objfile
;
7027 struct comp_unit_head
*cu_header
= &cu
->header
;
7028 struct dwarf_block
*blk
;
7033 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7034 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7035 cu_header
->addr_size
,
7036 TYPE_LENGTH (SYMBOL_TYPE
7038 SYMBOL_VALUE_BYTES (sym
) = (char *)
7039 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7040 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7041 it's body - store_unsigned_integer. */
7042 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7044 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7046 case DW_FORM_block1
:
7047 case DW_FORM_block2
:
7048 case DW_FORM_block4
:
7050 blk
= DW_BLOCK (attr
);
7051 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7052 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7054 TYPE_LENGTH (SYMBOL_TYPE
7056 SYMBOL_VALUE_BYTES (sym
) = (char *)
7057 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7058 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7059 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7062 /* The DW_AT_const_value attributes are supposed to carry the
7063 symbol's value "represented as it would be on the target
7064 architecture." By the time we get here, it's already been
7065 converted to host endianness, so we just need to sign- or
7066 zero-extend it as appropriate. */
7068 dwarf2_const_value_data (attr
, sym
, 8);
7071 dwarf2_const_value_data (attr
, sym
, 16);
7074 dwarf2_const_value_data (attr
, sym
, 32);
7077 dwarf2_const_value_data (attr
, sym
, 64);
7081 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7082 SYMBOL_CLASS (sym
) = LOC_CONST
;
7086 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7087 SYMBOL_CLASS (sym
) = LOC_CONST
;
7091 complaint (&symfile_complaints
,
7092 _("unsupported const value attribute form: '%s'"),
7093 dwarf_form_name (attr
->form
));
7094 SYMBOL_VALUE (sym
) = 0;
7095 SYMBOL_CLASS (sym
) = LOC_CONST
;
7101 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7102 or zero-extend it as appropriate for the symbol's type. */
7104 dwarf2_const_value_data (struct attribute
*attr
,
7108 LONGEST l
= DW_UNSND (attr
);
7110 if (bits
< sizeof (l
) * 8)
7112 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7113 l
&= ((LONGEST
) 1 << bits
) - 1;
7115 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7118 SYMBOL_VALUE (sym
) = l
;
7119 SYMBOL_CLASS (sym
) = LOC_CONST
;
7123 /* Return the type of the die in question using its DW_AT_type attribute. */
7125 static struct type
*
7126 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7129 struct attribute
*type_attr
;
7130 struct die_info
*type_die
;
7132 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7135 /* A missing DW_AT_type represents a void type. */
7136 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7139 type_die
= follow_die_ref (die
, type_attr
, cu
);
7141 type
= tag_type_to_type (type_die
, cu
);
7144 dump_die (type_die
);
7145 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7151 /* Return the containing type of the die in question using its
7152 DW_AT_containing_type attribute. */
7154 static struct type
*
7155 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7157 struct type
*type
= NULL
;
7158 struct attribute
*type_attr
;
7159 struct die_info
*type_die
= NULL
;
7161 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7164 type_die
= follow_die_ref (die
, type_attr
, cu
);
7165 type
= tag_type_to_type (type_die
, cu
);
7170 dump_die (type_die
);
7171 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7177 static struct type
*
7178 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7186 read_type_die (die
, cu
);
7190 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7198 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7200 char *prefix
= determine_prefix (die
, cu
);
7201 const char *old_prefix
= processing_current_prefix
;
7202 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7203 processing_current_prefix
= prefix
;
7207 case DW_TAG_class_type
:
7208 case DW_TAG_structure_type
:
7209 case DW_TAG_union_type
:
7210 read_structure_type (die
, cu
);
7212 case DW_TAG_enumeration_type
:
7213 read_enumeration_type (die
, cu
);
7215 case DW_TAG_subprogram
:
7216 case DW_TAG_subroutine_type
:
7217 read_subroutine_type (die
, cu
);
7219 case DW_TAG_array_type
:
7220 read_array_type (die
, cu
);
7222 case DW_TAG_pointer_type
:
7223 read_tag_pointer_type (die
, cu
);
7225 case DW_TAG_ptr_to_member_type
:
7226 read_tag_ptr_to_member_type (die
, cu
);
7228 case DW_TAG_reference_type
:
7229 read_tag_reference_type (die
, cu
);
7231 case DW_TAG_const_type
:
7232 read_tag_const_type (die
, cu
);
7234 case DW_TAG_volatile_type
:
7235 read_tag_volatile_type (die
, cu
);
7237 case DW_TAG_string_type
:
7238 read_tag_string_type (die
, cu
);
7240 case DW_TAG_typedef
:
7241 read_typedef (die
, cu
);
7243 case DW_TAG_subrange_type
:
7244 read_subrange_type (die
, cu
);
7246 case DW_TAG_base_type
:
7247 read_base_type (die
, cu
);
7250 complaint (&symfile_complaints
, _("unexepected tag in read_type_die: '%s'"),
7251 dwarf_tag_name (die
->tag
));
7255 processing_current_prefix
= old_prefix
;
7256 do_cleanups (back_to
);
7259 /* Return the name of the namespace/class that DIE is defined within,
7260 or "" if we can't tell. The caller should xfree the result. */
7262 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7263 therein) for an example of how to use this function to deal with
7264 DW_AT_specification. */
7267 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7269 struct die_info
*parent
;
7271 if (cu
->language
!= language_cplus
7272 && cu
->language
!= language_java
)
7275 parent
= die
->parent
;
7279 return xstrdup ("");
7283 switch (parent
->tag
) {
7284 case DW_TAG_namespace
:
7286 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7287 before doing this check? */
7288 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7290 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7295 char *parent_prefix
= determine_prefix (parent
, cu
);
7296 char *retval
= typename_concat (NULL
, parent_prefix
,
7297 namespace_name (parent
, &dummy
,
7300 xfree (parent_prefix
);
7305 case DW_TAG_class_type
:
7306 case DW_TAG_structure_type
:
7308 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7310 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7314 const char *old_prefix
= processing_current_prefix
;
7315 char *new_prefix
= determine_prefix (parent
, cu
);
7318 processing_current_prefix
= new_prefix
;
7319 retval
= determine_class_name (parent
, cu
);
7320 processing_current_prefix
= old_prefix
;
7327 return determine_prefix (parent
, cu
);
7332 /* Return a newly-allocated string formed by concatenating PREFIX and
7333 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7334 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7335 perform an obconcat, otherwise allocate storage for the result. The CU argument
7336 is used to determine the language and hence, the appropriate separator. */
7338 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7341 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7342 struct dwarf2_cu
*cu
)
7346 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7348 else if (cu
->language
== language_java
)
7355 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7360 strcpy (retval
, prefix
);
7361 strcat (retval
, sep
);
7364 strcat (retval
, suffix
);
7370 /* We have an obstack. */
7371 return obconcat (obs
, prefix
, sep
, suffix
);
7375 static struct type
*
7376 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7378 struct objfile
*objfile
= cu
->objfile
;
7380 /* FIXME - this should not produce a new (struct type *)
7381 every time. It should cache base types. */
7385 case DW_ATE_address
:
7386 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7388 case DW_ATE_boolean
:
7389 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7391 case DW_ATE_complex_float
:
7394 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7398 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7404 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7408 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7415 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7418 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7422 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7426 case DW_ATE_signed_char
:
7427 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7429 case DW_ATE_unsigned
:
7433 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7436 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7440 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7444 case DW_ATE_unsigned_char
:
7445 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7448 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7455 copy_die (struct die_info
*old_die
)
7457 struct die_info
*new_die
;
7460 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7461 memset (new_die
, 0, sizeof (struct die_info
));
7463 new_die
->tag
= old_die
->tag
;
7464 new_die
->has_children
= old_die
->has_children
;
7465 new_die
->abbrev
= old_die
->abbrev
;
7466 new_die
->offset
= old_die
->offset
;
7467 new_die
->type
= NULL
;
7469 num_attrs
= old_die
->num_attrs
;
7470 new_die
->num_attrs
= num_attrs
;
7471 new_die
->attrs
= (struct attribute
*)
7472 xmalloc (num_attrs
* sizeof (struct attribute
));
7474 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7476 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7477 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7478 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7481 new_die
->next
= NULL
;
7486 /* Return sibling of die, NULL if no sibling. */
7488 static struct die_info
*
7489 sibling_die (struct die_info
*die
)
7491 return die
->sibling
;
7494 /* Get linkage name of a die, return NULL if not found. */
7497 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7499 struct attribute
*attr
;
7501 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7502 if (attr
&& DW_STRING (attr
))
7503 return DW_STRING (attr
);
7504 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7505 if (attr
&& DW_STRING (attr
))
7506 return DW_STRING (attr
);
7510 /* Get name of a die, return NULL if not found. */
7513 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7515 struct attribute
*attr
;
7517 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7518 if (attr
&& DW_STRING (attr
))
7519 return DW_STRING (attr
);
7523 /* Return the die that this die in an extension of, or NULL if there
7526 static struct die_info
*
7527 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7529 struct attribute
*attr
;
7531 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7535 return follow_die_ref (die
, attr
, cu
);
7538 /* Convert a DIE tag into its string name. */
7541 dwarf_tag_name (unsigned tag
)
7545 case DW_TAG_padding
:
7546 return "DW_TAG_padding";
7547 case DW_TAG_array_type
:
7548 return "DW_TAG_array_type";
7549 case DW_TAG_class_type
:
7550 return "DW_TAG_class_type";
7551 case DW_TAG_entry_point
:
7552 return "DW_TAG_entry_point";
7553 case DW_TAG_enumeration_type
:
7554 return "DW_TAG_enumeration_type";
7555 case DW_TAG_formal_parameter
:
7556 return "DW_TAG_formal_parameter";
7557 case DW_TAG_imported_declaration
:
7558 return "DW_TAG_imported_declaration";
7560 return "DW_TAG_label";
7561 case DW_TAG_lexical_block
:
7562 return "DW_TAG_lexical_block";
7564 return "DW_TAG_member";
7565 case DW_TAG_pointer_type
:
7566 return "DW_TAG_pointer_type";
7567 case DW_TAG_reference_type
:
7568 return "DW_TAG_reference_type";
7569 case DW_TAG_compile_unit
:
7570 return "DW_TAG_compile_unit";
7571 case DW_TAG_string_type
:
7572 return "DW_TAG_string_type";
7573 case DW_TAG_structure_type
:
7574 return "DW_TAG_structure_type";
7575 case DW_TAG_subroutine_type
:
7576 return "DW_TAG_subroutine_type";
7577 case DW_TAG_typedef
:
7578 return "DW_TAG_typedef";
7579 case DW_TAG_union_type
:
7580 return "DW_TAG_union_type";
7581 case DW_TAG_unspecified_parameters
:
7582 return "DW_TAG_unspecified_parameters";
7583 case DW_TAG_variant
:
7584 return "DW_TAG_variant";
7585 case DW_TAG_common_block
:
7586 return "DW_TAG_common_block";
7587 case DW_TAG_common_inclusion
:
7588 return "DW_TAG_common_inclusion";
7589 case DW_TAG_inheritance
:
7590 return "DW_TAG_inheritance";
7591 case DW_TAG_inlined_subroutine
:
7592 return "DW_TAG_inlined_subroutine";
7594 return "DW_TAG_module";
7595 case DW_TAG_ptr_to_member_type
:
7596 return "DW_TAG_ptr_to_member_type";
7597 case DW_TAG_set_type
:
7598 return "DW_TAG_set_type";
7599 case DW_TAG_subrange_type
:
7600 return "DW_TAG_subrange_type";
7601 case DW_TAG_with_stmt
:
7602 return "DW_TAG_with_stmt";
7603 case DW_TAG_access_declaration
:
7604 return "DW_TAG_access_declaration";
7605 case DW_TAG_base_type
:
7606 return "DW_TAG_base_type";
7607 case DW_TAG_catch_block
:
7608 return "DW_TAG_catch_block";
7609 case DW_TAG_const_type
:
7610 return "DW_TAG_const_type";
7611 case DW_TAG_constant
:
7612 return "DW_TAG_constant";
7613 case DW_TAG_enumerator
:
7614 return "DW_TAG_enumerator";
7615 case DW_TAG_file_type
:
7616 return "DW_TAG_file_type";
7618 return "DW_TAG_friend";
7619 case DW_TAG_namelist
:
7620 return "DW_TAG_namelist";
7621 case DW_TAG_namelist_item
:
7622 return "DW_TAG_namelist_item";
7623 case DW_TAG_packed_type
:
7624 return "DW_TAG_packed_type";
7625 case DW_TAG_subprogram
:
7626 return "DW_TAG_subprogram";
7627 case DW_TAG_template_type_param
:
7628 return "DW_TAG_template_type_param";
7629 case DW_TAG_template_value_param
:
7630 return "DW_TAG_template_value_param";
7631 case DW_TAG_thrown_type
:
7632 return "DW_TAG_thrown_type";
7633 case DW_TAG_try_block
:
7634 return "DW_TAG_try_block";
7635 case DW_TAG_variant_part
:
7636 return "DW_TAG_variant_part";
7637 case DW_TAG_variable
:
7638 return "DW_TAG_variable";
7639 case DW_TAG_volatile_type
:
7640 return "DW_TAG_volatile_type";
7641 case DW_TAG_dwarf_procedure
:
7642 return "DW_TAG_dwarf_procedure";
7643 case DW_TAG_restrict_type
:
7644 return "DW_TAG_restrict_type";
7645 case DW_TAG_interface_type
:
7646 return "DW_TAG_interface_type";
7647 case DW_TAG_namespace
:
7648 return "DW_TAG_namespace";
7649 case DW_TAG_imported_module
:
7650 return "DW_TAG_imported_module";
7651 case DW_TAG_unspecified_type
:
7652 return "DW_TAG_unspecified_type";
7653 case DW_TAG_partial_unit
:
7654 return "DW_TAG_partial_unit";
7655 case DW_TAG_imported_unit
:
7656 return "DW_TAG_imported_unit";
7657 case DW_TAG_MIPS_loop
:
7658 return "DW_TAG_MIPS_loop";
7659 case DW_TAG_format_label
:
7660 return "DW_TAG_format_label";
7661 case DW_TAG_function_template
:
7662 return "DW_TAG_function_template";
7663 case DW_TAG_class_template
:
7664 return "DW_TAG_class_template";
7666 return "DW_TAG_<unknown>";
7670 /* Convert a DWARF attribute code into its string name. */
7673 dwarf_attr_name (unsigned attr
)
7678 return "DW_AT_sibling";
7679 case DW_AT_location
:
7680 return "DW_AT_location";
7682 return "DW_AT_name";
7683 case DW_AT_ordering
:
7684 return "DW_AT_ordering";
7685 case DW_AT_subscr_data
:
7686 return "DW_AT_subscr_data";
7687 case DW_AT_byte_size
:
7688 return "DW_AT_byte_size";
7689 case DW_AT_bit_offset
:
7690 return "DW_AT_bit_offset";
7691 case DW_AT_bit_size
:
7692 return "DW_AT_bit_size";
7693 case DW_AT_element_list
:
7694 return "DW_AT_element_list";
7695 case DW_AT_stmt_list
:
7696 return "DW_AT_stmt_list";
7698 return "DW_AT_low_pc";
7700 return "DW_AT_high_pc";
7701 case DW_AT_language
:
7702 return "DW_AT_language";
7704 return "DW_AT_member";
7706 return "DW_AT_discr";
7707 case DW_AT_discr_value
:
7708 return "DW_AT_discr_value";
7709 case DW_AT_visibility
:
7710 return "DW_AT_visibility";
7712 return "DW_AT_import";
7713 case DW_AT_string_length
:
7714 return "DW_AT_string_length";
7715 case DW_AT_common_reference
:
7716 return "DW_AT_common_reference";
7717 case DW_AT_comp_dir
:
7718 return "DW_AT_comp_dir";
7719 case DW_AT_const_value
:
7720 return "DW_AT_const_value";
7721 case DW_AT_containing_type
:
7722 return "DW_AT_containing_type";
7723 case DW_AT_default_value
:
7724 return "DW_AT_default_value";
7726 return "DW_AT_inline";
7727 case DW_AT_is_optional
:
7728 return "DW_AT_is_optional";
7729 case DW_AT_lower_bound
:
7730 return "DW_AT_lower_bound";
7731 case DW_AT_producer
:
7732 return "DW_AT_producer";
7733 case DW_AT_prototyped
:
7734 return "DW_AT_prototyped";
7735 case DW_AT_return_addr
:
7736 return "DW_AT_return_addr";
7737 case DW_AT_start_scope
:
7738 return "DW_AT_start_scope";
7739 case DW_AT_stride_size
:
7740 return "DW_AT_stride_size";
7741 case DW_AT_upper_bound
:
7742 return "DW_AT_upper_bound";
7743 case DW_AT_abstract_origin
:
7744 return "DW_AT_abstract_origin";
7745 case DW_AT_accessibility
:
7746 return "DW_AT_accessibility";
7747 case DW_AT_address_class
:
7748 return "DW_AT_address_class";
7749 case DW_AT_artificial
:
7750 return "DW_AT_artificial";
7751 case DW_AT_base_types
:
7752 return "DW_AT_base_types";
7753 case DW_AT_calling_convention
:
7754 return "DW_AT_calling_convention";
7756 return "DW_AT_count";
7757 case DW_AT_data_member_location
:
7758 return "DW_AT_data_member_location";
7759 case DW_AT_decl_column
:
7760 return "DW_AT_decl_column";
7761 case DW_AT_decl_file
:
7762 return "DW_AT_decl_file";
7763 case DW_AT_decl_line
:
7764 return "DW_AT_decl_line";
7765 case DW_AT_declaration
:
7766 return "DW_AT_declaration";
7767 case DW_AT_discr_list
:
7768 return "DW_AT_discr_list";
7769 case DW_AT_encoding
:
7770 return "DW_AT_encoding";
7771 case DW_AT_external
:
7772 return "DW_AT_external";
7773 case DW_AT_frame_base
:
7774 return "DW_AT_frame_base";
7776 return "DW_AT_friend";
7777 case DW_AT_identifier_case
:
7778 return "DW_AT_identifier_case";
7779 case DW_AT_macro_info
:
7780 return "DW_AT_macro_info";
7781 case DW_AT_namelist_items
:
7782 return "DW_AT_namelist_items";
7783 case DW_AT_priority
:
7784 return "DW_AT_priority";
7786 return "DW_AT_segment";
7787 case DW_AT_specification
:
7788 return "DW_AT_specification";
7789 case DW_AT_static_link
:
7790 return "DW_AT_static_link";
7792 return "DW_AT_type";
7793 case DW_AT_use_location
:
7794 return "DW_AT_use_location";
7795 case DW_AT_variable_parameter
:
7796 return "DW_AT_variable_parameter";
7797 case DW_AT_virtuality
:
7798 return "DW_AT_virtuality";
7799 case DW_AT_vtable_elem_location
:
7800 return "DW_AT_vtable_elem_location";
7801 case DW_AT_allocated
:
7802 return "DW_AT_allocated";
7803 case DW_AT_associated
:
7804 return "DW_AT_associated";
7805 case DW_AT_data_location
:
7806 return "DW_AT_data_location";
7808 return "DW_AT_stride";
7809 case DW_AT_entry_pc
:
7810 return "DW_AT_entry_pc";
7811 case DW_AT_use_UTF8
:
7812 return "DW_AT_use_UTF8";
7813 case DW_AT_extension
:
7814 return "DW_AT_extension";
7816 return "DW_AT_ranges";
7817 case DW_AT_trampoline
:
7818 return "DW_AT_trampoline";
7819 case DW_AT_call_column
:
7820 return "DW_AT_call_column";
7821 case DW_AT_call_file
:
7822 return "DW_AT_call_file";
7823 case DW_AT_call_line
:
7824 return "DW_AT_call_line";
7826 case DW_AT_MIPS_fde
:
7827 return "DW_AT_MIPS_fde";
7828 case DW_AT_MIPS_loop_begin
:
7829 return "DW_AT_MIPS_loop_begin";
7830 case DW_AT_MIPS_tail_loop_begin
:
7831 return "DW_AT_MIPS_tail_loop_begin";
7832 case DW_AT_MIPS_epilog_begin
:
7833 return "DW_AT_MIPS_epilog_begin";
7834 case DW_AT_MIPS_loop_unroll_factor
:
7835 return "DW_AT_MIPS_loop_unroll_factor";
7836 case DW_AT_MIPS_software_pipeline_depth
:
7837 return "DW_AT_MIPS_software_pipeline_depth";
7839 case DW_AT_MIPS_linkage_name
:
7840 return "DW_AT_MIPS_linkage_name";
7842 case DW_AT_sf_names
:
7843 return "DW_AT_sf_names";
7844 case DW_AT_src_info
:
7845 return "DW_AT_src_info";
7846 case DW_AT_mac_info
:
7847 return "DW_AT_mac_info";
7848 case DW_AT_src_coords
:
7849 return "DW_AT_src_coords";
7850 case DW_AT_body_begin
:
7851 return "DW_AT_body_begin";
7852 case DW_AT_body_end
:
7853 return "DW_AT_body_end";
7854 case DW_AT_GNU_vector
:
7855 return "DW_AT_GNU_vector";
7857 return "DW_AT_<unknown>";
7861 /* Convert a DWARF value form code into its string name. */
7864 dwarf_form_name (unsigned form
)
7869 return "DW_FORM_addr";
7870 case DW_FORM_block2
:
7871 return "DW_FORM_block2";
7872 case DW_FORM_block4
:
7873 return "DW_FORM_block4";
7875 return "DW_FORM_data2";
7877 return "DW_FORM_data4";
7879 return "DW_FORM_data8";
7880 case DW_FORM_string
:
7881 return "DW_FORM_string";
7883 return "DW_FORM_block";
7884 case DW_FORM_block1
:
7885 return "DW_FORM_block1";
7887 return "DW_FORM_data1";
7889 return "DW_FORM_flag";
7891 return "DW_FORM_sdata";
7893 return "DW_FORM_strp";
7895 return "DW_FORM_udata";
7896 case DW_FORM_ref_addr
:
7897 return "DW_FORM_ref_addr";
7899 return "DW_FORM_ref1";
7901 return "DW_FORM_ref2";
7903 return "DW_FORM_ref4";
7905 return "DW_FORM_ref8";
7906 case DW_FORM_ref_udata
:
7907 return "DW_FORM_ref_udata";
7908 case DW_FORM_indirect
:
7909 return "DW_FORM_indirect";
7911 return "DW_FORM_<unknown>";
7915 /* Convert a DWARF stack opcode into its string name. */
7918 dwarf_stack_op_name (unsigned op
)
7923 return "DW_OP_addr";
7925 return "DW_OP_deref";
7927 return "DW_OP_const1u";
7929 return "DW_OP_const1s";
7931 return "DW_OP_const2u";
7933 return "DW_OP_const2s";
7935 return "DW_OP_const4u";
7937 return "DW_OP_const4s";
7939 return "DW_OP_const8u";
7941 return "DW_OP_const8s";
7943 return "DW_OP_constu";
7945 return "DW_OP_consts";
7949 return "DW_OP_drop";
7951 return "DW_OP_over";
7953 return "DW_OP_pick";
7955 return "DW_OP_swap";
7959 return "DW_OP_xderef";
7967 return "DW_OP_minus";
7979 return "DW_OP_plus";
7980 case DW_OP_plus_uconst
:
7981 return "DW_OP_plus_uconst";
7987 return "DW_OP_shra";
8005 return "DW_OP_skip";
8007 return "DW_OP_lit0";
8009 return "DW_OP_lit1";
8011 return "DW_OP_lit2";
8013 return "DW_OP_lit3";
8015 return "DW_OP_lit4";
8017 return "DW_OP_lit5";
8019 return "DW_OP_lit6";
8021 return "DW_OP_lit7";
8023 return "DW_OP_lit8";
8025 return "DW_OP_lit9";
8027 return "DW_OP_lit10";
8029 return "DW_OP_lit11";
8031 return "DW_OP_lit12";
8033 return "DW_OP_lit13";
8035 return "DW_OP_lit14";
8037 return "DW_OP_lit15";
8039 return "DW_OP_lit16";
8041 return "DW_OP_lit17";
8043 return "DW_OP_lit18";
8045 return "DW_OP_lit19";
8047 return "DW_OP_lit20";
8049 return "DW_OP_lit21";
8051 return "DW_OP_lit22";
8053 return "DW_OP_lit23";
8055 return "DW_OP_lit24";
8057 return "DW_OP_lit25";
8059 return "DW_OP_lit26";
8061 return "DW_OP_lit27";
8063 return "DW_OP_lit28";
8065 return "DW_OP_lit29";
8067 return "DW_OP_lit30";
8069 return "DW_OP_lit31";
8071 return "DW_OP_reg0";
8073 return "DW_OP_reg1";
8075 return "DW_OP_reg2";
8077 return "DW_OP_reg3";
8079 return "DW_OP_reg4";
8081 return "DW_OP_reg5";
8083 return "DW_OP_reg6";
8085 return "DW_OP_reg7";
8087 return "DW_OP_reg8";
8089 return "DW_OP_reg9";
8091 return "DW_OP_reg10";
8093 return "DW_OP_reg11";
8095 return "DW_OP_reg12";
8097 return "DW_OP_reg13";
8099 return "DW_OP_reg14";
8101 return "DW_OP_reg15";
8103 return "DW_OP_reg16";
8105 return "DW_OP_reg17";
8107 return "DW_OP_reg18";
8109 return "DW_OP_reg19";
8111 return "DW_OP_reg20";
8113 return "DW_OP_reg21";
8115 return "DW_OP_reg22";
8117 return "DW_OP_reg23";
8119 return "DW_OP_reg24";
8121 return "DW_OP_reg25";
8123 return "DW_OP_reg26";
8125 return "DW_OP_reg27";
8127 return "DW_OP_reg28";
8129 return "DW_OP_reg29";
8131 return "DW_OP_reg30";
8133 return "DW_OP_reg31";
8135 return "DW_OP_breg0";
8137 return "DW_OP_breg1";
8139 return "DW_OP_breg2";
8141 return "DW_OP_breg3";
8143 return "DW_OP_breg4";
8145 return "DW_OP_breg5";
8147 return "DW_OP_breg6";
8149 return "DW_OP_breg7";
8151 return "DW_OP_breg8";
8153 return "DW_OP_breg9";
8155 return "DW_OP_breg10";
8157 return "DW_OP_breg11";
8159 return "DW_OP_breg12";
8161 return "DW_OP_breg13";
8163 return "DW_OP_breg14";
8165 return "DW_OP_breg15";
8167 return "DW_OP_breg16";
8169 return "DW_OP_breg17";
8171 return "DW_OP_breg18";
8173 return "DW_OP_breg19";
8175 return "DW_OP_breg20";
8177 return "DW_OP_breg21";
8179 return "DW_OP_breg22";
8181 return "DW_OP_breg23";
8183 return "DW_OP_breg24";
8185 return "DW_OP_breg25";
8187 return "DW_OP_breg26";
8189 return "DW_OP_breg27";
8191 return "DW_OP_breg28";
8193 return "DW_OP_breg29";
8195 return "DW_OP_breg30";
8197 return "DW_OP_breg31";
8199 return "DW_OP_regx";
8201 return "DW_OP_fbreg";
8203 return "DW_OP_bregx";
8205 return "DW_OP_piece";
8206 case DW_OP_deref_size
:
8207 return "DW_OP_deref_size";
8208 case DW_OP_xderef_size
:
8209 return "DW_OP_xderef_size";
8212 /* DWARF 3 extensions. */
8213 case DW_OP_push_object_address
:
8214 return "DW_OP_push_object_address";
8216 return "DW_OP_call2";
8218 return "DW_OP_call4";
8219 case DW_OP_call_ref
:
8220 return "DW_OP_call_ref";
8221 /* GNU extensions. */
8222 case DW_OP_GNU_push_tls_address
:
8223 return "DW_OP_GNU_push_tls_address";
8225 return "OP_<unknown>";
8230 dwarf_bool_name (unsigned mybool
)
8238 /* Convert a DWARF type code into its string name. */
8241 dwarf_type_encoding_name (unsigned enc
)
8245 case DW_ATE_address
:
8246 return "DW_ATE_address";
8247 case DW_ATE_boolean
:
8248 return "DW_ATE_boolean";
8249 case DW_ATE_complex_float
:
8250 return "DW_ATE_complex_float";
8252 return "DW_ATE_float";
8254 return "DW_ATE_signed";
8255 case DW_ATE_signed_char
:
8256 return "DW_ATE_signed_char";
8257 case DW_ATE_unsigned
:
8258 return "DW_ATE_unsigned";
8259 case DW_ATE_unsigned_char
:
8260 return "DW_ATE_unsigned_char";
8261 case DW_ATE_imaginary_float
:
8262 return "DW_ATE_imaginary_float";
8264 return "DW_ATE_<unknown>";
8268 /* Convert a DWARF call frame info operation to its string name. */
8272 dwarf_cfi_name (unsigned cfi_opc
)
8276 case DW_CFA_advance_loc
:
8277 return "DW_CFA_advance_loc";
8279 return "DW_CFA_offset";
8280 case DW_CFA_restore
:
8281 return "DW_CFA_restore";
8283 return "DW_CFA_nop";
8284 case DW_CFA_set_loc
:
8285 return "DW_CFA_set_loc";
8286 case DW_CFA_advance_loc1
:
8287 return "DW_CFA_advance_loc1";
8288 case DW_CFA_advance_loc2
:
8289 return "DW_CFA_advance_loc2";
8290 case DW_CFA_advance_loc4
:
8291 return "DW_CFA_advance_loc4";
8292 case DW_CFA_offset_extended
:
8293 return "DW_CFA_offset_extended";
8294 case DW_CFA_restore_extended
:
8295 return "DW_CFA_restore_extended";
8296 case DW_CFA_undefined
:
8297 return "DW_CFA_undefined";
8298 case DW_CFA_same_value
:
8299 return "DW_CFA_same_value";
8300 case DW_CFA_register
:
8301 return "DW_CFA_register";
8302 case DW_CFA_remember_state
:
8303 return "DW_CFA_remember_state";
8304 case DW_CFA_restore_state
:
8305 return "DW_CFA_restore_state";
8306 case DW_CFA_def_cfa
:
8307 return "DW_CFA_def_cfa";
8308 case DW_CFA_def_cfa_register
:
8309 return "DW_CFA_def_cfa_register";
8310 case DW_CFA_def_cfa_offset
:
8311 return "DW_CFA_def_cfa_offset";
8314 case DW_CFA_def_cfa_expression
:
8315 return "DW_CFA_def_cfa_expression";
8316 case DW_CFA_expression
:
8317 return "DW_CFA_expression";
8318 case DW_CFA_offset_extended_sf
:
8319 return "DW_CFA_offset_extended_sf";
8320 case DW_CFA_def_cfa_sf
:
8321 return "DW_CFA_def_cfa_sf";
8322 case DW_CFA_def_cfa_offset_sf
:
8323 return "DW_CFA_def_cfa_offset_sf";
8325 /* SGI/MIPS specific */
8326 case DW_CFA_MIPS_advance_loc8
:
8327 return "DW_CFA_MIPS_advance_loc8";
8329 /* GNU extensions */
8330 case DW_CFA_GNU_window_save
:
8331 return "DW_CFA_GNU_window_save";
8332 case DW_CFA_GNU_args_size
:
8333 return "DW_CFA_GNU_args_size";
8334 case DW_CFA_GNU_negative_offset_extended
:
8335 return "DW_CFA_GNU_negative_offset_extended";
8338 return "DW_CFA_<unknown>";
8344 dump_die (struct die_info
*die
)
8348 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8349 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8350 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8351 dwarf_bool_name (die
->child
!= NULL
));
8353 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8354 for (i
= 0; i
< die
->num_attrs
; ++i
)
8356 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8357 dwarf_attr_name (die
->attrs
[i
].name
),
8358 dwarf_form_name (die
->attrs
[i
].form
));
8359 switch (die
->attrs
[i
].form
)
8361 case DW_FORM_ref_addr
:
8363 fprintf_unfiltered (gdb_stderr
, "address: ");
8364 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8366 case DW_FORM_block2
:
8367 case DW_FORM_block4
:
8369 case DW_FORM_block1
:
8370 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8375 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8376 (long) (DW_ADDR (&die
->attrs
[i
])));
8384 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8386 case DW_FORM_string
:
8388 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8389 DW_STRING (&die
->attrs
[i
])
8390 ? DW_STRING (&die
->attrs
[i
]) : "");
8393 if (DW_UNSND (&die
->attrs
[i
]))
8394 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8396 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8398 case DW_FORM_indirect
:
8399 /* the reader will have reduced the indirect form to
8400 the "base form" so this form should not occur */
8401 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8404 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8405 die
->attrs
[i
].form
);
8407 fprintf_unfiltered (gdb_stderr
, "\n");
8412 dump_die_list (struct die_info
*die
)
8417 if (die
->child
!= NULL
)
8418 dump_die_list (die
->child
);
8419 if (die
->sibling
!= NULL
)
8420 dump_die_list (die
->sibling
);
8425 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8426 struct dwarf2_cu
*cu
)
8429 struct die_info
*old
;
8431 h
= (offset
% REF_HASH_SIZE
);
8432 old
= cu
->die_ref_table
[h
];
8433 die
->next_ref
= old
;
8434 cu
->die_ref_table
[h
] = die
;
8438 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8440 unsigned int result
= 0;
8444 case DW_FORM_ref_addr
:
8449 case DW_FORM_ref_udata
:
8450 result
= DW_ADDR (attr
);
8453 complaint (&symfile_complaints
,
8454 _("unsupported die ref attribute form: '%s'"),
8455 dwarf_form_name (attr
->form
));
8460 /* Return the constant value held by the given attribute. Return -1
8461 if the value held by the attribute is not constant. */
8464 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8466 if (attr
->form
== DW_FORM_sdata
)
8467 return DW_SND (attr
);
8468 else if (attr
->form
== DW_FORM_udata
8469 || attr
->form
== DW_FORM_data1
8470 || attr
->form
== DW_FORM_data2
8471 || attr
->form
== DW_FORM_data4
8472 || attr
->form
== DW_FORM_data8
)
8473 return DW_UNSND (attr
);
8476 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8477 dwarf_form_name (attr
->form
));
8478 return default_value
;
8482 static struct die_info
*
8483 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8484 struct dwarf2_cu
*cu
)
8486 struct die_info
*die
;
8487 unsigned int offset
;
8489 struct die_info temp_die
;
8490 struct dwarf2_cu
*target_cu
;
8492 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8494 if (DW_ADDR (attr
) < cu
->header
.offset
8495 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8497 struct dwarf2_per_cu_data
*per_cu
;
8498 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8500 target_cu
= per_cu
->cu
;
8505 h
= (offset
% REF_HASH_SIZE
);
8506 die
= target_cu
->die_ref_table
[h
];
8509 if (die
->offset
== offset
)
8511 die
= die
->next_ref
;
8514 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8515 "at 0x%lx [in module %s]"),
8516 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8521 static struct type
*
8522 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8523 struct dwarf2_cu
*cu
)
8525 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8527 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8528 typeid, objfile
->name
);
8531 /* Look for this particular type in the fundamental type vector. If
8532 one is not found, create and install one appropriate for the
8533 current language and the current target machine. */
8535 if (cu
->ftypes
[typeid] == NULL
)
8537 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8540 return (cu
->ftypes
[typeid]);
8543 /* Decode simple location descriptions.
8544 Given a pointer to a dwarf block that defines a location, compute
8545 the location and return the value.
8547 NOTE drow/2003-11-18: This function is called in two situations
8548 now: for the address of static or global variables (partial symbols
8549 only) and for offsets into structures which are expected to be
8550 (more or less) constant. The partial symbol case should go away,
8551 and only the constant case should remain. That will let this
8552 function complain more accurately. A few special modes are allowed
8553 without complaint for global variables (for instance, global
8554 register values and thread-local values).
8556 A location description containing no operations indicates that the
8557 object is optimized out. The return value is 0 for that case.
8558 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8559 callers will only want a very basic result and this can become a
8562 When the result is a register number, the global isreg flag is set,
8563 otherwise it is cleared.
8565 Note that stack[0] is unused except as a default error return.
8566 Note that stack overflow is not yet handled. */
8569 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8571 struct objfile
*objfile
= cu
->objfile
;
8572 struct comp_unit_head
*cu_header
= &cu
->header
;
8574 int size
= blk
->size
;
8575 char *data
= blk
->data
;
8576 CORE_ADDR stack
[64];
8578 unsigned int bytes_read
, unsnd
;
8623 stack
[++stacki
] = op
- DW_OP_lit0
;
8659 stack
[++stacki
] = op
- DW_OP_reg0
;
8661 dwarf2_complex_location_expr_complaint ();
8666 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8668 stack
[++stacki
] = unsnd
;
8670 dwarf2_complex_location_expr_complaint ();
8674 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8680 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8685 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8690 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8695 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8700 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8705 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8710 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8716 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8721 stack
[stacki
+ 1] = stack
[stacki
];
8726 stack
[stacki
- 1] += stack
[stacki
];
8730 case DW_OP_plus_uconst
:
8731 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8736 stack
[stacki
- 1] -= stack
[stacki
];
8741 /* If we're not the last op, then we definitely can't encode
8742 this using GDB's address_class enum. This is valid for partial
8743 global symbols, although the variable's address will be bogus
8746 dwarf2_complex_location_expr_complaint ();
8749 case DW_OP_GNU_push_tls_address
:
8750 /* The top of the stack has the offset from the beginning
8751 of the thread control block at which the variable is located. */
8752 /* Nothing should follow this operator, so the top of stack would
8754 /* This is valid for partial global symbols, but the variable's
8755 address will be bogus in the psymtab. */
8757 dwarf2_complex_location_expr_complaint ();
8761 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8762 dwarf_stack_op_name (op
));
8763 return (stack
[stacki
]);
8766 return (stack
[stacki
]);
8769 /* memory allocation interface */
8771 static struct dwarf_block
*
8772 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8774 struct dwarf_block
*blk
;
8776 blk
= (struct dwarf_block
*)
8777 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8781 static struct abbrev_info
*
8782 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8784 struct abbrev_info
*abbrev
;
8786 abbrev
= (struct abbrev_info
*)
8787 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8788 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8792 static struct die_info
*
8793 dwarf_alloc_die (void)
8795 struct die_info
*die
;
8797 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8798 memset (die
, 0, sizeof (struct die_info
));
8803 /* Macro support. */
8806 /* Return the full name of file number I in *LH's file name table.
8807 Use COMP_DIR as the name of the current directory of the
8808 compilation. The result is allocated using xmalloc; the caller is
8809 responsible for freeing it. */
8811 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8813 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8815 if (IS_ABSOLUTE_PATH (fe
->name
))
8816 return xstrdup (fe
->name
);
8824 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8830 dir_len
= strlen (dir
);
8831 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8832 strcpy (full_name
, dir
);
8833 full_name
[dir_len
] = '/';
8834 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8838 return xstrdup (fe
->name
);
8843 static struct macro_source_file
*
8844 macro_start_file (int file
, int line
,
8845 struct macro_source_file
*current_file
,
8846 const char *comp_dir
,
8847 struct line_header
*lh
, struct objfile
*objfile
)
8849 /* The full name of this source file. */
8850 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8852 /* We don't create a macro table for this compilation unit
8853 at all until we actually get a filename. */
8854 if (! pending_macros
)
8855 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8856 objfile
->macro_cache
);
8859 /* If we have no current file, then this must be the start_file
8860 directive for the compilation unit's main source file. */
8861 current_file
= macro_set_main (pending_macros
, full_name
);
8863 current_file
= macro_include (current_file
, line
, full_name
);
8867 return current_file
;
8871 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8872 followed by a null byte. */
8874 copy_string (const char *buf
, int len
)
8876 char *s
= xmalloc (len
+ 1);
8877 memcpy (s
, buf
, len
);
8885 consume_improper_spaces (const char *p
, const char *body
)
8889 complaint (&symfile_complaints
,
8890 _("macro definition contains spaces in formal argument list:\n`%s'"),
8902 parse_macro_definition (struct macro_source_file
*file
, int line
,
8907 /* The body string takes one of two forms. For object-like macro
8908 definitions, it should be:
8910 <macro name> " " <definition>
8912 For function-like macro definitions, it should be:
8914 <macro name> "() " <definition>
8916 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8918 Spaces may appear only where explicitly indicated, and in the
8921 The Dwarf 2 spec says that an object-like macro's name is always
8922 followed by a space, but versions of GCC around March 2002 omit
8923 the space when the macro's definition is the empty string.
8925 The Dwarf 2 spec says that there should be no spaces between the
8926 formal arguments in a function-like macro's formal argument list,
8927 but versions of GCC around March 2002 include spaces after the
8931 /* Find the extent of the macro name. The macro name is terminated
8932 by either a space or null character (for an object-like macro) or
8933 an opening paren (for a function-like macro). */
8934 for (p
= body
; *p
; p
++)
8935 if (*p
== ' ' || *p
== '(')
8938 if (*p
== ' ' || *p
== '\0')
8940 /* It's an object-like macro. */
8941 int name_len
= p
- body
;
8942 char *name
= copy_string (body
, name_len
);
8943 const char *replacement
;
8946 replacement
= body
+ name_len
+ 1;
8949 dwarf2_macro_malformed_definition_complaint (body
);
8950 replacement
= body
+ name_len
;
8953 macro_define_object (file
, line
, name
, replacement
);
8959 /* It's a function-like macro. */
8960 char *name
= copy_string (body
, p
- body
);
8963 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
8967 p
= consume_improper_spaces (p
, body
);
8969 /* Parse the formal argument list. */
8970 while (*p
&& *p
!= ')')
8972 /* Find the extent of the current argument name. */
8973 const char *arg_start
= p
;
8975 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
8978 if (! *p
|| p
== arg_start
)
8979 dwarf2_macro_malformed_definition_complaint (body
);
8982 /* Make sure argv has room for the new argument. */
8983 if (argc
>= argv_size
)
8986 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
8989 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
8992 p
= consume_improper_spaces (p
, body
);
8994 /* Consume the comma, if present. */
8999 p
= consume_improper_spaces (p
, body
);
9008 /* Perfectly formed definition, no complaints. */
9009 macro_define_function (file
, line
, name
,
9010 argc
, (const char **) argv
,
9012 else if (*p
== '\0')
9014 /* Complain, but do define it. */
9015 dwarf2_macro_malformed_definition_complaint (body
);
9016 macro_define_function (file
, line
, name
,
9017 argc
, (const char **) argv
,
9021 /* Just complain. */
9022 dwarf2_macro_malformed_definition_complaint (body
);
9025 /* Just complain. */
9026 dwarf2_macro_malformed_definition_complaint (body
);
9032 for (i
= 0; i
< argc
; i
++)
9038 dwarf2_macro_malformed_definition_complaint (body
);
9043 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9044 char *comp_dir
, bfd
*abfd
,
9045 struct dwarf2_cu
*cu
)
9047 char *mac_ptr
, *mac_end
;
9048 struct macro_source_file
*current_file
= 0;
9050 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9052 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9056 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9057 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9058 + dwarf2_per_objfile
->macinfo_size
;
9062 enum dwarf_macinfo_record_type macinfo_type
;
9064 /* Do we at least have room for a macinfo type byte? */
9065 if (mac_ptr
>= mac_end
)
9067 dwarf2_macros_too_long_complaint ();
9071 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9074 switch (macinfo_type
)
9076 /* A zero macinfo type indicates the end of the macro
9081 case DW_MACINFO_define
:
9082 case DW_MACINFO_undef
:
9088 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9089 mac_ptr
+= bytes_read
;
9090 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9091 mac_ptr
+= bytes_read
;
9094 complaint (&symfile_complaints
,
9095 _("debug info gives macro %s outside of any file: %s"),
9097 DW_MACINFO_define
? "definition" : macinfo_type
==
9098 DW_MACINFO_undef
? "undefinition" :
9099 "something-or-other", body
);
9102 if (macinfo_type
== DW_MACINFO_define
)
9103 parse_macro_definition (current_file
, line
, body
);
9104 else if (macinfo_type
== DW_MACINFO_undef
)
9105 macro_undef (current_file
, line
, body
);
9110 case DW_MACINFO_start_file
:
9115 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9116 mac_ptr
+= bytes_read
;
9117 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9118 mac_ptr
+= bytes_read
;
9120 current_file
= macro_start_file (file
, line
,
9121 current_file
, comp_dir
,
9126 case DW_MACINFO_end_file
:
9128 complaint (&symfile_complaints
,
9129 _("macro debug info has an unmatched `close_file' directive"));
9132 current_file
= current_file
->included_by
;
9135 enum dwarf_macinfo_record_type next_type
;
9137 /* GCC circa March 2002 doesn't produce the zero
9138 type byte marking the end of the compilation
9139 unit. Complain if it's not there, but exit no
9142 /* Do we at least have room for a macinfo type byte? */
9143 if (mac_ptr
>= mac_end
)
9145 dwarf2_macros_too_long_complaint ();
9149 /* We don't increment mac_ptr here, so this is just
9151 next_type
= read_1_byte (abfd
, mac_ptr
);
9153 complaint (&symfile_complaints
,
9154 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9161 case DW_MACINFO_vendor_ext
:
9167 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9168 mac_ptr
+= bytes_read
;
9169 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9170 mac_ptr
+= bytes_read
;
9172 /* We don't recognize any vendor extensions. */
9179 /* Check if the attribute's form is a DW_FORM_block*
9180 if so return true else false. */
9182 attr_form_is_block (struct attribute
*attr
)
9184 return (attr
== NULL
? 0 :
9185 attr
->form
== DW_FORM_block1
9186 || attr
->form
== DW_FORM_block2
9187 || attr
->form
== DW_FORM_block4
9188 || attr
->form
== DW_FORM_block
);
9192 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9193 struct dwarf2_cu
*cu
)
9195 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9197 struct dwarf2_loclist_baton
*baton
;
9199 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9200 sizeof (struct dwarf2_loclist_baton
));
9201 baton
->objfile
= cu
->objfile
;
9203 /* We don't know how long the location list is, but make sure we
9204 don't run off the edge of the section. */
9205 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9206 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9207 baton
->base_address
= cu
->header
.base_address
;
9208 if (cu
->header
.base_known
== 0)
9209 complaint (&symfile_complaints
,
9210 _("Location list used without specifying the CU base address."));
9212 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9213 SYMBOL_LOCATION_BATON (sym
) = baton
;
9217 struct dwarf2_locexpr_baton
*baton
;
9219 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9220 sizeof (struct dwarf2_locexpr_baton
));
9221 baton
->objfile
= cu
->objfile
;
9223 if (attr_form_is_block (attr
))
9225 /* Note that we're just copying the block's data pointer
9226 here, not the actual data. We're still pointing into the
9227 info_buffer for SYM's objfile; right now we never release
9228 that buffer, but when we do clean up properly this may
9230 baton
->size
= DW_BLOCK (attr
)->size
;
9231 baton
->data
= DW_BLOCK (attr
)->data
;
9235 dwarf2_invalid_attrib_class_complaint ("location description",
9236 SYMBOL_NATURAL_NAME (sym
));
9241 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9242 SYMBOL_LOCATION_BATON (sym
) = baton
;
9246 /* Locate the compilation unit from CU's objfile which contains the
9247 DIE at OFFSET. Raises an error on failure. */
9249 static struct dwarf2_per_cu_data
*
9250 dwarf2_find_containing_comp_unit (unsigned long offset
,
9251 struct objfile
*objfile
)
9253 struct dwarf2_per_cu_data
*this_cu
;
9257 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9260 int mid
= low
+ (high
- low
) / 2;
9261 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9266 gdb_assert (low
== high
);
9267 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9270 error (_("Dwarf Error: could not find partial DIE containing "
9271 "offset 0x%lx [in module %s]"),
9272 (long) offset
, bfd_get_filename (objfile
->obfd
));
9274 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9275 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9279 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9280 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9281 && offset
>= this_cu
->offset
+ this_cu
->length
)
9282 error (_("invalid dwarf2 offset %ld"), offset
);
9283 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9288 /* Locate the compilation unit from OBJFILE which is located at exactly
9289 OFFSET. Raises an error on failure. */
9291 static struct dwarf2_per_cu_data
*
9292 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9294 struct dwarf2_per_cu_data
*this_cu
;
9295 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9296 if (this_cu
->offset
!= offset
)
9297 error (_("no compilation unit with offset %ld."), offset
);
9301 /* Release one cached compilation unit, CU. We unlink it from the tree
9302 of compilation units, but we don't remove it from the read_in_chain;
9303 the caller is responsible for that. */
9306 free_one_comp_unit (void *data
)
9308 struct dwarf2_cu
*cu
= data
;
9310 if (cu
->per_cu
!= NULL
)
9311 cu
->per_cu
->cu
= NULL
;
9314 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9316 free_die_list (cu
->dies
);
9321 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9322 when we're finished with it. We can't free the pointer itself, but be
9323 sure to unlink it from the cache. Also release any associated storage
9324 and perform cache maintenance.
9326 Only used during partial symbol parsing. */
9329 free_stack_comp_unit (void *data
)
9331 struct dwarf2_cu
*cu
= data
;
9333 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9334 cu
->partial_dies
= NULL
;
9336 if (cu
->per_cu
!= NULL
)
9338 /* This compilation unit is on the stack in our caller, so we
9339 should not xfree it. Just unlink it. */
9340 cu
->per_cu
->cu
= NULL
;
9343 /* If we had a per-cu pointer, then we may have other compilation
9344 units loaded, so age them now. */
9345 age_cached_comp_units ();
9349 /* Free all cached compilation units. */
9352 free_cached_comp_units (void *data
)
9354 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9356 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9357 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9358 while (per_cu
!= NULL
)
9360 struct dwarf2_per_cu_data
*next_cu
;
9362 next_cu
= per_cu
->cu
->read_in_chain
;
9364 free_one_comp_unit (per_cu
->cu
);
9365 *last_chain
= next_cu
;
9371 /* Increase the age counter on each cached compilation unit, and free
9372 any that are too old. */
9375 age_cached_comp_units (void)
9377 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9379 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9380 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9381 while (per_cu
!= NULL
)
9383 per_cu
->cu
->last_used
++;
9384 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9385 dwarf2_mark (per_cu
->cu
);
9386 per_cu
= per_cu
->cu
->read_in_chain
;
9389 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9390 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9391 while (per_cu
!= NULL
)
9393 struct dwarf2_per_cu_data
*next_cu
;
9395 next_cu
= per_cu
->cu
->read_in_chain
;
9397 if (!per_cu
->cu
->mark
)
9399 free_one_comp_unit (per_cu
->cu
);
9400 *last_chain
= next_cu
;
9403 last_chain
= &per_cu
->cu
->read_in_chain
;
9409 /* Remove a single compilation unit from the cache. */
9412 free_one_cached_comp_unit (void *target_cu
)
9414 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9416 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9417 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9418 while (per_cu
!= NULL
)
9420 struct dwarf2_per_cu_data
*next_cu
;
9422 next_cu
= per_cu
->cu
->read_in_chain
;
9424 if (per_cu
->cu
== target_cu
)
9426 free_one_comp_unit (per_cu
->cu
);
9427 *last_chain
= next_cu
;
9431 last_chain
= &per_cu
->cu
->read_in_chain
;
9437 /* A pair of DIE offset and GDB type pointer. We store these
9438 in a hash table separate from the DIEs, and preserve them
9439 when the DIEs are flushed out of cache. */
9441 struct dwarf2_offset_and_type
9443 unsigned int offset
;
9447 /* Hash function for a dwarf2_offset_and_type. */
9450 offset_and_type_hash (const void *item
)
9452 const struct dwarf2_offset_and_type
*ofs
= item
;
9456 /* Equality function for a dwarf2_offset_and_type. */
9459 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9461 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9462 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9463 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9466 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9467 table if necessary. */
9470 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9472 struct dwarf2_offset_and_type
**slot
, ofs
;
9476 if (cu
->per_cu
== NULL
)
9479 if (cu
->per_cu
->type_hash
== NULL
)
9480 cu
->per_cu
->type_hash
9481 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9482 offset_and_type_hash
,
9485 &cu
->objfile
->objfile_obstack
,
9486 hashtab_obstack_allocate
,
9487 dummy_obstack_deallocate
);
9489 ofs
.offset
= die
->offset
;
9491 slot
= (struct dwarf2_offset_and_type
**)
9492 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9493 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9497 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9498 have a saved type. */
9500 static struct type
*
9501 get_die_type (struct die_info
*die
, htab_t type_hash
)
9503 struct dwarf2_offset_and_type
*slot
, ofs
;
9505 ofs
.offset
= die
->offset
;
9506 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9513 /* Restore the types of the DIE tree starting at START_DIE from the hash
9514 table saved in CU. */
9517 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9519 struct die_info
*die
;
9521 if (cu
->per_cu
->type_hash
== NULL
)
9524 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9526 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9527 if (die
->child
!= NULL
)
9528 reset_die_and_siblings_types (die
->child
, cu
);
9532 /* Set the mark field in CU and in every other compilation unit in the
9533 cache that we must keep because we are keeping CU. */
9535 /* Add a dependence relationship from CU to REF_PER_CU. */
9538 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9539 struct dwarf2_per_cu_data
*ref_per_cu
)
9543 if (cu
->dependencies
== NULL
)
9545 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9546 NULL
, &cu
->comp_unit_obstack
,
9547 hashtab_obstack_allocate
,
9548 dummy_obstack_deallocate
);
9550 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9555 /* Set the mark field in CU and in every other compilation unit in the
9556 cache that we must keep because we are keeping CU. */
9559 dwarf2_mark_helper (void **slot
, void *data
)
9561 struct dwarf2_per_cu_data
*per_cu
;
9563 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9564 if (per_cu
->cu
->mark
)
9566 per_cu
->cu
->mark
= 1;
9568 if (per_cu
->cu
->dependencies
!= NULL
)
9569 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9575 dwarf2_mark (struct dwarf2_cu
*cu
)
9580 if (cu
->dependencies
!= NULL
)
9581 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9585 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9589 per_cu
->cu
->mark
= 0;
9590 per_cu
= per_cu
->cu
->read_in_chain
;
9594 /* Allocation function for the libiberty hash table which uses an
9598 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
9600 unsigned int total
= size
* count
;
9601 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
9602 memset (ptr
, 0, total
);
9606 /* Trivial deallocation function for the libiberty splay tree and hash
9607 table - don't deallocate anything. Rely on later deletion of the
9611 dummy_obstack_deallocate (void *object
, void *data
)
9616 /* Trivial hash function for partial_die_info: the hash value of a DIE
9617 is its offset in .debug_info for this objfile. */
9620 partial_die_hash (const void *item
)
9622 const struct partial_die_info
*part_die
= item
;
9623 return part_die
->offset
;
9626 /* Trivial comparison function for partial_die_info structures: two DIEs
9627 are equal if they have the same offset. */
9630 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9632 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9633 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9634 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9637 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9638 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9641 set_dwarf2_cmd (char *args
, int from_tty
)
9643 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9647 show_dwarf2_cmd (char *args
, int from_tty
)
9649 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9652 void _initialize_dwarf2_read (void);
9655 _initialize_dwarf2_read (void)
9657 dwarf2_objfile_data_key
= register_objfile_data ();
9659 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9660 Set DWARF 2 specific variables.\n\
9661 Configure DWARF 2 variables such as the cache size"),
9662 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9663 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9665 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9666 Show DWARF 2 specific variables\n\
9667 Show DWARF 2 variables such as the cache size"),
9668 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9669 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9671 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9672 &dwarf2_max_cache_age
, _("\
9673 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9674 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9675 A higher limit means that cached compilation units will be stored\n\
9676 in memory longer, and more total memory will be used. Zero disables\n\
9677 caching, which can slow down startup."),
9679 show_dwarf2_max_cache_age
,
9680 &set_dwarf2_cmdlist
,
9681 &show_dwarf2_cmdlist
);