1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 Free Software Foundation, Inc.
6 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
7 Inc. with support from Florida State University (under contract
8 with the Ada Joint Program Office), and Silicon Graphics, Inc.
9 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
10 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
11 support in dwarfread.c
13 This file is part of GDB.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or (at
18 your option) any later version.
20 This program is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 59 Temple Place - Suite 330,
28 Boston, MA 02111-1307, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
42 #include "complaints.h"
44 #include "dwarf2expr.h"
45 #include "dwarf2loc.h"
46 #include "cp-support.h"
52 #include "gdb_string.h"
53 #include "gdb_assert.h"
54 #include <sys/types.h>
56 /* A note on memory usage for this file.
58 At the present time, this code reads the debug info sections into
59 the objfile's objfile_obstack. A definite improvement for startup
60 time, on platforms which do not emit relocations for debug
61 sections, would be to use mmap instead. The object's complete
62 debug information is loaded into memory, partly to simplify
63 absolute DIE references.
65 Whether using obstacks or mmap, the sections should remain loaded
66 until the objfile is released, and pointers into the section data
67 can be used for any other data associated to the objfile (symbol
68 names, type names, location expressions to name a few). */
70 #ifndef DWARF2_REG_TO_REGNUM
71 #define DWARF2_REG_TO_REGNUM(REG) (REG)
75 /* .debug_info header for a compilation unit
76 Because of alignment constraints, this structure has padding and cannot
77 be mapped directly onto the beginning of the .debug_info section. */
78 typedef struct comp_unit_header
80 unsigned int length
; /* length of the .debug_info
82 unsigned short version
; /* version number -- 2 for DWARF
84 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
85 unsigned char addr_size
; /* byte size of an address -- 4 */
88 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
91 /* .debug_pubnames header
92 Because of alignment constraints, this structure has padding and cannot
93 be mapped directly onto the beginning of the .debug_info section. */
94 typedef struct pubnames_header
96 unsigned int length
; /* length of the .debug_pubnames
98 unsigned char version
; /* version number -- 2 for DWARF
100 unsigned int info_offset
; /* offset into .debug_info section */
101 unsigned int info_size
; /* byte size of .debug_info section
105 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
107 /* .debug_pubnames header
108 Because of alignment constraints, this structure has padding and cannot
109 be mapped directly onto the beginning of the .debug_info section. */
110 typedef struct aranges_header
112 unsigned int length
; /* byte len of the .debug_aranges
114 unsigned short version
; /* version number -- 2 for DWARF
116 unsigned int info_offset
; /* offset into .debug_info section */
117 unsigned char addr_size
; /* byte size of an address */
118 unsigned char seg_size
; /* byte size of segment descriptor */
121 #define _ACTUAL_ARANGES_HEADER_SIZE 12
123 /* .debug_line statement program prologue
124 Because of alignment constraints, this structure has padding and cannot
125 be mapped directly onto the beginning of the .debug_info section. */
126 typedef struct statement_prologue
128 unsigned int total_length
; /* byte length of the statement
130 unsigned short version
; /* version number -- 2 for DWARF
132 unsigned int prologue_length
; /* # bytes between prologue &
134 unsigned char minimum_instruction_length
; /* byte size of
136 unsigned char default_is_stmt
; /* initial value of is_stmt
139 unsigned char line_range
;
140 unsigned char opcode_base
; /* number assigned to first special
142 unsigned char *standard_opcode_lengths
;
146 static const struct objfile_data
*dwarf2_objfile_data_key
;
148 struct dwarf2_per_objfile
150 /* Sizes of debugging sections. */
151 unsigned int info_size
;
152 unsigned int abbrev_size
;
153 unsigned int line_size
;
154 unsigned int pubnames_size
;
155 unsigned int aranges_size
;
156 unsigned int loc_size
;
157 unsigned int macinfo_size
;
158 unsigned int str_size
;
159 unsigned int ranges_size
;
160 unsigned int frame_size
;
161 unsigned int eh_frame_size
;
163 /* Loaded data from the sections. */
168 char *macinfo_buffer
;
172 /* A list of all the compilation units. This is used to locate
173 the target compilation unit of a particular reference. */
174 struct dwarf2_per_cu_data
**all_comp_units
;
176 /* The number of compilation units in ALL_COMP_UNITS. */
179 /* A chain of compilation units that are currently read in, so that
180 they can be freed later. */
181 struct dwarf2_per_cu_data
*read_in_chain
;
184 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
186 static asection
*dwarf_info_section
;
187 static asection
*dwarf_abbrev_section
;
188 static asection
*dwarf_line_section
;
189 static asection
*dwarf_pubnames_section
;
190 static asection
*dwarf_aranges_section
;
191 static asection
*dwarf_loc_section
;
192 static asection
*dwarf_macinfo_section
;
193 static asection
*dwarf_str_section
;
194 static asection
*dwarf_ranges_section
;
195 asection
*dwarf_frame_section
;
196 asection
*dwarf_eh_frame_section
;
198 /* names of the debugging sections */
200 #define INFO_SECTION ".debug_info"
201 #define ABBREV_SECTION ".debug_abbrev"
202 #define LINE_SECTION ".debug_line"
203 #define PUBNAMES_SECTION ".debug_pubnames"
204 #define ARANGES_SECTION ".debug_aranges"
205 #define LOC_SECTION ".debug_loc"
206 #define MACINFO_SECTION ".debug_macinfo"
207 #define STR_SECTION ".debug_str"
208 #define RANGES_SECTION ".debug_ranges"
209 #define FRAME_SECTION ".debug_frame"
210 #define EH_FRAME_SECTION ".eh_frame"
212 /* local data types */
214 /* We hold several abbreviation tables in memory at the same time. */
215 #ifndef ABBREV_HASH_SIZE
216 #define ABBREV_HASH_SIZE 121
219 /* The data in a compilation unit header, after target2host
220 translation, looks like this. */
221 struct comp_unit_head
223 unsigned long length
;
225 unsigned int abbrev_offset
;
226 unsigned char addr_size
;
227 unsigned char signed_addr_p
;
228 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
229 unsigned int initial_length_size
; /* size of the length field; either
232 /* Offset to the first byte of this compilation unit header in the
233 * .debug_info section, for resolving relative reference dies. */
237 /* Pointer to this compilation unit header in the .debug_info
242 /* Pointer to the first die of this compilatio unit. This will
243 * be the first byte following the compilation unit header. */
247 /* Pointer to the next compilation unit header in the program. */
249 struct comp_unit_head
*next
;
251 /* Base address of this compilation unit. */
253 CORE_ADDR base_address
;
255 /* Non-zero if base_address has been set. */
260 /* Fixed size for the DIE hash table. */
261 #ifndef REF_HASH_SIZE
262 #define REF_HASH_SIZE 1021
265 /* Internal state when decoding a particular compilation unit. */
268 /* The objfile containing this compilation unit. */
269 struct objfile
*objfile
;
271 /* The header of the compilation unit.
273 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
274 should logically be moved to the dwarf2_cu structure. */
275 struct comp_unit_head header
;
277 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
279 /* The language we are debugging. */
280 enum language language
;
281 const struct language_defn
*language_defn
;
283 const char *producer
;
285 /* The generic symbol table building routines have separate lists for
286 file scope symbols and all all other scopes (local scopes). So
287 we need to select the right one to pass to add_symbol_to_list().
288 We do it by keeping a pointer to the correct list in list_in_scope.
290 FIXME: The original dwarf code just treated the file scope as the
291 first local scope, and all other local scopes as nested local
292 scopes, and worked fine. Check to see if we really need to
293 distinguish these in buildsym.c. */
294 struct pending
**list_in_scope
;
296 /* Maintain an array of referenced fundamental types for the current
297 compilation unit being read. For DWARF version 1, we have to construct
298 the fundamental types on the fly, since no information about the
299 fundamental types is supplied. Each such fundamental type is created by
300 calling a language dependent routine to create the type, and then a
301 pointer to that type is then placed in the array at the index specified
302 by it's FT_<TYPENAME> value. The array has a fixed size set by the
303 FT_NUM_MEMBERS compile time constant, which is the number of predefined
304 fundamental types gdb knows how to construct. */
305 struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
307 /* DWARF abbreviation table associated with this compilation unit. */
308 struct abbrev_info
**dwarf2_abbrevs
;
310 /* Storage for the abbrev table. */
311 struct obstack abbrev_obstack
;
313 /* Hash table holding all the loaded partial DIEs. */
316 /* Storage for things with the same lifetime as this read-in compilation
317 unit, including partial DIEs. */
318 struct obstack comp_unit_obstack
;
320 /* When multiple dwarf2_cu structures are living in memory, this field
321 chains them all together, so that they can be released efficiently.
322 We will probably also want a generation counter so that most-recently-used
323 compilation units are cached... */
324 struct dwarf2_per_cu_data
*read_in_chain
;
326 /* Backchain to our per_cu entry if the tree has been built. */
327 struct dwarf2_per_cu_data
*per_cu
;
329 /* How many compilation units ago was this CU last referenced? */
332 /* A hash table of die offsets for following references. */
333 struct die_info
*die_ref_table
[REF_HASH_SIZE
];
335 /* Full DIEs if read in. */
336 struct die_info
*dies
;
338 /* A set of pointers to dwarf2_per_cu_data objects for compilation
339 units referenced by this one. Only set during full symbol processing;
340 partial symbol tables do not have dependencies. */
343 /* Mark used when releasing cached dies. */
344 unsigned int mark
: 1;
346 /* This flag will be set if this compilation unit might include
347 inter-compilation-unit references. */
348 unsigned int has_form_ref_addr
: 1;
350 /* This flag will be set if this compilation unit includes any
351 DW_TAG_namespace DIEs. If we know that there are explicit
352 DIEs for namespaces, we don't need to try to infer them
353 from mangled names. */
354 unsigned int has_namespace_info
: 1;
357 /* Persistent data held for a compilation unit, even when not
358 processing it. We put a pointer to this structure in the
359 read_symtab_private field of the psymtab. If we encounter
360 inter-compilation-unit references, we also maintain a sorted
361 list of all compilation units. */
363 struct dwarf2_per_cu_data
365 /* The start offset and length of this compilation unit. 2**31-1
366 bytes should suffice to store the length of any compilation unit
367 - if it doesn't, GDB will fall over anyway. */
368 unsigned long offset
;
369 unsigned long length
: 31;
371 /* Flag indicating this compilation unit will be read in before
372 any of the current compilation units are processed. */
373 unsigned long queued
: 1;
375 /* Set iff currently read in. */
376 struct dwarf2_cu
*cu
;
378 /* If full symbols for this CU have been read in, then this field
379 holds a map of DIE offsets to types. It isn't always possible
380 to reconstruct this information later, so we have to preserve
384 /* The partial symbol table associated with this compilation unit. */
385 struct partial_symtab
*psymtab
;
388 /* The line number information for a compilation unit (found in the
389 .debug_line section) begins with a "statement program header",
390 which contains the following information. */
393 unsigned int total_length
;
394 unsigned short version
;
395 unsigned int header_length
;
396 unsigned char minimum_instruction_length
;
397 unsigned char default_is_stmt
;
399 unsigned char line_range
;
400 unsigned char opcode_base
;
402 /* standard_opcode_lengths[i] is the number of operands for the
403 standard opcode whose value is i. This means that
404 standard_opcode_lengths[0] is unused, and the last meaningful
405 element is standard_opcode_lengths[opcode_base - 1]. */
406 unsigned char *standard_opcode_lengths
;
408 /* The include_directories table. NOTE! These strings are not
409 allocated with xmalloc; instead, they are pointers into
410 debug_line_buffer. If you try to free them, `free' will get
412 unsigned int num_include_dirs
, include_dirs_size
;
415 /* The file_names table. NOTE! These strings are not allocated
416 with xmalloc; instead, they are pointers into debug_line_buffer.
417 Don't try to free them directly. */
418 unsigned int num_file_names
, file_names_size
;
422 unsigned int dir_index
;
423 unsigned int mod_time
;
425 int included_p
; /* Non-zero if referenced by the Line Number Program. */
428 /* The start and end of the statement program following this
429 header. These point into dwarf2_per_objfile->line_buffer. */
430 char *statement_program_start
, *statement_program_end
;
433 /* When we construct a partial symbol table entry we only
434 need this much information. */
435 struct partial_die_info
437 /* Offset of this DIE. */
440 /* DWARF-2 tag for this DIE. */
441 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
443 /* Language code associated with this DIE. This is only used
444 for the compilation unit DIE. */
445 unsigned int language
: 8;
447 /* Assorted flags describing the data found in this DIE. */
448 unsigned int has_children
: 1;
449 unsigned int is_external
: 1;
450 unsigned int is_declaration
: 1;
451 unsigned int has_type
: 1;
452 unsigned int has_specification
: 1;
453 unsigned int has_stmt_list
: 1;
454 unsigned int has_pc_info
: 1;
456 /* Flag set if the SCOPE field of this structure has been
458 unsigned int scope_set
: 1;
460 /* The name of this DIE. Normally the value of DW_AT_name, but
461 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
466 /* The scope to prepend to our children. This is generally
467 allocated on the comp_unit_obstack, so will disappear
468 when this compilation unit leaves the cache. */
471 /* The location description associated with this DIE, if any. */
472 struct dwarf_block
*locdesc
;
474 /* If HAS_PC_INFO, the PC range associated with this DIE. */
478 /* Pointer into the info_buffer pointing at the target of
479 DW_AT_sibling, if any. */
482 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
483 DW_AT_specification (or DW_AT_abstract_origin or
485 unsigned int spec_offset
;
487 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
488 unsigned int line_offset
;
490 /* Pointers to this DIE's parent, first child, and next sibling,
492 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
495 /* This data structure holds the information of an abbrev. */
498 unsigned int number
; /* number identifying abbrev */
499 enum dwarf_tag tag
; /* dwarf tag */
500 unsigned short has_children
; /* boolean */
501 unsigned short num_attrs
; /* number of attributes */
502 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
503 struct abbrev_info
*next
; /* next in chain */
508 enum dwarf_attribute name
;
509 enum dwarf_form form
;
512 /* This data structure holds a complete die structure. */
515 enum dwarf_tag tag
; /* Tag indicating type of die */
516 unsigned int abbrev
; /* Abbrev number */
517 unsigned int offset
; /* Offset in .debug_info section */
518 unsigned int num_attrs
; /* Number of attributes */
519 struct attribute
*attrs
; /* An array of attributes */
520 struct die_info
*next_ref
; /* Next die in ref hash table */
522 /* The dies in a compilation unit form an n-ary tree. PARENT
523 points to this die's parent; CHILD points to the first child of
524 this node; and all the children of a given node are chained
525 together via their SIBLING fields, terminated by a die whose
527 struct die_info
*child
; /* Its first child, if any. */
528 struct die_info
*sibling
; /* Its next sibling, if any. */
529 struct die_info
*parent
; /* Its parent, if any. */
531 struct type
*type
; /* Cached type information */
534 /* Attributes have a name and a value */
537 enum dwarf_attribute name
;
538 enum dwarf_form form
;
542 struct dwarf_block
*blk
;
550 struct function_range
553 CORE_ADDR lowpc
, highpc
;
555 struct function_range
*next
;
558 /* Get at parts of an attribute structure */
560 #define DW_STRING(attr) ((attr)->u.str)
561 #define DW_UNSND(attr) ((attr)->u.unsnd)
562 #define DW_BLOCK(attr) ((attr)->u.blk)
563 #define DW_SND(attr) ((attr)->u.snd)
564 #define DW_ADDR(attr) ((attr)->u.addr)
566 /* Blocks are a bunch of untyped bytes. */
573 #ifndef ATTR_ALLOC_CHUNK
574 #define ATTR_ALLOC_CHUNK 4
577 /* Allocate fields for structs, unions and enums in this size. */
578 #ifndef DW_FIELD_ALLOC_CHUNK
579 #define DW_FIELD_ALLOC_CHUNK 4
582 /* A zeroed version of a partial die for initialization purposes. */
583 static struct partial_die_info zeroed_partial_die
;
585 /* FIXME: decode_locdesc sets these variables to describe the location
586 to the caller. These ought to be a structure or something. If
587 none of the flags are set, the object lives at the address returned
588 by decode_locdesc. */
590 static int isreg
; /* Object lives in register.
591 decode_locdesc's return value is
592 the register number. */
594 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
595 but this would require a corresponding change in unpack_field_as_long
597 static int bits_per_byte
= 8;
599 /* The routines that read and process dies for a C struct or C++ class
600 pass lists of data member fields and lists of member function fields
601 in an instance of a field_info structure, as defined below. */
604 /* List of data member and baseclasses fields. */
607 struct nextfield
*next
;
614 /* Number of fields. */
617 /* Number of baseclasses. */
620 /* Set if the accesibility of one of the fields is not public. */
621 int non_public_fields
;
623 /* Member function fields array, entries are allocated in the order they
624 are encountered in the object file. */
627 struct nextfnfield
*next
;
628 struct fn_field fnfield
;
632 /* Member function fieldlist array, contains name of possibly overloaded
633 member function, number of overloaded member functions and a pointer
634 to the head of the member function field chain. */
639 struct nextfnfield
*head
;
643 /* Number of entries in the fnfieldlists array. */
647 /* One item on the queue of compilation units to read in full symbols
649 struct dwarf2_queue_item
651 struct dwarf2_per_cu_data
*per_cu
;
652 struct dwarf2_queue_item
*next
;
655 /* The current queue. */
656 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
658 /* Loaded secondary compilation units are kept in memory until they
659 have not been referenced for the processing of this many
660 compilation units. Set this to zero to disable caching. Cache
661 sizes of up to at least twenty will improve startup time for
662 typical inter-CU-reference binaries, at an obvious memory cost. */
663 static int dwarf2_max_cache_age
= 5;
665 /* Various complaints about symbol reading that don't abort the process */
668 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
670 complaint (&symfile_complaints
,
671 "statement list doesn't fit in .debug_line section");
675 dwarf2_complex_location_expr_complaint (void)
677 complaint (&symfile_complaints
, "location expression too complex");
681 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
684 complaint (&symfile_complaints
,
685 "const value length mismatch for '%s', got %d, expected %d", arg1
,
690 dwarf2_macros_too_long_complaint (void)
692 complaint (&symfile_complaints
,
693 "macro info runs off end of `.debug_macinfo' section");
697 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
699 complaint (&symfile_complaints
,
700 "macro debug info contains a malformed macro definition:\n`%s'",
705 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
707 complaint (&symfile_complaints
,
708 "invalid attribute class or form for '%s' in '%s'", arg1
, arg2
);
711 /* local function prototypes */
713 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
716 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
719 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
722 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
723 struct partial_die_info
*,
724 struct partial_symtab
*);
726 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
728 static void scan_partial_symbols (struct partial_die_info
*,
729 CORE_ADDR
*, CORE_ADDR
*,
732 static void add_partial_symbol (struct partial_die_info
*,
735 static int pdi_needs_namespace (enum dwarf_tag tag
);
737 static void add_partial_namespace (struct partial_die_info
*pdi
,
738 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
739 struct dwarf2_cu
*cu
);
741 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
742 struct dwarf2_cu
*cu
);
744 static char *locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
747 struct dwarf2_cu
*cu
);
749 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
751 static void psymtab_to_symtab_1 (struct partial_symtab
*);
753 char *dwarf2_read_section (struct objfile
*, asection
*);
755 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
757 static void dwarf2_free_abbrev_table (void *);
759 static struct abbrev_info
*peek_die_abbrev (char *, int *, struct dwarf2_cu
*);
761 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
764 static struct partial_die_info
*load_partial_dies (bfd
*, char *, int,
767 static char *read_partial_die (struct partial_die_info
*,
768 struct abbrev_info
*abbrev
, unsigned int,
769 bfd
*, char *, struct dwarf2_cu
*);
771 static struct partial_die_info
*find_partial_die (unsigned long,
774 static void fixup_partial_die (struct partial_die_info
*,
777 static char *read_full_die (struct die_info
**, bfd
*, char *,
778 struct dwarf2_cu
*, int *);
780 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
781 bfd
*, char *, struct dwarf2_cu
*);
783 static char *read_attribute_value (struct attribute
*, unsigned,
784 bfd
*, char *, struct dwarf2_cu
*);
786 static unsigned int read_1_byte (bfd
*, char *);
788 static int read_1_signed_byte (bfd
*, char *);
790 static unsigned int read_2_bytes (bfd
*, char *);
792 static unsigned int read_4_bytes (bfd
*, char *);
794 static unsigned long read_8_bytes (bfd
*, char *);
796 static CORE_ADDR
read_address (bfd
*, char *ptr
, struct dwarf2_cu
*,
799 static LONGEST
read_initial_length (bfd
*, char *,
800 struct comp_unit_head
*, int *bytes_read
);
802 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
805 static char *read_n_bytes (bfd
*, char *, unsigned int);
807 static char *read_string (bfd
*, char *, unsigned int *);
809 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
812 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
814 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
816 static char *skip_leb128 (bfd
*, char *);
818 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
820 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
823 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
824 struct dwarf2_cu
*cu
);
826 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
828 static struct die_info
*die_specification (struct die_info
*die
,
831 static void free_line_header (struct line_header
*lh
);
833 static void add_file_name (struct line_header
*, char *, unsigned int,
834 unsigned int, unsigned int);
836 static struct line_header
*(dwarf_decode_line_header
837 (unsigned int offset
,
838 bfd
*abfd
, struct dwarf2_cu
*cu
));
840 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
841 struct dwarf2_cu
*, struct partial_symtab
*);
843 static void dwarf2_start_subfile (char *, char *);
845 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
848 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
851 static void dwarf2_const_value_data (struct attribute
*attr
,
855 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
857 static struct type
*die_containing_type (struct die_info
*,
860 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
862 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
864 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
866 static char *typename_concat (struct obstack
*, const char *prefix
, const char *suffix
,
869 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
871 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
873 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
875 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
877 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
879 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
881 static int dwarf2_get_pc_bounds (struct die_info
*,
882 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
884 static void get_scope_pc_bounds (struct die_info
*,
885 CORE_ADDR
*, CORE_ADDR
*,
888 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
891 static void dwarf2_attach_fields_to_type (struct field_info
*,
892 struct type
*, struct dwarf2_cu
*);
894 static void dwarf2_add_member_fn (struct field_info
*,
895 struct die_info
*, struct type
*,
898 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
899 struct type
*, struct dwarf2_cu
*);
901 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
903 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
905 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
907 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
909 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
911 static const char *namespace_name (struct die_info
*die
,
912 int *is_anonymous
, struct dwarf2_cu
*);
914 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
916 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
918 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
920 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
922 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
924 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
927 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
929 static void read_tag_ptr_to_member_type (struct die_info
*,
932 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
934 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
936 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
938 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
940 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
942 static struct die_info
*read_comp_unit (char *, bfd
*, struct dwarf2_cu
*);
944 static struct die_info
*read_die_and_children (char *info_ptr
, bfd
*abfd
,
947 struct die_info
*parent
);
949 static struct die_info
*read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
952 struct die_info
*parent
);
954 static void free_die_list (struct die_info
*);
956 static void process_die (struct die_info
*, struct dwarf2_cu
*);
958 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
960 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
962 static struct die_info
*dwarf2_extension (struct die_info
*die
,
965 static char *dwarf_tag_name (unsigned int);
967 static char *dwarf_attr_name (unsigned int);
969 static char *dwarf_form_name (unsigned int);
971 static char *dwarf_stack_op_name (unsigned int);
973 static char *dwarf_bool_name (unsigned int);
975 static char *dwarf_type_encoding_name (unsigned int);
978 static char *dwarf_cfi_name (unsigned int);
980 struct die_info
*copy_die (struct die_info
*);
983 static struct die_info
*sibling_die (struct die_info
*);
985 static void dump_die (struct die_info
*);
987 static void dump_die_list (struct die_info
*);
989 static void store_in_ref_table (unsigned int, struct die_info
*,
992 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
995 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
997 static struct die_info
*follow_die_ref (struct die_info
*,
1001 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
1002 struct dwarf2_cu
*);
1004 /* memory allocation interface */
1006 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1008 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1010 static struct die_info
*dwarf_alloc_die (void);
1012 static void initialize_cu_func_list (struct dwarf2_cu
*);
1014 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1015 struct dwarf2_cu
*);
1017 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1018 char *, bfd
*, struct dwarf2_cu
*);
1020 static int attr_form_is_block (struct attribute
*);
1023 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
1024 struct dwarf2_cu
*cu
);
1026 static char *skip_one_die (char *info_ptr
, struct abbrev_info
*abbrev
,
1027 struct dwarf2_cu
*cu
);
1029 static void free_stack_comp_unit (void *);
1031 static void *hashtab_obstack_allocate (void *data
, size_t size
, size_t count
);
1033 static void dummy_obstack_deallocate (void *object
, void *data
);
1035 static hashval_t
partial_die_hash (const void *item
);
1037 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1039 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1040 (unsigned long offset
, struct objfile
*objfile
);
1042 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1043 (unsigned long offset
, struct objfile
*objfile
);
1045 static void free_one_comp_unit (void *);
1047 static void free_cached_comp_units (void *);
1049 static void age_cached_comp_units (void);
1051 static void free_one_cached_comp_unit (void *);
1053 static void set_die_type (struct die_info
*, struct type
*,
1054 struct dwarf2_cu
*);
1056 static void reset_die_and_siblings_types (struct die_info
*,
1057 struct dwarf2_cu
*);
1059 static void create_all_comp_units (struct objfile
*);
1061 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*);
1063 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1065 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1066 struct dwarf2_per_cu_data
*);
1068 static void dwarf2_mark (struct dwarf2_cu
*);
1070 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1072 /* Try to locate the sections we need for DWARF 2 debugging
1073 information and return true if we have enough to do something. */
1076 dwarf2_has_info (struct objfile
*objfile
)
1078 struct dwarf2_per_objfile
*data
;
1080 /* Initialize per-objfile state. */
1081 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1082 memset (data
, 0, sizeof (*data
));
1083 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1084 dwarf2_per_objfile
= data
;
1086 dwarf_info_section
= 0;
1087 dwarf_abbrev_section
= 0;
1088 dwarf_line_section
= 0;
1089 dwarf_str_section
= 0;
1090 dwarf_macinfo_section
= 0;
1091 dwarf_frame_section
= 0;
1092 dwarf_eh_frame_section
= 0;
1093 dwarf_ranges_section
= 0;
1094 dwarf_loc_section
= 0;
1096 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1097 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1100 /* This function is mapped across the sections and remembers the
1101 offset and size of each of the debugging sections we are interested
1105 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
1107 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1109 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1110 dwarf_info_section
= sectp
;
1112 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1114 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1115 dwarf_abbrev_section
= sectp
;
1117 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1119 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1120 dwarf_line_section
= sectp
;
1122 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1124 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1125 dwarf_pubnames_section
= sectp
;
1127 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1129 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1130 dwarf_aranges_section
= sectp
;
1132 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1134 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1135 dwarf_loc_section
= sectp
;
1137 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1139 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1140 dwarf_macinfo_section
= sectp
;
1142 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1144 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1145 dwarf_str_section
= sectp
;
1147 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1149 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1150 dwarf_frame_section
= sectp
;
1152 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1154 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1155 if (aflag
& SEC_HAS_CONTENTS
)
1157 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1158 dwarf_eh_frame_section
= sectp
;
1161 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1163 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1164 dwarf_ranges_section
= sectp
;
1168 /* Build a partial symbol table. */
1171 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1173 /* We definitely need the .debug_info and .debug_abbrev sections */
1175 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1176 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1178 if (dwarf_line_section
)
1179 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1181 dwarf2_per_objfile
->line_buffer
= NULL
;
1183 if (dwarf_str_section
)
1184 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1186 dwarf2_per_objfile
->str_buffer
= NULL
;
1188 if (dwarf_macinfo_section
)
1189 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1190 dwarf_macinfo_section
);
1192 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1194 if (dwarf_ranges_section
)
1195 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1197 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1199 if (dwarf_loc_section
)
1200 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1202 dwarf2_per_objfile
->loc_buffer
= NULL
;
1205 || (objfile
->global_psymbols
.size
== 0
1206 && objfile
->static_psymbols
.size
== 0))
1208 init_psymbol_list (objfile
, 1024);
1212 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1214 /* Things are significantly easier if we have .debug_aranges and
1215 .debug_pubnames sections */
1217 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1221 /* only test this case for now */
1223 /* In this case we have to work a bit harder */
1224 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1229 /* Build the partial symbol table from the information in the
1230 .debug_pubnames and .debug_aranges sections. */
1233 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1235 bfd
*abfd
= objfile
->obfd
;
1236 char *aranges_buffer
, *pubnames_buffer
;
1237 char *aranges_ptr
, *pubnames_ptr
;
1238 unsigned int entry_length
, version
, info_offset
, info_size
;
1240 pubnames_buffer
= dwarf2_read_section (objfile
,
1241 dwarf_pubnames_section
);
1242 pubnames_ptr
= pubnames_buffer
;
1243 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1245 struct comp_unit_head cu_header
;
1248 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1250 pubnames_ptr
+= bytes_read
;
1251 version
= read_1_byte (abfd
, pubnames_ptr
);
1253 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1255 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1259 aranges_buffer
= dwarf2_read_section (objfile
,
1260 dwarf_aranges_section
);
1265 /* Read in the comp unit header information from the debug_info at
1269 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1270 char *info_ptr
, bfd
*abfd
)
1274 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1276 info_ptr
+= bytes_read
;
1277 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1279 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1281 info_ptr
+= bytes_read
;
1282 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1284 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1285 if (signed_addr
< 0)
1286 internal_error (__FILE__
, __LINE__
,
1287 "read_comp_unit_head: dwarf from non elf file");
1288 cu_header
->signed_addr_p
= signed_addr
;
1293 partial_read_comp_unit_head (struct comp_unit_head
*header
, char *info_ptr
,
1296 char *beg_of_comp_unit
= info_ptr
;
1298 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1300 if (header
->version
!= 2)
1301 error ("Dwarf Error: wrong version in compilation unit header "
1302 "(is %d, should be %d) [in module %s]", header
->version
,
1303 2, bfd_get_filename (abfd
));
1305 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1306 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1307 "(offset 0x%lx + 6) [in module %s]",
1308 (long) header
->abbrev_offset
,
1309 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1310 bfd_get_filename (abfd
));
1312 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1313 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1314 error ("Dwarf Error: bad length (0x%lx) in compilation unit header "
1315 "(offset 0x%lx + 0) [in module %s]",
1316 (long) header
->length
,
1317 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1318 bfd_get_filename (abfd
));
1323 /* Allocate a new partial symtab for file named NAME and mark this new
1324 partial symtab as being an include of PST. */
1327 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1328 struct objfile
*objfile
)
1330 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1332 subpst
->section_offsets
= pst
->section_offsets
;
1333 subpst
->textlow
= 0;
1334 subpst
->texthigh
= 0;
1336 subpst
->dependencies
= (struct partial_symtab
**)
1337 obstack_alloc (&objfile
->objfile_obstack
,
1338 sizeof (struct partial_symtab
*));
1339 subpst
->dependencies
[0] = pst
;
1340 subpst
->number_of_dependencies
= 1;
1342 subpst
->globals_offset
= 0;
1343 subpst
->n_global_syms
= 0;
1344 subpst
->statics_offset
= 0;
1345 subpst
->n_static_syms
= 0;
1346 subpst
->symtab
= NULL
;
1347 subpst
->read_symtab
= pst
->read_symtab
;
1350 /* No private part is necessary for include psymtabs. This property
1351 can be used to differentiate between such include psymtabs and
1352 the regular ones. */
1353 subpst
->read_symtab_private
= NULL
;
1356 /* Read the Line Number Program data and extract the list of files
1357 included by the source file represented by PST. Build an include
1358 partial symtab for each of these included files.
1360 This procedure assumes that there *is* a Line Number Program in
1361 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1362 before calling this procedure. */
1365 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1366 struct partial_die_info
*pdi
,
1367 struct partial_symtab
*pst
)
1369 struct objfile
*objfile
= cu
->objfile
;
1370 bfd
*abfd
= objfile
->obfd
;
1371 struct line_header
*lh
;
1373 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1375 return; /* No linetable, so no includes. */
1377 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1379 free_line_header (lh
);
1383 /* Build the partial symbol table by doing a quick pass through the
1384 .debug_info and .debug_abbrev sections. */
1387 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1389 /* Instead of reading this into a big buffer, we should probably use
1390 mmap() on architectures that support it. (FIXME) */
1391 bfd
*abfd
= objfile
->obfd
;
1393 char *beg_of_comp_unit
;
1394 struct partial_die_info comp_unit_die
;
1395 struct partial_symtab
*pst
;
1396 struct cleanup
*back_to
;
1397 CORE_ADDR lowpc
, highpc
, baseaddr
;
1399 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1401 /* Any cached compilation units will be linked by the per-objfile
1402 read_in_chain. Make sure to free them when we're done. */
1403 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1405 create_all_comp_units (objfile
);
1407 /* Since the objects we're extracting from .debug_info vary in
1408 length, only the individual functions to extract them (like
1409 read_comp_unit_head and load_partial_die) can really know whether
1410 the buffer is large enough to hold another complete object.
1412 At the moment, they don't actually check that. If .debug_info
1413 holds just one extra byte after the last compilation unit's dies,
1414 then read_comp_unit_head will happily read off the end of the
1415 buffer. read_partial_die is similarly casual. Those functions
1418 For this loop condition, simply checking whether there's any data
1419 left at all should be sufficient. */
1420 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1421 + dwarf2_per_objfile
->info_size
))
1423 struct cleanup
*back_to_inner
;
1424 struct dwarf2_cu cu
;
1425 struct abbrev_info
*abbrev
;
1426 unsigned int bytes_read
;
1427 struct dwarf2_per_cu_data
*this_cu
;
1429 beg_of_comp_unit
= info_ptr
;
1431 memset (&cu
, 0, sizeof (cu
));
1433 obstack_init (&cu
.comp_unit_obstack
);
1435 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1437 cu
.objfile
= objfile
;
1438 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1440 /* Complete the cu_header */
1441 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1442 cu
.header
.first_die_ptr
= info_ptr
;
1443 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1445 cu
.list_in_scope
= &file_symbols
;
1447 /* Read the abbrevs for this compilation unit into a table */
1448 dwarf2_read_abbrevs (abfd
, &cu
);
1449 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1451 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1453 /* Read the compilation unit die */
1454 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1455 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1456 abfd
, info_ptr
, &cu
);
1458 /* Set the language we're debugging */
1459 set_cu_language (comp_unit_die
.language
, &cu
);
1461 /* Allocate a new partial symbol table structure */
1462 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1463 comp_unit_die
.name
? comp_unit_die
.name
: "",
1464 comp_unit_die
.lowpc
,
1465 objfile
->global_psymbols
.next
,
1466 objfile
->static_psymbols
.next
);
1468 if (comp_unit_die
.dirname
)
1469 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1471 pst
->read_symtab_private
= (char *) this_cu
;
1473 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1475 /* Store the function that reads in the rest of the symbol table */
1476 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1478 /* If this compilation unit was already read in, free the
1479 cached copy in order to read it in again. This is
1480 necessary because we skipped some symbols when we first
1481 read in the compilation unit (see load_partial_dies).
1482 This problem could be avoided, but the benefit is
1484 if (this_cu
->cu
!= NULL
)
1485 free_one_cached_comp_unit (this_cu
->cu
);
1487 cu
.per_cu
= this_cu
;
1489 /* Note that this is a pointer to our stack frame, being
1490 added to a global data structure. It will be cleaned up
1491 in free_stack_comp_unit when we finish with this
1492 compilation unit. */
1495 this_cu
->psymtab
= pst
;
1497 /* Check if comp unit has_children.
1498 If so, read the rest of the partial symbols from this comp unit.
1499 If not, there's no more debug_info for this comp unit. */
1500 if (comp_unit_die
.has_children
)
1502 struct partial_die_info
*first_die
;
1504 lowpc
= ((CORE_ADDR
) -1);
1505 highpc
= ((CORE_ADDR
) 0);
1507 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1509 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1511 /* If we didn't find a lowpc, set it to highpc to avoid
1512 complaints from `maint check'. */
1513 if (lowpc
== ((CORE_ADDR
) -1))
1516 /* If the compilation unit didn't have an explicit address range,
1517 then use the information extracted from its child dies. */
1518 if (! comp_unit_die
.has_pc_info
)
1520 comp_unit_die
.lowpc
= lowpc
;
1521 comp_unit_die
.highpc
= highpc
;
1524 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1525 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1527 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1528 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1529 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1530 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1531 sort_pst_symbols (pst
);
1533 /* If there is already a psymtab or symtab for a file of this
1534 name, remove it. (If there is a symtab, more drastic things
1535 also happen.) This happens in VxWorks. */
1536 free_named_symtabs (pst
->filename
);
1538 if (comp_unit_die
.has_stmt_list
)
1540 /* Get the list of files included in the current compilation unit,
1541 and build a psymtab for each of them. */
1542 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1545 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1546 + cu
.header
.initial_length_size
;
1548 do_cleanups (back_to_inner
);
1550 do_cleanups (back_to
);
1553 /* Load the DIEs for a secondary CU into memory. */
1556 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1558 bfd
*abfd
= objfile
->obfd
;
1559 char *info_ptr
, *beg_of_comp_unit
;
1560 struct partial_die_info comp_unit_die
;
1561 struct dwarf2_cu
*cu
;
1562 struct abbrev_info
*abbrev
;
1563 unsigned int bytes_read
;
1564 struct cleanup
*back_to
;
1566 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1567 beg_of_comp_unit
= info_ptr
;
1569 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1570 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1572 obstack_init (&cu
->comp_unit_obstack
);
1574 cu
->objfile
= objfile
;
1575 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1577 /* Complete the cu_header. */
1578 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1579 cu
->header
.first_die_ptr
= info_ptr
;
1580 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1582 /* Read the abbrevs for this compilation unit into a table. */
1583 dwarf2_read_abbrevs (abfd
, cu
);
1584 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1586 /* Read the compilation unit die. */
1587 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1588 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1589 abfd
, info_ptr
, cu
);
1591 /* Set the language we're debugging. */
1592 set_cu_language (comp_unit_die
.language
, cu
);
1594 /* Link this compilation unit into the compilation unit tree. */
1596 cu
->per_cu
= this_cu
;
1598 /* Check if comp unit has_children.
1599 If so, read the rest of the partial symbols from this comp unit.
1600 If not, there's no more debug_info for this comp unit. */
1601 if (comp_unit_die
.has_children
)
1602 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1604 do_cleanups (back_to
);
1607 /* Create a list of all compilation units in OBJFILE. We do this only
1608 if an inter-comp-unit reference is found; presumably if there is one,
1609 there will be many, and one will occur early in the .debug_info section.
1610 So there's no point in building this list incrementally. */
1613 create_all_comp_units (struct objfile
*objfile
)
1617 struct dwarf2_per_cu_data
**all_comp_units
;
1618 char *info_ptr
= dwarf2_per_objfile
->info_buffer
;
1622 all_comp_units
= xmalloc (n_allocated
1623 * sizeof (struct dwarf2_per_cu_data
*));
1625 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1627 struct comp_unit_head cu_header
;
1628 char *beg_of_comp_unit
;
1629 struct dwarf2_per_cu_data
*this_cu
;
1630 unsigned long offset
;
1633 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1635 /* Read just enough information to find out where the next
1636 compilation unit is. */
1637 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1638 &cu_header
, &bytes_read
);
1640 /* Save the compilation unit for later lookup. */
1641 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1642 sizeof (struct dwarf2_per_cu_data
));
1643 memset (this_cu
, 0, sizeof (*this_cu
));
1644 this_cu
->offset
= offset
;
1645 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1647 if (n_comp_units
== n_allocated
)
1650 all_comp_units
= xrealloc (all_comp_units
,
1652 * sizeof (struct dwarf2_per_cu_data
*));
1654 all_comp_units
[n_comp_units
++] = this_cu
;
1656 info_ptr
= info_ptr
+ this_cu
->length
;
1659 dwarf2_per_objfile
->all_comp_units
1660 = obstack_alloc (&objfile
->objfile_obstack
,
1661 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1662 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1663 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1664 xfree (all_comp_units
);
1665 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1668 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1669 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1673 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1674 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1676 struct objfile
*objfile
= cu
->objfile
;
1677 bfd
*abfd
= objfile
->obfd
;
1678 struct partial_die_info
*pdi
;
1680 /* Now, march along the PDI's, descending into ones which have
1681 interesting children but skipping the children of the other ones,
1682 until we reach the end of the compilation unit. */
1688 fixup_partial_die (pdi
, cu
);
1690 /* Anonymous namespaces have no name but have interesting
1691 children, so we need to look at them. Ditto for anonymous
1694 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1695 || pdi
->tag
== DW_TAG_enumeration_type
)
1699 case DW_TAG_subprogram
:
1700 if (pdi
->has_pc_info
)
1702 if (pdi
->lowpc
< *lowpc
)
1704 *lowpc
= pdi
->lowpc
;
1706 if (pdi
->highpc
> *highpc
)
1708 *highpc
= pdi
->highpc
;
1710 if (!pdi
->is_declaration
)
1712 add_partial_symbol (pdi
, cu
);
1716 case DW_TAG_variable
:
1717 case DW_TAG_typedef
:
1718 case DW_TAG_union_type
:
1719 if (!pdi
->is_declaration
)
1721 add_partial_symbol (pdi
, cu
);
1724 case DW_TAG_class_type
:
1725 case DW_TAG_structure_type
:
1726 if (!pdi
->is_declaration
)
1728 add_partial_symbol (pdi
, cu
);
1731 case DW_TAG_enumeration_type
:
1732 if (!pdi
->is_declaration
)
1733 add_partial_enumeration (pdi
, cu
);
1735 case DW_TAG_base_type
:
1736 case DW_TAG_subrange_type
:
1737 /* File scope base type definitions are added to the partial
1739 add_partial_symbol (pdi
, cu
);
1741 case DW_TAG_namespace
:
1742 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1749 /* If the die has a sibling, skip to the sibling. */
1751 pdi
= pdi
->die_sibling
;
1755 /* Functions used to compute the fully scoped name of a partial DIE.
1757 Normally, this is simple. For C++, the parent DIE's fully scoped
1758 name is concatenated with "::" and the partial DIE's name. For
1759 Java, the same thing occurs except that "." is used instead of "::".
1760 Enumerators are an exception; they use the scope of their parent
1761 enumeration type, i.e. the name of the enumeration type is not
1762 prepended to the enumerator.
1764 There are two complexities. One is DW_AT_specification; in this
1765 case "parent" means the parent of the target of the specification,
1766 instead of the direct parent of the DIE. The other is compilers
1767 which do not emit DW_TAG_namespace; in this case we try to guess
1768 the fully qualified name of structure types from their members'
1769 linkage names. This must be done using the DIE's children rather
1770 than the children of any DW_AT_specification target. We only need
1771 to do this for structures at the top level, i.e. if the target of
1772 any DW_AT_specification (if any; otherwise the DIE itself) does not
1775 /* Compute the scope prefix associated with PDI's parent, in
1776 compilation unit CU. The result will be allocated on CU's
1777 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1778 field. NULL is returned if no prefix is necessary. */
1780 partial_die_parent_scope (struct partial_die_info
*pdi
,
1781 struct dwarf2_cu
*cu
)
1783 char *grandparent_scope
;
1784 struct partial_die_info
*parent
, *real_pdi
;
1786 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1787 then this means the parent of the specification DIE. */
1790 while (real_pdi
->has_specification
)
1791 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1793 parent
= real_pdi
->die_parent
;
1797 if (parent
->scope_set
)
1798 return parent
->scope
;
1800 fixup_partial_die (parent
, cu
);
1802 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1804 if (parent
->tag
== DW_TAG_namespace
1805 || parent
->tag
== DW_TAG_structure_type
1806 || parent
->tag
== DW_TAG_class_type
1807 || parent
->tag
== DW_TAG_union_type
)
1809 if (grandparent_scope
== NULL
)
1810 parent
->scope
= parent
->name
;
1812 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1815 else if (parent
->tag
== DW_TAG_enumeration_type
)
1816 /* Enumerators should not get the name of the enumeration as a prefix. */
1817 parent
->scope
= grandparent_scope
;
1820 /* FIXME drow/2004-04-01: What should we be doing with
1821 function-local names? For partial symbols, we should probably be
1823 complaint (&symfile_complaints
,
1824 "unhandled containing DIE tag %d for DIE at %d",
1825 parent
->tag
, pdi
->offset
);
1826 parent
->scope
= grandparent_scope
;
1829 parent
->scope_set
= 1;
1830 return parent
->scope
;
1833 /* Return the fully scoped name associated with PDI, from compilation unit
1834 CU. The result will be allocated with malloc. */
1836 partial_die_full_name (struct partial_die_info
*pdi
,
1837 struct dwarf2_cu
*cu
)
1841 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1842 if (parent_scope
== NULL
)
1845 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1849 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1851 struct objfile
*objfile
= cu
->objfile
;
1854 const char *my_prefix
;
1855 const struct partial_symbol
*psym
= NULL
;
1857 int built_actual_name
= 0;
1859 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1863 if (pdi_needs_namespace (pdi
->tag
))
1865 actual_name
= partial_die_full_name (pdi
, cu
);
1867 built_actual_name
= 1;
1870 if (actual_name
== NULL
)
1871 actual_name
= pdi
->name
;
1875 case DW_TAG_subprogram
:
1876 if (pdi
->is_external
)
1878 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1879 mst_text, objfile); */
1880 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1881 VAR_DOMAIN
, LOC_BLOCK
,
1882 &objfile
->global_psymbols
,
1883 0, pdi
->lowpc
+ baseaddr
,
1884 cu
->language
, objfile
);
1888 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1889 mst_file_text, objfile); */
1890 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1891 VAR_DOMAIN
, LOC_BLOCK
,
1892 &objfile
->static_psymbols
,
1893 0, pdi
->lowpc
+ baseaddr
,
1894 cu
->language
, objfile
);
1897 case DW_TAG_variable
:
1898 if (pdi
->is_external
)
1901 Don't enter into the minimal symbol tables as there is
1902 a minimal symbol table entry from the ELF symbols already.
1903 Enter into partial symbol table if it has a location
1904 descriptor or a type.
1905 If the location descriptor is missing, new_symbol will create
1906 a LOC_UNRESOLVED symbol, the address of the variable will then
1907 be determined from the minimal symbol table whenever the variable
1909 The address for the partial symbol table entry is not
1910 used by GDB, but it comes in handy for debugging partial symbol
1914 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1915 if (pdi
->locdesc
|| pdi
->has_type
)
1916 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1917 VAR_DOMAIN
, LOC_STATIC
,
1918 &objfile
->global_psymbols
,
1920 cu
->language
, objfile
);
1924 /* Static Variable. Skip symbols without location descriptors. */
1925 if (pdi
->locdesc
== NULL
)
1927 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1928 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1929 mst_file_data, objfile); */
1930 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1931 VAR_DOMAIN
, LOC_STATIC
,
1932 &objfile
->static_psymbols
,
1934 cu
->language
, objfile
);
1937 case DW_TAG_typedef
:
1938 case DW_TAG_base_type
:
1939 case DW_TAG_subrange_type
:
1940 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1941 VAR_DOMAIN
, LOC_TYPEDEF
,
1942 &objfile
->static_psymbols
,
1943 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1945 case DW_TAG_namespace
:
1946 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1947 VAR_DOMAIN
, LOC_TYPEDEF
,
1948 &objfile
->global_psymbols
,
1949 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1951 case DW_TAG_class_type
:
1952 case DW_TAG_structure_type
:
1953 case DW_TAG_union_type
:
1954 case DW_TAG_enumeration_type
:
1955 /* Skip aggregate types without children, these are external
1957 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1958 static vs. global. */
1959 if (pdi
->has_children
== 0)
1961 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1962 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1963 (cu
->language
== language_cplus
1964 || cu
->language
== language_java
)
1965 ? &objfile
->global_psymbols
1966 : &objfile
->static_psymbols
,
1967 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1969 if (cu
->language
== language_cplus
1970 || cu
->language
== language_java
)
1972 /* For C++ and Java, these implicitly act as typedefs as well. */
1973 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1974 VAR_DOMAIN
, LOC_TYPEDEF
,
1975 &objfile
->global_psymbols
,
1976 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1979 case DW_TAG_enumerator
:
1980 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1981 VAR_DOMAIN
, LOC_CONST
,
1982 (cu
->language
== language_cplus
1983 || cu
->language
== language_java
)
1984 ? &objfile
->global_psymbols
1985 : &objfile
->static_psymbols
,
1986 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1992 /* Check to see if we should scan the name for possible namespace
1993 info. Only do this if this is C++, if we don't have namespace
1994 debugging info in the file, if the psym is of an appropriate type
1995 (otherwise we'll have psym == NULL), and if we actually had a
1996 mangled name to begin with. */
1998 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
1999 cases which do not set PSYM above? */
2001 if (cu
->language
== language_cplus
2002 && cu
->has_namespace_info
== 0
2004 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2005 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2008 if (built_actual_name
)
2009 xfree (actual_name
);
2012 /* Determine whether a die of type TAG living in a C++ class or
2013 namespace needs to have the name of the scope prepended to the
2014 name listed in the die. */
2017 pdi_needs_namespace (enum dwarf_tag tag
)
2021 case DW_TAG_namespace
:
2022 case DW_TAG_typedef
:
2023 case DW_TAG_class_type
:
2024 case DW_TAG_structure_type
:
2025 case DW_TAG_union_type
:
2026 case DW_TAG_enumeration_type
:
2027 case DW_TAG_enumerator
:
2034 /* Read a partial die corresponding to a namespace; also, add a symbol
2035 corresponding to that namespace to the symbol table. NAMESPACE is
2036 the name of the enclosing namespace. */
2039 add_partial_namespace (struct partial_die_info
*pdi
,
2040 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2041 struct dwarf2_cu
*cu
)
2043 struct objfile
*objfile
= cu
->objfile
;
2045 /* Add a symbol for the namespace. */
2047 add_partial_symbol (pdi
, cu
);
2049 /* Now scan partial symbols in that namespace. */
2051 if (pdi
->has_children
)
2052 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2055 /* See if we can figure out if the class lives in a namespace. We do
2056 this by looking for a member function; its demangled name will
2057 contain namespace info, if there is any. */
2060 guess_structure_name (struct partial_die_info
*struct_pdi
,
2061 struct dwarf2_cu
*cu
)
2063 if ((cu
->language
== language_cplus
2064 || cu
->language
== language_java
)
2065 && cu
->has_namespace_info
== 0
2066 && struct_pdi
->has_children
)
2068 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2069 what template types look like, because the demangler
2070 frequently doesn't give the same name as the debug info. We
2071 could fix this by only using the demangled name to get the
2072 prefix (but see comment in read_structure_type). */
2074 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2075 struct partial_die_info
*real_pdi
;
2077 /* If this DIE (this DIE's specification, if any) has a parent, then
2078 we should not do this. We'll prepend the parent's fully qualified
2079 name when we create the partial symbol. */
2081 real_pdi
= struct_pdi
;
2082 while (real_pdi
->has_specification
)
2083 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2085 if (real_pdi
->die_parent
!= NULL
)
2088 while (child_pdi
!= NULL
)
2090 if (child_pdi
->tag
== DW_TAG_subprogram
)
2092 char *actual_class_name
2093 = language_class_name_from_physname (cu
->language_defn
,
2095 if (actual_class_name
!= NULL
)
2098 = obsavestring (actual_class_name
,
2099 strlen (actual_class_name
),
2100 &cu
->comp_unit_obstack
);
2101 xfree (actual_class_name
);
2106 child_pdi
= child_pdi
->die_sibling
;
2111 /* Read a partial die corresponding to an enumeration type. */
2114 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2115 struct dwarf2_cu
*cu
)
2117 struct objfile
*objfile
= cu
->objfile
;
2118 bfd
*abfd
= objfile
->obfd
;
2119 struct partial_die_info
*pdi
;
2121 if (enum_pdi
->name
!= NULL
)
2122 add_partial_symbol (enum_pdi
, cu
);
2124 pdi
= enum_pdi
->die_child
;
2127 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2128 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
2130 add_partial_symbol (pdi
, cu
);
2131 pdi
= pdi
->die_sibling
;
2135 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2136 Return the corresponding abbrev, or NULL if the number is zero (indicating
2137 an empty DIE). In either case *BYTES_READ will be set to the length of
2138 the initial number. */
2140 static struct abbrev_info
*
2141 peek_die_abbrev (char *info_ptr
, int *bytes_read
, struct dwarf2_cu
*cu
)
2143 bfd
*abfd
= cu
->objfile
->obfd
;
2144 unsigned int abbrev_number
;
2145 struct abbrev_info
*abbrev
;
2147 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2149 if (abbrev_number
== 0)
2152 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2155 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number
,
2156 bfd_get_filename (abfd
));
2162 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2163 pointer to the end of a series of DIEs, terminated by an empty
2164 DIE. Any children of the skipped DIEs will also be skipped. */
2167 skip_children (char *info_ptr
, struct dwarf2_cu
*cu
)
2169 struct abbrev_info
*abbrev
;
2170 unsigned int bytes_read
;
2174 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2176 return info_ptr
+ bytes_read
;
2178 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2182 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2183 should point just after the initial uleb128 of a DIE, and the
2184 abbrev corresponding to that skipped uleb128 should be passed in
2185 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2189 skip_one_die (char *info_ptr
, struct abbrev_info
*abbrev
,
2190 struct dwarf2_cu
*cu
)
2192 unsigned int bytes_read
;
2193 struct attribute attr
;
2194 bfd
*abfd
= cu
->objfile
->obfd
;
2195 unsigned int form
, i
;
2197 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2199 /* The only abbrev we care about is DW_AT_sibling. */
2200 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2202 read_attribute (&attr
, &abbrev
->attrs
[i
],
2203 abfd
, info_ptr
, cu
);
2204 if (attr
.form
== DW_FORM_ref_addr
)
2205 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
2207 return dwarf2_per_objfile
->info_buffer
2208 + dwarf2_get_ref_die_offset (&attr
, cu
);
2211 /* If it isn't DW_AT_sibling, skip this attribute. */
2212 form
= abbrev
->attrs
[i
].form
;
2217 case DW_FORM_ref_addr
:
2218 info_ptr
+= cu
->header
.addr_size
;
2237 case DW_FORM_string
:
2238 read_string (abfd
, info_ptr
, &bytes_read
);
2239 info_ptr
+= bytes_read
;
2242 info_ptr
+= cu
->header
.offset_size
;
2245 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2246 info_ptr
+= bytes_read
;
2248 case DW_FORM_block1
:
2249 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2251 case DW_FORM_block2
:
2252 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2254 case DW_FORM_block4
:
2255 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2259 case DW_FORM_ref_udata
:
2260 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2262 case DW_FORM_indirect
:
2263 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2264 info_ptr
+= bytes_read
;
2265 /* We need to continue parsing from here, so just go back to
2267 goto skip_attribute
;
2270 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
2271 dwarf_form_name (form
),
2272 bfd_get_filename (abfd
));
2276 if (abbrev
->has_children
)
2277 return skip_children (info_ptr
, cu
);
2282 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2283 the next DIE after ORIG_PDI. */
2286 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
2287 bfd
*abfd
, struct dwarf2_cu
*cu
)
2289 /* Do we know the sibling already? */
2291 if (orig_pdi
->sibling
)
2292 return orig_pdi
->sibling
;
2294 /* Are there any children to deal with? */
2296 if (!orig_pdi
->has_children
)
2299 /* Skip the children the long way. */
2301 return skip_children (info_ptr
, cu
);
2304 /* Expand this partial symbol table into a full symbol table. */
2307 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2309 /* FIXME: This is barely more than a stub. */
2314 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
2320 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
2321 gdb_flush (gdb_stdout
);
2324 /* Restore our global data. */
2325 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2326 dwarf2_objfile_data_key
);
2328 psymtab_to_symtab_1 (pst
);
2330 /* Finish up the debug error message. */
2332 printf_filtered ("done.\n");
2337 /* Add PER_CU to the queue. */
2340 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2342 struct dwarf2_queue_item
*item
;
2345 item
= xmalloc (sizeof (*item
));
2346 item
->per_cu
= per_cu
;
2349 if (dwarf2_queue
== NULL
)
2350 dwarf2_queue
= item
;
2352 dwarf2_queue_tail
->next
= item
;
2354 dwarf2_queue_tail
= item
;
2357 /* Process the queue. */
2360 process_queue (struct objfile
*objfile
)
2362 struct dwarf2_queue_item
*item
, *next_item
;
2364 /* Initially, there is just one item on the queue. Load its DIEs,
2365 and the DIEs of any other compilation units it requires,
2368 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2370 /* Read in this compilation unit. This may add new items to
2371 the end of the queue. */
2372 load_full_comp_unit (item
->per_cu
);
2374 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2375 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2377 /* If this compilation unit has already had full symbols created,
2378 reset the TYPE fields in each DIE. */
2379 if (item
->per_cu
->psymtab
->readin
)
2380 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2384 /* Now everything left on the queue needs to be read in. Process
2385 them, one at a time, removing from the queue as we finish. */
2386 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2388 if (!item
->per_cu
->psymtab
->readin
)
2389 process_full_comp_unit (item
->per_cu
);
2391 item
->per_cu
->queued
= 0;
2392 next_item
= item
->next
;
2396 dwarf2_queue_tail
= NULL
;
2399 /* Free all allocated queue entries. This function only releases anything if
2400 an error was thrown; if the queue was processed then it would have been
2401 freed as we went along. */
2404 dwarf2_release_queue (void *dummy
)
2406 struct dwarf2_queue_item
*item
, *last
;
2408 item
= dwarf2_queue
;
2411 /* Anything still marked queued is likely to be in an
2412 inconsistent state, so discard it. */
2413 if (item
->per_cu
->queued
)
2415 if (item
->per_cu
->cu
!= NULL
)
2416 free_one_cached_comp_unit (item
->per_cu
->cu
);
2417 item
->per_cu
->queued
= 0;
2425 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2428 /* Read in full symbols for PST, and anything it depends on. */
2431 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2433 struct dwarf2_per_cu_data
*per_cu
;
2434 struct cleanup
*back_to
;
2437 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2438 if (!pst
->dependencies
[i
]->readin
)
2440 /* Inform about additional files that need to be read in. */
2443 fputs_filtered (" ", gdb_stdout
);
2445 fputs_filtered ("and ", gdb_stdout
);
2447 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2448 wrap_here (""); /* Flush output */
2449 gdb_flush (gdb_stdout
);
2451 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2454 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2458 /* It's an include file, no symbols to read for it.
2459 Everything is in the parent symtab. */
2464 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2466 queue_comp_unit (per_cu
);
2468 process_queue (pst
->objfile
);
2470 /* Age the cache, releasing compilation units that have not
2471 been used recently. */
2472 age_cached_comp_units ();
2474 do_cleanups (back_to
);
2477 /* Load the DIEs associated with PST and PER_CU into memory. */
2479 static struct dwarf2_cu
*
2480 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2482 struct partial_symtab
*pst
= per_cu
->psymtab
;
2483 bfd
*abfd
= pst
->objfile
->obfd
;
2484 struct dwarf2_cu
*cu
;
2485 unsigned long offset
;
2487 struct cleanup
*back_to
, *free_cu_cleanup
;
2488 struct attribute
*attr
;
2491 /* Set local variables from the partial symbol table info. */
2492 offset
= per_cu
->offset
;
2494 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2496 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2497 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2499 /* If an error occurs while loading, release our storage. */
2500 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2502 cu
->objfile
= pst
->objfile
;
2504 /* read in the comp_unit header */
2505 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2507 /* Read the abbrevs for this compilation unit */
2508 dwarf2_read_abbrevs (abfd
, cu
);
2509 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2511 cu
->header
.offset
= offset
;
2513 cu
->per_cu
= per_cu
;
2516 /* We use this obstack for block values in dwarf_alloc_block. */
2517 obstack_init (&cu
->comp_unit_obstack
);
2519 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2521 /* We try not to read any attributes in this function, because not
2522 all objfiles needed for references have been loaded yet, and symbol
2523 table processing isn't initialized. But we have to set the CU language,
2524 or we won't be able to build types correctly. */
2525 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2527 set_cu_language (DW_UNSND (attr
), cu
);
2529 set_cu_language (language_minimal
, cu
);
2531 do_cleanups (back_to
);
2533 /* We've successfully allocated this compilation unit. Let our caller
2534 clean it up when finished with it. */
2535 discard_cleanups (free_cu_cleanup
);
2540 /* Generate full symbol information for PST and CU, whose DIEs have
2541 already been loaded into memory. */
2544 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2546 struct partial_symtab
*pst
= per_cu
->psymtab
;
2547 struct dwarf2_cu
*cu
= per_cu
->cu
;
2548 struct objfile
*objfile
= pst
->objfile
;
2549 bfd
*abfd
= objfile
->obfd
;
2550 CORE_ADDR lowpc
, highpc
;
2551 struct symtab
*symtab
;
2552 struct cleanup
*back_to
;
2553 struct attribute
*attr
;
2556 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2558 /* We're in the global namespace. */
2559 processing_current_prefix
= "";
2562 back_to
= make_cleanup (really_free_pendings
, NULL
);
2564 cu
->list_in_scope
= &file_symbols
;
2566 /* Find the base address of the compilation unit for range lists and
2567 location lists. It will normally be specified by DW_AT_low_pc.
2568 In DWARF-3 draft 4, the base address could be overridden by
2569 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2570 compilation units with discontinuous ranges. */
2572 cu
->header
.base_known
= 0;
2573 cu
->header
.base_address
= 0;
2575 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2578 cu
->header
.base_address
= DW_ADDR (attr
);
2579 cu
->header
.base_known
= 1;
2583 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2586 cu
->header
.base_address
= DW_ADDR (attr
);
2587 cu
->header
.base_known
= 1;
2591 /* Do line number decoding in read_file_scope () */
2592 process_die (cu
->dies
, cu
);
2594 /* Some compilers don't define a DW_AT_high_pc attribute for the
2595 compilation unit. If the DW_AT_high_pc is missing, synthesize
2596 it, by scanning the DIE's below the compilation unit. */
2597 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2599 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2601 /* Set symtab language to language from DW_AT_language.
2602 If the compilation is from a C file generated by language preprocessors,
2603 do not set the language if it was already deduced by start_subfile. */
2605 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2607 symtab
->language
= cu
->language
;
2609 pst
->symtab
= symtab
;
2612 do_cleanups (back_to
);
2615 /* Process a die and its children. */
2618 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2622 case DW_TAG_padding
:
2624 case DW_TAG_compile_unit
:
2625 read_file_scope (die
, cu
);
2627 case DW_TAG_subprogram
:
2628 read_subroutine_type (die
, cu
);
2629 read_func_scope (die
, cu
);
2631 case DW_TAG_inlined_subroutine
:
2632 /* FIXME: These are ignored for now.
2633 They could be used to set breakpoints on all inlined instances
2634 of a function and make GDB `next' properly over inlined functions. */
2636 case DW_TAG_lexical_block
:
2637 case DW_TAG_try_block
:
2638 case DW_TAG_catch_block
:
2639 read_lexical_block_scope (die
, cu
);
2641 case DW_TAG_class_type
:
2642 case DW_TAG_structure_type
:
2643 case DW_TAG_union_type
:
2644 read_structure_type (die
, cu
);
2645 process_structure_scope (die
, cu
);
2647 case DW_TAG_enumeration_type
:
2648 read_enumeration_type (die
, cu
);
2649 process_enumeration_scope (die
, cu
);
2652 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2653 a symbol or process any children. Therefore it doesn't do anything
2654 that won't be done on-demand by read_type_die. */
2655 case DW_TAG_subroutine_type
:
2656 read_subroutine_type (die
, cu
);
2658 case DW_TAG_array_type
:
2659 read_array_type (die
, cu
);
2661 case DW_TAG_pointer_type
:
2662 read_tag_pointer_type (die
, cu
);
2664 case DW_TAG_ptr_to_member_type
:
2665 read_tag_ptr_to_member_type (die
, cu
);
2667 case DW_TAG_reference_type
:
2668 read_tag_reference_type (die
, cu
);
2670 case DW_TAG_string_type
:
2671 read_tag_string_type (die
, cu
);
2675 case DW_TAG_base_type
:
2676 read_base_type (die
, cu
);
2677 /* Add a typedef symbol for the type definition, if it has a
2679 new_symbol (die
, die
->type
, cu
);
2681 case DW_TAG_subrange_type
:
2682 read_subrange_type (die
, cu
);
2683 /* Add a typedef symbol for the type definition, if it has a
2685 new_symbol (die
, die
->type
, cu
);
2687 case DW_TAG_common_block
:
2688 read_common_block (die
, cu
);
2690 case DW_TAG_common_inclusion
:
2692 case DW_TAG_namespace
:
2693 processing_has_namespace_info
= 1;
2694 read_namespace (die
, cu
);
2696 case DW_TAG_imported_declaration
:
2697 case DW_TAG_imported_module
:
2698 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2699 information contained in these. DW_TAG_imported_declaration
2700 dies shouldn't have children; DW_TAG_imported_module dies
2701 shouldn't in the C++ case, but conceivably could in the
2702 Fortran case, so we'll have to replace this gdb_assert if
2703 Fortran compilers start generating that info. */
2704 processing_has_namespace_info
= 1;
2705 gdb_assert (die
->child
== NULL
);
2708 new_symbol (die
, NULL
, cu
);
2714 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2716 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2720 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2722 struct objfile
*objfile
= cu
->objfile
;
2723 struct comp_unit_head
*cu_header
= &cu
->header
;
2724 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2725 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2726 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2727 struct attribute
*attr
;
2728 char *name
= "<unknown>";
2729 char *comp_dir
= NULL
;
2730 struct die_info
*child_die
;
2731 bfd
*abfd
= objfile
->obfd
;
2732 struct line_header
*line_header
= 0;
2735 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2737 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2739 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2740 from finish_block. */
2741 if (lowpc
== ((CORE_ADDR
) -1))
2746 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2749 name
= DW_STRING (attr
);
2751 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2754 comp_dir
= DW_STRING (attr
);
2757 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2758 directory, get rid of it. */
2759 char *cp
= strchr (comp_dir
, ':');
2761 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2766 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2769 set_cu_language (DW_UNSND (attr
), cu
);
2772 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2774 cu
->producer
= DW_STRING (attr
);
2776 /* We assume that we're processing GCC output. */
2777 processing_gcc_compilation
= 2;
2779 /* FIXME:Do something here. */
2780 if (dip
->at_producer
!= NULL
)
2782 handle_producer (dip
->at_producer
);
2786 /* The compilation unit may be in a different language or objfile,
2787 zero out all remembered fundamental types. */
2788 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2790 start_symtab (name
, comp_dir
, lowpc
);
2791 record_debugformat ("DWARF 2");
2793 initialize_cu_func_list (cu
);
2795 /* Process all dies in compilation unit. */
2796 if (die
->child
!= NULL
)
2798 child_die
= die
->child
;
2799 while (child_die
&& child_die
->tag
)
2801 process_die (child_die
, cu
);
2802 child_die
= sibling_die (child_die
);
2806 /* Decode line number information if present. */
2807 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2810 unsigned int line_offset
= DW_UNSND (attr
);
2811 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2814 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2815 (void *) line_header
);
2816 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2820 /* Decode macro information, if present. Dwarf 2 macro information
2821 refers to information in the line number info statement program
2822 header, so we can only read it if we've read the header
2824 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2825 if (attr
&& line_header
)
2827 unsigned int macro_offset
= DW_UNSND (attr
);
2828 dwarf_decode_macros (line_header
, macro_offset
,
2829 comp_dir
, abfd
, cu
);
2831 do_cleanups (back_to
);
2835 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2836 struct dwarf2_cu
*cu
)
2838 struct function_range
*thisfn
;
2840 thisfn
= (struct function_range
*)
2841 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2842 thisfn
->name
= name
;
2843 thisfn
->lowpc
= lowpc
;
2844 thisfn
->highpc
= highpc
;
2845 thisfn
->seen_line
= 0;
2846 thisfn
->next
= NULL
;
2848 if (cu
->last_fn
== NULL
)
2849 cu
->first_fn
= thisfn
;
2851 cu
->last_fn
->next
= thisfn
;
2853 cu
->last_fn
= thisfn
;
2857 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2859 struct objfile
*objfile
= cu
->objfile
;
2860 struct context_stack
*new;
2863 struct die_info
*child_die
;
2864 struct attribute
*attr
;
2866 const char *previous_prefix
= processing_current_prefix
;
2867 struct cleanup
*back_to
= NULL
;
2870 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2872 name
= dwarf2_linkage_name (die
, cu
);
2874 /* Ignore functions with missing or empty names and functions with
2875 missing or invalid low and high pc attributes. */
2876 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2879 if (cu
->language
== language_cplus
2880 || cu
->language
== language_java
)
2882 struct die_info
*spec_die
= die_specification (die
, cu
);
2884 /* NOTE: carlton/2004-01-23: We have to be careful in the
2885 presence of DW_AT_specification. For example, with GCC 3.4,
2890 // Definition of N::foo.
2894 then we'll have a tree of DIEs like this:
2896 1: DW_TAG_compile_unit
2897 2: DW_TAG_namespace // N
2898 3: DW_TAG_subprogram // declaration of N::foo
2899 4: DW_TAG_subprogram // definition of N::foo
2900 DW_AT_specification // refers to die #3
2902 Thus, when processing die #4, we have to pretend that we're
2903 in the context of its DW_AT_specification, namely the contex
2906 if (spec_die
!= NULL
)
2908 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2909 processing_current_prefix
= specification_prefix
;
2910 back_to
= make_cleanup (xfree
, specification_prefix
);
2917 /* Record the function range for dwarf_decode_lines. */
2918 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2920 new = push_context (0, lowpc
);
2921 new->name
= new_symbol (die
, die
->type
, cu
);
2923 /* If there is a location expression for DW_AT_frame_base, record
2925 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2927 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2928 expression is being recorded directly in the function's symbol
2929 and not in a separate frame-base object. I guess this hack is
2930 to avoid adding some sort of frame-base adjunct/annex to the
2931 function's symbol :-(. The problem with doing this is that it
2932 results in a function symbol with a location expression that
2933 has nothing to do with the location of the function, ouch! The
2934 relationship should be: a function's symbol has-a frame base; a
2935 frame-base has-a location expression. */
2936 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2938 cu
->list_in_scope
= &local_symbols
;
2940 if (die
->child
!= NULL
)
2942 child_die
= die
->child
;
2943 while (child_die
&& child_die
->tag
)
2945 process_die (child_die
, cu
);
2946 child_die
= sibling_die (child_die
);
2950 new = pop_context ();
2951 /* Make a block for the local symbols within. */
2952 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2953 lowpc
, highpc
, objfile
);
2955 /* In C++, we can have functions nested inside functions (e.g., when
2956 a function declares a class that has methods). This means that
2957 when we finish processing a function scope, we may need to go
2958 back to building a containing block's symbol lists. */
2959 local_symbols
= new->locals
;
2960 param_symbols
= new->params
;
2962 /* If we've finished processing a top-level function, subsequent
2963 symbols go in the file symbol list. */
2964 if (outermost_context_p ())
2965 cu
->list_in_scope
= &file_symbols
;
2967 processing_current_prefix
= previous_prefix
;
2968 if (back_to
!= NULL
)
2969 do_cleanups (back_to
);
2972 /* Process all the DIES contained within a lexical block scope. Start
2973 a new scope, process the dies, and then close the scope. */
2976 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2978 struct objfile
*objfile
= cu
->objfile
;
2979 struct context_stack
*new;
2980 CORE_ADDR lowpc
, highpc
;
2981 struct die_info
*child_die
;
2984 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2986 /* Ignore blocks with missing or invalid low and high pc attributes. */
2987 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2988 as multiple lexical blocks? Handling children in a sane way would
2989 be nasty. Might be easier to properly extend generic blocks to
2991 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2996 push_context (0, lowpc
);
2997 if (die
->child
!= NULL
)
2999 child_die
= die
->child
;
3000 while (child_die
&& child_die
->tag
)
3002 process_die (child_die
, cu
);
3003 child_die
= sibling_die (child_die
);
3006 new = pop_context ();
3008 if (local_symbols
!= NULL
)
3010 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3013 local_symbols
= new->locals
;
3016 /* Get low and high pc attributes from a die. Return 1 if the attributes
3017 are present and valid, otherwise, return 0. Return -1 if the range is
3018 discontinuous, i.e. derived from DW_AT_ranges information. */
3020 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3021 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3023 struct objfile
*objfile
= cu
->objfile
;
3024 struct comp_unit_head
*cu_header
= &cu
->header
;
3025 struct attribute
*attr
;
3026 bfd
*obfd
= objfile
->obfd
;
3031 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3034 high
= DW_ADDR (attr
);
3035 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3037 low
= DW_ADDR (attr
);
3039 /* Found high w/o low attribute. */
3042 /* Found consecutive range of addresses. */
3047 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3050 unsigned int addr_size
= cu_header
->addr_size
;
3051 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3052 /* Value of the DW_AT_ranges attribute is the offset in the
3053 .debug_ranges section. */
3054 unsigned int offset
= DW_UNSND (attr
);
3055 /* Base address selection entry. */
3063 found_base
= cu_header
->base_known
;
3064 base
= cu_header
->base_address
;
3066 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3068 complaint (&symfile_complaints
,
3069 "Offset %d out of bounds for DW_AT_ranges attribute",
3073 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3075 /* Read in the largest possible address. */
3076 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3077 if ((marker
& mask
) == mask
)
3079 /* If we found the largest possible address, then
3080 read the base address. */
3081 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3082 buffer
+= 2 * addr_size
;
3083 offset
+= 2 * addr_size
;
3091 CORE_ADDR range_beginning
, range_end
;
3093 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3094 buffer
+= addr_size
;
3095 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3096 buffer
+= addr_size
;
3097 offset
+= 2 * addr_size
;
3099 /* An end of list marker is a pair of zero addresses. */
3100 if (range_beginning
== 0 && range_end
== 0)
3101 /* Found the end of list entry. */
3104 /* Each base address selection entry is a pair of 2 values.
3105 The first is the largest possible address, the second is
3106 the base address. Check for a base address here. */
3107 if ((range_beginning
& mask
) == mask
)
3109 /* If we found the largest possible address, then
3110 read the base address. */
3111 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3118 /* We have no valid base address for the ranges
3120 complaint (&symfile_complaints
,
3121 "Invalid .debug_ranges data (no base address)");
3125 range_beginning
+= base
;
3128 /* FIXME: This is recording everything as a low-high
3129 segment of consecutive addresses. We should have a
3130 data structure for discontiguous block ranges
3134 low
= range_beginning
;
3140 if (range_beginning
< low
)
3141 low
= range_beginning
;
3142 if (range_end
> high
)
3148 /* If the first entry is an end-of-list marker, the range
3149 describes an empty scope, i.e. no instructions. */
3159 /* When using the GNU linker, .gnu.linkonce. sections are used to
3160 eliminate duplicate copies of functions and vtables and such.
3161 The linker will arbitrarily choose one and discard the others.
3162 The AT_*_pc values for such functions refer to local labels in
3163 these sections. If the section from that file was discarded, the
3164 labels are not in the output, so the relocs get a value of 0.
3165 If this is a discarded function, mark the pc bounds as invalid,
3166 so that GDB will ignore it. */
3167 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
3175 /* Get the low and high pc's represented by the scope DIE, and store
3176 them in *LOWPC and *HIGHPC. If the correct values can't be
3177 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3180 get_scope_pc_bounds (struct die_info
*die
,
3181 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3182 struct dwarf2_cu
*cu
)
3184 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3185 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3186 CORE_ADDR current_low
, current_high
;
3188 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3190 best_low
= current_low
;
3191 best_high
= current_high
;
3195 struct die_info
*child
= die
->child
;
3197 while (child
&& child
->tag
)
3199 switch (child
->tag
) {
3200 case DW_TAG_subprogram
:
3201 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3203 best_low
= min (best_low
, current_low
);
3204 best_high
= max (best_high
, current_high
);
3207 case DW_TAG_namespace
:
3208 /* FIXME: carlton/2004-01-16: Should we do this for
3209 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3210 that current GCC's always emit the DIEs corresponding
3211 to definitions of methods of classes as children of a
3212 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3213 the DIEs giving the declarations, which could be
3214 anywhere). But I don't see any reason why the
3215 standards says that they have to be there. */
3216 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3218 if (current_low
!= ((CORE_ADDR
) -1))
3220 best_low
= min (best_low
, current_low
);
3221 best_high
= max (best_high
, current_high
);
3229 child
= sibling_die (child
);
3234 *highpc
= best_high
;
3237 /* Add an aggregate field to the field list. */
3240 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3241 struct dwarf2_cu
*cu
)
3243 struct objfile
*objfile
= cu
->objfile
;
3244 struct nextfield
*new_field
;
3245 struct attribute
*attr
;
3247 char *fieldname
= "";
3249 /* Allocate a new field list entry and link it in. */
3250 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3251 make_cleanup (xfree
, new_field
);
3252 memset (new_field
, 0, sizeof (struct nextfield
));
3253 new_field
->next
= fip
->fields
;
3254 fip
->fields
= new_field
;
3257 /* Handle accessibility and virtuality of field.
3258 The default accessibility for members is public, the default
3259 accessibility for inheritance is private. */
3260 if (die
->tag
!= DW_TAG_inheritance
)
3261 new_field
->accessibility
= DW_ACCESS_public
;
3263 new_field
->accessibility
= DW_ACCESS_private
;
3264 new_field
->virtuality
= DW_VIRTUALITY_none
;
3266 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3268 new_field
->accessibility
= DW_UNSND (attr
);
3269 if (new_field
->accessibility
!= DW_ACCESS_public
)
3270 fip
->non_public_fields
= 1;
3271 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3273 new_field
->virtuality
= DW_UNSND (attr
);
3275 fp
= &new_field
->field
;
3277 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3279 /* Data member other than a C++ static data member. */
3281 /* Get type of field. */
3282 fp
->type
= die_type (die
, cu
);
3284 FIELD_STATIC_KIND (*fp
) = 0;
3286 /* Get bit size of field (zero if none). */
3287 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3290 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3294 FIELD_BITSIZE (*fp
) = 0;
3297 /* Get bit offset of field. */
3298 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3301 FIELD_BITPOS (*fp
) =
3302 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3305 FIELD_BITPOS (*fp
) = 0;
3306 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3309 if (BITS_BIG_ENDIAN
)
3311 /* For big endian bits, the DW_AT_bit_offset gives the
3312 additional bit offset from the MSB of the containing
3313 anonymous object to the MSB of the field. We don't
3314 have to do anything special since we don't need to
3315 know the size of the anonymous object. */
3316 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3320 /* For little endian bits, compute the bit offset to the
3321 MSB of the anonymous object, subtract off the number of
3322 bits from the MSB of the field to the MSB of the
3323 object, and then subtract off the number of bits of
3324 the field itself. The result is the bit offset of
3325 the LSB of the field. */
3327 int bit_offset
= DW_UNSND (attr
);
3329 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3332 /* The size of the anonymous object containing
3333 the bit field is explicit, so use the
3334 indicated size (in bytes). */
3335 anonymous_size
= DW_UNSND (attr
);
3339 /* The size of the anonymous object containing
3340 the bit field must be inferred from the type
3341 attribute of the data member containing the
3343 anonymous_size
= TYPE_LENGTH (fp
->type
);
3345 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3346 - bit_offset
- FIELD_BITSIZE (*fp
);
3350 /* Get name of field. */
3351 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3352 if (attr
&& DW_STRING (attr
))
3353 fieldname
= DW_STRING (attr
);
3355 /* The name is already allocated along with this objfile, so we don't
3356 need to duplicate it for the type. */
3357 fp
->name
= fieldname
;
3359 /* Change accessibility for artificial fields (e.g. virtual table
3360 pointer or virtual base class pointer) to private. */
3361 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3363 new_field
->accessibility
= DW_ACCESS_private
;
3364 fip
->non_public_fields
= 1;
3367 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3369 /* C++ static member. */
3371 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3372 is a declaration, but all versions of G++ as of this writing
3373 (so through at least 3.2.1) incorrectly generate
3374 DW_TAG_variable tags. */
3378 /* Get name of field. */
3379 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3380 if (attr
&& DW_STRING (attr
))
3381 fieldname
= DW_STRING (attr
);
3385 /* Get physical name. */
3386 physname
= dwarf2_linkage_name (die
, cu
);
3388 /* The name is already allocated along with this objfile, so we don't
3389 need to duplicate it for the type. */
3390 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3391 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3392 FIELD_NAME (*fp
) = fieldname
;
3394 else if (die
->tag
== DW_TAG_inheritance
)
3396 /* C++ base class field. */
3397 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3399 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3401 FIELD_BITSIZE (*fp
) = 0;
3402 FIELD_STATIC_KIND (*fp
) = 0;
3403 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3404 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3405 fip
->nbaseclasses
++;
3409 /* Create the vector of fields, and attach it to the type. */
3412 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3413 struct dwarf2_cu
*cu
)
3415 int nfields
= fip
->nfields
;
3417 /* Record the field count, allocate space for the array of fields,
3418 and create blank accessibility bitfields if necessary. */
3419 TYPE_NFIELDS (type
) = nfields
;
3420 TYPE_FIELDS (type
) = (struct field
*)
3421 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3422 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3424 if (fip
->non_public_fields
)
3426 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3428 TYPE_FIELD_PRIVATE_BITS (type
) =
3429 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3430 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3432 TYPE_FIELD_PROTECTED_BITS (type
) =
3433 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3434 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3436 TYPE_FIELD_IGNORE_BITS (type
) =
3437 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3438 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3441 /* If the type has baseclasses, allocate and clear a bit vector for
3442 TYPE_FIELD_VIRTUAL_BITS. */
3443 if (fip
->nbaseclasses
)
3445 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3448 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3449 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3450 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3451 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3452 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3455 /* Copy the saved-up fields into the field vector. Start from the head
3456 of the list, adding to the tail of the field array, so that they end
3457 up in the same order in the array in which they were added to the list. */
3458 while (nfields
-- > 0)
3460 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3461 switch (fip
->fields
->accessibility
)
3463 case DW_ACCESS_private
:
3464 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3467 case DW_ACCESS_protected
:
3468 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3471 case DW_ACCESS_public
:
3475 /* Unknown accessibility. Complain and treat it as public. */
3477 complaint (&symfile_complaints
, "unsupported accessibility %d",
3478 fip
->fields
->accessibility
);
3482 if (nfields
< fip
->nbaseclasses
)
3484 switch (fip
->fields
->virtuality
)
3486 case DW_VIRTUALITY_virtual
:
3487 case DW_VIRTUALITY_pure_virtual
:
3488 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3492 fip
->fields
= fip
->fields
->next
;
3496 /* Add a member function to the proper fieldlist. */
3499 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3500 struct type
*type
, struct dwarf2_cu
*cu
)
3502 struct objfile
*objfile
= cu
->objfile
;
3503 struct attribute
*attr
;
3504 struct fnfieldlist
*flp
;
3506 struct fn_field
*fnp
;
3509 struct nextfnfield
*new_fnfield
;
3511 /* Get name of member function. */
3512 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3513 if (attr
&& DW_STRING (attr
))
3514 fieldname
= DW_STRING (attr
);
3518 /* Get the mangled name. */
3519 physname
= dwarf2_linkage_name (die
, cu
);
3521 /* Look up member function name in fieldlist. */
3522 for (i
= 0; i
< fip
->nfnfields
; i
++)
3524 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3528 /* Create new list element if necessary. */
3529 if (i
< fip
->nfnfields
)
3530 flp
= &fip
->fnfieldlists
[i
];
3533 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3535 fip
->fnfieldlists
= (struct fnfieldlist
*)
3536 xrealloc (fip
->fnfieldlists
,
3537 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3538 * sizeof (struct fnfieldlist
));
3539 if (fip
->nfnfields
== 0)
3540 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3542 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3543 flp
->name
= fieldname
;
3549 /* Create a new member function field and chain it to the field list
3551 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3552 make_cleanup (xfree
, new_fnfield
);
3553 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3554 new_fnfield
->next
= flp
->head
;
3555 flp
->head
= new_fnfield
;
3558 /* Fill in the member function field info. */
3559 fnp
= &new_fnfield
->fnfield
;
3560 /* The name is already allocated along with this objfile, so we don't
3561 need to duplicate it for the type. */
3562 fnp
->physname
= physname
? physname
: "";
3563 fnp
->type
= alloc_type (objfile
);
3564 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3566 int nparams
= TYPE_NFIELDS (die
->type
);
3568 /* TYPE is the domain of this method, and DIE->TYPE is the type
3569 of the method itself (TYPE_CODE_METHOD). */
3570 smash_to_method_type (fnp
->type
, type
,
3571 TYPE_TARGET_TYPE (die
->type
),
3572 TYPE_FIELDS (die
->type
),
3573 TYPE_NFIELDS (die
->type
),
3574 TYPE_VARARGS (die
->type
));
3576 /* Handle static member functions.
3577 Dwarf2 has no clean way to discern C++ static and non-static
3578 member functions. G++ helps GDB by marking the first
3579 parameter for non-static member functions (which is the
3580 this pointer) as artificial. We obtain this information
3581 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3582 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3583 fnp
->voffset
= VOFFSET_STATIC
;
3586 complaint (&symfile_complaints
, "member function type missing for '%s'",
3589 /* Get fcontext from DW_AT_containing_type if present. */
3590 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3591 fnp
->fcontext
= die_containing_type (die
, cu
);
3593 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3594 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3596 /* Get accessibility. */
3597 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3600 switch (DW_UNSND (attr
))
3602 case DW_ACCESS_private
:
3603 fnp
->is_private
= 1;
3605 case DW_ACCESS_protected
:
3606 fnp
->is_protected
= 1;
3611 /* Check for artificial methods. */
3612 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3613 if (attr
&& DW_UNSND (attr
) != 0)
3614 fnp
->is_artificial
= 1;
3616 /* Get index in virtual function table if it is a virtual member function. */
3617 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3620 /* Support the .debug_loc offsets */
3621 if (attr_form_is_block (attr
))
3623 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3625 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3627 dwarf2_complex_location_expr_complaint ();
3631 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3637 /* Create the vector of member function fields, and attach it to the type. */
3640 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3641 struct dwarf2_cu
*cu
)
3643 struct fnfieldlist
*flp
;
3644 int total_length
= 0;
3647 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3648 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3649 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3651 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3653 struct nextfnfield
*nfp
= flp
->head
;
3654 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3657 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3658 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3659 fn_flp
->fn_fields
= (struct fn_field
*)
3660 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3661 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3662 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3664 total_length
+= flp
->length
;
3667 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3668 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3672 /* Returns non-zero if NAME is the name of a vtable member in CU's
3673 language, zero otherwise. */
3675 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3677 static const char vptr
[] = "_vptr";
3678 static const char vtable
[] = "vtable";
3680 /* Look for the C++ and Java forms of the vtable. */
3681 if ((cu
->language
== language_java
3682 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3683 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3684 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3691 /* Called when we find the DIE that starts a structure or union scope
3692 (definition) to process all dies that define the members of the
3695 NOTE: we need to call struct_type regardless of whether or not the
3696 DIE has an at_name attribute, since it might be an anonymous
3697 structure or union. This gets the type entered into our set of
3700 However, if the structure is incomplete (an opaque struct/union)
3701 then suppress creating a symbol table entry for it since gdb only
3702 wants to find the one with the complete definition. Note that if
3703 it is complete, we just call new_symbol, which does it's own
3704 checking about whether the struct/union is anonymous or not (and
3705 suppresses creating a symbol table entry itself). */
3708 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3710 struct objfile
*objfile
= cu
->objfile
;
3712 struct attribute
*attr
;
3713 const char *previous_prefix
= processing_current_prefix
;
3714 struct cleanup
*back_to
= NULL
;
3719 type
= alloc_type (objfile
);
3721 INIT_CPLUS_SPECIFIC (type
);
3722 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3723 if (attr
&& DW_STRING (attr
))
3725 if (cu
->language
== language_cplus
3726 || cu
->language
== language_java
)
3728 char *new_prefix
= determine_class_name (die
, cu
);
3729 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3730 strlen (new_prefix
),
3731 &objfile
->objfile_obstack
);
3732 back_to
= make_cleanup (xfree
, new_prefix
);
3733 processing_current_prefix
= new_prefix
;
3737 /* The name is already allocated along with this objfile, so
3738 we don't need to duplicate it for the type. */
3739 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3743 if (die
->tag
== DW_TAG_structure_type
)
3745 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3747 else if (die
->tag
== DW_TAG_union_type
)
3749 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3753 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3755 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3758 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3761 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3765 TYPE_LENGTH (type
) = 0;
3768 if (die_is_declaration (die
, cu
))
3769 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3771 /* We need to add the type field to the die immediately so we don't
3772 infinitely recurse when dealing with pointers to the structure
3773 type within the structure itself. */
3774 set_die_type (die
, type
, cu
);
3776 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3778 struct field_info fi
;
3779 struct die_info
*child_die
;
3780 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3782 memset (&fi
, 0, sizeof (struct field_info
));
3784 child_die
= die
->child
;
3786 while (child_die
&& child_die
->tag
)
3788 if (child_die
->tag
== DW_TAG_member
3789 || child_die
->tag
== DW_TAG_variable
)
3791 /* NOTE: carlton/2002-11-05: A C++ static data member
3792 should be a DW_TAG_member that is a declaration, but
3793 all versions of G++ as of this writing (so through at
3794 least 3.2.1) incorrectly generate DW_TAG_variable
3795 tags for them instead. */
3796 dwarf2_add_field (&fi
, child_die
, cu
);
3798 else if (child_die
->tag
== DW_TAG_subprogram
)
3800 /* C++ member function. */
3801 read_type_die (child_die
, cu
);
3802 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3804 else if (child_die
->tag
== DW_TAG_inheritance
)
3806 /* C++ base class field. */
3807 dwarf2_add_field (&fi
, child_die
, cu
);
3809 child_die
= sibling_die (child_die
);
3812 /* Attach fields and member functions to the type. */
3814 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3817 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3819 /* Get the type which refers to the base class (possibly this
3820 class itself) which contains the vtable pointer for the current
3821 class from the DW_AT_containing_type attribute. */
3823 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3825 struct type
*t
= die_containing_type (die
, cu
);
3827 TYPE_VPTR_BASETYPE (type
) = t
;
3832 /* Our own class provides vtbl ptr. */
3833 for (i
= TYPE_NFIELDS (t
) - 1;
3834 i
>= TYPE_N_BASECLASSES (t
);
3837 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3839 if (is_vtable_name (fieldname
, cu
))
3841 TYPE_VPTR_FIELDNO (type
) = i
;
3846 /* Complain if virtual function table field not found. */
3847 if (i
< TYPE_N_BASECLASSES (t
))
3848 complaint (&symfile_complaints
,
3849 "virtual function table pointer not found when defining class '%s'",
3850 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3855 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3860 do_cleanups (back_to
);
3863 processing_current_prefix
= previous_prefix
;
3864 if (back_to
!= NULL
)
3865 do_cleanups (back_to
);
3869 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3871 struct objfile
*objfile
= cu
->objfile
;
3872 const char *previous_prefix
= processing_current_prefix
;
3873 struct die_info
*child_die
= die
->child
;
3875 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3876 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3878 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3879 snapshots) has been known to create a die giving a declaration
3880 for a class that has, as a child, a die giving a definition for a
3881 nested class. So we have to process our children even if the
3882 current die is a declaration. Normally, of course, a declaration
3883 won't have any children at all. */
3885 while (child_die
!= NULL
&& child_die
->tag
)
3887 if (child_die
->tag
== DW_TAG_member
3888 || child_die
->tag
== DW_TAG_variable
3889 || child_die
->tag
== DW_TAG_inheritance
)
3894 process_die (child_die
, cu
);
3896 child_die
= sibling_die (child_die
);
3899 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3900 new_symbol (die
, die
->type
, cu
);
3902 processing_current_prefix
= previous_prefix
;
3905 /* Given a DW_AT_enumeration_type die, set its type. We do not
3906 complete the type's fields yet, or create any symbols. */
3909 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3911 struct objfile
*objfile
= cu
->objfile
;
3913 struct attribute
*attr
;
3918 type
= alloc_type (objfile
);
3920 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3921 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3922 if (attr
&& DW_STRING (attr
))
3924 char *name
= DW_STRING (attr
);
3926 if (processing_has_namespace_info
)
3928 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
3929 processing_current_prefix
,
3934 /* The name is already allocated along with this objfile, so
3935 we don't need to duplicate it for the type. */
3936 TYPE_TAG_NAME (type
) = name
;
3940 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3943 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3947 TYPE_LENGTH (type
) = 0;
3950 set_die_type (die
, type
, cu
);
3953 /* Determine the name of the type represented by DIE, which should be
3954 a named C++ or Java compound type. Return the name in question; the caller
3955 is responsible for xfree()'ing it. */
3958 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3960 struct cleanup
*back_to
= NULL
;
3961 struct die_info
*spec_die
= die_specification (die
, cu
);
3962 char *new_prefix
= NULL
;
3964 /* If this is the definition of a class that is declared by another
3965 die, then processing_current_prefix may not be accurate; see
3966 read_func_scope for a similar example. */
3967 if (spec_die
!= NULL
)
3969 char *specification_prefix
= determine_prefix (spec_die
, cu
);
3970 processing_current_prefix
= specification_prefix
;
3971 back_to
= make_cleanup (xfree
, specification_prefix
);
3974 /* If we don't have namespace debug info, guess the name by trying
3975 to demangle the names of members, just like we did in
3976 guess_structure_name. */
3977 if (!processing_has_namespace_info
)
3979 struct die_info
*child
;
3981 for (child
= die
->child
;
3982 child
!= NULL
&& child
->tag
!= 0;
3983 child
= sibling_die (child
))
3985 if (child
->tag
== DW_TAG_subprogram
)
3988 = language_class_name_from_physname (cu
->language_defn
,
3992 if (new_prefix
!= NULL
)
3998 if (new_prefix
== NULL
)
4000 const char *name
= dwarf2_name (die
, cu
);
4001 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4002 name
? name
: "<<anonymous>>",
4006 if (back_to
!= NULL
)
4007 do_cleanups (back_to
);
4012 /* Given a pointer to a die which begins an enumeration, process all
4013 the dies that define the members of the enumeration, and create the
4014 symbol for the enumeration type.
4016 NOTE: We reverse the order of the element list. */
4019 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4021 struct objfile
*objfile
= cu
->objfile
;
4022 struct die_info
*child_die
;
4023 struct field
*fields
;
4024 struct attribute
*attr
;
4027 int unsigned_enum
= 1;
4031 if (die
->child
!= NULL
)
4033 child_die
= die
->child
;
4034 while (child_die
&& child_die
->tag
)
4036 if (child_die
->tag
!= DW_TAG_enumerator
)
4038 process_die (child_die
, cu
);
4042 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4045 sym
= new_symbol (child_die
, die
->type
, cu
);
4046 if (SYMBOL_VALUE (sym
) < 0)
4049 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4051 fields
= (struct field
*)
4053 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4054 * sizeof (struct field
));
4057 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4058 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4059 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4060 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4061 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4067 child_die
= sibling_die (child_die
);
4072 TYPE_NFIELDS (die
->type
) = num_fields
;
4073 TYPE_FIELDS (die
->type
) = (struct field
*)
4074 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4075 memcpy (TYPE_FIELDS (die
->type
), fields
,
4076 sizeof (struct field
) * num_fields
);
4080 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4083 new_symbol (die
, die
->type
, cu
);
4086 /* Extract all information from a DW_TAG_array_type DIE and put it in
4087 the DIE's type field. For now, this only handles one dimensional
4091 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4093 struct objfile
*objfile
= cu
->objfile
;
4094 struct die_info
*child_die
;
4095 struct type
*type
= NULL
;
4096 struct type
*element_type
, *range_type
, *index_type
;
4097 struct type
**range_types
= NULL
;
4098 struct attribute
*attr
;
4100 struct cleanup
*back_to
;
4102 /* Return if we've already decoded this type. */
4108 element_type
= die_type (die
, cu
);
4110 /* Irix 6.2 native cc creates array types without children for
4111 arrays with unspecified length. */
4112 if (die
->child
== NULL
)
4114 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4115 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4116 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4121 back_to
= make_cleanup (null_cleanup
, NULL
);
4122 child_die
= die
->child
;
4123 while (child_die
&& child_die
->tag
)
4125 if (child_die
->tag
== DW_TAG_subrange_type
)
4127 read_subrange_type (child_die
, cu
);
4129 if (child_die
->type
!= NULL
)
4131 /* The range type was succesfully read. Save it for
4132 the array type creation. */
4133 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4135 range_types
= (struct type
**)
4136 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4137 * sizeof (struct type
*));
4139 make_cleanup (free_current_contents
, &range_types
);
4141 range_types
[ndim
++] = child_die
->type
;
4144 child_die
= sibling_die (child_die
);
4147 /* Dwarf2 dimensions are output from left to right, create the
4148 necessary array types in backwards order. */
4150 type
= element_type
;
4152 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4156 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4161 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4164 /* Understand Dwarf2 support for vector types (like they occur on
4165 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4166 array type. This is not part of the Dwarf2/3 standard yet, but a
4167 custom vendor extension. The main difference between a regular
4168 array and the vector variant is that vectors are passed by value
4170 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4172 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4174 do_cleanups (back_to
);
4176 /* Install the type in the die. */
4177 set_die_type (die
, type
, cu
);
4180 static enum dwarf_array_dim_ordering
4181 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4183 struct attribute
*attr
;
4185 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4187 if (attr
) return DW_SND (attr
);
4190 GNU F77 is a special case, as at 08/2004 array type info is the
4191 opposite order to the dwarf2 specification, but data is still
4192 laid out as per normal fortran.
4194 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4198 if (cu
->language
== language_fortran
&&
4199 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4201 return DW_ORD_row_major
;
4204 switch (cu
->language_defn
->la_array_ordering
)
4206 case array_column_major
:
4207 return DW_ORD_col_major
;
4208 case array_row_major
:
4210 return DW_ORD_row_major
;
4215 /* First cut: install each common block member as a global variable. */
4218 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4220 struct die_info
*child_die
;
4221 struct attribute
*attr
;
4223 CORE_ADDR base
= (CORE_ADDR
) 0;
4225 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4228 /* Support the .debug_loc offsets */
4229 if (attr_form_is_block (attr
))
4231 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4233 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4235 dwarf2_complex_location_expr_complaint ();
4239 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4240 "common block member");
4243 if (die
->child
!= NULL
)
4245 child_die
= die
->child
;
4246 while (child_die
&& child_die
->tag
)
4248 sym
= new_symbol (child_die
, NULL
, cu
);
4249 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4252 SYMBOL_VALUE_ADDRESS (sym
) =
4253 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4254 add_symbol_to_list (sym
, &global_symbols
);
4256 child_die
= sibling_die (child_die
);
4261 /* Read a C++ namespace. */
4264 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4266 struct objfile
*objfile
= cu
->objfile
;
4267 const char *previous_prefix
= processing_current_prefix
;
4270 struct die_info
*current_die
;
4271 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4273 name
= namespace_name (die
, &is_anonymous
, cu
);
4275 /* Now build the name of the current namespace. */
4277 if (previous_prefix
[0] == '\0')
4279 processing_current_prefix
= name
;
4283 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4284 make_cleanup (xfree
, temp_name
);
4285 processing_current_prefix
= temp_name
;
4288 /* Add a symbol associated to this if we haven't seen the namespace
4289 before. Also, add a using directive if it's an anonymous
4292 if (dwarf2_extension (die
, cu
) == NULL
)
4296 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4297 this cast will hopefully become unnecessary. */
4298 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4299 (char *) processing_current_prefix
,
4301 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4303 new_symbol (die
, type
, cu
);
4304 set_die_type (die
, type
, cu
);
4307 cp_add_using_directive (processing_current_prefix
,
4308 strlen (previous_prefix
),
4309 strlen (processing_current_prefix
));
4312 if (die
->child
!= NULL
)
4314 struct die_info
*child_die
= die
->child
;
4316 while (child_die
&& child_die
->tag
)
4318 process_die (child_die
, cu
);
4319 child_die
= sibling_die (child_die
);
4323 processing_current_prefix
= previous_prefix
;
4324 do_cleanups (back_to
);
4327 /* Return the name of the namespace represented by DIE. Set
4328 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4332 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4334 struct die_info
*current_die
;
4335 const char *name
= NULL
;
4337 /* Loop through the extensions until we find a name. */
4339 for (current_die
= die
;
4340 current_die
!= NULL
;
4341 current_die
= dwarf2_extension (die
, cu
))
4343 name
= dwarf2_name (current_die
, cu
);
4348 /* Is it an anonymous namespace? */
4350 *is_anonymous
= (name
== NULL
);
4352 name
= "(anonymous namespace)";
4357 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4358 the user defined type vector. */
4361 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4363 struct comp_unit_head
*cu_header
= &cu
->header
;
4365 struct attribute
*attr_byte_size
;
4366 struct attribute
*attr_address_class
;
4367 int byte_size
, addr_class
;
4374 type
= lookup_pointer_type (die_type (die
, cu
));
4376 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4378 byte_size
= DW_UNSND (attr_byte_size
);
4380 byte_size
= cu_header
->addr_size
;
4382 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4383 if (attr_address_class
)
4384 addr_class
= DW_UNSND (attr_address_class
);
4386 addr_class
= DW_ADDR_none
;
4388 /* If the pointer size or address class is different than the
4389 default, create a type variant marked as such and set the
4390 length accordingly. */
4391 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4393 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4397 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4398 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4399 type
= make_type_with_address_space (type
, type_flags
);
4401 else if (TYPE_LENGTH (type
) != byte_size
)
4403 complaint (&symfile_complaints
, "invalid pointer size %d", byte_size
);
4406 /* Should we also complain about unhandled address classes? */
4410 TYPE_LENGTH (type
) = byte_size
;
4411 set_die_type (die
, type
, cu
);
4414 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4415 the user defined type vector. */
4418 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4420 struct objfile
*objfile
= cu
->objfile
;
4422 struct type
*to_type
;
4423 struct type
*domain
;
4430 type
= alloc_type (objfile
);
4431 to_type
= die_type (die
, cu
);
4432 domain
= die_containing_type (die
, cu
);
4433 smash_to_member_type (type
, domain
, to_type
);
4435 set_die_type (die
, type
, cu
);
4438 /* Extract all information from a DW_TAG_reference_type DIE and add to
4439 the user defined type vector. */
4442 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4444 struct comp_unit_head
*cu_header
= &cu
->header
;
4446 struct attribute
*attr
;
4453 type
= lookup_reference_type (die_type (die
, cu
));
4454 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4457 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4461 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4463 set_die_type (die
, type
, cu
);
4467 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4469 struct type
*base_type
;
4476 base_type
= die_type (die
, cu
);
4477 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4482 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4484 struct type
*base_type
;
4491 base_type
= die_type (die
, cu
);
4492 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4496 /* Extract all information from a DW_TAG_string_type DIE and add to
4497 the user defined type vector. It isn't really a user defined type,
4498 but it behaves like one, with other DIE's using an AT_user_def_type
4499 attribute to reference it. */
4502 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4504 struct objfile
*objfile
= cu
->objfile
;
4505 struct type
*type
, *range_type
, *index_type
, *char_type
;
4506 struct attribute
*attr
;
4507 unsigned int length
;
4514 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4517 length
= DW_UNSND (attr
);
4521 /* check for the DW_AT_byte_size attribute */
4522 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4525 length
= DW_UNSND (attr
);
4532 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4533 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4534 if (cu
->language
== language_fortran
)
4536 /* Need to create a unique string type for bounds
4538 type
= create_string_type (0, range_type
);
4542 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4543 type
= create_string_type (char_type
, range_type
);
4545 set_die_type (die
, type
, cu
);
4548 /* Handle DIES due to C code like:
4552 int (*funcp)(int a, long l);
4556 ('funcp' generates a DW_TAG_subroutine_type DIE)
4560 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4562 struct type
*type
; /* Type that this function returns */
4563 struct type
*ftype
; /* Function that returns above type */
4564 struct attribute
*attr
;
4566 /* Decode the type that this subroutine returns */
4571 type
= die_type (die
, cu
);
4572 ftype
= make_function_type (type
, (struct type
**) 0);
4574 /* All functions in C++ and Java have prototypes. */
4575 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4576 if ((attr
&& (DW_UNSND (attr
) != 0))
4577 || cu
->language
== language_cplus
4578 || cu
->language
== language_java
)
4579 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4581 if (die
->child
!= NULL
)
4583 struct die_info
*child_die
;
4587 /* Count the number of parameters.
4588 FIXME: GDB currently ignores vararg functions, but knows about
4589 vararg member functions. */
4590 child_die
= die
->child
;
4591 while (child_die
&& child_die
->tag
)
4593 if (child_die
->tag
== DW_TAG_formal_parameter
)
4595 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4596 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4597 child_die
= sibling_die (child_die
);
4600 /* Allocate storage for parameters and fill them in. */
4601 TYPE_NFIELDS (ftype
) = nparams
;
4602 TYPE_FIELDS (ftype
) = (struct field
*)
4603 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
4605 child_die
= die
->child
;
4606 while (child_die
&& child_die
->tag
)
4608 if (child_die
->tag
== DW_TAG_formal_parameter
)
4610 /* Dwarf2 has no clean way to discern C++ static and non-static
4611 member functions. G++ helps GDB by marking the first
4612 parameter for non-static member functions (which is the
4613 this pointer) as artificial. We pass this information
4614 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4615 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4617 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4619 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4620 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4623 child_die
= sibling_die (child_die
);
4627 set_die_type (die
, ftype
, cu
);
4631 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4633 struct objfile
*objfile
= cu
->objfile
;
4634 struct attribute
*attr
;
4639 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4640 if (attr
&& DW_STRING (attr
))
4642 name
= DW_STRING (attr
);
4644 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4645 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4647 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4651 /* Find a representation of a given base type and install
4652 it in the TYPE field of the die. */
4655 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4657 struct objfile
*objfile
= cu
->objfile
;
4659 struct attribute
*attr
;
4660 int encoding
= 0, size
= 0;
4662 /* If we've already decoded this die, this is a no-op. */
4668 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4671 encoding
= DW_UNSND (attr
);
4673 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4676 size
= DW_UNSND (attr
);
4678 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4679 if (attr
&& DW_STRING (attr
))
4681 enum type_code code
= TYPE_CODE_INT
;
4686 case DW_ATE_address
:
4687 /* Turn DW_ATE_address into a void * pointer. */
4688 code
= TYPE_CODE_PTR
;
4689 type_flags
|= TYPE_FLAG_UNSIGNED
;
4691 case DW_ATE_boolean
:
4692 code
= TYPE_CODE_BOOL
;
4693 type_flags
|= TYPE_FLAG_UNSIGNED
;
4695 case DW_ATE_complex_float
:
4696 code
= TYPE_CODE_COMPLEX
;
4699 code
= TYPE_CODE_FLT
;
4702 case DW_ATE_signed_char
:
4704 case DW_ATE_unsigned
:
4705 case DW_ATE_unsigned_char
:
4706 type_flags
|= TYPE_FLAG_UNSIGNED
;
4709 complaint (&symfile_complaints
, "unsupported DW_AT_encoding: '%s'",
4710 dwarf_type_encoding_name (encoding
));
4713 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4714 if (encoding
== DW_ATE_address
)
4715 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4717 else if (encoding
== DW_ATE_complex_float
)
4720 TYPE_TARGET_TYPE (type
)
4721 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4722 else if (size
== 16)
4723 TYPE_TARGET_TYPE (type
)
4724 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4726 TYPE_TARGET_TYPE (type
)
4727 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4732 type
= dwarf_base_type (encoding
, size
, cu
);
4734 set_die_type (die
, type
, cu
);
4737 /* Read the given DW_AT_subrange DIE. */
4740 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4742 struct type
*base_type
;
4743 struct type
*range_type
;
4744 struct attribute
*attr
;
4748 /* If we have already decoded this die, then nothing more to do. */
4752 base_type
= die_type (die
, cu
);
4753 if (base_type
== NULL
)
4755 complaint (&symfile_complaints
,
4756 "DW_AT_type missing from DW_TAG_subrange_type");
4760 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4761 base_type
= alloc_type (NULL
);
4763 if (cu
->language
== language_fortran
)
4765 /* FORTRAN implies a lower bound of 1, if not given. */
4769 /* FIXME: For variable sized arrays either of these could be
4770 a variable rather than a constant value. We'll allow it,
4771 but we don't know how to handle it. */
4772 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4774 low
= dwarf2_get_attr_constant_value (attr
, 0);
4776 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4779 if (attr
->form
== DW_FORM_block1
)
4781 /* GCC encodes arrays with unspecified or dynamic length
4782 with a DW_FORM_block1 attribute.
4783 FIXME: GDB does not yet know how to handle dynamic
4784 arrays properly, treat them as arrays with unspecified
4787 FIXME: jimb/2003-09-22: GDB does not really know
4788 how to handle arrays of unspecified length
4789 either; we just represent them as zero-length
4790 arrays. Choose an appropriate upper bound given
4791 the lower bound we've computed above. */
4795 high
= dwarf2_get_attr_constant_value (attr
, 1);
4798 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4800 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4801 if (attr
&& DW_STRING (attr
))
4802 TYPE_NAME (range_type
) = DW_STRING (attr
);
4804 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4806 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4808 set_die_type (die
, range_type
, cu
);
4812 /* Read a whole compilation unit into a linked list of dies. */
4814 static struct die_info
*
4815 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4817 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4820 /* Read a single die and all its descendents. Set the die's sibling
4821 field to NULL; set other fields in the die correctly, and set all
4822 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4823 location of the info_ptr after reading all of those dies. PARENT
4824 is the parent of the die in question. */
4826 static struct die_info
*
4827 read_die_and_children (char *info_ptr
, bfd
*abfd
,
4828 struct dwarf2_cu
*cu
,
4829 char **new_info_ptr
,
4830 struct die_info
*parent
)
4832 struct die_info
*die
;
4836 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4837 store_in_ref_table (die
->offset
, die
, cu
);
4841 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4847 *new_info_ptr
= cur_ptr
;
4850 die
->sibling
= NULL
;
4851 die
->parent
= parent
;
4855 /* Read a die, all of its descendents, and all of its siblings; set
4856 all of the fields of all of the dies correctly. Arguments are as
4857 in read_die_and_children. */
4859 static struct die_info
*
4860 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
4861 struct dwarf2_cu
*cu
,
4862 char **new_info_ptr
,
4863 struct die_info
*parent
)
4865 struct die_info
*first_die
, *last_sibling
;
4869 first_die
= last_sibling
= NULL
;
4873 struct die_info
*die
4874 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4882 last_sibling
->sibling
= die
;
4887 *new_info_ptr
= cur_ptr
;
4897 /* Free a linked list of dies. */
4900 free_die_list (struct die_info
*dies
)
4902 struct die_info
*die
, *next
;
4907 if (die
->child
!= NULL
)
4908 free_die_list (die
->child
);
4909 next
= die
->sibling
;
4916 /* Read the contents of the section at OFFSET and of size SIZE from the
4917 object file specified by OBJFILE into the objfile_obstack and return it. */
4920 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4922 bfd
*abfd
= objfile
->obfd
;
4924 bfd_size_type size
= bfd_get_section_size (sectp
);
4929 buf
= (char *) obstack_alloc (&objfile
->objfile_obstack
, size
);
4931 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
4935 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4936 || bfd_bread (buf
, size
, abfd
) != size
)
4937 error ("Dwarf Error: Can't read DWARF data from '%s'",
4938 bfd_get_filename (abfd
));
4943 /* In DWARF version 2, the description of the debugging information is
4944 stored in a separate .debug_abbrev section. Before we read any
4945 dies from a section we read in all abbreviations and install them
4946 in a hash table. This function also sets flags in CU describing
4947 the data found in the abbrev table. */
4950 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4952 struct comp_unit_head
*cu_header
= &cu
->header
;
4954 struct abbrev_info
*cur_abbrev
;
4955 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4956 unsigned int abbrev_form
, hash_number
;
4957 struct attr_abbrev
*cur_attrs
;
4958 unsigned int allocated_attrs
;
4960 /* Initialize dwarf2 abbrevs */
4961 obstack_init (&cu
->abbrev_obstack
);
4962 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
4964 * sizeof (struct abbrev_info
*)));
4965 memset (cu
->dwarf2_abbrevs
, 0,
4966 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
4968 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
4969 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4970 abbrev_ptr
+= bytes_read
;
4972 allocated_attrs
= ATTR_ALLOC_CHUNK
;
4973 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
4975 /* loop until we reach an abbrev number of 0 */
4976 while (abbrev_number
)
4978 cur_abbrev
= dwarf_alloc_abbrev (cu
);
4980 /* read in abbrev header */
4981 cur_abbrev
->number
= abbrev_number
;
4982 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4983 abbrev_ptr
+= bytes_read
;
4984 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
4987 if (cur_abbrev
->tag
== DW_TAG_namespace
)
4988 cu
->has_namespace_info
= 1;
4990 /* now read in declarations */
4991 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4992 abbrev_ptr
+= bytes_read
;
4993 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4994 abbrev_ptr
+= bytes_read
;
4997 if (cur_abbrev
->num_attrs
== allocated_attrs
)
4999 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5001 = xrealloc (cur_attrs
, (allocated_attrs
5002 * sizeof (struct attr_abbrev
)));
5005 /* Record whether this compilation unit might have
5006 inter-compilation-unit references. If we don't know what form
5007 this attribute will have, then it might potentially be a
5008 DW_FORM_ref_addr, so we conservatively expect inter-CU
5011 if (abbrev_form
== DW_FORM_ref_addr
5012 || abbrev_form
== DW_FORM_indirect
)
5013 cu
->has_form_ref_addr
= 1;
5015 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5016 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5017 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5018 abbrev_ptr
+= bytes_read
;
5019 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5020 abbrev_ptr
+= bytes_read
;
5023 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5024 (cur_abbrev
->num_attrs
5025 * sizeof (struct attr_abbrev
)));
5026 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5027 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5029 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5030 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5031 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5033 /* Get next abbreviation.
5034 Under Irix6 the abbreviations for a compilation unit are not
5035 always properly terminated with an abbrev number of 0.
5036 Exit loop if we encounter an abbreviation which we have
5037 already read (which means we are about to read the abbreviations
5038 for the next compile unit) or if the end of the abbreviation
5039 table is reached. */
5040 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5041 >= dwarf2_per_objfile
->abbrev_size
)
5043 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5044 abbrev_ptr
+= bytes_read
;
5045 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5052 /* Release the memory used by the abbrev table for a compilation unit. */
5055 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5057 struct dwarf2_cu
*cu
= ptr_to_cu
;
5059 obstack_free (&cu
->abbrev_obstack
, NULL
);
5060 cu
->dwarf2_abbrevs
= NULL
;
5063 /* Lookup an abbrev_info structure in the abbrev hash table. */
5065 static struct abbrev_info
*
5066 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5068 unsigned int hash_number
;
5069 struct abbrev_info
*abbrev
;
5071 hash_number
= number
% ABBREV_HASH_SIZE
;
5072 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5076 if (abbrev
->number
== number
)
5079 abbrev
= abbrev
->next
;
5084 /* Returns nonzero if TAG represents a type that we might generate a partial
5088 is_type_tag_for_partial (int tag
)
5093 /* Some types that would be reasonable to generate partial symbols for,
5094 that we don't at present. */
5095 case DW_TAG_array_type
:
5096 case DW_TAG_file_type
:
5097 case DW_TAG_ptr_to_member_type
:
5098 case DW_TAG_set_type
:
5099 case DW_TAG_string_type
:
5100 case DW_TAG_subroutine_type
:
5102 case DW_TAG_base_type
:
5103 case DW_TAG_class_type
:
5104 case DW_TAG_enumeration_type
:
5105 case DW_TAG_structure_type
:
5106 case DW_TAG_subrange_type
:
5107 case DW_TAG_typedef
:
5108 case DW_TAG_union_type
:
5115 /* Load all DIEs that are interesting for partial symbols into memory. */
5117 static struct partial_die_info
*
5118 load_partial_dies (bfd
*abfd
, char *info_ptr
, int building_psymtab
,
5119 struct dwarf2_cu
*cu
)
5121 struct partial_die_info
*part_die
;
5122 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5123 struct abbrev_info
*abbrev
;
5124 unsigned int bytes_read
;
5126 int nesting_level
= 1;
5132 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5136 &cu
->comp_unit_obstack
,
5137 hashtab_obstack_allocate
,
5138 dummy_obstack_deallocate
);
5140 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5141 sizeof (struct partial_die_info
));
5145 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5147 /* A NULL abbrev means the end of a series of children. */
5150 if (--nesting_level
== 0)
5152 /* PART_DIE was probably the last thing allocated on the
5153 comp_unit_obstack, so we could call obstack_free
5154 here. We don't do that because the waste is small,
5155 and will be cleaned up when we're done with this
5156 compilation unit. This way, we're also more robust
5157 against other users of the comp_unit_obstack. */
5160 info_ptr
+= bytes_read
;
5161 last_die
= parent_die
;
5162 parent_die
= parent_die
->die_parent
;
5166 /* Check whether this DIE is interesting enough to save. */
5167 if (!is_type_tag_for_partial (abbrev
->tag
)
5168 && abbrev
->tag
!= DW_TAG_enumerator
5169 && abbrev
->tag
!= DW_TAG_subprogram
5170 && abbrev
->tag
!= DW_TAG_variable
5171 && abbrev
->tag
!= DW_TAG_namespace
)
5173 /* Otherwise we skip to the next sibling, if any. */
5174 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5178 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5179 abfd
, info_ptr
, cu
);
5181 /* This two-pass algorithm for processing partial symbols has a
5182 high cost in cache pressure. Thus, handle some simple cases
5183 here which cover the majority of C partial symbols. DIEs
5184 which neither have specification tags in them, nor could have
5185 specification tags elsewhere pointing at them, can simply be
5186 processed and discarded.
5188 This segment is also optional; scan_partial_symbols and
5189 add_partial_symbol will handle these DIEs if we chain
5190 them in normally. When compilers which do not emit large
5191 quantities of duplicate debug information are more common,
5192 this code can probably be removed. */
5194 /* Any complete simple types at the top level (pretty much all
5195 of them, for a language without namespaces), can be processed
5197 if (parent_die
== NULL
5198 && part_die
->has_specification
== 0
5199 && part_die
->is_declaration
== 0
5200 && (part_die
->tag
== DW_TAG_typedef
5201 || part_die
->tag
== DW_TAG_base_type
5202 || part_die
->tag
== DW_TAG_subrange_type
))
5204 if (building_psymtab
&& part_die
->name
!= NULL
)
5205 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5206 VAR_DOMAIN
, LOC_TYPEDEF
,
5207 &cu
->objfile
->static_psymbols
,
5208 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5209 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5213 /* If we're at the second level, and we're an enumerator, and
5214 our parent has no specification (meaning possibly lives in a
5215 namespace elsewhere), then we can add the partial symbol now
5216 instead of queueing it. */
5217 if (part_die
->tag
== DW_TAG_enumerator
5218 && parent_die
!= NULL
5219 && parent_die
->die_parent
== NULL
5220 && parent_die
->tag
== DW_TAG_enumeration_type
5221 && parent_die
->has_specification
== 0)
5223 if (part_die
->name
== NULL
)
5224 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
5225 else if (building_psymtab
)
5226 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5227 VAR_DOMAIN
, LOC_CONST
,
5228 (cu
->language
== language_cplus
5229 || cu
->language
== language_java
)
5230 ? &cu
->objfile
->global_psymbols
5231 : &cu
->objfile
->static_psymbols
,
5232 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5234 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5238 /* We'll save this DIE so link it in. */
5239 part_die
->die_parent
= parent_die
;
5240 part_die
->die_sibling
= NULL
;
5241 part_die
->die_child
= NULL
;
5243 if (last_die
&& last_die
== parent_die
)
5244 last_die
->die_child
= part_die
;
5246 last_die
->die_sibling
= part_die
;
5248 last_die
= part_die
;
5250 if (first_die
== NULL
)
5251 first_die
= part_die
;
5253 /* Maybe add the DIE to the hash table. Not all DIEs that we
5254 find interesting need to be in the hash table, because we
5255 also have the parent/sibling/child chains; only those that we
5256 might refer to by offset later during partial symbol reading.
5258 For now this means things that might have be the target of a
5259 DW_AT_specification, DW_AT_abstract_origin, or
5260 DW_AT_extension. DW_AT_extension will refer only to
5261 namespaces; DW_AT_abstract_origin refers to functions (and
5262 many things under the function DIE, but we do not recurse
5263 into function DIEs during partial symbol reading) and
5264 possibly variables as well; DW_AT_specification refers to
5265 declarations. Declarations ought to have the DW_AT_declaration
5266 flag. It happens that GCC forgets to put it in sometimes, but
5267 only for functions, not for types.
5269 Adding more things than necessary to the hash table is harmless
5270 except for the performance cost. Adding too few will result in
5271 internal errors in find_partial_die. */
5273 if (abbrev
->tag
== DW_TAG_subprogram
5274 || abbrev
->tag
== DW_TAG_variable
5275 || abbrev
->tag
== DW_TAG_namespace
5276 || part_die
->is_declaration
)
5280 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5281 part_die
->offset
, INSERT
);
5285 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5286 sizeof (struct partial_die_info
));
5288 /* For some DIEs we want to follow their children (if any). For C
5289 we have no reason to follow the children of structures; for other
5290 languages we have to, both so that we can get at method physnames
5291 to infer fully qualified class names, and for DW_AT_specification. */
5292 if (last_die
->has_children
5293 && (last_die
->tag
== DW_TAG_namespace
5294 || last_die
->tag
== DW_TAG_enumeration_type
5295 || (cu
->language
!= language_c
5296 && (last_die
->tag
== DW_TAG_class_type
5297 || last_die
->tag
== DW_TAG_structure_type
5298 || last_die
->tag
== DW_TAG_union_type
))))
5301 parent_die
= last_die
;
5305 /* Otherwise we skip to the next sibling, if any. */
5306 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5308 /* Back to the top, do it again. */
5312 /* Read a minimal amount of information into the minimal die structure. */
5315 read_partial_die (struct partial_die_info
*part_die
,
5316 struct abbrev_info
*abbrev
,
5317 unsigned int abbrev_len
, bfd
*abfd
,
5318 char *info_ptr
, struct dwarf2_cu
*cu
)
5320 unsigned int bytes_read
, i
;
5321 struct attribute attr
;
5322 int has_low_pc_attr
= 0;
5323 int has_high_pc_attr
= 0;
5325 memset (part_die
, 0, sizeof (struct partial_die_info
));
5327 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5329 info_ptr
+= abbrev_len
;
5334 part_die
->tag
= abbrev
->tag
;
5335 part_die
->has_children
= abbrev
->has_children
;
5337 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5339 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5341 /* Store the data if it is of an attribute we want to keep in a
5342 partial symbol table. */
5347 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5348 if (part_die
->name
== NULL
)
5349 part_die
->name
= DW_STRING (&attr
);
5351 case DW_AT_comp_dir
:
5352 if (part_die
->dirname
== NULL
)
5353 part_die
->dirname
= DW_STRING (&attr
);
5355 case DW_AT_MIPS_linkage_name
:
5356 part_die
->name
= DW_STRING (&attr
);
5359 has_low_pc_attr
= 1;
5360 part_die
->lowpc
= DW_ADDR (&attr
);
5363 has_high_pc_attr
= 1;
5364 part_die
->highpc
= DW_ADDR (&attr
);
5366 case DW_AT_location
:
5367 /* Support the .debug_loc offsets */
5368 if (attr_form_is_block (&attr
))
5370 part_die
->locdesc
= DW_BLOCK (&attr
);
5372 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5374 dwarf2_complex_location_expr_complaint ();
5378 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5379 "partial symbol information");
5382 case DW_AT_language
:
5383 part_die
->language
= DW_UNSND (&attr
);
5385 case DW_AT_external
:
5386 part_die
->is_external
= DW_UNSND (&attr
);
5388 case DW_AT_declaration
:
5389 part_die
->is_declaration
= DW_UNSND (&attr
);
5392 part_die
->has_type
= 1;
5394 case DW_AT_abstract_origin
:
5395 case DW_AT_specification
:
5396 case DW_AT_extension
:
5397 part_die
->has_specification
= 1;
5398 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5401 /* Ignore absolute siblings, they might point outside of
5402 the current compile unit. */
5403 if (attr
.form
== DW_FORM_ref_addr
)
5404 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
5406 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5407 + dwarf2_get_ref_die_offset (&attr
, cu
);
5409 case DW_AT_stmt_list
:
5410 part_die
->has_stmt_list
= 1;
5411 part_die
->line_offset
= DW_UNSND (&attr
);
5418 /* When using the GNU linker, .gnu.linkonce. sections are used to
5419 eliminate duplicate copies of functions and vtables and such.
5420 The linker will arbitrarily choose one and discard the others.
5421 The AT_*_pc values for such functions refer to local labels in
5422 these sections. If the section from that file was discarded, the
5423 labels are not in the output, so the relocs get a value of 0.
5424 If this is a discarded function, mark the pc bounds as invalid,
5425 so that GDB will ignore it. */
5426 if (has_low_pc_attr
&& has_high_pc_attr
5427 && part_die
->lowpc
< part_die
->highpc
5428 && (part_die
->lowpc
!= 0
5429 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5430 part_die
->has_pc_info
= 1;
5434 /* Find a cached partial DIE at OFFSET in CU. */
5436 static struct partial_die_info
*
5437 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5439 struct partial_die_info
*lookup_die
= NULL
;
5440 struct partial_die_info part_die
;
5442 part_die
.offset
= offset
;
5443 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5445 if (lookup_die
== NULL
)
5446 internal_error (__FILE__
, __LINE__
,
5447 "could not find partial DIE in cache\n");
5452 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5454 static struct partial_die_info
*
5455 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5457 struct dwarf2_per_cu_data
*per_cu
;
5459 if (offset
>= cu
->header
.offset
5460 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5461 return find_partial_die_in_comp_unit (offset
, cu
);
5463 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5465 if (per_cu
->cu
== NULL
)
5467 load_comp_unit (per_cu
, cu
->objfile
);
5468 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5469 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5472 per_cu
->cu
->last_used
= 0;
5473 return find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5476 /* Adjust PART_DIE before generating a symbol for it. This function
5477 may set the is_external flag or change the DIE's name. */
5480 fixup_partial_die (struct partial_die_info
*part_die
,
5481 struct dwarf2_cu
*cu
)
5483 /* If we found a reference attribute and the DIE has no name, try
5484 to find a name in the referred to DIE. */
5486 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5488 struct partial_die_info
*spec_die
;
5490 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5492 fixup_partial_die (spec_die
, cu
);
5496 part_die
->name
= spec_die
->name
;
5498 /* Copy DW_AT_external attribute if it is set. */
5499 if (spec_die
->is_external
)
5500 part_die
->is_external
= spec_die
->is_external
;
5504 /* Set default names for some unnamed DIEs. */
5505 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5506 || part_die
->tag
== DW_TAG_class_type
))
5507 part_die
->name
= "(anonymous class)";
5509 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5510 part_die
->name
= "(anonymous namespace)";
5512 if (part_die
->tag
== DW_TAG_structure_type
5513 || part_die
->tag
== DW_TAG_class_type
5514 || part_die
->tag
== DW_TAG_union_type
)
5515 guess_structure_name (part_die
, cu
);
5518 /* Read the die from the .debug_info section buffer. Set DIEP to
5519 point to a newly allocated die with its information, except for its
5520 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5521 whether the die has children or not. */
5524 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
5525 struct dwarf2_cu
*cu
, int *has_children
)
5527 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5528 struct abbrev_info
*abbrev
;
5529 struct die_info
*die
;
5531 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5532 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5533 info_ptr
+= bytes_read
;
5536 die
= dwarf_alloc_die ();
5538 die
->abbrev
= abbrev_number
;
5545 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5548 error ("Dwarf Error: could not find abbrev number %d [in module %s]",
5550 bfd_get_filename (abfd
));
5552 die
= dwarf_alloc_die ();
5553 die
->offset
= offset
;
5554 die
->tag
= abbrev
->tag
;
5555 die
->abbrev
= abbrev_number
;
5558 die
->num_attrs
= abbrev
->num_attrs
;
5559 die
->attrs
= (struct attribute
*)
5560 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5562 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5564 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5565 abfd
, info_ptr
, cu
);
5567 /* If this attribute is an absolute reference to a different
5568 compilation unit, make sure that compilation unit is loaded
5570 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5571 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5572 || (DW_ADDR (&die
->attrs
[i
])
5573 >= cu
->header
.offset
+ cu
->header
.length
)))
5575 struct dwarf2_per_cu_data
*per_cu
;
5576 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5579 /* Mark the dependence relation so that we don't flush PER_CU
5581 dwarf2_add_dependence (cu
, per_cu
);
5583 /* If it's already on the queue, we have nothing to do. */
5587 /* If the compilation unit is already loaded, just mark it as
5589 if (per_cu
->cu
!= NULL
)
5591 per_cu
->cu
->last_used
= 0;
5595 /* Add it to the queue. */
5596 queue_comp_unit (per_cu
);
5601 *has_children
= abbrev
->has_children
;
5605 /* Read an attribute value described by an attribute form. */
5608 read_attribute_value (struct attribute
*attr
, unsigned form
,
5609 bfd
*abfd
, char *info_ptr
,
5610 struct dwarf2_cu
*cu
)
5612 struct comp_unit_head
*cu_header
= &cu
->header
;
5613 unsigned int bytes_read
;
5614 struct dwarf_block
*blk
;
5620 case DW_FORM_ref_addr
:
5621 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5622 info_ptr
+= bytes_read
;
5624 case DW_FORM_block2
:
5625 blk
= dwarf_alloc_block (cu
);
5626 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5628 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5629 info_ptr
+= blk
->size
;
5630 DW_BLOCK (attr
) = blk
;
5632 case DW_FORM_block4
:
5633 blk
= dwarf_alloc_block (cu
);
5634 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5636 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5637 info_ptr
+= blk
->size
;
5638 DW_BLOCK (attr
) = blk
;
5641 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5645 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5649 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5652 case DW_FORM_string
:
5653 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5654 info_ptr
+= bytes_read
;
5657 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5659 info_ptr
+= bytes_read
;
5662 blk
= dwarf_alloc_block (cu
);
5663 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5664 info_ptr
+= bytes_read
;
5665 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5666 info_ptr
+= blk
->size
;
5667 DW_BLOCK (attr
) = blk
;
5669 case DW_FORM_block1
:
5670 blk
= dwarf_alloc_block (cu
);
5671 blk
->size
= read_1_byte (abfd
, info_ptr
);
5673 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5674 info_ptr
+= blk
->size
;
5675 DW_BLOCK (attr
) = blk
;
5678 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5682 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5686 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5687 info_ptr
+= bytes_read
;
5690 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5691 info_ptr
+= bytes_read
;
5694 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5698 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5702 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5706 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5709 case DW_FORM_ref_udata
:
5710 DW_ADDR (attr
) = (cu
->header
.offset
5711 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5712 info_ptr
+= bytes_read
;
5714 case DW_FORM_indirect
:
5715 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5716 info_ptr
+= bytes_read
;
5717 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5720 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
5721 dwarf_form_name (form
),
5722 bfd_get_filename (abfd
));
5727 /* Read an attribute described by an abbreviated attribute. */
5730 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5731 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
5733 attr
->name
= abbrev
->name
;
5734 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5737 /* read dwarf information from a buffer */
5740 read_1_byte (bfd
*abfd
, char *buf
)
5742 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
5746 read_1_signed_byte (bfd
*abfd
, char *buf
)
5748 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
5752 read_2_bytes (bfd
*abfd
, char *buf
)
5754 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5758 read_2_signed_bytes (bfd
*abfd
, char *buf
)
5760 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5764 read_4_bytes (bfd
*abfd
, char *buf
)
5766 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5770 read_4_signed_bytes (bfd
*abfd
, char *buf
)
5772 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5775 static unsigned long
5776 read_8_bytes (bfd
*abfd
, char *buf
)
5778 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5782 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
5784 struct comp_unit_head
*cu_header
= &cu
->header
;
5785 CORE_ADDR retval
= 0;
5787 if (cu_header
->signed_addr_p
)
5789 switch (cu_header
->addr_size
)
5792 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5795 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5798 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
5801 internal_error (__FILE__
, __LINE__
,
5802 "read_address: bad switch, signed [in module %s]",
5803 bfd_get_filename (abfd
));
5808 switch (cu_header
->addr_size
)
5811 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5814 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5817 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5820 internal_error (__FILE__
, __LINE__
,
5821 "read_address: bad switch, unsigned [in module %s]",
5822 bfd_get_filename (abfd
));
5826 *bytes_read
= cu_header
->addr_size
;
5830 /* Read the initial length from a section. The (draft) DWARF 3
5831 specification allows the initial length to take up either 4 bytes
5832 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5833 bytes describe the length and all offsets will be 8 bytes in length
5836 An older, non-standard 64-bit format is also handled by this
5837 function. The older format in question stores the initial length
5838 as an 8-byte quantity without an escape value. Lengths greater
5839 than 2^32 aren't very common which means that the initial 4 bytes
5840 is almost always zero. Since a length value of zero doesn't make
5841 sense for the 32-bit format, this initial zero can be considered to
5842 be an escape value which indicates the presence of the older 64-bit
5843 format. As written, the code can't detect (old format) lengths
5844 greater than 4GB. If it becomes necessary to handle lengths somewhat
5845 larger than 4GB, we could allow other small values (such as the
5846 non-sensical values of 1, 2, and 3) to also be used as escape values
5847 indicating the presence of the old format.
5849 The value returned via bytes_read should be used to increment
5850 the relevant pointer after calling read_initial_length().
5852 As a side effect, this function sets the fields initial_length_size
5853 and offset_size in cu_header to the values appropriate for the
5854 length field. (The format of the initial length field determines
5855 the width of file offsets to be fetched later with fetch_offset().)
5857 [ Note: read_initial_length() and read_offset() are based on the
5858 document entitled "DWARF Debugging Information Format", revision
5859 3, draft 8, dated November 19, 2001. This document was obtained
5862 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5864 This document is only a draft and is subject to change. (So beware.)
5866 Details regarding the older, non-standard 64-bit format were
5867 determined empirically by examining 64-bit ELF files produced
5868 by the SGI toolchain on an IRIX 6.5 machine.
5870 - Kevin, July 16, 2002
5874 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
5879 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5881 if (retval
== 0xffffffff)
5883 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
5885 if (cu_header
!= NULL
)
5887 cu_header
->initial_length_size
= 12;
5888 cu_header
->offset_size
= 8;
5891 else if (retval
== 0)
5893 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
5895 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5897 if (cu_header
!= NULL
)
5899 cu_header
->initial_length_size
= 8;
5900 cu_header
->offset_size
= 8;
5906 if (cu_header
!= NULL
)
5908 cu_header
->initial_length_size
= 4;
5909 cu_header
->offset_size
= 4;
5916 /* Read an offset from the data stream. The size of the offset is
5917 given by cu_header->offset_size. */
5920 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
5925 switch (cu_header
->offset_size
)
5928 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5932 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5936 internal_error (__FILE__
, __LINE__
,
5937 "read_offset: bad switch [in module %s]",
5938 bfd_get_filename (abfd
));
5945 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
5947 /* If the size of a host char is 8 bits, we can return a pointer
5948 to the buffer, otherwise we have to copy the data to a buffer
5949 allocated on the temporary obstack. */
5950 gdb_assert (HOST_CHAR_BIT
== 8);
5955 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5957 /* If the size of a host char is 8 bits, we can return a pointer
5958 to the string, otherwise we have to copy the string to a buffer
5959 allocated on the temporary obstack. */
5960 gdb_assert (HOST_CHAR_BIT
== 8);
5963 *bytes_read_ptr
= 1;
5966 *bytes_read_ptr
= strlen (buf
) + 1;
5971 read_indirect_string (bfd
*abfd
, char *buf
,
5972 const struct comp_unit_head
*cu_header
,
5973 unsigned int *bytes_read_ptr
)
5975 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
5976 (int *) bytes_read_ptr
);
5978 if (dwarf2_per_objfile
->str_buffer
== NULL
)
5980 error ("DW_FORM_strp used without .debug_str section [in module %s]",
5981 bfd_get_filename (abfd
));
5984 if (str_offset
>= dwarf2_per_objfile
->str_size
)
5986 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
5987 bfd_get_filename (abfd
));
5990 gdb_assert (HOST_CHAR_BIT
== 8);
5991 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
5993 return dwarf2_per_objfile
->str_buffer
+ str_offset
;
5996 static unsigned long
5997 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5999 unsigned long result
;
6000 unsigned int num_read
;
6010 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6013 result
|= ((unsigned long)(byte
& 127) << shift
);
6014 if ((byte
& 128) == 0)
6020 *bytes_read_ptr
= num_read
;
6025 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
6028 int i
, shift
, size
, num_read
;
6038 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6041 result
|= ((long)(byte
& 127) << shift
);
6043 if ((byte
& 128) == 0)
6048 if ((shift
< size
) && (byte
& 0x40))
6050 result
|= -(1 << shift
);
6052 *bytes_read_ptr
= num_read
;
6056 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6059 skip_leb128 (bfd
*abfd
, char *buf
)
6065 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
6067 if ((byte
& 128) == 0)
6073 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6079 cu
->language
= language_c
;
6081 case DW_LANG_C_plus_plus
:
6082 cu
->language
= language_cplus
;
6084 case DW_LANG_Fortran77
:
6085 case DW_LANG_Fortran90
:
6086 case DW_LANG_Fortran95
:
6087 cu
->language
= language_fortran
;
6089 case DW_LANG_Mips_Assembler
:
6090 cu
->language
= language_asm
;
6093 cu
->language
= language_java
;
6097 case DW_LANG_Cobol74
:
6098 case DW_LANG_Cobol85
:
6099 case DW_LANG_Pascal83
:
6100 case DW_LANG_Modula2
:
6102 cu
->language
= language_minimal
;
6105 cu
->language_defn
= language_def (cu
->language
);
6108 /* Return the named attribute or NULL if not there. */
6110 static struct attribute
*
6111 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6114 struct attribute
*spec
= NULL
;
6116 for (i
= 0; i
< die
->num_attrs
; ++i
)
6118 if (die
->attrs
[i
].name
== name
)
6119 return &die
->attrs
[i
];
6120 if (die
->attrs
[i
].name
== DW_AT_specification
6121 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6122 spec
= &die
->attrs
[i
];
6126 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6131 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6132 and holds a non-zero value. This function should only be used for
6133 DW_FORM_flag attributes. */
6136 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6138 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6140 return (attr
&& DW_UNSND (attr
));
6144 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6146 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6147 which value is non-zero. However, we have to be careful with
6148 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6149 (via dwarf2_flag_true_p) follows this attribute. So we may
6150 end up accidently finding a declaration attribute that belongs
6151 to a different DIE referenced by the specification attribute,
6152 even though the given DIE does not have a declaration attribute. */
6153 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6154 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6157 /* Return the die giving the specification for DIE, if there is
6160 static struct die_info
*
6161 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6163 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6165 if (spec_attr
== NULL
)
6168 return follow_die_ref (die
, spec_attr
, cu
);
6171 /* Free the line_header structure *LH, and any arrays and strings it
6174 free_line_header (struct line_header
*lh
)
6176 if (lh
->standard_opcode_lengths
)
6177 xfree (lh
->standard_opcode_lengths
);
6179 /* Remember that all the lh->file_names[i].name pointers are
6180 pointers into debug_line_buffer, and don't need to be freed. */
6182 xfree (lh
->file_names
);
6184 /* Similarly for the include directory names. */
6185 if (lh
->include_dirs
)
6186 xfree (lh
->include_dirs
);
6192 /* Add an entry to LH's include directory table. */
6194 add_include_dir (struct line_header
*lh
, char *include_dir
)
6196 /* Grow the array if necessary. */
6197 if (lh
->include_dirs_size
== 0)
6199 lh
->include_dirs_size
= 1; /* for testing */
6200 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6201 * sizeof (*lh
->include_dirs
));
6203 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6205 lh
->include_dirs_size
*= 2;
6206 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6207 (lh
->include_dirs_size
6208 * sizeof (*lh
->include_dirs
)));
6211 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6215 /* Add an entry to LH's file name table. */
6217 add_file_name (struct line_header
*lh
,
6219 unsigned int dir_index
,
6220 unsigned int mod_time
,
6221 unsigned int length
)
6223 struct file_entry
*fe
;
6225 /* Grow the array if necessary. */
6226 if (lh
->file_names_size
== 0)
6228 lh
->file_names_size
= 1; /* for testing */
6229 lh
->file_names
= xmalloc (lh
->file_names_size
6230 * sizeof (*lh
->file_names
));
6232 else if (lh
->num_file_names
>= lh
->file_names_size
)
6234 lh
->file_names_size
*= 2;
6235 lh
->file_names
= xrealloc (lh
->file_names
,
6236 (lh
->file_names_size
6237 * sizeof (*lh
->file_names
)));
6240 fe
= &lh
->file_names
[lh
->num_file_names
++];
6242 fe
->dir_index
= dir_index
;
6243 fe
->mod_time
= mod_time
;
6244 fe
->length
= length
;
6249 /* Read the statement program header starting at OFFSET in
6250 .debug_line, according to the endianness of ABFD. Return a pointer
6251 to a struct line_header, allocated using xmalloc.
6253 NOTE: the strings in the include directory and file name tables of
6254 the returned object point into debug_line_buffer, and must not be
6256 static struct line_header
*
6257 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6258 struct dwarf2_cu
*cu
)
6260 struct cleanup
*back_to
;
6261 struct line_header
*lh
;
6265 char *cur_dir
, *cur_file
;
6267 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6269 complaint (&symfile_complaints
, "missing .debug_line section");
6273 /* Make sure that at least there's room for the total_length field. That
6274 could be 12 bytes long, but we're just going to fudge that. */
6275 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6277 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6281 lh
= xmalloc (sizeof (*lh
));
6282 memset (lh
, 0, sizeof (*lh
));
6283 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6286 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6288 /* read in the header */
6289 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
6290 line_ptr
+= bytes_read
;
6291 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6292 + dwarf2_per_objfile
->line_size
))
6294 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6297 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6298 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6300 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6301 line_ptr
+= bytes_read
;
6302 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6304 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6306 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6308 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6310 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6312 lh
->standard_opcode_lengths
6313 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
6315 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6316 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6318 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6322 /* Read directory table */
6323 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6325 line_ptr
+= bytes_read
;
6326 add_include_dir (lh
, cur_dir
);
6328 line_ptr
+= bytes_read
;
6330 /* Read file name table */
6331 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6333 unsigned int dir_index
, mod_time
, length
;
6335 line_ptr
+= bytes_read
;
6336 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6337 line_ptr
+= bytes_read
;
6338 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6339 line_ptr
+= bytes_read
;
6340 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6341 line_ptr
+= bytes_read
;
6343 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6345 line_ptr
+= bytes_read
;
6346 lh
->statement_program_start
= line_ptr
;
6348 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6349 + dwarf2_per_objfile
->line_size
))
6350 complaint (&symfile_complaints
,
6351 "line number info header doesn't fit in `.debug_line' section");
6353 discard_cleanups (back_to
);
6357 /* This function exists to work around a bug in certain compilers
6358 (particularly GCC 2.95), in which the first line number marker of a
6359 function does not show up until after the prologue, right before
6360 the second line number marker. This function shifts ADDRESS down
6361 to the beginning of the function if necessary, and is called on
6362 addresses passed to record_line. */
6365 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6367 struct function_range
*fn
;
6369 /* Find the function_range containing address. */
6374 cu
->cached_fn
= cu
->first_fn
;
6378 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6384 while (fn
&& fn
!= cu
->cached_fn
)
6385 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6395 if (address
!= fn
->lowpc
)
6396 complaint (&symfile_complaints
,
6397 "misplaced first line number at 0x%lx for '%s'",
6398 (unsigned long) address
, fn
->name
);
6403 /* Decode the Line Number Program (LNP) for the given line_header
6404 structure and CU. The actual information extracted and the type
6405 of structures created from the LNP depends on the value of PST.
6407 1. If PST is NULL, then this procedure uses the data from the program
6408 to create all necessary symbol tables, and their linetables.
6409 The compilation directory of the file is passed in COMP_DIR,
6410 and must not be NULL.
6412 2. If PST is not NULL, this procedure reads the program to determine
6413 the list of files included by the unit represented by PST, and
6414 builds all the associated partial symbol tables. In this case,
6415 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6416 is not used to compute the full name of the symtab, and therefore
6417 omitting it when building the partial symtab does not introduce
6418 the potential for inconsistency - a partial symtab and its associated
6419 symbtab having a different fullname -). */
6422 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6423 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6427 unsigned int bytes_read
;
6428 unsigned char op_code
, extended_op
, adj_opcode
;
6430 struct objfile
*objfile
= cu
->objfile
;
6431 const int decode_for_pst_p
= (pst
!= NULL
);
6433 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6435 line_ptr
= lh
->statement_program_start
;
6436 line_end
= lh
->statement_program_end
;
6438 /* Read the statement sequences until there's nothing left. */
6439 while (line_ptr
< line_end
)
6441 /* state machine registers */
6442 CORE_ADDR address
= 0;
6443 unsigned int file
= 1;
6444 unsigned int line
= 1;
6445 unsigned int column
= 0;
6446 int is_stmt
= lh
->default_is_stmt
;
6447 int basic_block
= 0;
6448 int end_sequence
= 0;
6450 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6452 /* Start a subfile for the current file of the state machine. */
6453 /* lh->include_dirs and lh->file_names are 0-based, but the
6454 directory and file name numbers in the statement program
6456 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6459 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6462 dwarf2_start_subfile (fe
->name
, dir
);
6465 /* Decode the table. */
6466 while (!end_sequence
)
6468 op_code
= read_1_byte (abfd
, line_ptr
);
6471 if (op_code
>= lh
->opcode_base
)
6472 { /* Special operand. */
6473 adj_opcode
= op_code
- lh
->opcode_base
;
6474 address
+= (adj_opcode
/ lh
->line_range
)
6475 * lh
->minimum_instruction_length
;
6476 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6477 lh
->file_names
[file
- 1].included_p
= 1;
6478 if (!decode_for_pst_p
)
6480 /* append row to matrix using current values */
6481 record_line (current_subfile
, line
,
6482 check_cu_functions (address
, cu
));
6486 else switch (op_code
)
6488 case DW_LNS_extended_op
:
6489 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6490 line_ptr
+= bytes_read
;
6491 extended_op
= read_1_byte (abfd
, line_ptr
);
6493 switch (extended_op
)
6495 case DW_LNE_end_sequence
:
6497 lh
->file_names
[file
- 1].included_p
= 1;
6498 if (!decode_for_pst_p
)
6499 record_line (current_subfile
, 0, address
);
6501 case DW_LNE_set_address
:
6502 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6503 line_ptr
+= bytes_read
;
6504 address
+= baseaddr
;
6506 case DW_LNE_define_file
:
6509 unsigned int dir_index
, mod_time
, length
;
6511 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6512 line_ptr
+= bytes_read
;
6514 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6515 line_ptr
+= bytes_read
;
6517 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6518 line_ptr
+= bytes_read
;
6520 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6521 line_ptr
+= bytes_read
;
6522 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6526 complaint (&symfile_complaints
,
6527 "mangled .debug_line section");
6532 lh
->file_names
[file
- 1].included_p
= 1;
6533 if (!decode_for_pst_p
)
6534 record_line (current_subfile
, line
,
6535 check_cu_functions (address
, cu
));
6538 case DW_LNS_advance_pc
:
6539 address
+= lh
->minimum_instruction_length
6540 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6541 line_ptr
+= bytes_read
;
6543 case DW_LNS_advance_line
:
6544 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6545 line_ptr
+= bytes_read
;
6547 case DW_LNS_set_file
:
6549 /* lh->include_dirs and lh->file_names are 0-based,
6550 but the directory and file name numbers in the
6551 statement program are 1-based. */
6552 struct file_entry
*fe
;
6554 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6555 line_ptr
+= bytes_read
;
6556 fe
= &lh
->file_names
[file
- 1];
6558 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6561 if (!decode_for_pst_p
)
6562 dwarf2_start_subfile (fe
->name
, dir
);
6565 case DW_LNS_set_column
:
6566 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6567 line_ptr
+= bytes_read
;
6569 case DW_LNS_negate_stmt
:
6570 is_stmt
= (!is_stmt
);
6572 case DW_LNS_set_basic_block
:
6575 /* Add to the address register of the state machine the
6576 address increment value corresponding to special opcode
6577 255. Ie, this value is scaled by the minimum instruction
6578 length since special opcode 255 would have scaled the
6580 case DW_LNS_const_add_pc
:
6581 address
+= (lh
->minimum_instruction_length
6582 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6584 case DW_LNS_fixed_advance_pc
:
6585 address
+= read_2_bytes (abfd
, line_ptr
);
6589 { /* Unknown standard opcode, ignore it. */
6591 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6593 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6594 line_ptr
+= bytes_read
;
6601 if (decode_for_pst_p
)
6605 /* Now that we're done scanning the Line Header Program, we can
6606 create the psymtab of each included file. */
6607 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6608 if (lh
->file_names
[file_index
].included_p
== 1)
6610 char *include_name
= lh
->file_names
[file_index
].name
;
6612 if (strcmp (include_name
, pst
->filename
) != 0)
6613 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6618 /* Start a subfile for DWARF. FILENAME is the name of the file and
6619 DIRNAME the name of the source directory which contains FILENAME
6620 or NULL if not known.
6621 This routine tries to keep line numbers from identical absolute and
6622 relative file names in a common subfile.
6624 Using the `list' example from the GDB testsuite, which resides in
6625 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6626 of /srcdir/list0.c yields the following debugging information for list0.c:
6628 DW_AT_name: /srcdir/list0.c
6629 DW_AT_comp_dir: /compdir
6630 files.files[0].name: list0.h
6631 files.files[0].dir: /srcdir
6632 files.files[1].name: list0.c
6633 files.files[1].dir: /srcdir
6635 The line number information for list0.c has to end up in a single
6636 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6639 dwarf2_start_subfile (char *filename
, char *dirname
)
6641 /* If the filename isn't absolute, try to match an existing subfile
6642 with the full pathname. */
6644 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6646 struct subfile
*subfile
;
6647 char *fullname
= concat (dirname
, "/", filename
, NULL
);
6649 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
6651 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
6653 current_subfile
= subfile
;
6660 start_subfile (filename
, dirname
);
6664 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6665 struct dwarf2_cu
*cu
)
6667 struct objfile
*objfile
= cu
->objfile
;
6668 struct comp_unit_head
*cu_header
= &cu
->header
;
6670 /* NOTE drow/2003-01-30: There used to be a comment and some special
6671 code here to turn a symbol with DW_AT_external and a
6672 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6673 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6674 with some versions of binutils) where shared libraries could have
6675 relocations against symbols in their debug information - the
6676 minimal symbol would have the right address, but the debug info
6677 would not. It's no longer necessary, because we will explicitly
6678 apply relocations when we read in the debug information now. */
6680 /* A DW_AT_location attribute with no contents indicates that a
6681 variable has been optimized away. */
6682 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6684 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6688 /* Handle one degenerate form of location expression specially, to
6689 preserve GDB's previous behavior when section offsets are
6690 specified. If this is just a DW_OP_addr then mark this symbol
6693 if (attr_form_is_block (attr
)
6694 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6695 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6699 SYMBOL_VALUE_ADDRESS (sym
) =
6700 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6701 fixup_symbol_section (sym
, objfile
);
6702 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6703 SYMBOL_SECTION (sym
));
6704 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6708 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6709 expression evaluator, and use LOC_COMPUTED only when necessary
6710 (i.e. when the value of a register or memory location is
6711 referenced, or a thread-local block, etc.). Then again, it might
6712 not be worthwhile. I'm assuming that it isn't unless performance
6713 or memory numbers show me otherwise. */
6715 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6716 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6719 /* Given a pointer to a DWARF information entry, figure out if we need
6720 to make a symbol table entry for it, and if so, create a new entry
6721 and return a pointer to it.
6722 If TYPE is NULL, determine symbol type from the die, otherwise
6723 used the passed type. */
6725 static struct symbol
*
6726 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6728 struct objfile
*objfile
= cu
->objfile
;
6729 struct symbol
*sym
= NULL
;
6731 struct attribute
*attr
= NULL
;
6732 struct attribute
*attr2
= NULL
;
6735 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6737 if (die
->tag
!= DW_TAG_namespace
)
6738 name
= dwarf2_linkage_name (die
, cu
);
6740 name
= TYPE_NAME (type
);
6744 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6745 sizeof (struct symbol
));
6746 OBJSTAT (objfile
, n_syms
++);
6747 memset (sym
, 0, sizeof (struct symbol
));
6749 /* Cache this symbol's name and the name's demangled form (if any). */
6750 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6751 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6753 /* Default assumptions.
6754 Use the passed type or decode it from the die. */
6755 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6756 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6758 SYMBOL_TYPE (sym
) = type
;
6760 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6761 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6764 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6769 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6772 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6774 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6776 case DW_TAG_subprogram
:
6777 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6779 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6780 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6781 if (attr2
&& (DW_UNSND (attr2
) != 0))
6783 add_symbol_to_list (sym
, &global_symbols
);
6787 add_symbol_to_list (sym
, cu
->list_in_scope
);
6790 case DW_TAG_variable
:
6791 /* Compilation with minimal debug info may result in variables
6792 with missing type entries. Change the misleading `void' type
6793 to something sensible. */
6794 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6795 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6796 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6797 "<variable, no debug info>",
6799 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6802 dwarf2_const_value (attr
, sym
, cu
);
6803 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6804 if (attr2
&& (DW_UNSND (attr2
) != 0))
6805 add_symbol_to_list (sym
, &global_symbols
);
6807 add_symbol_to_list (sym
, cu
->list_in_scope
);
6810 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6813 var_decode_location (attr
, sym
, cu
);
6814 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6815 if (attr2
&& (DW_UNSND (attr2
) != 0))
6816 add_symbol_to_list (sym
, &global_symbols
);
6818 add_symbol_to_list (sym
, cu
->list_in_scope
);
6822 /* We do not know the address of this symbol.
6823 If it is an external symbol and we have type information
6824 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6825 The address of the variable will then be determined from
6826 the minimal symbol table whenever the variable is
6828 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6829 if (attr2
&& (DW_UNSND (attr2
) != 0)
6830 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6832 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6833 add_symbol_to_list (sym
, &global_symbols
);
6837 case DW_TAG_formal_parameter
:
6838 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6841 var_decode_location (attr
, sym
, cu
);
6842 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6843 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6844 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6846 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6849 dwarf2_const_value (attr
, sym
, cu
);
6851 add_symbol_to_list (sym
, cu
->list_in_scope
);
6853 case DW_TAG_unspecified_parameters
:
6854 /* From varargs functions; gdb doesn't seem to have any
6855 interest in this information, so just ignore it for now.
6858 case DW_TAG_class_type
:
6859 case DW_TAG_structure_type
:
6860 case DW_TAG_union_type
:
6861 case DW_TAG_enumeration_type
:
6862 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6863 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6865 /* Make sure that the symbol includes appropriate enclosing
6866 classes/namespaces in its name. These are calculated in
6867 read_structure_type, and the correct name is saved in
6870 if (cu
->language
== language_cplus
6871 || cu
->language
== language_java
)
6873 struct type
*type
= SYMBOL_TYPE (sym
);
6875 if (TYPE_TAG_NAME (type
) != NULL
)
6877 /* FIXME: carlton/2003-11-10: Should this use
6878 SYMBOL_SET_NAMES instead? (The same problem also
6879 arises further down in this function.) */
6880 /* The type's name is already allocated along with
6881 this objfile, so we don't need to duplicate it
6883 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
6888 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6889 really ever be static objects: otherwise, if you try
6890 to, say, break of a class's method and you're in a file
6891 which doesn't mention that class, it won't work unless
6892 the check for all static symbols in lookup_symbol_aux
6893 saves you. See the OtherFileClass tests in
6894 gdb.c++/namespace.exp. */
6896 struct pending
**list_to_add
;
6898 list_to_add
= (cu
->list_in_scope
== &file_symbols
6899 && (cu
->language
== language_cplus
6900 || cu
->language
== language_java
)
6901 ? &global_symbols
: cu
->list_in_scope
);
6903 add_symbol_to_list (sym
, list_to_add
);
6905 /* The semantics of C++ state that "struct foo { ... }" also
6906 defines a typedef for "foo". A Java class declaration also
6907 defines a typedef for the class. Synthesize a typedef symbol
6908 so that "ptype foo" works as expected. */
6909 if (cu
->language
== language_cplus
6910 || cu
->language
== language_java
)
6912 struct symbol
*typedef_sym
= (struct symbol
*)
6913 obstack_alloc (&objfile
->objfile_obstack
,
6914 sizeof (struct symbol
));
6915 *typedef_sym
= *sym
;
6916 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
6917 /* The symbol's name is already allocated along with
6918 this objfile, so we don't need to duplicate it for
6920 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
6921 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NATURAL_NAME (sym
);
6922 add_symbol_to_list (typedef_sym
, list_to_add
);
6926 case DW_TAG_typedef
:
6927 if (processing_has_namespace_info
6928 && processing_current_prefix
[0] != '\0')
6930 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6931 processing_current_prefix
,
6934 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6935 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6936 add_symbol_to_list (sym
, cu
->list_in_scope
);
6938 case DW_TAG_base_type
:
6939 case DW_TAG_subrange_type
:
6940 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6941 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6942 add_symbol_to_list (sym
, cu
->list_in_scope
);
6944 case DW_TAG_enumerator
:
6945 if (processing_has_namespace_info
6946 && processing_current_prefix
[0] != '\0')
6948 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
6949 processing_current_prefix
,
6952 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6955 dwarf2_const_value (attr
, sym
, cu
);
6958 /* NOTE: carlton/2003-11-10: See comment above in the
6959 DW_TAG_class_type, etc. block. */
6961 struct pending
**list_to_add
;
6963 list_to_add
= (cu
->list_in_scope
== &file_symbols
6964 && (cu
->language
== language_cplus
6965 || cu
->language
== language_java
)
6966 ? &global_symbols
: cu
->list_in_scope
);
6968 add_symbol_to_list (sym
, list_to_add
);
6971 case DW_TAG_namespace
:
6972 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6973 add_symbol_to_list (sym
, &global_symbols
);
6976 /* Not a tag we recognize. Hopefully we aren't processing
6977 trash data, but since we must specifically ignore things
6978 we don't recognize, there is nothing else we should do at
6980 complaint (&symfile_complaints
, "unsupported tag: '%s'",
6981 dwarf_tag_name (die
->tag
));
6988 /* Copy constant value from an attribute to a symbol. */
6991 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
6992 struct dwarf2_cu
*cu
)
6994 struct objfile
*objfile
= cu
->objfile
;
6995 struct comp_unit_head
*cu_header
= &cu
->header
;
6996 struct dwarf_block
*blk
;
7001 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7002 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7003 cu_header
->addr_size
,
7004 TYPE_LENGTH (SYMBOL_TYPE
7006 SYMBOL_VALUE_BYTES (sym
) = (char *)
7007 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7008 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7009 it's body - store_unsigned_integer. */
7010 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7012 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7014 case DW_FORM_block1
:
7015 case DW_FORM_block2
:
7016 case DW_FORM_block4
:
7018 blk
= DW_BLOCK (attr
);
7019 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7020 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7022 TYPE_LENGTH (SYMBOL_TYPE
7024 SYMBOL_VALUE_BYTES (sym
) = (char *)
7025 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7026 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7027 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7030 /* The DW_AT_const_value attributes are supposed to carry the
7031 symbol's value "represented as it would be on the target
7032 architecture." By the time we get here, it's already been
7033 converted to host endianness, so we just need to sign- or
7034 zero-extend it as appropriate. */
7036 dwarf2_const_value_data (attr
, sym
, 8);
7039 dwarf2_const_value_data (attr
, sym
, 16);
7042 dwarf2_const_value_data (attr
, sym
, 32);
7045 dwarf2_const_value_data (attr
, sym
, 64);
7049 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7050 SYMBOL_CLASS (sym
) = LOC_CONST
;
7054 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7055 SYMBOL_CLASS (sym
) = LOC_CONST
;
7059 complaint (&symfile_complaints
,
7060 "unsupported const value attribute form: '%s'",
7061 dwarf_form_name (attr
->form
));
7062 SYMBOL_VALUE (sym
) = 0;
7063 SYMBOL_CLASS (sym
) = LOC_CONST
;
7069 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7070 or zero-extend it as appropriate for the symbol's type. */
7072 dwarf2_const_value_data (struct attribute
*attr
,
7076 LONGEST l
= DW_UNSND (attr
);
7078 if (bits
< sizeof (l
) * 8)
7080 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7081 l
&= ((LONGEST
) 1 << bits
) - 1;
7083 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7086 SYMBOL_VALUE (sym
) = l
;
7087 SYMBOL_CLASS (sym
) = LOC_CONST
;
7091 /* Return the type of the die in question using its DW_AT_type attribute. */
7093 static struct type
*
7094 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7097 struct attribute
*type_attr
;
7098 struct die_info
*type_die
;
7100 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7103 /* A missing DW_AT_type represents a void type. */
7104 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7107 type_die
= follow_die_ref (die
, type_attr
, cu
);
7109 type
= tag_type_to_type (type_die
, cu
);
7112 dump_die (type_die
);
7113 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
7119 /* Return the containing type of the die in question using its
7120 DW_AT_containing_type attribute. */
7122 static struct type
*
7123 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7125 struct type
*type
= NULL
;
7126 struct attribute
*type_attr
;
7127 struct die_info
*type_die
= NULL
;
7129 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7132 type_die
= follow_die_ref (die
, type_attr
, cu
);
7133 type
= tag_type_to_type (type_die
, cu
);
7138 dump_die (type_die
);
7139 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
7145 static struct type
*
7146 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7154 read_type_die (die
, cu
);
7158 error ("Dwarf Error: Cannot find type of die [in module %s]",
7166 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7168 char *prefix
= determine_prefix (die
, cu
);
7169 const char *old_prefix
= processing_current_prefix
;
7170 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7171 processing_current_prefix
= prefix
;
7175 case DW_TAG_class_type
:
7176 case DW_TAG_structure_type
:
7177 case DW_TAG_union_type
:
7178 read_structure_type (die
, cu
);
7180 case DW_TAG_enumeration_type
:
7181 read_enumeration_type (die
, cu
);
7183 case DW_TAG_subprogram
:
7184 case DW_TAG_subroutine_type
:
7185 read_subroutine_type (die
, cu
);
7187 case DW_TAG_array_type
:
7188 read_array_type (die
, cu
);
7190 case DW_TAG_pointer_type
:
7191 read_tag_pointer_type (die
, cu
);
7193 case DW_TAG_ptr_to_member_type
:
7194 read_tag_ptr_to_member_type (die
, cu
);
7196 case DW_TAG_reference_type
:
7197 read_tag_reference_type (die
, cu
);
7199 case DW_TAG_const_type
:
7200 read_tag_const_type (die
, cu
);
7202 case DW_TAG_volatile_type
:
7203 read_tag_volatile_type (die
, cu
);
7205 case DW_TAG_string_type
:
7206 read_tag_string_type (die
, cu
);
7208 case DW_TAG_typedef
:
7209 read_typedef (die
, cu
);
7211 case DW_TAG_subrange_type
:
7212 read_subrange_type (die
, cu
);
7214 case DW_TAG_base_type
:
7215 read_base_type (die
, cu
);
7218 complaint (&symfile_complaints
, "unexepected tag in read_type_die: '%s'",
7219 dwarf_tag_name (die
->tag
));
7223 processing_current_prefix
= old_prefix
;
7224 do_cleanups (back_to
);
7227 /* Return the name of the namespace/class that DIE is defined within,
7228 or "" if we can't tell. The caller should xfree the result. */
7230 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7231 therein) for an example of how to use this function to deal with
7232 DW_AT_specification. */
7235 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7237 struct die_info
*parent
;
7239 if (cu
->language
!= language_cplus
7240 && cu
->language
!= language_java
)
7243 parent
= die
->parent
;
7247 return xstrdup ("");
7251 switch (parent
->tag
) {
7252 case DW_TAG_namespace
:
7254 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7255 before doing this check? */
7256 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7258 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7263 char *parent_prefix
= determine_prefix (parent
, cu
);
7264 char *retval
= typename_concat (NULL
, parent_prefix
,
7265 namespace_name (parent
, &dummy
,
7268 xfree (parent_prefix
);
7273 case DW_TAG_class_type
:
7274 case DW_TAG_structure_type
:
7276 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7278 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7282 const char *old_prefix
= processing_current_prefix
;
7283 char *new_prefix
= determine_prefix (parent
, cu
);
7286 processing_current_prefix
= new_prefix
;
7287 retval
= determine_class_name (parent
, cu
);
7288 processing_current_prefix
= old_prefix
;
7295 return determine_prefix (parent
, cu
);
7300 /* Return a newly-allocated string formed by concatenating PREFIX and
7301 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7302 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7303 perform an obconcat, otherwise allocate storage for the result. The CU argument
7304 is used to determine the language and hence, the appropriate separator. */
7306 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7309 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7310 struct dwarf2_cu
*cu
)
7314 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7316 else if (cu
->language
== language_java
)
7323 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7328 strcpy (retval
, prefix
);
7329 strcat (retval
, sep
);
7332 strcat (retval
, suffix
);
7338 /* We have an obstack. */
7339 return obconcat (obs
, prefix
, sep
, suffix
);
7343 static struct type
*
7344 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7346 struct objfile
*objfile
= cu
->objfile
;
7348 /* FIXME - this should not produce a new (struct type *)
7349 every time. It should cache base types. */
7353 case DW_ATE_address
:
7354 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7356 case DW_ATE_boolean
:
7357 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7359 case DW_ATE_complex_float
:
7362 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7366 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7372 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7376 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7383 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7386 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7390 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7394 case DW_ATE_signed_char
:
7395 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7397 case DW_ATE_unsigned
:
7401 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7404 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7408 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7412 case DW_ATE_unsigned_char
:
7413 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7416 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7423 copy_die (struct die_info
*old_die
)
7425 struct die_info
*new_die
;
7428 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7429 memset (new_die
, 0, sizeof (struct die_info
));
7431 new_die
->tag
= old_die
->tag
;
7432 new_die
->has_children
= old_die
->has_children
;
7433 new_die
->abbrev
= old_die
->abbrev
;
7434 new_die
->offset
= old_die
->offset
;
7435 new_die
->type
= NULL
;
7437 num_attrs
= old_die
->num_attrs
;
7438 new_die
->num_attrs
= num_attrs
;
7439 new_die
->attrs
= (struct attribute
*)
7440 xmalloc (num_attrs
* sizeof (struct attribute
));
7442 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7444 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7445 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7446 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7449 new_die
->next
= NULL
;
7454 /* Return sibling of die, NULL if no sibling. */
7456 static struct die_info
*
7457 sibling_die (struct die_info
*die
)
7459 return die
->sibling
;
7462 /* Get linkage name of a die, return NULL if not found. */
7465 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7467 struct attribute
*attr
;
7469 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7470 if (attr
&& DW_STRING (attr
))
7471 return DW_STRING (attr
);
7472 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7473 if (attr
&& DW_STRING (attr
))
7474 return DW_STRING (attr
);
7478 /* Get name of a die, return NULL if not found. */
7481 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7483 struct attribute
*attr
;
7485 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7486 if (attr
&& DW_STRING (attr
))
7487 return DW_STRING (attr
);
7491 /* Return the die that this die in an extension of, or NULL if there
7494 static struct die_info
*
7495 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7497 struct attribute
*attr
;
7499 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7503 return follow_die_ref (die
, attr
, cu
);
7506 /* Convert a DIE tag into its string name. */
7509 dwarf_tag_name (unsigned tag
)
7513 case DW_TAG_padding
:
7514 return "DW_TAG_padding";
7515 case DW_TAG_array_type
:
7516 return "DW_TAG_array_type";
7517 case DW_TAG_class_type
:
7518 return "DW_TAG_class_type";
7519 case DW_TAG_entry_point
:
7520 return "DW_TAG_entry_point";
7521 case DW_TAG_enumeration_type
:
7522 return "DW_TAG_enumeration_type";
7523 case DW_TAG_formal_parameter
:
7524 return "DW_TAG_formal_parameter";
7525 case DW_TAG_imported_declaration
:
7526 return "DW_TAG_imported_declaration";
7528 return "DW_TAG_label";
7529 case DW_TAG_lexical_block
:
7530 return "DW_TAG_lexical_block";
7532 return "DW_TAG_member";
7533 case DW_TAG_pointer_type
:
7534 return "DW_TAG_pointer_type";
7535 case DW_TAG_reference_type
:
7536 return "DW_TAG_reference_type";
7537 case DW_TAG_compile_unit
:
7538 return "DW_TAG_compile_unit";
7539 case DW_TAG_string_type
:
7540 return "DW_TAG_string_type";
7541 case DW_TAG_structure_type
:
7542 return "DW_TAG_structure_type";
7543 case DW_TAG_subroutine_type
:
7544 return "DW_TAG_subroutine_type";
7545 case DW_TAG_typedef
:
7546 return "DW_TAG_typedef";
7547 case DW_TAG_union_type
:
7548 return "DW_TAG_union_type";
7549 case DW_TAG_unspecified_parameters
:
7550 return "DW_TAG_unspecified_parameters";
7551 case DW_TAG_variant
:
7552 return "DW_TAG_variant";
7553 case DW_TAG_common_block
:
7554 return "DW_TAG_common_block";
7555 case DW_TAG_common_inclusion
:
7556 return "DW_TAG_common_inclusion";
7557 case DW_TAG_inheritance
:
7558 return "DW_TAG_inheritance";
7559 case DW_TAG_inlined_subroutine
:
7560 return "DW_TAG_inlined_subroutine";
7562 return "DW_TAG_module";
7563 case DW_TAG_ptr_to_member_type
:
7564 return "DW_TAG_ptr_to_member_type";
7565 case DW_TAG_set_type
:
7566 return "DW_TAG_set_type";
7567 case DW_TAG_subrange_type
:
7568 return "DW_TAG_subrange_type";
7569 case DW_TAG_with_stmt
:
7570 return "DW_TAG_with_stmt";
7571 case DW_TAG_access_declaration
:
7572 return "DW_TAG_access_declaration";
7573 case DW_TAG_base_type
:
7574 return "DW_TAG_base_type";
7575 case DW_TAG_catch_block
:
7576 return "DW_TAG_catch_block";
7577 case DW_TAG_const_type
:
7578 return "DW_TAG_const_type";
7579 case DW_TAG_constant
:
7580 return "DW_TAG_constant";
7581 case DW_TAG_enumerator
:
7582 return "DW_TAG_enumerator";
7583 case DW_TAG_file_type
:
7584 return "DW_TAG_file_type";
7586 return "DW_TAG_friend";
7587 case DW_TAG_namelist
:
7588 return "DW_TAG_namelist";
7589 case DW_TAG_namelist_item
:
7590 return "DW_TAG_namelist_item";
7591 case DW_TAG_packed_type
:
7592 return "DW_TAG_packed_type";
7593 case DW_TAG_subprogram
:
7594 return "DW_TAG_subprogram";
7595 case DW_TAG_template_type_param
:
7596 return "DW_TAG_template_type_param";
7597 case DW_TAG_template_value_param
:
7598 return "DW_TAG_template_value_param";
7599 case DW_TAG_thrown_type
:
7600 return "DW_TAG_thrown_type";
7601 case DW_TAG_try_block
:
7602 return "DW_TAG_try_block";
7603 case DW_TAG_variant_part
:
7604 return "DW_TAG_variant_part";
7605 case DW_TAG_variable
:
7606 return "DW_TAG_variable";
7607 case DW_TAG_volatile_type
:
7608 return "DW_TAG_volatile_type";
7609 case DW_TAG_dwarf_procedure
:
7610 return "DW_TAG_dwarf_procedure";
7611 case DW_TAG_restrict_type
:
7612 return "DW_TAG_restrict_type";
7613 case DW_TAG_interface_type
:
7614 return "DW_TAG_interface_type";
7615 case DW_TAG_namespace
:
7616 return "DW_TAG_namespace";
7617 case DW_TAG_imported_module
:
7618 return "DW_TAG_imported_module";
7619 case DW_TAG_unspecified_type
:
7620 return "DW_TAG_unspecified_type";
7621 case DW_TAG_partial_unit
:
7622 return "DW_TAG_partial_unit";
7623 case DW_TAG_imported_unit
:
7624 return "DW_TAG_imported_unit";
7625 case DW_TAG_MIPS_loop
:
7626 return "DW_TAG_MIPS_loop";
7627 case DW_TAG_format_label
:
7628 return "DW_TAG_format_label";
7629 case DW_TAG_function_template
:
7630 return "DW_TAG_function_template";
7631 case DW_TAG_class_template
:
7632 return "DW_TAG_class_template";
7634 return "DW_TAG_<unknown>";
7638 /* Convert a DWARF attribute code into its string name. */
7641 dwarf_attr_name (unsigned attr
)
7646 return "DW_AT_sibling";
7647 case DW_AT_location
:
7648 return "DW_AT_location";
7650 return "DW_AT_name";
7651 case DW_AT_ordering
:
7652 return "DW_AT_ordering";
7653 case DW_AT_subscr_data
:
7654 return "DW_AT_subscr_data";
7655 case DW_AT_byte_size
:
7656 return "DW_AT_byte_size";
7657 case DW_AT_bit_offset
:
7658 return "DW_AT_bit_offset";
7659 case DW_AT_bit_size
:
7660 return "DW_AT_bit_size";
7661 case DW_AT_element_list
:
7662 return "DW_AT_element_list";
7663 case DW_AT_stmt_list
:
7664 return "DW_AT_stmt_list";
7666 return "DW_AT_low_pc";
7668 return "DW_AT_high_pc";
7669 case DW_AT_language
:
7670 return "DW_AT_language";
7672 return "DW_AT_member";
7674 return "DW_AT_discr";
7675 case DW_AT_discr_value
:
7676 return "DW_AT_discr_value";
7677 case DW_AT_visibility
:
7678 return "DW_AT_visibility";
7680 return "DW_AT_import";
7681 case DW_AT_string_length
:
7682 return "DW_AT_string_length";
7683 case DW_AT_common_reference
:
7684 return "DW_AT_common_reference";
7685 case DW_AT_comp_dir
:
7686 return "DW_AT_comp_dir";
7687 case DW_AT_const_value
:
7688 return "DW_AT_const_value";
7689 case DW_AT_containing_type
:
7690 return "DW_AT_containing_type";
7691 case DW_AT_default_value
:
7692 return "DW_AT_default_value";
7694 return "DW_AT_inline";
7695 case DW_AT_is_optional
:
7696 return "DW_AT_is_optional";
7697 case DW_AT_lower_bound
:
7698 return "DW_AT_lower_bound";
7699 case DW_AT_producer
:
7700 return "DW_AT_producer";
7701 case DW_AT_prototyped
:
7702 return "DW_AT_prototyped";
7703 case DW_AT_return_addr
:
7704 return "DW_AT_return_addr";
7705 case DW_AT_start_scope
:
7706 return "DW_AT_start_scope";
7707 case DW_AT_stride_size
:
7708 return "DW_AT_stride_size";
7709 case DW_AT_upper_bound
:
7710 return "DW_AT_upper_bound";
7711 case DW_AT_abstract_origin
:
7712 return "DW_AT_abstract_origin";
7713 case DW_AT_accessibility
:
7714 return "DW_AT_accessibility";
7715 case DW_AT_address_class
:
7716 return "DW_AT_address_class";
7717 case DW_AT_artificial
:
7718 return "DW_AT_artificial";
7719 case DW_AT_base_types
:
7720 return "DW_AT_base_types";
7721 case DW_AT_calling_convention
:
7722 return "DW_AT_calling_convention";
7724 return "DW_AT_count";
7725 case DW_AT_data_member_location
:
7726 return "DW_AT_data_member_location";
7727 case DW_AT_decl_column
:
7728 return "DW_AT_decl_column";
7729 case DW_AT_decl_file
:
7730 return "DW_AT_decl_file";
7731 case DW_AT_decl_line
:
7732 return "DW_AT_decl_line";
7733 case DW_AT_declaration
:
7734 return "DW_AT_declaration";
7735 case DW_AT_discr_list
:
7736 return "DW_AT_discr_list";
7737 case DW_AT_encoding
:
7738 return "DW_AT_encoding";
7739 case DW_AT_external
:
7740 return "DW_AT_external";
7741 case DW_AT_frame_base
:
7742 return "DW_AT_frame_base";
7744 return "DW_AT_friend";
7745 case DW_AT_identifier_case
:
7746 return "DW_AT_identifier_case";
7747 case DW_AT_macro_info
:
7748 return "DW_AT_macro_info";
7749 case DW_AT_namelist_items
:
7750 return "DW_AT_namelist_items";
7751 case DW_AT_priority
:
7752 return "DW_AT_priority";
7754 return "DW_AT_segment";
7755 case DW_AT_specification
:
7756 return "DW_AT_specification";
7757 case DW_AT_static_link
:
7758 return "DW_AT_static_link";
7760 return "DW_AT_type";
7761 case DW_AT_use_location
:
7762 return "DW_AT_use_location";
7763 case DW_AT_variable_parameter
:
7764 return "DW_AT_variable_parameter";
7765 case DW_AT_virtuality
:
7766 return "DW_AT_virtuality";
7767 case DW_AT_vtable_elem_location
:
7768 return "DW_AT_vtable_elem_location";
7769 case DW_AT_allocated
:
7770 return "DW_AT_allocated";
7771 case DW_AT_associated
:
7772 return "DW_AT_associated";
7773 case DW_AT_data_location
:
7774 return "DW_AT_data_location";
7776 return "DW_AT_stride";
7777 case DW_AT_entry_pc
:
7778 return "DW_AT_entry_pc";
7779 case DW_AT_use_UTF8
:
7780 return "DW_AT_use_UTF8";
7781 case DW_AT_extension
:
7782 return "DW_AT_extension";
7784 return "DW_AT_ranges";
7785 case DW_AT_trampoline
:
7786 return "DW_AT_trampoline";
7787 case DW_AT_call_column
:
7788 return "DW_AT_call_column";
7789 case DW_AT_call_file
:
7790 return "DW_AT_call_file";
7791 case DW_AT_call_line
:
7792 return "DW_AT_call_line";
7794 case DW_AT_MIPS_fde
:
7795 return "DW_AT_MIPS_fde";
7796 case DW_AT_MIPS_loop_begin
:
7797 return "DW_AT_MIPS_loop_begin";
7798 case DW_AT_MIPS_tail_loop_begin
:
7799 return "DW_AT_MIPS_tail_loop_begin";
7800 case DW_AT_MIPS_epilog_begin
:
7801 return "DW_AT_MIPS_epilog_begin";
7802 case DW_AT_MIPS_loop_unroll_factor
:
7803 return "DW_AT_MIPS_loop_unroll_factor";
7804 case DW_AT_MIPS_software_pipeline_depth
:
7805 return "DW_AT_MIPS_software_pipeline_depth";
7807 case DW_AT_MIPS_linkage_name
:
7808 return "DW_AT_MIPS_linkage_name";
7810 case DW_AT_sf_names
:
7811 return "DW_AT_sf_names";
7812 case DW_AT_src_info
:
7813 return "DW_AT_src_info";
7814 case DW_AT_mac_info
:
7815 return "DW_AT_mac_info";
7816 case DW_AT_src_coords
:
7817 return "DW_AT_src_coords";
7818 case DW_AT_body_begin
:
7819 return "DW_AT_body_begin";
7820 case DW_AT_body_end
:
7821 return "DW_AT_body_end";
7822 case DW_AT_GNU_vector
:
7823 return "DW_AT_GNU_vector";
7825 return "DW_AT_<unknown>";
7829 /* Convert a DWARF value form code into its string name. */
7832 dwarf_form_name (unsigned form
)
7837 return "DW_FORM_addr";
7838 case DW_FORM_block2
:
7839 return "DW_FORM_block2";
7840 case DW_FORM_block4
:
7841 return "DW_FORM_block4";
7843 return "DW_FORM_data2";
7845 return "DW_FORM_data4";
7847 return "DW_FORM_data8";
7848 case DW_FORM_string
:
7849 return "DW_FORM_string";
7851 return "DW_FORM_block";
7852 case DW_FORM_block1
:
7853 return "DW_FORM_block1";
7855 return "DW_FORM_data1";
7857 return "DW_FORM_flag";
7859 return "DW_FORM_sdata";
7861 return "DW_FORM_strp";
7863 return "DW_FORM_udata";
7864 case DW_FORM_ref_addr
:
7865 return "DW_FORM_ref_addr";
7867 return "DW_FORM_ref1";
7869 return "DW_FORM_ref2";
7871 return "DW_FORM_ref4";
7873 return "DW_FORM_ref8";
7874 case DW_FORM_ref_udata
:
7875 return "DW_FORM_ref_udata";
7876 case DW_FORM_indirect
:
7877 return "DW_FORM_indirect";
7879 return "DW_FORM_<unknown>";
7883 /* Convert a DWARF stack opcode into its string name. */
7886 dwarf_stack_op_name (unsigned op
)
7891 return "DW_OP_addr";
7893 return "DW_OP_deref";
7895 return "DW_OP_const1u";
7897 return "DW_OP_const1s";
7899 return "DW_OP_const2u";
7901 return "DW_OP_const2s";
7903 return "DW_OP_const4u";
7905 return "DW_OP_const4s";
7907 return "DW_OP_const8u";
7909 return "DW_OP_const8s";
7911 return "DW_OP_constu";
7913 return "DW_OP_consts";
7917 return "DW_OP_drop";
7919 return "DW_OP_over";
7921 return "DW_OP_pick";
7923 return "DW_OP_swap";
7927 return "DW_OP_xderef";
7935 return "DW_OP_minus";
7947 return "DW_OP_plus";
7948 case DW_OP_plus_uconst
:
7949 return "DW_OP_plus_uconst";
7955 return "DW_OP_shra";
7973 return "DW_OP_skip";
7975 return "DW_OP_lit0";
7977 return "DW_OP_lit1";
7979 return "DW_OP_lit2";
7981 return "DW_OP_lit3";
7983 return "DW_OP_lit4";
7985 return "DW_OP_lit5";
7987 return "DW_OP_lit6";
7989 return "DW_OP_lit7";
7991 return "DW_OP_lit8";
7993 return "DW_OP_lit9";
7995 return "DW_OP_lit10";
7997 return "DW_OP_lit11";
7999 return "DW_OP_lit12";
8001 return "DW_OP_lit13";
8003 return "DW_OP_lit14";
8005 return "DW_OP_lit15";
8007 return "DW_OP_lit16";
8009 return "DW_OP_lit17";
8011 return "DW_OP_lit18";
8013 return "DW_OP_lit19";
8015 return "DW_OP_lit20";
8017 return "DW_OP_lit21";
8019 return "DW_OP_lit22";
8021 return "DW_OP_lit23";
8023 return "DW_OP_lit24";
8025 return "DW_OP_lit25";
8027 return "DW_OP_lit26";
8029 return "DW_OP_lit27";
8031 return "DW_OP_lit28";
8033 return "DW_OP_lit29";
8035 return "DW_OP_lit30";
8037 return "DW_OP_lit31";
8039 return "DW_OP_reg0";
8041 return "DW_OP_reg1";
8043 return "DW_OP_reg2";
8045 return "DW_OP_reg3";
8047 return "DW_OP_reg4";
8049 return "DW_OP_reg5";
8051 return "DW_OP_reg6";
8053 return "DW_OP_reg7";
8055 return "DW_OP_reg8";
8057 return "DW_OP_reg9";
8059 return "DW_OP_reg10";
8061 return "DW_OP_reg11";
8063 return "DW_OP_reg12";
8065 return "DW_OP_reg13";
8067 return "DW_OP_reg14";
8069 return "DW_OP_reg15";
8071 return "DW_OP_reg16";
8073 return "DW_OP_reg17";
8075 return "DW_OP_reg18";
8077 return "DW_OP_reg19";
8079 return "DW_OP_reg20";
8081 return "DW_OP_reg21";
8083 return "DW_OP_reg22";
8085 return "DW_OP_reg23";
8087 return "DW_OP_reg24";
8089 return "DW_OP_reg25";
8091 return "DW_OP_reg26";
8093 return "DW_OP_reg27";
8095 return "DW_OP_reg28";
8097 return "DW_OP_reg29";
8099 return "DW_OP_reg30";
8101 return "DW_OP_reg31";
8103 return "DW_OP_breg0";
8105 return "DW_OP_breg1";
8107 return "DW_OP_breg2";
8109 return "DW_OP_breg3";
8111 return "DW_OP_breg4";
8113 return "DW_OP_breg5";
8115 return "DW_OP_breg6";
8117 return "DW_OP_breg7";
8119 return "DW_OP_breg8";
8121 return "DW_OP_breg9";
8123 return "DW_OP_breg10";
8125 return "DW_OP_breg11";
8127 return "DW_OP_breg12";
8129 return "DW_OP_breg13";
8131 return "DW_OP_breg14";
8133 return "DW_OP_breg15";
8135 return "DW_OP_breg16";
8137 return "DW_OP_breg17";
8139 return "DW_OP_breg18";
8141 return "DW_OP_breg19";
8143 return "DW_OP_breg20";
8145 return "DW_OP_breg21";
8147 return "DW_OP_breg22";
8149 return "DW_OP_breg23";
8151 return "DW_OP_breg24";
8153 return "DW_OP_breg25";
8155 return "DW_OP_breg26";
8157 return "DW_OP_breg27";
8159 return "DW_OP_breg28";
8161 return "DW_OP_breg29";
8163 return "DW_OP_breg30";
8165 return "DW_OP_breg31";
8167 return "DW_OP_regx";
8169 return "DW_OP_fbreg";
8171 return "DW_OP_bregx";
8173 return "DW_OP_piece";
8174 case DW_OP_deref_size
:
8175 return "DW_OP_deref_size";
8176 case DW_OP_xderef_size
:
8177 return "DW_OP_xderef_size";
8180 /* DWARF 3 extensions. */
8181 case DW_OP_push_object_address
:
8182 return "DW_OP_push_object_address";
8184 return "DW_OP_call2";
8186 return "DW_OP_call4";
8187 case DW_OP_call_ref
:
8188 return "DW_OP_call_ref";
8189 /* GNU extensions. */
8190 case DW_OP_GNU_push_tls_address
:
8191 return "DW_OP_GNU_push_tls_address";
8193 return "OP_<unknown>";
8198 dwarf_bool_name (unsigned mybool
)
8206 /* Convert a DWARF type code into its string name. */
8209 dwarf_type_encoding_name (unsigned enc
)
8213 case DW_ATE_address
:
8214 return "DW_ATE_address";
8215 case DW_ATE_boolean
:
8216 return "DW_ATE_boolean";
8217 case DW_ATE_complex_float
:
8218 return "DW_ATE_complex_float";
8220 return "DW_ATE_float";
8222 return "DW_ATE_signed";
8223 case DW_ATE_signed_char
:
8224 return "DW_ATE_signed_char";
8225 case DW_ATE_unsigned
:
8226 return "DW_ATE_unsigned";
8227 case DW_ATE_unsigned_char
:
8228 return "DW_ATE_unsigned_char";
8229 case DW_ATE_imaginary_float
:
8230 return "DW_ATE_imaginary_float";
8232 return "DW_ATE_<unknown>";
8236 /* Convert a DWARF call frame info operation to its string name. */
8240 dwarf_cfi_name (unsigned cfi_opc
)
8244 case DW_CFA_advance_loc
:
8245 return "DW_CFA_advance_loc";
8247 return "DW_CFA_offset";
8248 case DW_CFA_restore
:
8249 return "DW_CFA_restore";
8251 return "DW_CFA_nop";
8252 case DW_CFA_set_loc
:
8253 return "DW_CFA_set_loc";
8254 case DW_CFA_advance_loc1
:
8255 return "DW_CFA_advance_loc1";
8256 case DW_CFA_advance_loc2
:
8257 return "DW_CFA_advance_loc2";
8258 case DW_CFA_advance_loc4
:
8259 return "DW_CFA_advance_loc4";
8260 case DW_CFA_offset_extended
:
8261 return "DW_CFA_offset_extended";
8262 case DW_CFA_restore_extended
:
8263 return "DW_CFA_restore_extended";
8264 case DW_CFA_undefined
:
8265 return "DW_CFA_undefined";
8266 case DW_CFA_same_value
:
8267 return "DW_CFA_same_value";
8268 case DW_CFA_register
:
8269 return "DW_CFA_register";
8270 case DW_CFA_remember_state
:
8271 return "DW_CFA_remember_state";
8272 case DW_CFA_restore_state
:
8273 return "DW_CFA_restore_state";
8274 case DW_CFA_def_cfa
:
8275 return "DW_CFA_def_cfa";
8276 case DW_CFA_def_cfa_register
:
8277 return "DW_CFA_def_cfa_register";
8278 case DW_CFA_def_cfa_offset
:
8279 return "DW_CFA_def_cfa_offset";
8282 case DW_CFA_def_cfa_expression
:
8283 return "DW_CFA_def_cfa_expression";
8284 case DW_CFA_expression
:
8285 return "DW_CFA_expression";
8286 case DW_CFA_offset_extended_sf
:
8287 return "DW_CFA_offset_extended_sf";
8288 case DW_CFA_def_cfa_sf
:
8289 return "DW_CFA_def_cfa_sf";
8290 case DW_CFA_def_cfa_offset_sf
:
8291 return "DW_CFA_def_cfa_offset_sf";
8293 /* SGI/MIPS specific */
8294 case DW_CFA_MIPS_advance_loc8
:
8295 return "DW_CFA_MIPS_advance_loc8";
8297 /* GNU extensions */
8298 case DW_CFA_GNU_window_save
:
8299 return "DW_CFA_GNU_window_save";
8300 case DW_CFA_GNU_args_size
:
8301 return "DW_CFA_GNU_args_size";
8302 case DW_CFA_GNU_negative_offset_extended
:
8303 return "DW_CFA_GNU_negative_offset_extended";
8306 return "DW_CFA_<unknown>";
8312 dump_die (struct die_info
*die
)
8316 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8317 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8318 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8319 dwarf_bool_name (die
->child
!= NULL
));
8321 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8322 for (i
= 0; i
< die
->num_attrs
; ++i
)
8324 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8325 dwarf_attr_name (die
->attrs
[i
].name
),
8326 dwarf_form_name (die
->attrs
[i
].form
));
8327 switch (die
->attrs
[i
].form
)
8329 case DW_FORM_ref_addr
:
8331 fprintf_unfiltered (gdb_stderr
, "address: ");
8332 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8334 case DW_FORM_block2
:
8335 case DW_FORM_block4
:
8337 case DW_FORM_block1
:
8338 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8343 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8344 (long) (DW_ADDR (&die
->attrs
[i
])));
8352 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8354 case DW_FORM_string
:
8356 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8357 DW_STRING (&die
->attrs
[i
])
8358 ? DW_STRING (&die
->attrs
[i
]) : "");
8361 if (DW_UNSND (&die
->attrs
[i
]))
8362 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8364 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8366 case DW_FORM_indirect
:
8367 /* the reader will have reduced the indirect form to
8368 the "base form" so this form should not occur */
8369 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8372 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8373 die
->attrs
[i
].form
);
8375 fprintf_unfiltered (gdb_stderr
, "\n");
8380 dump_die_list (struct die_info
*die
)
8385 if (die
->child
!= NULL
)
8386 dump_die_list (die
->child
);
8387 if (die
->sibling
!= NULL
)
8388 dump_die_list (die
->sibling
);
8393 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8394 struct dwarf2_cu
*cu
)
8397 struct die_info
*old
;
8399 h
= (offset
% REF_HASH_SIZE
);
8400 old
= cu
->die_ref_table
[h
];
8401 die
->next_ref
= old
;
8402 cu
->die_ref_table
[h
] = die
;
8406 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8408 unsigned int result
= 0;
8412 case DW_FORM_ref_addr
:
8417 case DW_FORM_ref_udata
:
8418 result
= DW_ADDR (attr
);
8421 complaint (&symfile_complaints
,
8422 "unsupported die ref attribute form: '%s'",
8423 dwarf_form_name (attr
->form
));
8428 /* Return the constant value held by the given attribute. Return -1
8429 if the value held by the attribute is not constant. */
8432 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8434 if (attr
->form
== DW_FORM_sdata
)
8435 return DW_SND (attr
);
8436 else if (attr
->form
== DW_FORM_udata
8437 || attr
->form
== DW_FORM_data1
8438 || attr
->form
== DW_FORM_data2
8439 || attr
->form
== DW_FORM_data4
8440 || attr
->form
== DW_FORM_data8
)
8441 return DW_UNSND (attr
);
8444 complaint (&symfile_complaints
, "Attribute value is not a constant (%s)",
8445 dwarf_form_name (attr
->form
));
8446 return default_value
;
8450 static struct die_info
*
8451 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8452 struct dwarf2_cu
*cu
)
8454 struct die_info
*die
;
8455 unsigned int offset
;
8457 struct die_info temp_die
;
8458 struct dwarf2_cu
*target_cu
;
8460 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8462 if (DW_ADDR (attr
) < cu
->header
.offset
8463 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8465 struct dwarf2_per_cu_data
*per_cu
;
8466 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8468 target_cu
= per_cu
->cu
;
8473 h
= (offset
% REF_HASH_SIZE
);
8474 die
= target_cu
->die_ref_table
[h
];
8477 if (die
->offset
== offset
)
8479 die
= die
->next_ref
;
8482 error ("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8483 "at 0x%lx [in module %s]",
8484 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8489 static struct type
*
8490 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8491 struct dwarf2_cu
*cu
)
8493 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8495 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
8496 typeid, objfile
->name
);
8499 /* Look for this particular type in the fundamental type vector. If
8500 one is not found, create and install one appropriate for the
8501 current language and the current target machine. */
8503 if (cu
->ftypes
[typeid] == NULL
)
8505 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8508 return (cu
->ftypes
[typeid]);
8511 /* Decode simple location descriptions.
8512 Given a pointer to a dwarf block that defines a location, compute
8513 the location and return the value.
8515 NOTE drow/2003-11-18: This function is called in two situations
8516 now: for the address of static or global variables (partial symbols
8517 only) and for offsets into structures which are expected to be
8518 (more or less) constant. The partial symbol case should go away,
8519 and only the constant case should remain. That will let this
8520 function complain more accurately. A few special modes are allowed
8521 without complaint for global variables (for instance, global
8522 register values and thread-local values).
8524 A location description containing no operations indicates that the
8525 object is optimized out. The return value is 0 for that case.
8526 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8527 callers will only want a very basic result and this can become a
8530 When the result is a register number, the global isreg flag is set,
8531 otherwise it is cleared.
8533 Note that stack[0] is unused except as a default error return.
8534 Note that stack overflow is not yet handled. */
8537 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8539 struct objfile
*objfile
= cu
->objfile
;
8540 struct comp_unit_head
*cu_header
= &cu
->header
;
8542 int size
= blk
->size
;
8543 char *data
= blk
->data
;
8544 CORE_ADDR stack
[64];
8546 unsigned int bytes_read
, unsnd
;
8591 stack
[++stacki
] = op
- DW_OP_lit0
;
8627 stack
[++stacki
] = op
- DW_OP_reg0
;
8629 dwarf2_complex_location_expr_complaint ();
8634 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8636 stack
[++stacki
] = unsnd
;
8638 dwarf2_complex_location_expr_complaint ();
8642 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8648 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8653 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8658 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8663 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8668 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8673 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8678 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8684 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8689 stack
[stacki
+ 1] = stack
[stacki
];
8694 stack
[stacki
- 1] += stack
[stacki
];
8698 case DW_OP_plus_uconst
:
8699 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8704 stack
[stacki
- 1] -= stack
[stacki
];
8709 /* If we're not the last op, then we definitely can't encode
8710 this using GDB's address_class enum. This is valid for partial
8711 global symbols, although the variable's address will be bogus
8714 dwarf2_complex_location_expr_complaint ();
8717 case DW_OP_GNU_push_tls_address
:
8718 /* The top of the stack has the offset from the beginning
8719 of the thread control block at which the variable is located. */
8720 /* Nothing should follow this operator, so the top of stack would
8722 /* This is valid for partial global symbols, but the variable's
8723 address will be bogus in the psymtab. */
8725 dwarf2_complex_location_expr_complaint ();
8729 complaint (&symfile_complaints
, "unsupported stack op: '%s'",
8730 dwarf_stack_op_name (op
));
8731 return (stack
[stacki
]);
8734 return (stack
[stacki
]);
8737 /* memory allocation interface */
8739 static struct dwarf_block
*
8740 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8742 struct dwarf_block
*blk
;
8744 blk
= (struct dwarf_block
*)
8745 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8749 static struct abbrev_info
*
8750 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8752 struct abbrev_info
*abbrev
;
8754 abbrev
= (struct abbrev_info
*)
8755 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8756 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8760 static struct die_info
*
8761 dwarf_alloc_die (void)
8763 struct die_info
*die
;
8765 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8766 memset (die
, 0, sizeof (struct die_info
));
8771 /* Macro support. */
8774 /* Return the full name of file number I in *LH's file name table.
8775 Use COMP_DIR as the name of the current directory of the
8776 compilation. The result is allocated using xmalloc; the caller is
8777 responsible for freeing it. */
8779 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8781 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8783 if (IS_ABSOLUTE_PATH (fe
->name
))
8784 return xstrdup (fe
->name
);
8792 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8798 dir_len
= strlen (dir
);
8799 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8800 strcpy (full_name
, dir
);
8801 full_name
[dir_len
] = '/';
8802 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8806 return xstrdup (fe
->name
);
8811 static struct macro_source_file
*
8812 macro_start_file (int file
, int line
,
8813 struct macro_source_file
*current_file
,
8814 const char *comp_dir
,
8815 struct line_header
*lh
, struct objfile
*objfile
)
8817 /* The full name of this source file. */
8818 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8820 /* We don't create a macro table for this compilation unit
8821 at all until we actually get a filename. */
8822 if (! pending_macros
)
8823 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8824 objfile
->macro_cache
);
8827 /* If we have no current file, then this must be the start_file
8828 directive for the compilation unit's main source file. */
8829 current_file
= macro_set_main (pending_macros
, full_name
);
8831 current_file
= macro_include (current_file
, line
, full_name
);
8835 return current_file
;
8839 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8840 followed by a null byte. */
8842 copy_string (const char *buf
, int len
)
8844 char *s
= xmalloc (len
+ 1);
8845 memcpy (s
, buf
, len
);
8853 consume_improper_spaces (const char *p
, const char *body
)
8857 complaint (&symfile_complaints
,
8858 "macro definition contains spaces in formal argument list:\n`%s'",
8870 parse_macro_definition (struct macro_source_file
*file
, int line
,
8875 /* The body string takes one of two forms. For object-like macro
8876 definitions, it should be:
8878 <macro name> " " <definition>
8880 For function-like macro definitions, it should be:
8882 <macro name> "() " <definition>
8884 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8886 Spaces may appear only where explicitly indicated, and in the
8889 The Dwarf 2 spec says that an object-like macro's name is always
8890 followed by a space, but versions of GCC around March 2002 omit
8891 the space when the macro's definition is the empty string.
8893 The Dwarf 2 spec says that there should be no spaces between the
8894 formal arguments in a function-like macro's formal argument list,
8895 but versions of GCC around March 2002 include spaces after the
8899 /* Find the extent of the macro name. The macro name is terminated
8900 by either a space or null character (for an object-like macro) or
8901 an opening paren (for a function-like macro). */
8902 for (p
= body
; *p
; p
++)
8903 if (*p
== ' ' || *p
== '(')
8906 if (*p
== ' ' || *p
== '\0')
8908 /* It's an object-like macro. */
8909 int name_len
= p
- body
;
8910 char *name
= copy_string (body
, name_len
);
8911 const char *replacement
;
8914 replacement
= body
+ name_len
+ 1;
8917 dwarf2_macro_malformed_definition_complaint (body
);
8918 replacement
= body
+ name_len
;
8921 macro_define_object (file
, line
, name
, replacement
);
8927 /* It's a function-like macro. */
8928 char *name
= copy_string (body
, p
- body
);
8931 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
8935 p
= consume_improper_spaces (p
, body
);
8937 /* Parse the formal argument list. */
8938 while (*p
&& *p
!= ')')
8940 /* Find the extent of the current argument name. */
8941 const char *arg_start
= p
;
8943 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
8946 if (! *p
|| p
== arg_start
)
8947 dwarf2_macro_malformed_definition_complaint (body
);
8950 /* Make sure argv has room for the new argument. */
8951 if (argc
>= argv_size
)
8954 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
8957 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
8960 p
= consume_improper_spaces (p
, body
);
8962 /* Consume the comma, if present. */
8967 p
= consume_improper_spaces (p
, body
);
8976 /* Perfectly formed definition, no complaints. */
8977 macro_define_function (file
, line
, name
,
8978 argc
, (const char **) argv
,
8980 else if (*p
== '\0')
8982 /* Complain, but do define it. */
8983 dwarf2_macro_malformed_definition_complaint (body
);
8984 macro_define_function (file
, line
, name
,
8985 argc
, (const char **) argv
,
8989 /* Just complain. */
8990 dwarf2_macro_malformed_definition_complaint (body
);
8993 /* Just complain. */
8994 dwarf2_macro_malformed_definition_complaint (body
);
9000 for (i
= 0; i
< argc
; i
++)
9006 dwarf2_macro_malformed_definition_complaint (body
);
9011 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9012 char *comp_dir
, bfd
*abfd
,
9013 struct dwarf2_cu
*cu
)
9015 char *mac_ptr
, *mac_end
;
9016 struct macro_source_file
*current_file
= 0;
9018 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9020 complaint (&symfile_complaints
, "missing .debug_macinfo section");
9024 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9025 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9026 + dwarf2_per_objfile
->macinfo_size
;
9030 enum dwarf_macinfo_record_type macinfo_type
;
9032 /* Do we at least have room for a macinfo type byte? */
9033 if (mac_ptr
>= mac_end
)
9035 dwarf2_macros_too_long_complaint ();
9039 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9042 switch (macinfo_type
)
9044 /* A zero macinfo type indicates the end of the macro
9049 case DW_MACINFO_define
:
9050 case DW_MACINFO_undef
:
9056 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9057 mac_ptr
+= bytes_read
;
9058 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9059 mac_ptr
+= bytes_read
;
9062 complaint (&symfile_complaints
,
9063 "debug info gives macro %s outside of any file: %s",
9065 DW_MACINFO_define
? "definition" : macinfo_type
==
9066 DW_MACINFO_undef
? "undefinition" :
9067 "something-or-other", body
);
9070 if (macinfo_type
== DW_MACINFO_define
)
9071 parse_macro_definition (current_file
, line
, body
);
9072 else if (macinfo_type
== DW_MACINFO_undef
)
9073 macro_undef (current_file
, line
, body
);
9078 case DW_MACINFO_start_file
:
9083 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9084 mac_ptr
+= bytes_read
;
9085 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9086 mac_ptr
+= bytes_read
;
9088 current_file
= macro_start_file (file
, line
,
9089 current_file
, comp_dir
,
9094 case DW_MACINFO_end_file
:
9096 complaint (&symfile_complaints
,
9097 "macro debug info has an unmatched `close_file' directive");
9100 current_file
= current_file
->included_by
;
9103 enum dwarf_macinfo_record_type next_type
;
9105 /* GCC circa March 2002 doesn't produce the zero
9106 type byte marking the end of the compilation
9107 unit. Complain if it's not there, but exit no
9110 /* Do we at least have room for a macinfo type byte? */
9111 if (mac_ptr
>= mac_end
)
9113 dwarf2_macros_too_long_complaint ();
9117 /* We don't increment mac_ptr here, so this is just
9119 next_type
= read_1_byte (abfd
, mac_ptr
);
9121 complaint (&symfile_complaints
,
9122 "no terminating 0-type entry for macros in `.debug_macinfo' section");
9129 case DW_MACINFO_vendor_ext
:
9135 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9136 mac_ptr
+= bytes_read
;
9137 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9138 mac_ptr
+= bytes_read
;
9140 /* We don't recognize any vendor extensions. */
9147 /* Check if the attribute's form is a DW_FORM_block*
9148 if so return true else false. */
9150 attr_form_is_block (struct attribute
*attr
)
9152 return (attr
== NULL
? 0 :
9153 attr
->form
== DW_FORM_block1
9154 || attr
->form
== DW_FORM_block2
9155 || attr
->form
== DW_FORM_block4
9156 || attr
->form
== DW_FORM_block
);
9160 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9161 struct dwarf2_cu
*cu
)
9163 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9165 struct dwarf2_loclist_baton
*baton
;
9167 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9168 sizeof (struct dwarf2_loclist_baton
));
9169 baton
->objfile
= cu
->objfile
;
9171 /* We don't know how long the location list is, but make sure we
9172 don't run off the edge of the section. */
9173 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9174 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9175 baton
->base_address
= cu
->header
.base_address
;
9176 if (cu
->header
.base_known
== 0)
9177 complaint (&symfile_complaints
,
9178 "Location list used without specifying the CU base address.");
9180 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9181 SYMBOL_LOCATION_BATON (sym
) = baton
;
9185 struct dwarf2_locexpr_baton
*baton
;
9187 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9188 sizeof (struct dwarf2_locexpr_baton
));
9189 baton
->objfile
= cu
->objfile
;
9191 if (attr_form_is_block (attr
))
9193 /* Note that we're just copying the block's data pointer
9194 here, not the actual data. We're still pointing into the
9195 info_buffer for SYM's objfile; right now we never release
9196 that buffer, but when we do clean up properly this may
9198 baton
->size
= DW_BLOCK (attr
)->size
;
9199 baton
->data
= DW_BLOCK (attr
)->data
;
9203 dwarf2_invalid_attrib_class_complaint ("location description",
9204 SYMBOL_NATURAL_NAME (sym
));
9209 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9210 SYMBOL_LOCATION_BATON (sym
) = baton
;
9214 /* Locate the compilation unit from CU's objfile which contains the
9215 DIE at OFFSET. Raises an error on failure. */
9217 static struct dwarf2_per_cu_data
*
9218 dwarf2_find_containing_comp_unit (unsigned long offset
,
9219 struct objfile
*objfile
)
9221 struct dwarf2_per_cu_data
*this_cu
;
9225 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9228 int mid
= low
+ (high
- low
) / 2;
9229 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9234 gdb_assert (low
== high
);
9235 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9238 error ("Dwarf Error: could not find partial DIE containing "
9239 "offset 0x%lx [in module %s]",
9240 (long) offset
, bfd_get_filename (objfile
->obfd
));
9242 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9243 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9247 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9248 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9249 && offset
>= this_cu
->offset
+ this_cu
->length
)
9250 error ("invalid dwarf2 offset %ld", offset
);
9251 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9256 /* Locate the compilation unit from OBJFILE which is located at exactly
9257 OFFSET. Raises an error on failure. */
9259 static struct dwarf2_per_cu_data
*
9260 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9262 struct dwarf2_per_cu_data
*this_cu
;
9263 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9264 if (this_cu
->offset
!= offset
)
9265 error ("no compilation unit with offset %ld\n", offset
);
9269 /* Release one cached compilation unit, CU. We unlink it from the tree
9270 of compilation units, but we don't remove it from the read_in_chain;
9271 the caller is responsible for that. */
9274 free_one_comp_unit (void *data
)
9276 struct dwarf2_cu
*cu
= data
;
9278 if (cu
->per_cu
!= NULL
)
9279 cu
->per_cu
->cu
= NULL
;
9282 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9284 free_die_list (cu
->dies
);
9289 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9290 when we're finished with it. We can't free the pointer itself, but be
9291 sure to unlink it from the cache. Also release any associated storage
9292 and perform cache maintenance.
9294 Only used during partial symbol parsing. */
9297 free_stack_comp_unit (void *data
)
9299 struct dwarf2_cu
*cu
= data
;
9301 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9302 cu
->partial_dies
= NULL
;
9304 if (cu
->per_cu
!= NULL
)
9306 /* This compilation unit is on the stack in our caller, so we
9307 should not xfree it. Just unlink it. */
9308 cu
->per_cu
->cu
= NULL
;
9311 /* If we had a per-cu pointer, then we may have other compilation
9312 units loaded, so age them now. */
9313 age_cached_comp_units ();
9317 /* Free all cached compilation units. */
9320 free_cached_comp_units (void *data
)
9322 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9324 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9325 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9326 while (per_cu
!= NULL
)
9328 struct dwarf2_per_cu_data
*next_cu
;
9330 next_cu
= per_cu
->cu
->read_in_chain
;
9332 free_one_comp_unit (per_cu
->cu
);
9333 *last_chain
= next_cu
;
9339 /* Increase the age counter on each cached compilation unit, and free
9340 any that are too old. */
9343 age_cached_comp_units (void)
9345 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9347 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9348 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9349 while (per_cu
!= NULL
)
9351 per_cu
->cu
->last_used
++;
9352 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9353 dwarf2_mark (per_cu
->cu
);
9354 per_cu
= per_cu
->cu
->read_in_chain
;
9357 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9358 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9359 while (per_cu
!= NULL
)
9361 struct dwarf2_per_cu_data
*next_cu
;
9363 next_cu
= per_cu
->cu
->read_in_chain
;
9365 if (!per_cu
->cu
->mark
)
9367 free_one_comp_unit (per_cu
->cu
);
9368 *last_chain
= next_cu
;
9371 last_chain
= &per_cu
->cu
->read_in_chain
;
9377 /* Remove a single compilation unit from the cache. */
9380 free_one_cached_comp_unit (void *target_cu
)
9382 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9384 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9385 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9386 while (per_cu
!= NULL
)
9388 struct dwarf2_per_cu_data
*next_cu
;
9390 next_cu
= per_cu
->cu
->read_in_chain
;
9392 if (per_cu
->cu
== target_cu
)
9394 free_one_comp_unit (per_cu
->cu
);
9395 *last_chain
= next_cu
;
9399 last_chain
= &per_cu
->cu
->read_in_chain
;
9405 /* A pair of DIE offset and GDB type pointer. We store these
9406 in a hash table separate from the DIEs, and preserve them
9407 when the DIEs are flushed out of cache. */
9409 struct dwarf2_offset_and_type
9411 unsigned int offset
;
9415 /* Hash function for a dwarf2_offset_and_type. */
9418 offset_and_type_hash (const void *item
)
9420 const struct dwarf2_offset_and_type
*ofs
= item
;
9424 /* Equality function for a dwarf2_offset_and_type. */
9427 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9429 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9430 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9431 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9434 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9435 table if necessary. */
9438 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9440 struct dwarf2_offset_and_type
**slot
, ofs
;
9444 if (cu
->per_cu
== NULL
)
9447 if (cu
->per_cu
->type_hash
== NULL
)
9448 cu
->per_cu
->type_hash
9449 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9450 offset_and_type_hash
,
9453 &cu
->objfile
->objfile_obstack
,
9454 hashtab_obstack_allocate
,
9455 dummy_obstack_deallocate
);
9457 ofs
.offset
= die
->offset
;
9459 slot
= (struct dwarf2_offset_and_type
**)
9460 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9461 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9465 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9466 have a saved type. */
9468 static struct type
*
9469 get_die_type (struct die_info
*die
, htab_t type_hash
)
9471 struct dwarf2_offset_and_type
*slot
, ofs
;
9473 ofs
.offset
= die
->offset
;
9474 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9481 /* Restore the types of the DIE tree starting at START_DIE from the hash
9482 table saved in CU. */
9485 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9487 struct die_info
*die
;
9489 if (cu
->per_cu
->type_hash
== NULL
)
9492 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9494 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9495 if (die
->child
!= NULL
)
9496 reset_die_and_siblings_types (die
->child
, cu
);
9500 /* Set the mark field in CU and in every other compilation unit in the
9501 cache that we must keep because we are keeping CU. */
9503 /* Add a dependence relationship from CU to REF_PER_CU. */
9506 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9507 struct dwarf2_per_cu_data
*ref_per_cu
)
9511 if (cu
->dependencies
== NULL
)
9513 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9514 NULL
, &cu
->comp_unit_obstack
,
9515 hashtab_obstack_allocate
,
9516 dummy_obstack_deallocate
);
9518 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9523 /* Set the mark field in CU and in every other compilation unit in the
9524 cache that we must keep because we are keeping CU. */
9527 dwarf2_mark_helper (void **slot
, void *data
)
9529 struct dwarf2_per_cu_data
*per_cu
;
9531 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9532 if (per_cu
->cu
->mark
)
9534 per_cu
->cu
->mark
= 1;
9536 if (per_cu
->cu
->dependencies
!= NULL
)
9537 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9543 dwarf2_mark (struct dwarf2_cu
*cu
)
9548 if (cu
->dependencies
!= NULL
)
9549 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9553 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9557 per_cu
->cu
->mark
= 0;
9558 per_cu
= per_cu
->cu
->read_in_chain
;
9562 /* Allocation function for the libiberty hash table which uses an
9566 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
9568 unsigned int total
= size
* count
;
9569 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
9570 memset (ptr
, 0, total
);
9574 /* Trivial deallocation function for the libiberty splay tree and hash
9575 table - don't deallocate anything. Rely on later deletion of the
9579 dummy_obstack_deallocate (void *object
, void *data
)
9584 /* Trivial hash function for partial_die_info: the hash value of a DIE
9585 is its offset in .debug_info for this objfile. */
9588 partial_die_hash (const void *item
)
9590 const struct partial_die_info
*part_die
= item
;
9591 return part_die
->offset
;
9594 /* Trivial comparison function for partial_die_info structures: two DIEs
9595 are equal if they have the same offset. */
9598 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9600 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9601 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9602 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9605 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9606 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9609 set_dwarf2_cmd (char *args
, int from_tty
)
9611 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9615 show_dwarf2_cmd (char *args
, int from_tty
)
9617 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9620 void _initialize_dwarf2_read (void);
9623 _initialize_dwarf2_read (void)
9625 dwarf2_objfile_data_key
= register_objfile_data ();
9627 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
,
9628 "Set DWARF 2 specific variables.\n"
9629 "Configure DWARF 2 variables such as the cache size",
9630 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9631 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9633 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
,
9634 "Show DWARF 2 specific variables\n"
9635 "Show DWARF 2 variables such as the cache size",
9636 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9637 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9639 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9640 &dwarf2_max_cache_age
,
9641 "Set the upper bound on the age of cached "
9642 "dwarf2 compilation units.",
9643 "Show the upper bound on the age of cached "
9644 "dwarf2 compilation units.",
9645 "A higher limit means that cached "
9646 "compilation units will be stored\n"
9647 "in memory longer, and more total memory will "
9648 "be used. Zero disables\n"
9649 "caching, which can slow down startup.",
9650 "The upper bound on the age of cached "
9651 "dwarf2 compilation units is %d.",
9652 NULL
, NULL
, &set_dwarf2_cmdlist
,
9653 &show_dwarf2_cmdlist
);