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"
50 #include "gdb_string.h"
51 #include "gdb_assert.h"
52 #include <sys/types.h>
54 /* A note on memory usage for this file.
56 At the present time, this code reads the debug info sections into
57 the objfile's objfile_obstack. A definite improvement for startup
58 time, on platforms which do not emit relocations for debug
59 sections, would be to use mmap instead. The object's complete
60 debug information is loaded into memory, partly to simplify
61 absolute DIE references.
63 Whether using obstacks or mmap, the sections should remain loaded
64 until the objfile is released, and pointers into the section data
65 can be used for any other data associated to the objfile (symbol
66 names, type names, location expressions to name a few). */
68 #ifndef DWARF2_REG_TO_REGNUM
69 #define DWARF2_REG_TO_REGNUM(REG) (REG)
73 /* .debug_info header for a compilation unit
74 Because of alignment constraints, this structure has padding and cannot
75 be mapped directly onto the beginning of the .debug_info section. */
76 typedef struct comp_unit_header
78 unsigned int length
; /* length of the .debug_info
80 unsigned short version
; /* version number -- 2 for DWARF
82 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
83 unsigned char addr_size
; /* byte size of an address -- 4 */
86 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
89 /* .debug_pubnames header
90 Because of alignment constraints, this structure has padding and cannot
91 be mapped directly onto the beginning of the .debug_info section. */
92 typedef struct pubnames_header
94 unsigned int length
; /* length of the .debug_pubnames
96 unsigned char version
; /* version number -- 2 for DWARF
98 unsigned int info_offset
; /* offset into .debug_info section */
99 unsigned int info_size
; /* byte size of .debug_info section
103 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
105 /* .debug_pubnames header
106 Because of alignment constraints, this structure has padding and cannot
107 be mapped directly onto the beginning of the .debug_info section. */
108 typedef struct aranges_header
110 unsigned int length
; /* byte len of the .debug_aranges
112 unsigned short version
; /* version number -- 2 for DWARF
114 unsigned int info_offset
; /* offset into .debug_info section */
115 unsigned char addr_size
; /* byte size of an address */
116 unsigned char seg_size
; /* byte size of segment descriptor */
119 #define _ACTUAL_ARANGES_HEADER_SIZE 12
121 /* .debug_line statement program prologue
122 Because of alignment constraints, this structure has padding and cannot
123 be mapped directly onto the beginning of the .debug_info section. */
124 typedef struct statement_prologue
126 unsigned int total_length
; /* byte length of the statement
128 unsigned short version
; /* version number -- 2 for DWARF
130 unsigned int prologue_length
; /* # bytes between prologue &
132 unsigned char minimum_instruction_length
; /* byte size of
134 unsigned char default_is_stmt
; /* initial value of is_stmt
137 unsigned char line_range
;
138 unsigned char opcode_base
; /* number assigned to first special
140 unsigned char *standard_opcode_lengths
;
144 static const struct objfile_data
*dwarf2_objfile_data_key
;
146 struct dwarf2_per_objfile
148 /* Sizes of debugging sections. */
149 unsigned int info_size
;
150 unsigned int abbrev_size
;
151 unsigned int line_size
;
152 unsigned int pubnames_size
;
153 unsigned int aranges_size
;
154 unsigned int loc_size
;
155 unsigned int macinfo_size
;
156 unsigned int str_size
;
157 unsigned int ranges_size
;
158 unsigned int frame_size
;
159 unsigned int eh_frame_size
;
161 /* Loaded data from the sections. */
166 char *macinfo_buffer
;
171 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
173 static asection
*dwarf_info_section
;
174 static asection
*dwarf_abbrev_section
;
175 static asection
*dwarf_line_section
;
176 static asection
*dwarf_pubnames_section
;
177 static asection
*dwarf_aranges_section
;
178 static asection
*dwarf_loc_section
;
179 static asection
*dwarf_macinfo_section
;
180 static asection
*dwarf_str_section
;
181 static asection
*dwarf_ranges_section
;
182 asection
*dwarf_frame_section
;
183 asection
*dwarf_eh_frame_section
;
185 /* names of the debugging sections */
187 #define INFO_SECTION ".debug_info"
188 #define ABBREV_SECTION ".debug_abbrev"
189 #define LINE_SECTION ".debug_line"
190 #define PUBNAMES_SECTION ".debug_pubnames"
191 #define ARANGES_SECTION ".debug_aranges"
192 #define LOC_SECTION ".debug_loc"
193 #define MACINFO_SECTION ".debug_macinfo"
194 #define STR_SECTION ".debug_str"
195 #define RANGES_SECTION ".debug_ranges"
196 #define FRAME_SECTION ".debug_frame"
197 #define EH_FRAME_SECTION ".eh_frame"
199 /* local data types */
201 /* We hold several abbreviation tables in memory at the same time. */
202 #ifndef ABBREV_HASH_SIZE
203 #define ABBREV_HASH_SIZE 121
206 /* The data in a compilation unit header, after target2host
207 translation, looks like this. */
208 struct comp_unit_head
210 unsigned long length
;
212 unsigned int abbrev_offset
;
213 unsigned char addr_size
;
214 unsigned char signed_addr_p
;
215 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
216 unsigned int initial_length_size
; /* size of the length field; either
219 /* Offset to the first byte of this compilation unit header in the
220 * .debug_info section, for resolving relative reference dies. */
224 /* Pointer to this compilation unit header in the .debug_info
229 /* Pointer to the first die of this compilatio unit. This will
230 * be the first byte following the compilation unit header. */
234 /* Pointer to the next compilation unit header in the program. */
236 struct comp_unit_head
*next
;
238 /* Base address of this compilation unit. */
240 CORE_ADDR base_address
;
242 /* Non-zero if base_address has been set. */
247 /* Internal state when decoding a particular compilation unit. */
250 /* The objfile containing this compilation unit. */
251 struct objfile
*objfile
;
253 /* The header of the compilation unit.
255 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
256 should logically be moved to the dwarf2_cu structure. */
257 struct comp_unit_head header
;
259 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
261 /* The language we are debugging. */
262 enum language language
;
263 const struct language_defn
*language_defn
;
265 const char *producer
;
267 /* The generic symbol table building routines have separate lists for
268 file scope symbols and all all other scopes (local scopes). So
269 we need to select the right one to pass to add_symbol_to_list().
270 We do it by keeping a pointer to the correct list in list_in_scope.
272 FIXME: The original dwarf code just treated the file scope as the
273 first local scope, and all other local scopes as nested local
274 scopes, and worked fine. Check to see if we really need to
275 distinguish these in buildsym.c. */
276 struct pending
**list_in_scope
;
278 /* Maintain an array of referenced fundamental types for the current
279 compilation unit being read. For DWARF version 1, we have to construct
280 the fundamental types on the fly, since no information about the
281 fundamental types is supplied. Each such fundamental type is created by
282 calling a language dependent routine to create the type, and then a
283 pointer to that type is then placed in the array at the index specified
284 by it's FT_<TYPENAME> value. The array has a fixed size set by the
285 FT_NUM_MEMBERS compile time constant, which is the number of predefined
286 fundamental types gdb knows how to construct. */
287 struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
289 /* DWARF abbreviation table associated with this compilation unit. */
290 struct abbrev_info
**dwarf2_abbrevs
;
292 /* Storage for the abbrev table. */
293 struct obstack abbrev_obstack
;
295 /* Hash table holding all the loaded partial DIEs. */
298 /* Storage for things with the same lifetime as this read-in compilation
299 unit, including partial DIEs. */
300 struct obstack comp_unit_obstack
;
302 /* This flag will be set if this compilation unit includes any
303 DW_TAG_namespace DIEs. If we know that there are explicit
304 DIEs for namespaces, we don't need to try to infer them
305 from mangled names. */
306 unsigned int has_namespace_info
: 1;
309 /* The line number information for a compilation unit (found in the
310 .debug_line section) begins with a "statement program header",
311 which contains the following information. */
314 unsigned int total_length
;
315 unsigned short version
;
316 unsigned int header_length
;
317 unsigned char minimum_instruction_length
;
318 unsigned char default_is_stmt
;
320 unsigned char line_range
;
321 unsigned char opcode_base
;
323 /* standard_opcode_lengths[i] is the number of operands for the
324 standard opcode whose value is i. This means that
325 standard_opcode_lengths[0] is unused, and the last meaningful
326 element is standard_opcode_lengths[opcode_base - 1]. */
327 unsigned char *standard_opcode_lengths
;
329 /* The include_directories table. NOTE! These strings are not
330 allocated with xmalloc; instead, they are pointers into
331 debug_line_buffer. If you try to free them, `free' will get
333 unsigned int num_include_dirs
, include_dirs_size
;
336 /* The file_names table. NOTE! These strings are not allocated
337 with xmalloc; instead, they are pointers into debug_line_buffer.
338 Don't try to free them directly. */
339 unsigned int num_file_names
, file_names_size
;
343 unsigned int dir_index
;
344 unsigned int mod_time
;
346 int included_p
; /* Non-zero if referenced by the Line Number Program. */
349 /* The start and end of the statement program following this
350 header. These point into dwarf2_per_objfile->line_buffer. */
351 char *statement_program_start
, *statement_program_end
;
354 /* When we construct a partial symbol table entry we only
355 need this much information. */
356 struct partial_die_info
358 /* Offset of this DIE. */
361 /* DWARF-2 tag for this DIE. */
362 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
364 /* Language code associated with this DIE. This is only used
365 for the compilation unit DIE. */
366 unsigned int language
: 8;
368 /* Assorted flags describing the data found in this DIE. */
369 unsigned int has_children
: 1;
370 unsigned int is_external
: 1;
371 unsigned int is_declaration
: 1;
372 unsigned int has_type
: 1;
373 unsigned int has_specification
: 1;
374 unsigned int has_stmt_list
: 1;
375 unsigned int has_pc_info
: 1;
377 /* Flag set if the SCOPE field of this structure has been
379 unsigned int scope_set
: 1;
381 /* The name of this DIE. Normally the value of DW_AT_name, but
382 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
387 /* The scope to prepend to our children. This is generally
388 allocated on the comp_unit_obstack, so will disappear
389 when this compilation unit leaves the cache. */
392 /* The location description associated with this DIE, if any. */
393 struct dwarf_block
*locdesc
;
395 /* If HAS_PC_INFO, the PC range associated with this DIE. */
399 /* Pointer into the info_buffer pointing at the target of
400 DW_AT_sibling, if any. */
403 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
404 DW_AT_specification (or DW_AT_abstract_origin or
406 unsigned int spec_offset
;
408 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
409 unsigned int line_offset
;
411 /* Pointers to this DIE's parent, first child, and next sibling,
413 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
416 /* This data structure holds the information of an abbrev. */
419 unsigned int number
; /* number identifying abbrev */
420 enum dwarf_tag tag
; /* dwarf tag */
421 unsigned short has_children
; /* boolean */
422 unsigned short num_attrs
; /* number of attributes */
423 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
424 struct abbrev_info
*next
; /* next in chain */
429 enum dwarf_attribute name
;
430 enum dwarf_form form
;
433 /* This data structure holds a complete die structure. */
436 enum dwarf_tag tag
; /* Tag indicating type of die */
437 unsigned int abbrev
; /* Abbrev number */
438 unsigned int offset
; /* Offset in .debug_info section */
439 unsigned int num_attrs
; /* Number of attributes */
440 struct attribute
*attrs
; /* An array of attributes */
441 struct die_info
*next_ref
; /* Next die in ref hash table */
443 /* The dies in a compilation unit form an n-ary tree. PARENT
444 points to this die's parent; CHILD points to the first child of
445 this node; and all the children of a given node are chained
446 together via their SIBLING fields, terminated by a die whose
448 struct die_info
*child
; /* Its first child, if any. */
449 struct die_info
*sibling
; /* Its next sibling, if any. */
450 struct die_info
*parent
; /* Its parent, if any. */
452 struct type
*type
; /* Cached type information */
455 /* Attributes have a name and a value */
458 enum dwarf_attribute name
;
459 enum dwarf_form form
;
463 struct dwarf_block
*blk
;
471 struct function_range
474 CORE_ADDR lowpc
, highpc
;
476 struct function_range
*next
;
479 /* Get at parts of an attribute structure */
481 #define DW_STRING(attr) ((attr)->u.str)
482 #define DW_UNSND(attr) ((attr)->u.unsnd)
483 #define DW_BLOCK(attr) ((attr)->u.blk)
484 #define DW_SND(attr) ((attr)->u.snd)
485 #define DW_ADDR(attr) ((attr)->u.addr)
487 /* Blocks are a bunch of untyped bytes. */
494 #ifndef ATTR_ALLOC_CHUNK
495 #define ATTR_ALLOC_CHUNK 4
498 /* A hash table of die offsets for following references. */
499 #ifndef REF_HASH_SIZE
500 #define REF_HASH_SIZE 1021
503 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
505 /* Allocate fields for structs, unions and enums in this size. */
506 #ifndef DW_FIELD_ALLOC_CHUNK
507 #define DW_FIELD_ALLOC_CHUNK 4
510 /* A zeroed version of a partial die for initialization purposes. */
511 static struct partial_die_info zeroed_partial_die
;
513 /* FIXME: decode_locdesc sets these variables to describe the location
514 to the caller. These ought to be a structure or something. If
515 none of the flags are set, the object lives at the address returned
516 by decode_locdesc. */
518 static int isreg
; /* Object lives in register.
519 decode_locdesc's return value is
520 the register number. */
522 /* We put a pointer to this structure in the read_symtab_private field
527 /* Offset in .debug_info for this compilation unit. */
529 unsigned long dwarf_info_offset
;
532 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
533 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
535 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
536 but this would require a corresponding change in unpack_field_as_long
538 static int bits_per_byte
= 8;
540 /* The routines that read and process dies for a C struct or C++ class
541 pass lists of data member fields and lists of member function fields
542 in an instance of a field_info structure, as defined below. */
545 /* List of data member and baseclasses fields. */
548 struct nextfield
*next
;
555 /* Number of fields. */
558 /* Number of baseclasses. */
561 /* Set if the accesibility of one of the fields is not public. */
562 int non_public_fields
;
564 /* Member function fields array, entries are allocated in the order they
565 are encountered in the object file. */
568 struct nextfnfield
*next
;
569 struct fn_field fnfield
;
573 /* Member function fieldlist array, contains name of possibly overloaded
574 member function, number of overloaded member functions and a pointer
575 to the head of the member function field chain. */
580 struct nextfnfield
*head
;
584 /* Number of entries in the fnfieldlists array. */
588 /* Various complaints about symbol reading that don't abort the process */
591 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
593 complaint (&symfile_complaints
,
594 "statement list doesn't fit in .debug_line section");
598 dwarf2_complex_location_expr_complaint (void)
600 complaint (&symfile_complaints
, "location expression too complex");
604 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
607 complaint (&symfile_complaints
,
608 "const value length mismatch for '%s', got %d, expected %d", arg1
,
613 dwarf2_macros_too_long_complaint (void)
615 complaint (&symfile_complaints
,
616 "macro info runs off end of `.debug_macinfo' section");
620 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
622 complaint (&symfile_complaints
,
623 "macro debug info contains a malformed macro definition:\n`%s'",
628 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
630 complaint (&symfile_complaints
,
631 "invalid attribute class or form for '%s' in '%s'", arg1
, arg2
);
634 /* local function prototypes */
636 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
639 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
642 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
645 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
646 struct partial_die_info
*,
647 struct partial_symtab
*);
649 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
651 static void scan_partial_symbols (struct partial_die_info
*,
652 CORE_ADDR
*, CORE_ADDR
*,
655 static void add_partial_symbol (struct partial_die_info
*,
658 static int pdi_needs_namespace (enum dwarf_tag tag
);
660 static void add_partial_namespace (struct partial_die_info
*pdi
,
661 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
662 struct dwarf2_cu
*cu
);
664 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
665 struct dwarf2_cu
*cu
);
667 static char *locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
670 struct dwarf2_cu
*cu
);
672 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
674 static void psymtab_to_symtab_1 (struct partial_symtab
*);
676 char *dwarf2_read_section (struct objfile
*, asection
*);
678 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
680 static void dwarf2_free_abbrev_table (void *);
682 static struct abbrev_info
*peek_die_abbrev (char *, int *, struct dwarf2_cu
*);
684 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
687 static struct partial_die_info
*load_partial_dies (bfd
*, char *, int,
690 static char *read_partial_die (struct partial_die_info
*,
691 struct abbrev_info
*abbrev
, unsigned int,
692 bfd
*, char *, struct dwarf2_cu
*);
694 static struct partial_die_info
*find_partial_die (unsigned long,
696 struct dwarf2_cu
**);
698 static void fixup_partial_die (struct partial_die_info
*,
701 static char *read_full_die (struct die_info
**, bfd
*, char *,
702 struct dwarf2_cu
*, int *);
704 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
705 bfd
*, char *, struct dwarf2_cu
*);
707 static char *read_attribute_value (struct attribute
*, unsigned,
708 bfd
*, char *, struct dwarf2_cu
*);
710 static unsigned int read_1_byte (bfd
*, char *);
712 static int read_1_signed_byte (bfd
*, char *);
714 static unsigned int read_2_bytes (bfd
*, char *);
716 static unsigned int read_4_bytes (bfd
*, char *);
718 static unsigned long read_8_bytes (bfd
*, char *);
720 static CORE_ADDR
read_address (bfd
*, char *ptr
, struct dwarf2_cu
*,
723 static LONGEST
read_initial_length (bfd
*, char *,
724 struct comp_unit_head
*, int *bytes_read
);
726 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
729 static char *read_n_bytes (bfd
*, char *, unsigned int);
731 static char *read_string (bfd
*, char *, unsigned int *);
733 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
736 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
738 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
740 static char *skip_leb128 (bfd
*, char *);
742 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
744 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
747 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
748 struct dwarf2_cu
*cu
);
750 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
752 static struct die_info
*die_specification (struct die_info
*die
,
755 static void free_line_header (struct line_header
*lh
);
757 static void add_file_name (struct line_header
*, char *, unsigned int,
758 unsigned int, unsigned int);
760 static struct line_header
*(dwarf_decode_line_header
761 (unsigned int offset
,
762 bfd
*abfd
, struct dwarf2_cu
*cu
));
764 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
765 struct dwarf2_cu
*, struct partial_symtab
*);
767 static void dwarf2_start_subfile (char *, char *);
769 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
772 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
775 static void dwarf2_const_value_data (struct attribute
*attr
,
779 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
781 static struct type
*die_containing_type (struct die_info
*,
785 static struct type
*type_at_offset (unsigned int, struct objfile
*);
788 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
790 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
792 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
794 static char *typename_concat (const char *prefix
, const char *suffix
);
796 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
798 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
800 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
802 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
804 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
806 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
808 static int dwarf2_get_pc_bounds (struct die_info
*,
809 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
811 static void get_scope_pc_bounds (struct die_info
*,
812 CORE_ADDR
*, CORE_ADDR
*,
815 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
818 static void dwarf2_attach_fields_to_type (struct field_info
*,
819 struct type
*, struct dwarf2_cu
*);
821 static void dwarf2_add_member_fn (struct field_info
*,
822 struct die_info
*, struct type
*,
825 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
826 struct type
*, struct dwarf2_cu
*);
828 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
830 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
832 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
834 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
836 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
838 static const char *namespace_name (struct die_info
*die
,
839 int *is_anonymous
, struct dwarf2_cu
*);
841 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
843 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
845 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
847 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
849 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
851 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
854 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
856 static void read_tag_ptr_to_member_type (struct die_info
*,
859 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
861 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
863 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
865 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
867 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
869 static struct die_info
*read_comp_unit (char *, bfd
*, struct dwarf2_cu
*);
871 static struct die_info
*read_die_and_children (char *info_ptr
, bfd
*abfd
,
874 struct die_info
*parent
);
876 static struct die_info
*read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
879 struct die_info
*parent
);
881 static void free_die_list (struct die_info
*);
883 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
885 static void process_die (struct die_info
*, struct dwarf2_cu
*);
887 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
889 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
891 static struct die_info
*dwarf2_extension (struct die_info
*die
,
894 static char *dwarf_tag_name (unsigned int);
896 static char *dwarf_attr_name (unsigned int);
898 static char *dwarf_form_name (unsigned int);
900 static char *dwarf_stack_op_name (unsigned int);
902 static char *dwarf_bool_name (unsigned int);
904 static char *dwarf_type_encoding_name (unsigned int);
907 static char *dwarf_cfi_name (unsigned int);
909 struct die_info
*copy_die (struct die_info
*);
912 static struct die_info
*sibling_die (struct die_info
*);
914 static void dump_die (struct die_info
*);
916 static void dump_die_list (struct die_info
*);
918 static void store_in_ref_table (unsigned int, struct die_info
*);
920 static void dwarf2_empty_hash_tables (void);
922 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
925 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
927 static struct die_info
*follow_die_ref (unsigned int);
929 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
932 /* memory allocation interface */
934 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
936 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
938 static struct die_info
*dwarf_alloc_die (void);
940 static void initialize_cu_func_list (struct dwarf2_cu
*);
942 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
945 static void dwarf_decode_macros (struct line_header
*, unsigned int,
946 char *, bfd
*, struct dwarf2_cu
*);
948 static int attr_form_is_block (struct attribute
*);
951 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
952 struct dwarf2_cu
*cu
);
954 static char *skip_one_die (char *info_ptr
, struct abbrev_info
*abbrev
,
955 struct dwarf2_cu
*cu
);
957 static void free_stack_comp_unit (void *);
959 static void *hashtab_obstack_allocate (void *data
, size_t size
, size_t count
);
961 static void dummy_obstack_deallocate (void *object
, void *data
);
963 static hashval_t
partial_die_hash (const void *item
);
965 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
967 /* Try to locate the sections we need for DWARF 2 debugging
968 information and return true if we have enough to do something. */
971 dwarf2_has_info (struct objfile
*objfile
)
973 struct dwarf2_per_objfile
*data
;
975 /* Initialize per-objfile state. */
976 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
977 memset (data
, 0, sizeof (*data
));
978 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
979 dwarf2_per_objfile
= data
;
981 dwarf_info_section
= 0;
982 dwarf_abbrev_section
= 0;
983 dwarf_line_section
= 0;
984 dwarf_str_section
= 0;
985 dwarf_macinfo_section
= 0;
986 dwarf_frame_section
= 0;
987 dwarf_eh_frame_section
= 0;
988 dwarf_ranges_section
= 0;
989 dwarf_loc_section
= 0;
991 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
992 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
995 /* This function is mapped across the sections and remembers the
996 offset and size of each of the debugging sections we are interested
1000 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
1002 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1004 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1005 dwarf_info_section
= sectp
;
1007 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1009 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1010 dwarf_abbrev_section
= sectp
;
1012 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1014 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1015 dwarf_line_section
= sectp
;
1017 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1019 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1020 dwarf_pubnames_section
= sectp
;
1022 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1024 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1025 dwarf_aranges_section
= sectp
;
1027 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1029 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1030 dwarf_loc_section
= sectp
;
1032 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1034 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1035 dwarf_macinfo_section
= sectp
;
1037 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1039 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1040 dwarf_str_section
= sectp
;
1042 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1044 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1045 dwarf_frame_section
= sectp
;
1047 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1049 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1050 if (aflag
& SEC_HAS_CONTENTS
)
1052 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1053 dwarf_eh_frame_section
= sectp
;
1056 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1058 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1059 dwarf_ranges_section
= sectp
;
1063 /* Build a partial symbol table. */
1066 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1068 /* We definitely need the .debug_info and .debug_abbrev sections */
1070 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1071 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1073 if (dwarf_line_section
)
1074 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1076 dwarf2_per_objfile
->line_buffer
= NULL
;
1078 if (dwarf_str_section
)
1079 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1081 dwarf2_per_objfile
->str_buffer
= NULL
;
1083 if (dwarf_macinfo_section
)
1084 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1085 dwarf_macinfo_section
);
1087 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1089 if (dwarf_ranges_section
)
1090 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1092 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1094 if (dwarf_loc_section
)
1095 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1097 dwarf2_per_objfile
->loc_buffer
= NULL
;
1100 || (objfile
->global_psymbols
.size
== 0
1101 && objfile
->static_psymbols
.size
== 0))
1103 init_psymbol_list (objfile
, 1024);
1107 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1109 /* Things are significantly easier if we have .debug_aranges and
1110 .debug_pubnames sections */
1112 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1116 /* only test this case for now */
1118 /* In this case we have to work a bit harder */
1119 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1124 /* Build the partial symbol table from the information in the
1125 .debug_pubnames and .debug_aranges sections. */
1128 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1130 bfd
*abfd
= objfile
->obfd
;
1131 char *aranges_buffer
, *pubnames_buffer
;
1132 char *aranges_ptr
, *pubnames_ptr
;
1133 unsigned int entry_length
, version
, info_offset
, info_size
;
1135 pubnames_buffer
= dwarf2_read_section (objfile
,
1136 dwarf_pubnames_section
);
1137 pubnames_ptr
= pubnames_buffer
;
1138 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1140 struct comp_unit_head cu_header
;
1143 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1145 pubnames_ptr
+= bytes_read
;
1146 version
= read_1_byte (abfd
, pubnames_ptr
);
1148 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1150 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1154 aranges_buffer
= dwarf2_read_section (objfile
,
1155 dwarf_aranges_section
);
1160 /* Read in the comp unit header information from the debug_info at
1164 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1165 char *info_ptr
, bfd
*abfd
)
1169 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1171 info_ptr
+= bytes_read
;
1172 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1174 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1176 info_ptr
+= bytes_read
;
1177 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1179 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1180 if (signed_addr
< 0)
1181 internal_error (__FILE__
, __LINE__
,
1182 "read_comp_unit_head: dwarf from non elf file");
1183 cu_header
->signed_addr_p
= signed_addr
;
1188 partial_read_comp_unit_head (struct comp_unit_head
*header
, char *info_ptr
,
1191 char *beg_of_comp_unit
= info_ptr
;
1193 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1195 if (header
->version
!= 2)
1196 error ("Dwarf Error: wrong version in compilation unit header "
1197 "(is %d, should be %d) [in module %s]", header
->version
,
1198 2, bfd_get_filename (abfd
));
1200 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1201 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1202 "(offset 0x%lx + 6) [in module %s]",
1203 (long) header
->abbrev_offset
,
1204 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1205 bfd_get_filename (abfd
));
1207 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1208 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1209 error ("Dwarf Error: bad length (0x%lx) in compilation unit header "
1210 "(offset 0x%lx + 0) [in module %s]",
1211 (long) header
->length
,
1212 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1213 bfd_get_filename (abfd
));
1218 /* Allocate a new partial symtab for file named NAME and mark this new
1219 partial symtab as being an include of PST. */
1222 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1223 struct objfile
*objfile
)
1225 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1227 subpst
->section_offsets
= pst
->section_offsets
;
1228 subpst
->textlow
= 0;
1229 subpst
->texthigh
= 0;
1231 subpst
->dependencies
= (struct partial_symtab
**)
1232 obstack_alloc (&objfile
->objfile_obstack
,
1233 sizeof (struct partial_symtab
*));
1234 subpst
->dependencies
[0] = pst
;
1235 subpst
->number_of_dependencies
= 1;
1237 subpst
->globals_offset
= 0;
1238 subpst
->n_global_syms
= 0;
1239 subpst
->statics_offset
= 0;
1240 subpst
->n_static_syms
= 0;
1241 subpst
->symtab
= NULL
;
1242 subpst
->read_symtab
= pst
->read_symtab
;
1245 /* No private part is necessary for include psymtabs. This property
1246 can be used to differentiate between such include psymtabs and
1247 the regular ones. If it ever happens that a regular psymtab can
1248 legitimally have a NULL private part, then we'll have to add a
1249 dedicated field for that in the dwarf2_pinfo structure. */
1250 subpst
->read_symtab_private
= NULL
;
1253 /* Read the Line Number Program data and extract the list of files
1254 included by the source file represented by PST. Build an include
1255 partial symtab for each of these included files.
1257 This procedure assumes that there *is* a Line Number Program in
1258 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1259 before calling this procedure. */
1262 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1263 struct partial_die_info
*pdi
,
1264 struct partial_symtab
*pst
)
1266 struct objfile
*objfile
= cu
->objfile
;
1267 bfd
*abfd
= objfile
->obfd
;
1268 struct line_header
*lh
;
1270 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1272 return; /* No linetable, so no includes. */
1274 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1276 free_line_header (lh
);
1280 /* Build the partial symbol table by doing a quick pass through the
1281 .debug_info and .debug_abbrev sections. */
1284 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1286 /* Instead of reading this into a big buffer, we should probably use
1287 mmap() on architectures that support it. (FIXME) */
1288 bfd
*abfd
= objfile
->obfd
;
1290 char *beg_of_comp_unit
;
1291 struct partial_die_info comp_unit_die
;
1292 struct partial_symtab
*pst
;
1293 CORE_ADDR lowpc
, highpc
, baseaddr
;
1295 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1297 /* Since the objects we're extracting from .debug_info vary in
1298 length, only the individual functions to extract them (like
1299 read_comp_unit_head and load_partial_die) can really know whether
1300 the buffer is large enough to hold another complete object.
1302 At the moment, they don't actually check that. If .debug_info
1303 holds just one extra byte after the last compilation unit's dies,
1304 then read_comp_unit_head will happily read off the end of the
1305 buffer. read_partial_die is similarly casual. Those functions
1308 For this loop condition, simply checking whether there's any data
1309 left at all should be sufficient. */
1310 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1311 + dwarf2_per_objfile
->info_size
))
1313 struct cleanup
*back_to_inner
;
1314 struct dwarf2_cu cu
;
1315 struct abbrev_info
*abbrev
;
1316 unsigned int bytes_read
;
1317 struct dwarf2_per_cu_data
*this_cu
;
1319 beg_of_comp_unit
= info_ptr
;
1321 memset (&cu
, 0, sizeof (cu
));
1323 obstack_init (&cu
.comp_unit_obstack
);
1325 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1327 cu
.objfile
= objfile
;
1328 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1330 /* Complete the cu_header */
1331 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1332 cu
.header
.first_die_ptr
= info_ptr
;
1333 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1335 cu
.list_in_scope
= &file_symbols
;
1337 cu
.partial_dies
= NULL
;
1339 /* Read the abbrevs for this compilation unit into a table */
1340 dwarf2_read_abbrevs (abfd
, &cu
);
1341 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1343 /* Read the compilation unit die */
1344 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1345 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1346 abfd
, info_ptr
, &cu
);
1348 /* Set the language we're debugging */
1349 set_cu_language (comp_unit_die
.language
, &cu
);
1351 /* Allocate a new partial symbol table structure */
1352 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1353 comp_unit_die
.name
? comp_unit_die
.name
: "",
1354 comp_unit_die
.lowpc
,
1355 objfile
->global_psymbols
.next
,
1356 objfile
->static_psymbols
.next
);
1358 if (comp_unit_die
.dirname
)
1359 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1361 pst
->read_symtab_private
= (char *)
1362 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct dwarf2_pinfo
));
1363 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1364 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1366 /* Store the function that reads in the rest of the symbol table */
1367 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1369 /* Check if comp unit has_children.
1370 If so, read the rest of the partial symbols from this comp unit.
1371 If not, there's no more debug_info for this comp unit. */
1372 if (comp_unit_die
.has_children
)
1374 struct partial_die_info
*first_die
;
1376 lowpc
= ((CORE_ADDR
) -1);
1377 highpc
= ((CORE_ADDR
) 0);
1379 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1381 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1383 /* If we didn't find a lowpc, set it to highpc to avoid
1384 complaints from `maint check'. */
1385 if (lowpc
== ((CORE_ADDR
) -1))
1388 /* If the compilation unit didn't have an explicit address range,
1389 then use the information extracted from its child dies. */
1390 if (! comp_unit_die
.has_pc_info
)
1392 comp_unit_die
.lowpc
= lowpc
;
1393 comp_unit_die
.highpc
= highpc
;
1396 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1397 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1399 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1400 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1401 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1402 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1403 sort_pst_symbols (pst
);
1405 /* If there is already a psymtab or symtab for a file of this
1406 name, remove it. (If there is a symtab, more drastic things
1407 also happen.) This happens in VxWorks. */
1408 free_named_symtabs (pst
->filename
);
1410 if (comp_unit_die
.has_stmt_list
)
1412 /* Get the list of files included in the current compilation unit,
1413 and build a psymtab for each of them. */
1414 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1417 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1418 + cu
.header
.initial_length_size
;
1420 do_cleanups (back_to_inner
);
1424 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1425 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1429 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1430 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1432 struct objfile
*objfile
= cu
->objfile
;
1433 bfd
*abfd
= objfile
->obfd
;
1434 struct partial_die_info
*pdi
;
1436 /* Now, march along the PDI's, descending into ones which have
1437 interesting children but skipping the children of the other ones,
1438 until we reach the end of the compilation unit. */
1444 fixup_partial_die (pdi
, cu
);
1446 /* Anonymous namespaces have no name but have interesting
1447 children, so we need to look at them. Ditto for anonymous
1450 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1451 || pdi
->tag
== DW_TAG_enumeration_type
)
1455 case DW_TAG_subprogram
:
1456 if (pdi
->has_pc_info
)
1458 if (pdi
->lowpc
< *lowpc
)
1460 *lowpc
= pdi
->lowpc
;
1462 if (pdi
->highpc
> *highpc
)
1464 *highpc
= pdi
->highpc
;
1466 if (!pdi
->is_declaration
)
1468 add_partial_symbol (pdi
, cu
);
1472 case DW_TAG_variable
:
1473 case DW_TAG_typedef
:
1474 case DW_TAG_union_type
:
1475 if (!pdi
->is_declaration
)
1477 add_partial_symbol (pdi
, cu
);
1480 case DW_TAG_class_type
:
1481 case DW_TAG_structure_type
:
1482 if (!pdi
->is_declaration
)
1484 add_partial_symbol (pdi
, cu
);
1487 case DW_TAG_enumeration_type
:
1488 if (!pdi
->is_declaration
)
1489 add_partial_enumeration (pdi
, cu
);
1491 case DW_TAG_base_type
:
1492 case DW_TAG_subrange_type
:
1493 /* File scope base type definitions are added to the partial
1495 add_partial_symbol (pdi
, cu
);
1497 case DW_TAG_namespace
:
1498 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1505 /* If the die has a sibling, skip to the sibling. */
1507 pdi
= pdi
->die_sibling
;
1511 /* Functions used to compute the fully scoped name of a partial DIE.
1513 Normally, this is simple. For C++, the parent DIE's fully scoped
1514 name is concatenated with "::" and the partial DIE's name.
1515 Enumerators are an exception; they use the scope of their parent
1516 enumeration type, i.e. the name of the enumeration type is not
1517 prepended to the enumerator.
1519 There are two complexities. One is DW_AT_specification; in this
1520 case "parent" means the parent of the target of the specification,
1521 instead of the direct parent of the DIE. The other is compilers
1522 which do not emit DW_TAG_namespace; in this case we try to guess
1523 the fully qualified name of structure types from their members'
1524 linkage names. This must be done using the DIE's children rather
1525 than the children of any DW_AT_specification target. We only need
1526 to do this for structures at the top level, i.e. if the target of
1527 any DW_AT_specification (if any; otherwise the DIE itself) does not
1530 /* Compute the scope prefix associated with PDI's parent, in
1531 compilation unit CU. The result will be allocated on CU's
1532 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1533 field. NULL is returned if no prefix is necessary. */
1535 partial_die_parent_scope (struct partial_die_info
*pdi
,
1536 struct dwarf2_cu
*cu
)
1538 char *grandparent_scope
;
1539 struct partial_die_info
*parent
, *real_pdi
;
1540 struct dwarf2_cu
*spec_cu
;
1542 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1543 then this means the parent of the specification DIE. */
1547 while (real_pdi
->has_specification
)
1548 real_pdi
= find_partial_die (real_pdi
->spec_offset
, spec_cu
, &spec_cu
);
1550 parent
= real_pdi
->die_parent
;
1554 if (parent
->scope_set
)
1555 return parent
->scope
;
1557 fixup_partial_die (parent
, cu
);
1559 grandparent_scope
= partial_die_parent_scope (parent
, spec_cu
);
1561 if (parent
->tag
== DW_TAG_namespace
1562 || parent
->tag
== DW_TAG_structure_type
1563 || parent
->tag
== DW_TAG_class_type
1564 || parent
->tag
== DW_TAG_union_type
)
1566 if (grandparent_scope
== NULL
)
1567 parent
->scope
= parent
->name
;
1569 parent
->scope
= obconcat (&cu
->comp_unit_obstack
, grandparent_scope
,
1570 "::", parent
->name
);
1572 else if (parent
->tag
== DW_TAG_enumeration_type
)
1573 /* Enumerators should not get the name of the enumeration as a prefix. */
1574 parent
->scope
= grandparent_scope
;
1577 /* FIXME drow/2004-04-01: What should we be doing with
1578 function-local names? For partial symbols, we should probably be
1580 complaint (&symfile_complaints
,
1581 "unhandled containing DIE tag %d for DIE at %d",
1582 parent
->tag
, pdi
->offset
);
1583 parent
->scope
= grandparent_scope
;
1586 parent
->scope_set
= 1;
1587 return parent
->scope
;
1590 /* Return the fully scoped name associated with PDI, from compilation unit
1591 CU. The result will be allocated with malloc. */
1593 partial_die_full_name (struct partial_die_info
*pdi
,
1594 struct dwarf2_cu
*cu
)
1598 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1599 if (parent_scope
== NULL
)
1602 return concat (parent_scope
, "::", pdi
->name
, NULL
);
1606 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1608 struct objfile
*objfile
= cu
->objfile
;
1611 const char *my_prefix
;
1612 const struct partial_symbol
*psym
= NULL
;
1614 int built_actual_name
= 0;
1616 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1620 if (pdi_needs_namespace (pdi
->tag
))
1622 actual_name
= partial_die_full_name (pdi
, cu
);
1624 built_actual_name
= 1;
1627 if (actual_name
== NULL
)
1628 actual_name
= pdi
->name
;
1632 case DW_TAG_subprogram
:
1633 if (pdi
->is_external
)
1635 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1636 mst_text, objfile); */
1637 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1638 VAR_DOMAIN
, LOC_BLOCK
,
1639 &objfile
->global_psymbols
,
1640 0, pdi
->lowpc
+ baseaddr
,
1641 cu
->language
, objfile
);
1645 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1646 mst_file_text, objfile); */
1647 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1648 VAR_DOMAIN
, LOC_BLOCK
,
1649 &objfile
->static_psymbols
,
1650 0, pdi
->lowpc
+ baseaddr
,
1651 cu
->language
, objfile
);
1654 case DW_TAG_variable
:
1655 if (pdi
->is_external
)
1658 Don't enter into the minimal symbol tables as there is
1659 a minimal symbol table entry from the ELF symbols already.
1660 Enter into partial symbol table if it has a location
1661 descriptor or a type.
1662 If the location descriptor is missing, new_symbol will create
1663 a LOC_UNRESOLVED symbol, the address of the variable will then
1664 be determined from the minimal symbol table whenever the variable
1666 The address for the partial symbol table entry is not
1667 used by GDB, but it comes in handy for debugging partial symbol
1671 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1672 if (pdi
->locdesc
|| pdi
->has_type
)
1673 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1674 VAR_DOMAIN
, LOC_STATIC
,
1675 &objfile
->global_psymbols
,
1677 cu
->language
, objfile
);
1681 /* Static Variable. Skip symbols without location descriptors. */
1682 if (pdi
->locdesc
== NULL
)
1684 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1685 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1686 mst_file_data, objfile); */
1687 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1688 VAR_DOMAIN
, LOC_STATIC
,
1689 &objfile
->static_psymbols
,
1691 cu
->language
, objfile
);
1694 case DW_TAG_typedef
:
1695 case DW_TAG_base_type
:
1696 case DW_TAG_subrange_type
:
1697 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1698 VAR_DOMAIN
, LOC_TYPEDEF
,
1699 &objfile
->static_psymbols
,
1700 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1702 case DW_TAG_namespace
:
1703 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1704 VAR_DOMAIN
, LOC_TYPEDEF
,
1705 &objfile
->global_psymbols
,
1706 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1708 case DW_TAG_class_type
:
1709 case DW_TAG_structure_type
:
1710 case DW_TAG_union_type
:
1711 case DW_TAG_enumeration_type
:
1712 /* Skip aggregate types without children, these are external
1714 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1715 static vs. global. */
1716 if (pdi
->has_children
== 0)
1718 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1719 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1720 cu
->language
== language_cplus
1721 ? &objfile
->global_psymbols
1722 : &objfile
->static_psymbols
,
1723 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1725 if (cu
->language
== language_cplus
)
1727 /* For C++, these implicitly act as typedefs as well. */
1728 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1729 VAR_DOMAIN
, LOC_TYPEDEF
,
1730 &objfile
->global_psymbols
,
1731 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1734 case DW_TAG_enumerator
:
1735 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1736 VAR_DOMAIN
, LOC_CONST
,
1737 cu
->language
== language_cplus
1738 ? &objfile
->global_psymbols
1739 : &objfile
->static_psymbols
,
1740 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1746 /* Check to see if we should scan the name for possible namespace
1747 info. Only do this if this is C++, if we don't have namespace
1748 debugging info in the file, if the psym is of an appropriate type
1749 (otherwise we'll have psym == NULL), and if we actually had a
1750 mangled name to begin with. */
1752 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
1753 cases which do not set PSYM above? */
1755 if (cu
->language
== language_cplus
1756 && cu
->has_namespace_info
== 0
1758 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
1759 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
1762 if (built_actual_name
)
1763 xfree (actual_name
);
1766 /* Determine whether a die of type TAG living in a C++ class or
1767 namespace needs to have the name of the scope prepended to the
1768 name listed in the die. */
1771 pdi_needs_namespace (enum dwarf_tag tag
)
1775 case DW_TAG_namespace
:
1776 case DW_TAG_typedef
:
1777 case DW_TAG_class_type
:
1778 case DW_TAG_structure_type
:
1779 case DW_TAG_union_type
:
1780 case DW_TAG_enumeration_type
:
1781 case DW_TAG_enumerator
:
1788 /* Read a partial die corresponding to a namespace; also, add a symbol
1789 corresponding to that namespace to the symbol table. NAMESPACE is
1790 the name of the enclosing namespace. */
1793 add_partial_namespace (struct partial_die_info
*pdi
,
1794 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1795 struct dwarf2_cu
*cu
)
1797 struct objfile
*objfile
= cu
->objfile
;
1799 /* Add a symbol for the namespace. */
1801 add_partial_symbol (pdi
, cu
);
1803 /* Now scan partial symbols in that namespace. */
1805 if (pdi
->has_children
)
1806 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
1809 /* See if we can figure out if the class lives in a namespace. We do
1810 this by looking for a member function; its demangled name will
1811 contain namespace info, if there is any. */
1814 guess_structure_name (struct partial_die_info
*struct_pdi
,
1815 struct dwarf2_cu
*cu
)
1817 if (cu
->language
== language_cplus
1818 && cu
->has_namespace_info
== 0
1819 && struct_pdi
->has_children
)
1821 /* NOTE: carlton/2003-10-07: Getting the info this way changes
1822 what template types look like, because the demangler
1823 frequently doesn't give the same name as the debug info. We
1824 could fix this by only using the demangled name to get the
1825 prefix (but see comment in read_structure_type). */
1827 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
1828 struct partial_die_info
*real_pdi
;
1829 struct dwarf2_cu
*spec_cu
;
1831 /* If this DIE (this DIE's specification, if any) has a parent, then
1832 we should not do this. We'll prepend the parent's fully qualified
1833 name when we create the partial symbol. */
1835 real_pdi
= struct_pdi
;
1837 while (real_pdi
->has_specification
)
1838 real_pdi
= find_partial_die (real_pdi
->spec_offset
, spec_cu
, &spec_cu
);
1840 if (real_pdi
->die_parent
!= NULL
)
1843 while (child_pdi
!= NULL
)
1845 if (child_pdi
->tag
== DW_TAG_subprogram
)
1847 char *actual_class_name
1848 = language_class_name_from_physname (cu
->language_defn
,
1850 if (actual_class_name
!= NULL
)
1853 = obsavestring (actual_class_name
,
1854 strlen (actual_class_name
),
1855 &cu
->comp_unit_obstack
);
1856 xfree (actual_class_name
);
1861 child_pdi
= child_pdi
->die_sibling
;
1866 /* Read a partial die corresponding to an enumeration type. */
1869 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1870 struct dwarf2_cu
*cu
)
1872 struct objfile
*objfile
= cu
->objfile
;
1873 bfd
*abfd
= objfile
->obfd
;
1874 struct partial_die_info
*pdi
;
1876 if (enum_pdi
->name
!= NULL
)
1877 add_partial_symbol (enum_pdi
, cu
);
1879 pdi
= enum_pdi
->die_child
;
1882 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
1883 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
1885 add_partial_symbol (pdi
, cu
);
1886 pdi
= pdi
->die_sibling
;
1890 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
1891 Return the corresponding abbrev, or NULL if the number is zero (indicating
1892 an empty DIE). In either case *BYTES_READ will be set to the length of
1893 the initial number. */
1895 static struct abbrev_info
*
1896 peek_die_abbrev (char *info_ptr
, int *bytes_read
, struct dwarf2_cu
*cu
)
1898 bfd
*abfd
= cu
->objfile
->obfd
;
1899 unsigned int abbrev_number
;
1900 struct abbrev_info
*abbrev
;
1902 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
1904 if (abbrev_number
== 0)
1907 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
1910 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number
,
1911 bfd_get_filename (abfd
));
1917 /* Scan the debug information for CU starting at INFO_PTR. Returns a
1918 pointer to the end of a series of DIEs, terminated by an empty
1919 DIE. Any children of the skipped DIEs will also be skipped. */
1922 skip_children (char *info_ptr
, struct dwarf2_cu
*cu
)
1924 struct abbrev_info
*abbrev
;
1925 unsigned int bytes_read
;
1929 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1931 return info_ptr
+ bytes_read
;
1933 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
1937 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
1938 should point just after the initial uleb128 of a DIE, and the
1939 abbrev corresponding to that skipped uleb128 should be passed in
1940 ABBREV. Returns a pointer to this DIE's sibling, skipping any
1944 skip_one_die (char *info_ptr
, struct abbrev_info
*abbrev
,
1945 struct dwarf2_cu
*cu
)
1947 unsigned int bytes_read
;
1948 struct attribute attr
;
1949 bfd
*abfd
= cu
->objfile
->obfd
;
1950 unsigned int form
, i
;
1952 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
1954 /* The only abbrev we care about is DW_AT_sibling. */
1955 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
1957 read_attribute (&attr
, &abbrev
->attrs
[i
],
1958 abfd
, info_ptr
, cu
);
1959 if (attr
.form
== DW_FORM_ref_addr
)
1960 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
1962 return dwarf2_per_objfile
->info_buffer
1963 + dwarf2_get_ref_die_offset (&attr
, cu
);
1966 /* If it isn't DW_AT_sibling, skip this attribute. */
1967 form
= abbrev
->attrs
[i
].form
;
1972 case DW_FORM_ref_addr
:
1973 info_ptr
+= cu
->header
.addr_size
;
1992 case DW_FORM_string
:
1993 read_string (abfd
, info_ptr
, &bytes_read
);
1994 info_ptr
+= bytes_read
;
1997 info_ptr
+= cu
->header
.offset_size
;
2000 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2001 info_ptr
+= bytes_read
;
2003 case DW_FORM_block1
:
2004 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2006 case DW_FORM_block2
:
2007 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2009 case DW_FORM_block4
:
2010 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2014 case DW_FORM_ref_udata
:
2015 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2017 case DW_FORM_indirect
:
2018 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2019 info_ptr
+= bytes_read
;
2020 /* We need to continue parsing from here, so just go back to
2022 goto skip_attribute
;
2025 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
2026 dwarf_form_name (form
),
2027 bfd_get_filename (abfd
));
2031 if (abbrev
->has_children
)
2032 return skip_children (info_ptr
, cu
);
2037 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2038 the next DIE after ORIG_PDI. */
2041 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
2042 bfd
*abfd
, struct dwarf2_cu
*cu
)
2044 /* Do we know the sibling already? */
2046 if (orig_pdi
->sibling
)
2047 return orig_pdi
->sibling
;
2049 /* Are there any children to deal with? */
2051 if (!orig_pdi
->has_children
)
2054 /* Skip the children the long way. */
2056 return skip_children (info_ptr
, cu
);
2059 /* Expand this partial symbol table into a full symbol table. */
2062 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2064 /* FIXME: This is barely more than a stub. */
2069 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
2075 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
2076 gdb_flush (gdb_stdout
);
2079 psymtab_to_symtab_1 (pst
);
2081 /* Finish up the debug error message. */
2083 printf_filtered ("done.\n");
2089 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2091 struct objfile
*objfile
= pst
->objfile
;
2092 bfd
*abfd
= objfile
->obfd
;
2093 struct dwarf2_cu cu
;
2094 struct die_info
*dies
;
2095 unsigned long offset
;
2096 CORE_ADDR lowpc
, highpc
;
2097 struct die_info
*child_die
;
2099 struct symtab
*symtab
;
2100 struct cleanup
*back_to
;
2101 struct attribute
*attr
;
2105 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2106 if (!pst
->dependencies
[i
]->readin
)
2108 /* Inform about additional files that need to be read in. */
2111 fputs_filtered (" ", gdb_stdout
);
2113 fputs_filtered ("and ", gdb_stdout
);
2115 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2116 wrap_here (""); /* Flush output */
2117 gdb_flush (gdb_stdout
);
2119 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2122 if (pst
->read_symtab_private
== NULL
)
2124 /* It's an include file, no symbols to read for it.
2125 Everything is in the parent symtab. */
2130 dwarf2_per_objfile
= objfile_data (pst
->objfile
, dwarf2_objfile_data_key
);
2132 /* Set local variables from the partial symbol table info. */
2133 offset
= DWARF_INFO_OFFSET (pst
);
2135 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2136 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2138 /* We're in the global namespace. */
2139 processing_current_prefix
= "";
2141 obstack_init (&cu
.comp_unit_obstack
);
2142 back_to
= make_cleanup (free_stack_comp_unit
, &cu
);
2145 make_cleanup (really_free_pendings
, NULL
);
2147 cu
.objfile
= objfile
;
2149 /* read in the comp_unit header */
2150 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
2152 /* Read the abbrevs for this compilation unit */
2153 dwarf2_read_abbrevs (abfd
, &cu
);
2154 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
2156 cu
.header
.offset
= offset
;
2158 cu
.list_in_scope
= &file_symbols
;
2160 dies
= read_comp_unit (info_ptr
, abfd
, &cu
);
2162 make_cleanup_free_die_list (dies
);
2164 /* Find the base address of the compilation unit for range lists and
2165 location lists. It will normally be specified by DW_AT_low_pc.
2166 In DWARF-3 draft 4, the base address could be overridden by
2167 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2168 compilation units with discontinuous ranges. */
2170 cu
.header
.base_known
= 0;
2171 cu
.header
.base_address
= 0;
2173 attr
= dwarf2_attr (dies
, DW_AT_entry_pc
, &cu
);
2176 cu
.header
.base_address
= DW_ADDR (attr
);
2177 cu
.header
.base_known
= 1;
2181 attr
= dwarf2_attr (dies
, DW_AT_low_pc
, &cu
);
2184 cu
.header
.base_address
= DW_ADDR (attr
);
2185 cu
.header
.base_known
= 1;
2189 /* Do line number decoding in read_file_scope () */
2190 process_die (dies
, &cu
);
2192 /* Some compilers don't define a DW_AT_high_pc attribute for the
2193 compilation unit. If the DW_AT_high_pc is missing, synthesize
2194 it, by scanning the DIE's below the compilation unit. */
2195 get_scope_pc_bounds (dies
, &lowpc
, &highpc
, &cu
);
2197 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2199 /* Set symtab language to language from DW_AT_language.
2200 If the compilation is from a C file generated by language preprocessors,
2201 do not set the language if it was already deduced by start_subfile. */
2203 && !(cu
.language
== language_c
&& symtab
->language
!= language_c
))
2205 symtab
->language
= cu
.language
;
2207 pst
->symtab
= symtab
;
2210 do_cleanups (back_to
);
2213 /* Process a die and its children. */
2216 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2220 case DW_TAG_padding
:
2222 case DW_TAG_compile_unit
:
2223 read_file_scope (die
, cu
);
2225 case DW_TAG_subprogram
:
2226 read_subroutine_type (die
, cu
);
2227 read_func_scope (die
, cu
);
2229 case DW_TAG_inlined_subroutine
:
2230 /* FIXME: These are ignored for now.
2231 They could be used to set breakpoints on all inlined instances
2232 of a function and make GDB `next' properly over inlined functions. */
2234 case DW_TAG_lexical_block
:
2235 case DW_TAG_try_block
:
2236 case DW_TAG_catch_block
:
2237 read_lexical_block_scope (die
, cu
);
2239 case DW_TAG_class_type
:
2240 case DW_TAG_structure_type
:
2241 case DW_TAG_union_type
:
2242 read_structure_type (die
, cu
);
2243 process_structure_scope (die
, cu
);
2245 case DW_TAG_enumeration_type
:
2246 read_enumeration_type (die
, cu
);
2247 process_enumeration_scope (die
, cu
);
2250 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2251 a symbol or process any children. Therefore it doesn't do anything
2252 that won't be done on-demand by read_type_die. */
2253 case DW_TAG_subroutine_type
:
2254 read_subroutine_type (die
, cu
);
2256 case DW_TAG_array_type
:
2257 read_array_type (die
, cu
);
2259 case DW_TAG_pointer_type
:
2260 read_tag_pointer_type (die
, cu
);
2262 case DW_TAG_ptr_to_member_type
:
2263 read_tag_ptr_to_member_type (die
, cu
);
2265 case DW_TAG_reference_type
:
2266 read_tag_reference_type (die
, cu
);
2268 case DW_TAG_string_type
:
2269 read_tag_string_type (die
, cu
);
2273 case DW_TAG_base_type
:
2274 read_base_type (die
, cu
);
2275 /* Add a typedef symbol for the type definition, if it has a
2277 new_symbol (die
, die
->type
, cu
);
2279 case DW_TAG_subrange_type
:
2280 read_subrange_type (die
, cu
);
2281 /* Add a typedef symbol for the type definition, if it has a
2283 new_symbol (die
, die
->type
, cu
);
2285 case DW_TAG_common_block
:
2286 read_common_block (die
, cu
);
2288 case DW_TAG_common_inclusion
:
2290 case DW_TAG_namespace
:
2291 processing_has_namespace_info
= 1;
2292 read_namespace (die
, cu
);
2294 case DW_TAG_imported_declaration
:
2295 case DW_TAG_imported_module
:
2296 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2297 information contained in these. DW_TAG_imported_declaration
2298 dies shouldn't have children; DW_TAG_imported_module dies
2299 shouldn't in the C++ case, but conceivably could in the
2300 Fortran case, so we'll have to replace this gdb_assert if
2301 Fortran compilers start generating that info. */
2302 processing_has_namespace_info
= 1;
2303 gdb_assert (die
->child
== NULL
);
2306 new_symbol (die
, NULL
, cu
);
2312 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2314 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2318 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2320 struct objfile
*objfile
= cu
->objfile
;
2321 struct comp_unit_head
*cu_header
= &cu
->header
;
2322 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2323 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2324 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2325 struct attribute
*attr
;
2326 char *name
= "<unknown>";
2327 char *comp_dir
= NULL
;
2328 struct die_info
*child_die
;
2329 bfd
*abfd
= objfile
->obfd
;
2330 struct line_header
*line_header
= 0;
2333 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2335 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2337 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2338 from finish_block. */
2339 if (lowpc
== ((CORE_ADDR
) -1))
2344 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2347 name
= DW_STRING (attr
);
2349 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2352 comp_dir
= DW_STRING (attr
);
2355 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2356 directory, get rid of it. */
2357 char *cp
= strchr (comp_dir
, ':');
2359 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2364 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2367 set_cu_language (DW_UNSND (attr
), cu
);
2370 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2372 cu
->producer
= DW_STRING (attr
);
2374 /* We assume that we're processing GCC output. */
2375 processing_gcc_compilation
= 2;
2377 /* FIXME:Do something here. */
2378 if (dip
->at_producer
!= NULL
)
2380 handle_producer (dip
->at_producer
);
2384 /* The compilation unit may be in a different language or objfile,
2385 zero out all remembered fundamental types. */
2386 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2388 start_symtab (name
, comp_dir
, lowpc
);
2389 record_debugformat ("DWARF 2");
2391 initialize_cu_func_list (cu
);
2393 /* Process all dies in compilation unit. */
2394 if (die
->child
!= NULL
)
2396 child_die
= die
->child
;
2397 while (child_die
&& child_die
->tag
)
2399 process_die (child_die
, cu
);
2400 child_die
= sibling_die (child_die
);
2404 /* Decode line number information if present. */
2405 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2408 unsigned int line_offset
= DW_UNSND (attr
);
2409 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2412 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2413 (void *) line_header
);
2414 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2418 /* Decode macro information, if present. Dwarf 2 macro information
2419 refers to information in the line number info statement program
2420 header, so we can only read it if we've read the header
2422 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2423 if (attr
&& line_header
)
2425 unsigned int macro_offset
= DW_UNSND (attr
);
2426 dwarf_decode_macros (line_header
, macro_offset
,
2427 comp_dir
, abfd
, cu
);
2429 do_cleanups (back_to
);
2433 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2434 struct dwarf2_cu
*cu
)
2436 struct function_range
*thisfn
;
2438 thisfn
= (struct function_range
*)
2439 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2440 thisfn
->name
= name
;
2441 thisfn
->lowpc
= lowpc
;
2442 thisfn
->highpc
= highpc
;
2443 thisfn
->seen_line
= 0;
2444 thisfn
->next
= NULL
;
2446 if (cu
->last_fn
== NULL
)
2447 cu
->first_fn
= thisfn
;
2449 cu
->last_fn
->next
= thisfn
;
2451 cu
->last_fn
= thisfn
;
2455 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2457 struct objfile
*objfile
= cu
->objfile
;
2458 struct context_stack
*new;
2461 struct die_info
*child_die
;
2462 struct attribute
*attr
;
2464 const char *previous_prefix
= processing_current_prefix
;
2465 struct cleanup
*back_to
= NULL
;
2468 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2470 name
= dwarf2_linkage_name (die
, cu
);
2472 /* Ignore functions with missing or empty names and functions with
2473 missing or invalid low and high pc attributes. */
2474 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2477 if (cu
->language
== language_cplus
)
2479 struct die_info
*spec_die
= die_specification (die
, cu
);
2481 /* NOTE: carlton/2004-01-23: We have to be careful in the
2482 presence of DW_AT_specification. For example, with GCC 3.4,
2487 // Definition of N::foo.
2491 then we'll have a tree of DIEs like this:
2493 1: DW_TAG_compile_unit
2494 2: DW_TAG_namespace // N
2495 3: DW_TAG_subprogram // declaration of N::foo
2496 4: DW_TAG_subprogram // definition of N::foo
2497 DW_AT_specification // refers to die #3
2499 Thus, when processing die #4, we have to pretend that we're
2500 in the context of its DW_AT_specification, namely the contex
2503 if (spec_die
!= NULL
)
2505 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2506 processing_current_prefix
= specification_prefix
;
2507 back_to
= make_cleanup (xfree
, specification_prefix
);
2514 /* Record the function range for dwarf_decode_lines. */
2515 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2517 new = push_context (0, lowpc
);
2518 new->name
= new_symbol (die
, die
->type
, cu
);
2520 /* If there is a location expression for DW_AT_frame_base, record
2522 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2524 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2525 expression is being recorded directly in the function's symbol
2526 and not in a separate frame-base object. I guess this hack is
2527 to avoid adding some sort of frame-base adjunct/annex to the
2528 function's symbol :-(. The problem with doing this is that it
2529 results in a function symbol with a location expression that
2530 has nothing to do with the location of the function, ouch! The
2531 relationship should be: a function's symbol has-a frame base; a
2532 frame-base has-a location expression. */
2533 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2535 cu
->list_in_scope
= &local_symbols
;
2537 if (die
->child
!= NULL
)
2539 child_die
= die
->child
;
2540 while (child_die
&& child_die
->tag
)
2542 process_die (child_die
, cu
);
2543 child_die
= sibling_die (child_die
);
2547 new = pop_context ();
2548 /* Make a block for the local symbols within. */
2549 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2550 lowpc
, highpc
, objfile
);
2552 /* In C++, we can have functions nested inside functions (e.g., when
2553 a function declares a class that has methods). This means that
2554 when we finish processing a function scope, we may need to go
2555 back to building a containing block's symbol lists. */
2556 local_symbols
= new->locals
;
2557 param_symbols
= new->params
;
2559 /* If we've finished processing a top-level function, subsequent
2560 symbols go in the file symbol list. */
2561 if (outermost_context_p ())
2562 cu
->list_in_scope
= &file_symbols
;
2564 processing_current_prefix
= previous_prefix
;
2565 if (back_to
!= NULL
)
2566 do_cleanups (back_to
);
2569 /* Process all the DIES contained within a lexical block scope. Start
2570 a new scope, process the dies, and then close the scope. */
2573 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2575 struct objfile
*objfile
= cu
->objfile
;
2576 struct context_stack
*new;
2577 CORE_ADDR lowpc
, highpc
;
2578 struct die_info
*child_die
;
2581 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2583 /* Ignore blocks with missing or invalid low and high pc attributes. */
2584 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2585 as multiple lexical blocks? Handling children in a sane way would
2586 be nasty. Might be easier to properly extend generic blocks to
2588 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2593 push_context (0, lowpc
);
2594 if (die
->child
!= NULL
)
2596 child_die
= die
->child
;
2597 while (child_die
&& child_die
->tag
)
2599 process_die (child_die
, cu
);
2600 child_die
= sibling_die (child_die
);
2603 new = pop_context ();
2605 if (local_symbols
!= NULL
)
2607 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2610 local_symbols
= new->locals
;
2613 /* Get low and high pc attributes from a die. Return 1 if the attributes
2614 are present and valid, otherwise, return 0. Return -1 if the range is
2615 discontinuous, i.e. derived from DW_AT_ranges information. */
2617 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
2618 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
2620 struct objfile
*objfile
= cu
->objfile
;
2621 struct comp_unit_head
*cu_header
= &cu
->header
;
2622 struct attribute
*attr
;
2623 bfd
*obfd
= objfile
->obfd
;
2628 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
2631 high
= DW_ADDR (attr
);
2632 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
2634 low
= DW_ADDR (attr
);
2636 /* Found high w/o low attribute. */
2639 /* Found consecutive range of addresses. */
2644 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
2647 unsigned int addr_size
= cu_header
->addr_size
;
2648 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2649 /* Value of the DW_AT_ranges attribute is the offset in the
2650 .debug_ranges section. */
2651 unsigned int offset
= DW_UNSND (attr
);
2652 /* Base address selection entry. */
2660 found_base
= cu_header
->base_known
;
2661 base
= cu_header
->base_address
;
2663 if (offset
>= dwarf2_per_objfile
->ranges_size
)
2665 complaint (&symfile_complaints
,
2666 "Offset %d out of bounds for DW_AT_ranges attribute",
2670 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
2672 /* Read in the largest possible address. */
2673 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
2674 if ((marker
& mask
) == mask
)
2676 /* If we found the largest possible address, then
2677 read the base address. */
2678 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2679 buffer
+= 2 * addr_size
;
2680 offset
+= 2 * addr_size
;
2688 CORE_ADDR range_beginning
, range_end
;
2690 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
2691 buffer
+= addr_size
;
2692 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
2693 buffer
+= addr_size
;
2694 offset
+= 2 * addr_size
;
2696 /* An end of list marker is a pair of zero addresses. */
2697 if (range_beginning
== 0 && range_end
== 0)
2698 /* Found the end of list entry. */
2701 /* Each base address selection entry is a pair of 2 values.
2702 The first is the largest possible address, the second is
2703 the base address. Check for a base address here. */
2704 if ((range_beginning
& mask
) == mask
)
2706 /* If we found the largest possible address, then
2707 read the base address. */
2708 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2715 /* We have no valid base address for the ranges
2717 complaint (&symfile_complaints
,
2718 "Invalid .debug_ranges data (no base address)");
2722 range_beginning
+= base
;
2725 /* FIXME: This is recording everything as a low-high
2726 segment of consecutive addresses. We should have a
2727 data structure for discontiguous block ranges
2731 low
= range_beginning
;
2737 if (range_beginning
< low
)
2738 low
= range_beginning
;
2739 if (range_end
> high
)
2745 /* If the first entry is an end-of-list marker, the range
2746 describes an empty scope, i.e. no instructions. */
2756 /* When using the GNU linker, .gnu.linkonce. sections are used to
2757 eliminate duplicate copies of functions and vtables and such.
2758 The linker will arbitrarily choose one and discard the others.
2759 The AT_*_pc values for such functions refer to local labels in
2760 these sections. If the section from that file was discarded, the
2761 labels are not in the output, so the relocs get a value of 0.
2762 If this is a discarded function, mark the pc bounds as invalid,
2763 so that GDB will ignore it. */
2764 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
2772 /* Get the low and high pc's represented by the scope DIE, and store
2773 them in *LOWPC and *HIGHPC. If the correct values can't be
2774 determined, set *LOWPC to -1 and *HIGHPC to 0. */
2777 get_scope_pc_bounds (struct die_info
*die
,
2778 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2779 struct dwarf2_cu
*cu
)
2781 CORE_ADDR best_low
= (CORE_ADDR
) -1;
2782 CORE_ADDR best_high
= (CORE_ADDR
) 0;
2783 CORE_ADDR current_low
, current_high
;
2785 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
2787 best_low
= current_low
;
2788 best_high
= current_high
;
2792 struct die_info
*child
= die
->child
;
2794 while (child
&& child
->tag
)
2796 switch (child
->tag
) {
2797 case DW_TAG_subprogram
:
2798 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
2800 best_low
= min (best_low
, current_low
);
2801 best_high
= max (best_high
, current_high
);
2804 case DW_TAG_namespace
:
2805 /* FIXME: carlton/2004-01-16: Should we do this for
2806 DW_TAG_class_type/DW_TAG_structure_type, too? I think
2807 that current GCC's always emit the DIEs corresponding
2808 to definitions of methods of classes as children of a
2809 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
2810 the DIEs giving the declarations, which could be
2811 anywhere). But I don't see any reason why the
2812 standards says that they have to be there. */
2813 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
2815 if (current_low
!= ((CORE_ADDR
) -1))
2817 best_low
= min (best_low
, current_low
);
2818 best_high
= max (best_high
, current_high
);
2826 child
= sibling_die (child
);
2831 *highpc
= best_high
;
2834 /* Add an aggregate field to the field list. */
2837 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2838 struct dwarf2_cu
*cu
)
2840 struct objfile
*objfile
= cu
->objfile
;
2841 struct nextfield
*new_field
;
2842 struct attribute
*attr
;
2844 char *fieldname
= "";
2846 /* Allocate a new field list entry and link it in. */
2847 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2848 make_cleanup (xfree
, new_field
);
2849 memset (new_field
, 0, sizeof (struct nextfield
));
2850 new_field
->next
= fip
->fields
;
2851 fip
->fields
= new_field
;
2854 /* Handle accessibility and virtuality of field.
2855 The default accessibility for members is public, the default
2856 accessibility for inheritance is private. */
2857 if (die
->tag
!= DW_TAG_inheritance
)
2858 new_field
->accessibility
= DW_ACCESS_public
;
2860 new_field
->accessibility
= DW_ACCESS_private
;
2861 new_field
->virtuality
= DW_VIRTUALITY_none
;
2863 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
2865 new_field
->accessibility
= DW_UNSND (attr
);
2866 if (new_field
->accessibility
!= DW_ACCESS_public
)
2867 fip
->non_public_fields
= 1;
2868 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
2870 new_field
->virtuality
= DW_UNSND (attr
);
2872 fp
= &new_field
->field
;
2874 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
2876 /* Data member other than a C++ static data member. */
2878 /* Get type of field. */
2879 fp
->type
= die_type (die
, cu
);
2881 FIELD_STATIC_KIND (*fp
) = 0;
2883 /* Get bit size of field (zero if none). */
2884 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
2887 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2891 FIELD_BITSIZE (*fp
) = 0;
2894 /* Get bit offset of field. */
2895 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
2898 FIELD_BITPOS (*fp
) =
2899 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
2902 FIELD_BITPOS (*fp
) = 0;
2903 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
2906 if (BITS_BIG_ENDIAN
)
2908 /* For big endian bits, the DW_AT_bit_offset gives the
2909 additional bit offset from the MSB of the containing
2910 anonymous object to the MSB of the field. We don't
2911 have to do anything special since we don't need to
2912 know the size of the anonymous object. */
2913 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2917 /* For little endian bits, compute the bit offset to the
2918 MSB of the anonymous object, subtract off the number of
2919 bits from the MSB of the field to the MSB of the
2920 object, and then subtract off the number of bits of
2921 the field itself. The result is the bit offset of
2922 the LSB of the field. */
2924 int bit_offset
= DW_UNSND (attr
);
2926 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
2929 /* The size of the anonymous object containing
2930 the bit field is explicit, so use the
2931 indicated size (in bytes). */
2932 anonymous_size
= DW_UNSND (attr
);
2936 /* The size of the anonymous object containing
2937 the bit field must be inferred from the type
2938 attribute of the data member containing the
2940 anonymous_size
= TYPE_LENGTH (fp
->type
);
2942 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2943 - bit_offset
- FIELD_BITSIZE (*fp
);
2947 /* Get name of field. */
2948 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2949 if (attr
&& DW_STRING (attr
))
2950 fieldname
= DW_STRING (attr
);
2952 /* The name is already allocated along with this objfile, so we don't
2953 need to duplicate it for the type. */
2954 fp
->name
= fieldname
;
2956 /* Change accessibility for artificial fields (e.g. virtual table
2957 pointer or virtual base class pointer) to private. */
2958 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
2960 new_field
->accessibility
= DW_ACCESS_private
;
2961 fip
->non_public_fields
= 1;
2964 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
2966 /* C++ static member. */
2968 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2969 is a declaration, but all versions of G++ as of this writing
2970 (so through at least 3.2.1) incorrectly generate
2971 DW_TAG_variable tags. */
2975 /* Get name of field. */
2976 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2977 if (attr
&& DW_STRING (attr
))
2978 fieldname
= DW_STRING (attr
);
2982 /* Get physical name. */
2983 physname
= dwarf2_linkage_name (die
, cu
);
2985 /* The name is already allocated along with this objfile, so we don't
2986 need to duplicate it for the type. */
2987 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
2988 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2989 FIELD_NAME (*fp
) = fieldname
;
2991 else if (die
->tag
== DW_TAG_inheritance
)
2993 /* C++ base class field. */
2994 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
2996 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
2998 FIELD_BITSIZE (*fp
) = 0;
2999 FIELD_STATIC_KIND (*fp
) = 0;
3000 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3001 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3002 fip
->nbaseclasses
++;
3006 /* Create the vector of fields, and attach it to the type. */
3009 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3010 struct dwarf2_cu
*cu
)
3012 int nfields
= fip
->nfields
;
3014 /* Record the field count, allocate space for the array of fields,
3015 and create blank accessibility bitfields if necessary. */
3016 TYPE_NFIELDS (type
) = nfields
;
3017 TYPE_FIELDS (type
) = (struct field
*)
3018 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3019 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3021 if (fip
->non_public_fields
)
3023 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3025 TYPE_FIELD_PRIVATE_BITS (type
) =
3026 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3027 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3029 TYPE_FIELD_PROTECTED_BITS (type
) =
3030 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3031 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3033 TYPE_FIELD_IGNORE_BITS (type
) =
3034 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3035 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3038 /* If the type has baseclasses, allocate and clear a bit vector for
3039 TYPE_FIELD_VIRTUAL_BITS. */
3040 if (fip
->nbaseclasses
)
3042 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3045 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3046 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3047 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3048 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3049 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3052 /* Copy the saved-up fields into the field vector. Start from the head
3053 of the list, adding to the tail of the field array, so that they end
3054 up in the same order in the array in which they were added to the list. */
3055 while (nfields
-- > 0)
3057 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3058 switch (fip
->fields
->accessibility
)
3060 case DW_ACCESS_private
:
3061 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3064 case DW_ACCESS_protected
:
3065 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3068 case DW_ACCESS_public
:
3072 /* Unknown accessibility. Complain and treat it as public. */
3074 complaint (&symfile_complaints
, "unsupported accessibility %d",
3075 fip
->fields
->accessibility
);
3079 if (nfields
< fip
->nbaseclasses
)
3081 switch (fip
->fields
->virtuality
)
3083 case DW_VIRTUALITY_virtual
:
3084 case DW_VIRTUALITY_pure_virtual
:
3085 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3089 fip
->fields
= fip
->fields
->next
;
3093 /* Add a member function to the proper fieldlist. */
3096 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3097 struct type
*type
, struct dwarf2_cu
*cu
)
3099 struct objfile
*objfile
= cu
->objfile
;
3100 struct attribute
*attr
;
3101 struct fnfieldlist
*flp
;
3103 struct fn_field
*fnp
;
3106 struct nextfnfield
*new_fnfield
;
3108 /* Get name of member function. */
3109 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3110 if (attr
&& DW_STRING (attr
))
3111 fieldname
= DW_STRING (attr
);
3115 /* Get the mangled name. */
3116 physname
= dwarf2_linkage_name (die
, cu
);
3118 /* Look up member function name in fieldlist. */
3119 for (i
= 0; i
< fip
->nfnfields
; i
++)
3121 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3125 /* Create new list element if necessary. */
3126 if (i
< fip
->nfnfields
)
3127 flp
= &fip
->fnfieldlists
[i
];
3130 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3132 fip
->fnfieldlists
= (struct fnfieldlist
*)
3133 xrealloc (fip
->fnfieldlists
,
3134 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3135 * sizeof (struct fnfieldlist
));
3136 if (fip
->nfnfields
== 0)
3137 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3139 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3140 flp
->name
= fieldname
;
3146 /* Create a new member function field and chain it to the field list
3148 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3149 make_cleanup (xfree
, new_fnfield
);
3150 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3151 new_fnfield
->next
= flp
->head
;
3152 flp
->head
= new_fnfield
;
3155 /* Fill in the member function field info. */
3156 fnp
= &new_fnfield
->fnfield
;
3157 /* The name is already allocated along with this objfile, so we don't
3158 need to duplicate it for the type. */
3159 fnp
->physname
= physname
? physname
: "";
3160 fnp
->type
= alloc_type (objfile
);
3161 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3163 int nparams
= TYPE_NFIELDS (die
->type
);
3165 /* TYPE is the domain of this method, and DIE->TYPE is the type
3166 of the method itself (TYPE_CODE_METHOD). */
3167 smash_to_method_type (fnp
->type
, type
,
3168 TYPE_TARGET_TYPE (die
->type
),
3169 TYPE_FIELDS (die
->type
),
3170 TYPE_NFIELDS (die
->type
),
3171 TYPE_VARARGS (die
->type
));
3173 /* Handle static member functions.
3174 Dwarf2 has no clean way to discern C++ static and non-static
3175 member functions. G++ helps GDB by marking the first
3176 parameter for non-static member functions (which is the
3177 this pointer) as artificial. We obtain this information
3178 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3179 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3180 fnp
->voffset
= VOFFSET_STATIC
;
3183 complaint (&symfile_complaints
, "member function type missing for '%s'",
3186 /* Get fcontext from DW_AT_containing_type if present. */
3187 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3188 fnp
->fcontext
= die_containing_type (die
, cu
);
3190 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3191 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3193 /* Get accessibility. */
3194 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3197 switch (DW_UNSND (attr
))
3199 case DW_ACCESS_private
:
3200 fnp
->is_private
= 1;
3202 case DW_ACCESS_protected
:
3203 fnp
->is_protected
= 1;
3208 /* Check for artificial methods. */
3209 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3210 if (attr
&& DW_UNSND (attr
) != 0)
3211 fnp
->is_artificial
= 1;
3213 /* Get index in virtual function table if it is a virtual member function. */
3214 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3217 /* Support the .debug_loc offsets */
3218 if (attr_form_is_block (attr
))
3220 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3222 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3224 dwarf2_complex_location_expr_complaint ();
3228 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3234 /* Create the vector of member function fields, and attach it to the type. */
3237 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3238 struct dwarf2_cu
*cu
)
3240 struct fnfieldlist
*flp
;
3241 int total_length
= 0;
3244 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3245 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3246 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3248 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3250 struct nextfnfield
*nfp
= flp
->head
;
3251 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3254 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3255 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3256 fn_flp
->fn_fields
= (struct fn_field
*)
3257 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3258 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3259 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3261 total_length
+= flp
->length
;
3264 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3265 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3269 /* Returns non-zero if NAME is the name of a vtable member in CU's
3270 language, zero otherwise. */
3272 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3274 static const char vptr
[] = "_vptr";
3276 /* C++ and some implementations of Java use this name. */
3277 if (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3278 && is_cplus_marker (name
[sizeof (vptr
) - 1]))
3285 /* Called when we find the DIE that starts a structure or union scope
3286 (definition) to process all dies that define the members of the
3289 NOTE: we need to call struct_type regardless of whether or not the
3290 DIE has an at_name attribute, since it might be an anonymous
3291 structure or union. This gets the type entered into our set of
3294 However, if the structure is incomplete (an opaque struct/union)
3295 then suppress creating a symbol table entry for it since gdb only
3296 wants to find the one with the complete definition. Note that if
3297 it is complete, we just call new_symbol, which does it's own
3298 checking about whether the struct/union is anonymous or not (and
3299 suppresses creating a symbol table entry itself). */
3302 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3304 struct objfile
*objfile
= cu
->objfile
;
3306 struct attribute
*attr
;
3307 const char *previous_prefix
= processing_current_prefix
;
3308 struct cleanup
*back_to
= NULL
;
3313 type
= alloc_type (objfile
);
3315 INIT_CPLUS_SPECIFIC (type
);
3316 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3317 if (attr
&& DW_STRING (attr
))
3319 if (cu
->language
== language_cplus
)
3321 char *new_prefix
= determine_class_name (die
, cu
);
3322 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3323 strlen (new_prefix
),
3324 &objfile
->objfile_obstack
);
3325 back_to
= make_cleanup (xfree
, new_prefix
);
3326 processing_current_prefix
= new_prefix
;
3330 /* The name is already allocated along with this objfile, so
3331 we don't need to duplicate it for the type. */
3332 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3336 if (die
->tag
== DW_TAG_structure_type
)
3338 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3340 else if (die
->tag
== DW_TAG_union_type
)
3342 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3346 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3348 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3351 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3354 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3358 TYPE_LENGTH (type
) = 0;
3361 if (die_is_declaration (die
, cu
))
3362 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3364 /* We need to add the type field to the die immediately so we don't
3365 infinitely recurse when dealing with pointers to the structure
3366 type within the structure itself. */
3369 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3371 struct field_info fi
;
3372 struct die_info
*child_die
;
3373 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3375 memset (&fi
, 0, sizeof (struct field_info
));
3377 child_die
= die
->child
;
3379 while (child_die
&& child_die
->tag
)
3381 if (child_die
->tag
== DW_TAG_member
3382 || child_die
->tag
== DW_TAG_variable
)
3384 /* NOTE: carlton/2002-11-05: A C++ static data member
3385 should be a DW_TAG_member that is a declaration, but
3386 all versions of G++ as of this writing (so through at
3387 least 3.2.1) incorrectly generate DW_TAG_variable
3388 tags for them instead. */
3389 dwarf2_add_field (&fi
, child_die
, cu
);
3391 else if (child_die
->tag
== DW_TAG_subprogram
)
3393 /* C++ member function. */
3394 read_type_die (child_die
, cu
);
3395 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3397 else if (child_die
->tag
== DW_TAG_inheritance
)
3399 /* C++ base class field. */
3400 dwarf2_add_field (&fi
, child_die
, cu
);
3402 child_die
= sibling_die (child_die
);
3405 /* Attach fields and member functions to the type. */
3407 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3410 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3412 /* Get the type which refers to the base class (possibly this
3413 class itself) which contains the vtable pointer for the current
3414 class from the DW_AT_containing_type attribute. */
3416 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3418 struct type
*t
= die_containing_type (die
, cu
);
3420 TYPE_VPTR_BASETYPE (type
) = t
;
3425 /* Our own class provides vtbl ptr. */
3426 for (i
= TYPE_NFIELDS (t
) - 1;
3427 i
>= TYPE_N_BASECLASSES (t
);
3430 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3432 if (is_vtable_name (fieldname
, cu
))
3434 TYPE_VPTR_FIELDNO (type
) = i
;
3439 /* Complain if virtual function table field not found. */
3440 if (i
< TYPE_N_BASECLASSES (t
))
3441 complaint (&symfile_complaints
,
3442 "virtual function table pointer not found when defining class '%s'",
3443 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3448 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3453 do_cleanups (back_to
);
3456 processing_current_prefix
= previous_prefix
;
3457 if (back_to
!= NULL
)
3458 do_cleanups (back_to
);
3462 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3464 struct objfile
*objfile
= cu
->objfile
;
3465 const char *previous_prefix
= processing_current_prefix
;
3466 struct die_info
*child_die
= die
->child
;
3468 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3469 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3471 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3472 snapshots) has been known to create a die giving a declaration
3473 for a class that has, as a child, a die giving a definition for a
3474 nested class. So we have to process our children even if the
3475 current die is a declaration. Normally, of course, a declaration
3476 won't have any children at all. */
3478 while (child_die
!= NULL
&& child_die
->tag
)
3480 if (child_die
->tag
== DW_TAG_member
3481 || child_die
->tag
== DW_TAG_variable
3482 || child_die
->tag
== DW_TAG_inheritance
)
3487 process_die (child_die
, cu
);
3489 child_die
= sibling_die (child_die
);
3492 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3493 new_symbol (die
, die
->type
, cu
);
3495 processing_current_prefix
= previous_prefix
;
3498 /* Given a DW_AT_enumeration_type die, set its type. We do not
3499 complete the type's fields yet, or create any symbols. */
3502 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3504 struct objfile
*objfile
= cu
->objfile
;
3506 struct attribute
*attr
;
3511 type
= alloc_type (objfile
);
3513 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3514 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3515 if (attr
&& DW_STRING (attr
))
3517 char *name
= DW_STRING (attr
);
3519 if (processing_has_namespace_info
)
3521 TYPE_TAG_NAME (type
) = obconcat (&objfile
->objfile_obstack
,
3522 processing_current_prefix
,
3523 processing_current_prefix
[0] == '\0'
3529 /* The name is already allocated along with this objfile, so
3530 we don't need to duplicate it for the type. */
3531 TYPE_TAG_NAME (type
) = name
;
3535 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3538 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3542 TYPE_LENGTH (type
) = 0;
3548 /* Determine the name of the type represented by DIE, which should be
3549 a named C++ compound type. Return the name in question; the caller
3550 is responsible for xfree()'ing it. */
3553 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3555 struct cleanup
*back_to
= NULL
;
3556 struct die_info
*spec_die
= die_specification (die
, cu
);
3557 char *new_prefix
= NULL
;
3559 /* If this is the definition of a class that is declared by another
3560 die, then processing_current_prefix may not be accurate; see
3561 read_func_scope for a similar example. */
3562 if (spec_die
!= NULL
)
3564 char *specification_prefix
= determine_prefix (spec_die
, cu
);
3565 processing_current_prefix
= specification_prefix
;
3566 back_to
= make_cleanup (xfree
, specification_prefix
);
3569 /* If we don't have namespace debug info, guess the name by trying
3570 to demangle the names of members, just like we did in
3571 guess_structure_name. */
3572 if (!processing_has_namespace_info
)
3574 struct die_info
*child
;
3576 for (child
= die
->child
;
3577 child
!= NULL
&& child
->tag
!= 0;
3578 child
= sibling_die (child
))
3580 if (child
->tag
== DW_TAG_subprogram
)
3583 = language_class_name_from_physname (cu
->language_defn
,
3587 if (new_prefix
!= NULL
)
3593 if (new_prefix
== NULL
)
3595 const char *name
= dwarf2_name (die
, cu
);
3596 new_prefix
= typename_concat (processing_current_prefix
,
3597 name
? name
: "<<anonymous>>");
3600 if (back_to
!= NULL
)
3601 do_cleanups (back_to
);
3606 /* Given a pointer to a die which begins an enumeration, process all
3607 the dies that define the members of the enumeration, and create the
3608 symbol for the enumeration type.
3610 NOTE: We reverse the order of the element list. */
3613 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3615 struct objfile
*objfile
= cu
->objfile
;
3616 struct die_info
*child_die
;
3617 struct field
*fields
;
3618 struct attribute
*attr
;
3621 int unsigned_enum
= 1;
3625 if (die
->child
!= NULL
)
3627 child_die
= die
->child
;
3628 while (child_die
&& child_die
->tag
)
3630 if (child_die
->tag
!= DW_TAG_enumerator
)
3632 process_die (child_die
, cu
);
3636 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
3639 sym
= new_symbol (child_die
, die
->type
, cu
);
3640 if (SYMBOL_VALUE (sym
) < 0)
3643 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3645 fields
= (struct field
*)
3647 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
3648 * sizeof (struct field
));
3651 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
3652 FIELD_TYPE (fields
[num_fields
]) = NULL
;
3653 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
3654 FIELD_BITSIZE (fields
[num_fields
]) = 0;
3655 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
3661 child_die
= sibling_die (child_die
);
3666 TYPE_NFIELDS (die
->type
) = num_fields
;
3667 TYPE_FIELDS (die
->type
) = (struct field
*)
3668 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
3669 memcpy (TYPE_FIELDS (die
->type
), fields
,
3670 sizeof (struct field
) * num_fields
);
3674 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
3677 new_symbol (die
, die
->type
, cu
);
3680 /* Extract all information from a DW_TAG_array_type DIE and put it in
3681 the DIE's type field. For now, this only handles one dimensional
3685 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3687 struct objfile
*objfile
= cu
->objfile
;
3688 struct die_info
*child_die
;
3689 struct type
*type
= NULL
;
3690 struct type
*element_type
, *range_type
, *index_type
;
3691 struct type
**range_types
= NULL
;
3692 struct attribute
*attr
;
3694 struct cleanup
*back_to
;
3696 /* Return if we've already decoded this type. */
3702 element_type
= die_type (die
, cu
);
3704 /* Irix 6.2 native cc creates array types without children for
3705 arrays with unspecified length. */
3706 if (die
->child
== NULL
)
3708 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
3709 range_type
= create_range_type (NULL
, index_type
, 0, -1);
3710 die
->type
= create_array_type (NULL
, element_type
, range_type
);
3714 back_to
= make_cleanup (null_cleanup
, NULL
);
3715 child_die
= die
->child
;
3716 while (child_die
&& child_die
->tag
)
3718 if (child_die
->tag
== DW_TAG_subrange_type
)
3720 read_subrange_type (child_die
, cu
);
3722 if (child_die
->type
!= NULL
)
3724 /* The range type was succesfully read. Save it for
3725 the array type creation. */
3726 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
3728 range_types
= (struct type
**)
3729 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
3730 * sizeof (struct type
*));
3732 make_cleanup (free_current_contents
, &range_types
);
3734 range_types
[ndim
++] = child_die
->type
;
3737 child_die
= sibling_die (child_die
);
3740 /* Dwarf2 dimensions are output from left to right, create the
3741 necessary array types in backwards order. */
3743 type
= element_type
;
3745 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
3749 type
= create_array_type (NULL
, type
, range_types
[i
++]);
3754 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
3757 /* Understand Dwarf2 support for vector types (like they occur on
3758 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3759 array type. This is not part of the Dwarf2/3 standard yet, but a
3760 custom vendor extension. The main difference between a regular
3761 array and the vector variant is that vectors are passed by value
3763 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
3765 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
3767 do_cleanups (back_to
);
3769 /* Install the type in the die. */
3773 static enum dwarf_array_dim_ordering
3774 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
3776 struct attribute
*attr
;
3778 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
3780 if (attr
) return DW_SND (attr
);
3783 GNU F77 is a special case, as at 08/2004 array type info is the
3784 opposite order to the dwarf2 specification, but data is still
3785 laid out as per normal fortran.
3787 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
3791 if (cu
->language
== language_fortran
&&
3792 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
3794 return DW_ORD_row_major
;
3797 switch (cu
->language_defn
->la_array_ordering
)
3799 case array_column_major
:
3800 return DW_ORD_col_major
;
3801 case array_row_major
:
3803 return DW_ORD_row_major
;
3808 /* First cut: install each common block member as a global variable. */
3811 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
3813 struct die_info
*child_die
;
3814 struct attribute
*attr
;
3816 CORE_ADDR base
= (CORE_ADDR
) 0;
3818 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
3821 /* Support the .debug_loc offsets */
3822 if (attr_form_is_block (attr
))
3824 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
3826 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3828 dwarf2_complex_location_expr_complaint ();
3832 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3833 "common block member");
3836 if (die
->child
!= NULL
)
3838 child_die
= die
->child
;
3839 while (child_die
&& child_die
->tag
)
3841 sym
= new_symbol (child_die
, NULL
, cu
);
3842 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
3845 SYMBOL_VALUE_ADDRESS (sym
) =
3846 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
3847 add_symbol_to_list (sym
, &global_symbols
);
3849 child_die
= sibling_die (child_die
);
3854 /* Read a C++ namespace. */
3857 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
3859 struct objfile
*objfile
= cu
->objfile
;
3860 const char *previous_prefix
= processing_current_prefix
;
3863 struct die_info
*current_die
;
3865 name
= namespace_name (die
, &is_anonymous
, cu
);
3867 /* Now build the name of the current namespace. */
3869 if (previous_prefix
[0] == '\0')
3871 processing_current_prefix
= name
;
3875 /* We need temp_name around because processing_current_prefix
3876 is a const char *. */
3877 char *temp_name
= alloca (strlen (previous_prefix
)
3878 + 2 + strlen(name
) + 1);
3879 strcpy (temp_name
, previous_prefix
);
3880 strcat (temp_name
, "::");
3881 strcat (temp_name
, name
);
3883 processing_current_prefix
= temp_name
;
3886 /* Add a symbol associated to this if we haven't seen the namespace
3887 before. Also, add a using directive if it's an anonymous
3890 if (dwarf2_extension (die
, cu
) == NULL
)
3894 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3895 this cast will hopefully become unnecessary. */
3896 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
3897 (char *) processing_current_prefix
,
3899 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
3901 new_symbol (die
, type
, cu
);
3905 cp_add_using_directive (processing_current_prefix
,
3906 strlen (previous_prefix
),
3907 strlen (processing_current_prefix
));
3910 if (die
->child
!= NULL
)
3912 struct die_info
*child_die
= die
->child
;
3914 while (child_die
&& child_die
->tag
)
3916 process_die (child_die
, cu
);
3917 child_die
= sibling_die (child_die
);
3921 processing_current_prefix
= previous_prefix
;
3924 /* Return the name of the namespace represented by DIE. Set
3925 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
3929 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
3931 struct die_info
*current_die
;
3932 const char *name
= NULL
;
3934 /* Loop through the extensions until we find a name. */
3936 for (current_die
= die
;
3937 current_die
!= NULL
;
3938 current_die
= dwarf2_extension (die
, cu
))
3940 name
= dwarf2_name (current_die
, cu
);
3945 /* Is it an anonymous namespace? */
3947 *is_anonymous
= (name
== NULL
);
3949 name
= "(anonymous namespace)";
3954 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3955 the user defined type vector. */
3958 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3960 struct comp_unit_head
*cu_header
= &cu
->header
;
3962 struct attribute
*attr_byte_size
;
3963 struct attribute
*attr_address_class
;
3964 int byte_size
, addr_class
;
3971 type
= lookup_pointer_type (die_type (die
, cu
));
3973 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3975 byte_size
= DW_UNSND (attr_byte_size
);
3977 byte_size
= cu_header
->addr_size
;
3979 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
3980 if (attr_address_class
)
3981 addr_class
= DW_UNSND (attr_address_class
);
3983 addr_class
= DW_ADDR_none
;
3985 /* If the pointer size or address class is different than the
3986 default, create a type variant marked as such and set the
3987 length accordingly. */
3988 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3990 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3994 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3995 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3996 type
= make_type_with_address_space (type
, type_flags
);
3998 else if (TYPE_LENGTH (type
) != byte_size
)
4000 complaint (&symfile_complaints
, "invalid pointer size %d", byte_size
);
4003 /* Should we also complain about unhandled address classes? */
4007 TYPE_LENGTH (type
) = byte_size
;
4011 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4012 the user defined type vector. */
4015 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4017 struct objfile
*objfile
= cu
->objfile
;
4019 struct type
*to_type
;
4020 struct type
*domain
;
4027 type
= alloc_type (objfile
);
4028 to_type
= die_type (die
, cu
);
4029 domain
= die_containing_type (die
, cu
);
4030 smash_to_member_type (type
, domain
, to_type
);
4035 /* Extract all information from a DW_TAG_reference_type DIE and add to
4036 the user defined type vector. */
4039 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4041 struct comp_unit_head
*cu_header
= &cu
->header
;
4043 struct attribute
*attr
;
4050 type
= lookup_reference_type (die_type (die
, cu
));
4051 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4054 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4058 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4064 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4066 struct type
*base_type
;
4073 base_type
= die_type (die
, cu
);
4074 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
4078 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4080 struct type
*base_type
;
4087 base_type
= die_type (die
, cu
);
4088 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
4091 /* Extract all information from a DW_TAG_string_type DIE and add to
4092 the user defined type vector. It isn't really a user defined type,
4093 but it behaves like one, with other DIE's using an AT_user_def_type
4094 attribute to reference it. */
4097 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4099 struct objfile
*objfile
= cu
->objfile
;
4100 struct type
*type
, *range_type
, *index_type
, *char_type
;
4101 struct attribute
*attr
;
4102 unsigned int length
;
4109 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4112 length
= DW_UNSND (attr
);
4116 /* check for the DW_AT_byte_size attribute */
4117 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4120 length
= DW_UNSND (attr
);
4127 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4128 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4129 if (cu
->language
== language_fortran
)
4131 /* Need to create a unique string type for bounds
4133 type
= create_string_type (0, range_type
);
4137 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4138 type
= create_string_type (char_type
, range_type
);
4143 /* Handle DIES due to C code like:
4147 int (*funcp)(int a, long l);
4151 ('funcp' generates a DW_TAG_subroutine_type DIE)
4155 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4157 struct type
*type
; /* Type that this function returns */
4158 struct type
*ftype
; /* Function that returns above type */
4159 struct attribute
*attr
;
4161 /* Decode the type that this subroutine returns */
4166 type
= die_type (die
, cu
);
4167 ftype
= lookup_function_type (type
);
4169 /* All functions in C++ have prototypes. */
4170 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4171 if ((attr
&& (DW_UNSND (attr
) != 0))
4172 || cu
->language
== language_cplus
)
4173 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4175 if (die
->child
!= NULL
)
4177 struct die_info
*child_die
;
4181 /* Count the number of parameters.
4182 FIXME: GDB currently ignores vararg functions, but knows about
4183 vararg member functions. */
4184 child_die
= die
->child
;
4185 while (child_die
&& child_die
->tag
)
4187 if (child_die
->tag
== DW_TAG_formal_parameter
)
4189 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4190 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4191 child_die
= sibling_die (child_die
);
4194 /* Allocate storage for parameters and fill them in. */
4195 TYPE_NFIELDS (ftype
) = nparams
;
4196 TYPE_FIELDS (ftype
) = (struct field
*)
4197 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
4199 child_die
= die
->child
;
4200 while (child_die
&& child_die
->tag
)
4202 if (child_die
->tag
== DW_TAG_formal_parameter
)
4204 /* Dwarf2 has no clean way to discern C++ static and non-static
4205 member functions. G++ helps GDB by marking the first
4206 parameter for non-static member functions (which is the
4207 this pointer) as artificial. We pass this information
4208 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4209 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4211 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4213 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4214 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4217 child_die
= sibling_die (child_die
);
4225 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4227 struct objfile
*objfile
= cu
->objfile
;
4228 struct attribute
*attr
;
4233 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4234 if (attr
&& DW_STRING (attr
))
4236 name
= DW_STRING (attr
);
4238 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
4239 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4243 /* Find a representation of a given base type and install
4244 it in the TYPE field of the die. */
4247 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4249 struct objfile
*objfile
= cu
->objfile
;
4251 struct attribute
*attr
;
4252 int encoding
= 0, size
= 0;
4254 /* If we've already decoded this die, this is a no-op. */
4260 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4263 encoding
= DW_UNSND (attr
);
4265 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4268 size
= DW_UNSND (attr
);
4270 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4271 if (attr
&& DW_STRING (attr
))
4273 enum type_code code
= TYPE_CODE_INT
;
4278 case DW_ATE_address
:
4279 /* Turn DW_ATE_address into a void * pointer. */
4280 code
= TYPE_CODE_PTR
;
4281 type_flags
|= TYPE_FLAG_UNSIGNED
;
4283 case DW_ATE_boolean
:
4284 code
= TYPE_CODE_BOOL
;
4285 type_flags
|= TYPE_FLAG_UNSIGNED
;
4287 case DW_ATE_complex_float
:
4288 code
= TYPE_CODE_COMPLEX
;
4291 code
= TYPE_CODE_FLT
;
4294 case DW_ATE_signed_char
:
4296 case DW_ATE_unsigned
:
4297 case DW_ATE_unsigned_char
:
4298 type_flags
|= TYPE_FLAG_UNSIGNED
;
4301 complaint (&symfile_complaints
, "unsupported DW_AT_encoding: '%s'",
4302 dwarf_type_encoding_name (encoding
));
4305 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4306 if (encoding
== DW_ATE_address
)
4307 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4309 else if (encoding
== DW_ATE_complex_float
)
4312 TYPE_TARGET_TYPE (type
)
4313 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4314 else if (size
== 16)
4315 TYPE_TARGET_TYPE (type
)
4316 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4318 TYPE_TARGET_TYPE (type
)
4319 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4324 type
= dwarf_base_type (encoding
, size
, cu
);
4329 /* Read the given DW_AT_subrange DIE. */
4332 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4334 struct type
*base_type
;
4335 struct type
*range_type
;
4336 struct attribute
*attr
;
4340 /* If we have already decoded this die, then nothing more to do. */
4344 base_type
= die_type (die
, cu
);
4345 if (base_type
== NULL
)
4347 complaint (&symfile_complaints
,
4348 "DW_AT_type missing from DW_TAG_subrange_type");
4352 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4353 base_type
= alloc_type (NULL
);
4355 if (cu
->language
== language_fortran
)
4357 /* FORTRAN implies a lower bound of 1, if not given. */
4361 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4363 low
= dwarf2_get_attr_constant_value (attr
, 0);
4365 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4368 if (attr
->form
== DW_FORM_block1
)
4370 /* GCC encodes arrays with unspecified or dynamic length
4371 with a DW_FORM_block1 attribute.
4372 FIXME: GDB does not yet know how to handle dynamic
4373 arrays properly, treat them as arrays with unspecified
4376 FIXME: jimb/2003-09-22: GDB does not really know
4377 how to handle arrays of unspecified length
4378 either; we just represent them as zero-length
4379 arrays. Choose an appropriate upper bound given
4380 the lower bound we've computed above. */
4384 high
= dwarf2_get_attr_constant_value (attr
, 1);
4387 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4389 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4390 if (attr
&& DW_STRING (attr
))
4391 TYPE_NAME (range_type
) = DW_STRING (attr
);
4393 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4395 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4397 die
->type
= range_type
;
4401 /* Read a whole compilation unit into a linked list of dies. */
4403 static struct die_info
*
4404 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4406 /* Reset die reference table; we are
4407 building new ones now. */
4408 dwarf2_empty_hash_tables ();
4410 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4413 /* Read a single die and all its descendents. Set the die's sibling
4414 field to NULL; set other fields in the die correctly, and set all
4415 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4416 location of the info_ptr after reading all of those dies. PARENT
4417 is the parent of the die in question. */
4419 static struct die_info
*
4420 read_die_and_children (char *info_ptr
, bfd
*abfd
,
4421 struct dwarf2_cu
*cu
,
4422 char **new_info_ptr
,
4423 struct die_info
*parent
)
4425 struct die_info
*die
;
4429 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4430 store_in_ref_table (die
->offset
, die
);
4434 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4440 *new_info_ptr
= cur_ptr
;
4443 die
->sibling
= NULL
;
4444 die
->parent
= parent
;
4448 /* Read a die, all of its descendents, and all of its siblings; set
4449 all of the fields of all of the dies correctly. Arguments are as
4450 in read_die_and_children. */
4452 static struct die_info
*
4453 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
4454 struct dwarf2_cu
*cu
,
4455 char **new_info_ptr
,
4456 struct die_info
*parent
)
4458 struct die_info
*first_die
, *last_sibling
;
4462 first_die
= last_sibling
= NULL
;
4466 struct die_info
*die
4467 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4475 last_sibling
->sibling
= die
;
4480 *new_info_ptr
= cur_ptr
;
4490 /* Free a linked list of dies. */
4493 free_die_list (struct die_info
*dies
)
4495 struct die_info
*die
, *next
;
4500 if (die
->child
!= NULL
)
4501 free_die_list (die
->child
);
4502 next
= die
->sibling
;
4510 do_free_die_list_cleanup (void *dies
)
4512 free_die_list (dies
);
4515 static struct cleanup
*
4516 make_cleanup_free_die_list (struct die_info
*dies
)
4518 return make_cleanup (do_free_die_list_cleanup
, dies
);
4522 /* Read the contents of the section at OFFSET and of size SIZE from the
4523 object file specified by OBJFILE into the objfile_obstack and return it. */
4526 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4528 bfd
*abfd
= objfile
->obfd
;
4530 bfd_size_type size
= bfd_get_section_size (sectp
);
4535 buf
= (char *) obstack_alloc (&objfile
->objfile_obstack
, size
);
4537 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
4541 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4542 || bfd_bread (buf
, size
, abfd
) != size
)
4543 error ("Dwarf Error: Can't read DWARF data from '%s'",
4544 bfd_get_filename (abfd
));
4549 /* In DWARF version 2, the description of the debugging information is
4550 stored in a separate .debug_abbrev section. Before we read any
4551 dies from a section we read in all abbreviations and install them
4552 in a hash table. This function also sets flags in CU describing
4553 the data found in the abbrev table. */
4556 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4558 struct comp_unit_head
*cu_header
= &cu
->header
;
4560 struct abbrev_info
*cur_abbrev
;
4561 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4562 unsigned int abbrev_form
, hash_number
;
4563 struct attr_abbrev
*cur_attrs
;
4564 unsigned int allocated_attrs
;
4566 /* Initialize dwarf2 abbrevs */
4567 obstack_init (&cu
->abbrev_obstack
);
4568 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
4570 * sizeof (struct abbrev_info
*)));
4571 memset (cu
->dwarf2_abbrevs
, 0,
4572 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
4574 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
4575 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4576 abbrev_ptr
+= bytes_read
;
4578 allocated_attrs
= ATTR_ALLOC_CHUNK
;
4579 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
4581 /* loop until we reach an abbrev number of 0 */
4582 while (abbrev_number
)
4584 cur_abbrev
= dwarf_alloc_abbrev (cu
);
4586 /* read in abbrev header */
4587 cur_abbrev
->number
= abbrev_number
;
4588 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4589 abbrev_ptr
+= bytes_read
;
4590 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
4593 if (cur_abbrev
->tag
== DW_TAG_namespace
)
4594 cu
->has_namespace_info
= 1;
4596 /* now read in declarations */
4597 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4598 abbrev_ptr
+= bytes_read
;
4599 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4600 abbrev_ptr
+= bytes_read
;
4603 if (cur_abbrev
->num_attrs
== allocated_attrs
)
4605 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
4607 = xrealloc (cur_attrs
, (allocated_attrs
4608 * sizeof (struct attr_abbrev
)));
4610 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
4611 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
4612 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4613 abbrev_ptr
+= bytes_read
;
4614 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4615 abbrev_ptr
+= bytes_read
;
4618 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
4619 (cur_abbrev
->num_attrs
4620 * sizeof (struct attr_abbrev
)));
4621 memcpy (cur_abbrev
->attrs
, cur_attrs
,
4622 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
4624 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
4625 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
4626 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
4628 /* Get next abbreviation.
4629 Under Irix6 the abbreviations for a compilation unit are not
4630 always properly terminated with an abbrev number of 0.
4631 Exit loop if we encounter an abbreviation which we have
4632 already read (which means we are about to read the abbreviations
4633 for the next compile unit) or if the end of the abbreviation
4634 table is reached. */
4635 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
4636 >= dwarf2_per_objfile
->abbrev_size
)
4638 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4639 abbrev_ptr
+= bytes_read
;
4640 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
4647 /* Release the memory used by the abbrev table for a compilation unit. */
4650 dwarf2_free_abbrev_table (void *ptr_to_cu
)
4652 struct dwarf2_cu
*cu
= ptr_to_cu
;
4654 obstack_free (&cu
->abbrev_obstack
, NULL
);
4655 cu
->dwarf2_abbrevs
= NULL
;
4658 /* Lookup an abbrev_info structure in the abbrev hash table. */
4660 static struct abbrev_info
*
4661 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
4663 unsigned int hash_number
;
4664 struct abbrev_info
*abbrev
;
4666 hash_number
= number
% ABBREV_HASH_SIZE
;
4667 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
4671 if (abbrev
->number
== number
)
4674 abbrev
= abbrev
->next
;
4679 /* Returns nonzero if TAG represents a type that we might generate a partial
4683 is_type_tag_for_partial (int tag
)
4688 /* Some types that would be reasonable to generate partial symbols for,
4689 that we don't at present. */
4690 case DW_TAG_array_type
:
4691 case DW_TAG_file_type
:
4692 case DW_TAG_ptr_to_member_type
:
4693 case DW_TAG_set_type
:
4694 case DW_TAG_string_type
:
4695 case DW_TAG_subroutine_type
:
4697 case DW_TAG_base_type
:
4698 case DW_TAG_class_type
:
4699 case DW_TAG_enumeration_type
:
4700 case DW_TAG_structure_type
:
4701 case DW_TAG_subrange_type
:
4702 case DW_TAG_typedef
:
4703 case DW_TAG_union_type
:
4710 /* Load all DIEs that are interesting for partial symbols into memory. */
4712 static struct partial_die_info
*
4713 load_partial_dies (bfd
*abfd
, char *info_ptr
, int building_psymtab
,
4714 struct dwarf2_cu
*cu
)
4716 struct partial_die_info
*part_die
;
4717 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
4718 struct abbrev_info
*abbrev
;
4719 unsigned int bytes_read
;
4721 int nesting_level
= 1;
4727 = htab_create_alloc_ex (cu
->header
.length
/ 12,
4731 &cu
->comp_unit_obstack
,
4732 hashtab_obstack_allocate
,
4733 dummy_obstack_deallocate
);
4735 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
4736 sizeof (struct partial_die_info
));
4740 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
4742 /* A NULL abbrev means the end of a series of children. */
4745 if (--nesting_level
== 0)
4747 /* PART_DIE was probably the last thing allocated on the
4748 comp_unit_obstack, so we could call obstack_free
4749 here. We don't do that because the waste is small,
4750 and will be cleaned up when we're done with this
4751 compilation unit. This way, we're also more robust
4752 against other users of the comp_unit_obstack. */
4755 info_ptr
+= bytes_read
;
4756 last_die
= parent_die
;
4757 parent_die
= parent_die
->die_parent
;
4761 /* Check whether this DIE is interesting enough to save. */
4762 if (!is_type_tag_for_partial (abbrev
->tag
)
4763 && abbrev
->tag
!= DW_TAG_enumerator
4764 && abbrev
->tag
!= DW_TAG_subprogram
4765 && abbrev
->tag
!= DW_TAG_variable
4766 && abbrev
->tag
!= DW_TAG_namespace
)
4768 /* Otherwise we skip to the next sibling, if any. */
4769 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
4773 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
4774 abfd
, info_ptr
, cu
);
4776 /* This two-pass algorithm for processing partial symbols has a
4777 high cost in cache pressure. Thus, handle some simple cases
4778 here which cover the majority of C partial symbols. DIEs
4779 which neither have specification tags in them, nor could have
4780 specification tags elsewhere pointing at them, can simply be
4781 processed and discarded.
4783 This segment is also optional; scan_partial_symbols and
4784 add_partial_symbol will handle these DIEs if we chain
4785 them in normally. When compilers which do not emit large
4786 quantities of duplicate debug information are more common,
4787 this code can probably be removed. */
4789 /* Any complete simple types at the top level (pretty much all
4790 of them, for a language without namespaces), can be processed
4792 if (parent_die
== NULL
4793 && part_die
->has_specification
== 0
4794 && part_die
->is_declaration
== 0
4795 && (part_die
->tag
== DW_TAG_typedef
4796 || part_die
->tag
== DW_TAG_base_type
4797 || part_die
->tag
== DW_TAG_subrange_type
))
4799 if (building_psymtab
&& part_die
->name
!= NULL
)
4800 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
4801 VAR_DOMAIN
, LOC_TYPEDEF
,
4802 &cu
->objfile
->static_psymbols
,
4803 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
4804 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
4808 /* If we're at the second level, and we're an enumerator, and
4809 our parent has no specification (meaning possibly lives in a
4810 namespace elsewhere), then we can add the partial symbol now
4811 instead of queueing it. */
4812 if (part_die
->tag
== DW_TAG_enumerator
4813 && parent_die
!= NULL
4814 && parent_die
->die_parent
== NULL
4815 && parent_die
->tag
== DW_TAG_enumeration_type
4816 && parent_die
->has_specification
== 0)
4818 if (part_die
->name
== NULL
)
4819 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
4820 else if (building_psymtab
)
4821 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
4822 VAR_DOMAIN
, LOC_CONST
,
4823 cu
->language
== language_cplus
4824 ? &cu
->objfile
->global_psymbols
4825 : &cu
->objfile
->static_psymbols
,
4826 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
4828 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
4832 /* We'll save this DIE so link it in. */
4833 part_die
->die_parent
= parent_die
;
4834 part_die
->die_sibling
= NULL
;
4835 part_die
->die_child
= NULL
;
4837 if (last_die
&& last_die
== parent_die
)
4838 last_die
->die_child
= part_die
;
4840 last_die
->die_sibling
= part_die
;
4842 last_die
= part_die
;
4844 if (first_die
== NULL
)
4845 first_die
= part_die
;
4847 /* Maybe add the DIE to the hash table. Not all DIEs that we
4848 find interesting need to be in the hash table, because we
4849 also have the parent/sibling/child chains; only those that we
4850 might refer to by offset later during partial symbol reading.
4852 For now this means things that might have be the target of a
4853 DW_AT_specification, DW_AT_abstract_origin, or
4854 DW_AT_extension. DW_AT_extension will refer only to
4855 namespaces; DW_AT_abstract_origin refers to functions (and
4856 many things under the function DIE, but we do not recurse
4857 into function DIEs during partial symbol reading) and
4858 possibly variables as well; DW_AT_specification refers to
4859 declarations. Declarations ought to have the DW_AT_declaration
4860 flag. It happens that GCC forgets to put it in sometimes, but
4861 only for functions, not for types.
4863 Adding more things than necessary to the hash table is harmless
4864 except for the performance cost. Adding too few will result in
4865 internal errors in find_partial_die. */
4867 if (abbrev
->tag
== DW_TAG_subprogram
4868 || abbrev
->tag
== DW_TAG_variable
4869 || abbrev
->tag
== DW_TAG_namespace
4870 || part_die
->is_declaration
)
4874 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
4875 part_die
->offset
, INSERT
);
4879 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
4880 sizeof (struct partial_die_info
));
4882 /* For some DIEs we want to follow their children (if any). For C
4883 we have no reason to follow the children of structures; for other
4884 languages we have to, both so that we can get at method physnames
4885 to infer fully qualified class names, and for DW_AT_specification. */
4886 if (last_die
->has_children
4887 && (last_die
->tag
== DW_TAG_namespace
4888 || last_die
->tag
== DW_TAG_enumeration_type
4889 || (cu
->language
!= language_c
4890 && (last_die
->tag
== DW_TAG_class_type
4891 || last_die
->tag
== DW_TAG_structure_type
4892 || last_die
->tag
== DW_TAG_union_type
))))
4895 parent_die
= last_die
;
4899 /* Otherwise we skip to the next sibling, if any. */
4900 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
4902 /* Back to the top, do it again. */
4906 /* Read a minimal amount of information into the minimal die structure. */
4909 read_partial_die (struct partial_die_info
*part_die
,
4910 struct abbrev_info
*abbrev
,
4911 unsigned int abbrev_len
, bfd
*abfd
,
4912 char *info_ptr
, struct dwarf2_cu
*cu
)
4914 unsigned int bytes_read
, i
;
4915 struct attribute attr
;
4916 int has_low_pc_attr
= 0;
4917 int has_high_pc_attr
= 0;
4919 memset (part_die
, 0, sizeof (struct partial_die_info
));
4921 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
4923 info_ptr
+= abbrev_len
;
4928 part_die
->tag
= abbrev
->tag
;
4929 part_die
->has_children
= abbrev
->has_children
;
4931 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4933 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
4935 /* Store the data if it is of an attribute we want to keep in a
4936 partial symbol table. */
4941 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
4942 if (part_die
->name
== NULL
)
4943 part_die
->name
= DW_STRING (&attr
);
4945 case DW_AT_comp_dir
:
4946 if (part_die
->dirname
== NULL
)
4947 part_die
->dirname
= DW_STRING (&attr
);
4949 case DW_AT_MIPS_linkage_name
:
4950 part_die
->name
= DW_STRING (&attr
);
4953 has_low_pc_attr
= 1;
4954 part_die
->lowpc
= DW_ADDR (&attr
);
4957 has_high_pc_attr
= 1;
4958 part_die
->highpc
= DW_ADDR (&attr
);
4960 case DW_AT_location
:
4961 /* Support the .debug_loc offsets */
4962 if (attr_form_is_block (&attr
))
4964 part_die
->locdesc
= DW_BLOCK (&attr
);
4966 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
4968 dwarf2_complex_location_expr_complaint ();
4972 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4973 "partial symbol information");
4976 case DW_AT_language
:
4977 part_die
->language
= DW_UNSND (&attr
);
4979 case DW_AT_external
:
4980 part_die
->is_external
= DW_UNSND (&attr
);
4982 case DW_AT_declaration
:
4983 part_die
->is_declaration
= DW_UNSND (&attr
);
4986 part_die
->has_type
= 1;
4988 case DW_AT_abstract_origin
:
4989 case DW_AT_specification
:
4990 case DW_AT_extension
:
4991 part_die
->has_specification
= 1;
4992 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
4995 /* Ignore absolute siblings, they might point outside of
4996 the current compile unit. */
4997 if (attr
.form
== DW_FORM_ref_addr
)
4998 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
5000 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5001 + dwarf2_get_ref_die_offset (&attr
, cu
);
5003 case DW_AT_stmt_list
:
5004 part_die
->has_stmt_list
= 1;
5005 part_die
->line_offset
= DW_UNSND (&attr
);
5012 /* When using the GNU linker, .gnu.linkonce. sections are used to
5013 eliminate duplicate copies of functions and vtables and such.
5014 The linker will arbitrarily choose one and discard the others.
5015 The AT_*_pc values for such functions refer to local labels in
5016 these sections. If the section from that file was discarded, the
5017 labels are not in the output, so the relocs get a value of 0.
5018 If this is a discarded function, mark the pc bounds as invalid,
5019 so that GDB will ignore it. */
5020 if (has_low_pc_attr
&& has_high_pc_attr
5021 && part_die
->lowpc
< part_die
->highpc
5022 && (part_die
->lowpc
!= 0
5023 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5024 part_die
->has_pc_info
= 1;
5028 /* Find a cached partial DIE at OFFSET in CU. */
5030 static struct partial_die_info
*
5031 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5033 struct partial_die_info
*lookup_die
= NULL
;
5034 struct partial_die_info part_die
;
5036 part_die
.offset
= offset
;
5037 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5039 if (lookup_die
== NULL
)
5040 internal_error (__FILE__
, __LINE__
,
5041 "could not find partial DIE in cache\n");
5046 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5048 static struct partial_die_info
*
5049 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
,
5050 struct dwarf2_cu
**target_cu
)
5052 struct dwarf2_per_cu_data
*per_cu
;
5054 if (offset
>= cu
->header
.offset
5055 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5058 return find_partial_die_in_comp_unit (offset
, cu
);
5061 internal_error (__FILE__
, __LINE__
,
5062 "unsupported inter-compilation-unit reference");
5065 /* Adjust PART_DIE before generating a symbol for it. This function
5066 may set the is_external flag or change the DIE's name. */
5069 fixup_partial_die (struct partial_die_info
*part_die
,
5070 struct dwarf2_cu
*cu
)
5072 /* If we found a reference attribute and the DIE has no name, try
5073 to find a name in the referred to DIE. */
5075 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5077 struct partial_die_info
*spec_die
;
5078 struct dwarf2_cu
*spec_cu
;
5080 spec_die
= find_partial_die (part_die
->spec_offset
, cu
, &spec_cu
);
5082 fixup_partial_die (spec_die
, spec_cu
);
5086 part_die
->name
= spec_die
->name
;
5088 /* Copy DW_AT_external attribute if it is set. */
5089 if (spec_die
->is_external
)
5090 part_die
->is_external
= spec_die
->is_external
;
5094 /* Set default names for some unnamed DIEs. */
5095 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5096 || part_die
->tag
== DW_TAG_class_type
))
5097 part_die
->name
= "(anonymous class)";
5099 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5100 part_die
->name
= "(anonymous namespace)";
5102 if (part_die
->tag
== DW_TAG_structure_type
5103 || part_die
->tag
== DW_TAG_class_type
5104 || part_die
->tag
== DW_TAG_union_type
)
5105 guess_structure_name (part_die
, cu
);
5108 /* Read the die from the .debug_info section buffer. Set DIEP to
5109 point to a newly allocated die with its information, except for its
5110 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5111 whether the die has children or not. */
5114 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
5115 struct dwarf2_cu
*cu
, int *has_children
)
5117 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5118 struct abbrev_info
*abbrev
;
5119 struct die_info
*die
;
5121 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5122 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5123 info_ptr
+= bytes_read
;
5126 die
= dwarf_alloc_die ();
5128 die
->abbrev
= abbrev_number
;
5135 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5138 error ("Dwarf Error: could not find abbrev number %d [in module %s]",
5140 bfd_get_filename (abfd
));
5142 die
= dwarf_alloc_die ();
5143 die
->offset
= offset
;
5144 die
->tag
= abbrev
->tag
;
5145 die
->abbrev
= abbrev_number
;
5148 die
->num_attrs
= abbrev
->num_attrs
;
5149 die
->attrs
= (struct attribute
*)
5150 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5152 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5154 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5155 abfd
, info_ptr
, cu
);
5159 *has_children
= abbrev
->has_children
;
5163 /* Read an attribute value described by an attribute form. */
5166 read_attribute_value (struct attribute
*attr
, unsigned form
,
5167 bfd
*abfd
, char *info_ptr
,
5168 struct dwarf2_cu
*cu
)
5170 struct comp_unit_head
*cu_header
= &cu
->header
;
5171 unsigned int bytes_read
;
5172 struct dwarf_block
*blk
;
5178 case DW_FORM_ref_addr
:
5179 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5180 info_ptr
+= bytes_read
;
5182 case DW_FORM_block2
:
5183 blk
= dwarf_alloc_block (cu
);
5184 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5186 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5187 info_ptr
+= blk
->size
;
5188 DW_BLOCK (attr
) = blk
;
5190 case DW_FORM_block4
:
5191 blk
= dwarf_alloc_block (cu
);
5192 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5194 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5195 info_ptr
+= blk
->size
;
5196 DW_BLOCK (attr
) = blk
;
5199 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5203 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5207 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5210 case DW_FORM_string
:
5211 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5212 info_ptr
+= bytes_read
;
5215 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5217 info_ptr
+= bytes_read
;
5220 blk
= dwarf_alloc_block (cu
);
5221 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5222 info_ptr
+= bytes_read
;
5223 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5224 info_ptr
+= blk
->size
;
5225 DW_BLOCK (attr
) = blk
;
5227 case DW_FORM_block1
:
5228 blk
= dwarf_alloc_block (cu
);
5229 blk
->size
= read_1_byte (abfd
, info_ptr
);
5231 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5232 info_ptr
+= blk
->size
;
5233 DW_BLOCK (attr
) = blk
;
5236 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5240 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5244 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5245 info_ptr
+= bytes_read
;
5248 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5249 info_ptr
+= bytes_read
;
5252 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5256 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5260 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5264 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5267 case DW_FORM_ref_udata
:
5268 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5269 info_ptr
+= bytes_read
;
5271 case DW_FORM_indirect
:
5272 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5273 info_ptr
+= bytes_read
;
5274 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5277 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
5278 dwarf_form_name (form
),
5279 bfd_get_filename (abfd
));
5284 /* Read an attribute described by an abbreviated attribute. */
5287 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5288 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
5290 attr
->name
= abbrev
->name
;
5291 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5294 /* read dwarf information from a buffer */
5297 read_1_byte (bfd
*abfd
, char *buf
)
5299 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
5303 read_1_signed_byte (bfd
*abfd
, char *buf
)
5305 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
5309 read_2_bytes (bfd
*abfd
, char *buf
)
5311 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5315 read_2_signed_bytes (bfd
*abfd
, char *buf
)
5317 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5321 read_4_bytes (bfd
*abfd
, char *buf
)
5323 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5327 read_4_signed_bytes (bfd
*abfd
, char *buf
)
5329 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5332 static unsigned long
5333 read_8_bytes (bfd
*abfd
, char *buf
)
5335 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5339 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
5341 struct comp_unit_head
*cu_header
= &cu
->header
;
5342 CORE_ADDR retval
= 0;
5344 if (cu_header
->signed_addr_p
)
5346 switch (cu_header
->addr_size
)
5349 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
5352 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
5355 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
5358 internal_error (__FILE__
, __LINE__
,
5359 "read_address: bad switch, signed [in module %s]",
5360 bfd_get_filename (abfd
));
5365 switch (cu_header
->addr_size
)
5368 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
5371 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5374 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5377 internal_error (__FILE__
, __LINE__
,
5378 "read_address: bad switch, unsigned [in module %s]",
5379 bfd_get_filename (abfd
));
5383 *bytes_read
= cu_header
->addr_size
;
5387 /* Read the initial length from a section. The (draft) DWARF 3
5388 specification allows the initial length to take up either 4 bytes
5389 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5390 bytes describe the length and all offsets will be 8 bytes in length
5393 An older, non-standard 64-bit format is also handled by this
5394 function. The older format in question stores the initial length
5395 as an 8-byte quantity without an escape value. Lengths greater
5396 than 2^32 aren't very common which means that the initial 4 bytes
5397 is almost always zero. Since a length value of zero doesn't make
5398 sense for the 32-bit format, this initial zero can be considered to
5399 be an escape value which indicates the presence of the older 64-bit
5400 format. As written, the code can't detect (old format) lengths
5401 greater than 4GB. If it becomes necessary to handle lengths somewhat
5402 larger than 4GB, we could allow other small values (such as the
5403 non-sensical values of 1, 2, and 3) to also be used as escape values
5404 indicating the presence of the old format.
5406 The value returned via bytes_read should be used to increment
5407 the relevant pointer after calling read_initial_length().
5409 As a side effect, this function sets the fields initial_length_size
5410 and offset_size in cu_header to the values appropriate for the
5411 length field. (The format of the initial length field determines
5412 the width of file offsets to be fetched later with fetch_offset().)
5414 [ Note: read_initial_length() and read_offset() are based on the
5415 document entitled "DWARF Debugging Information Format", revision
5416 3, draft 8, dated November 19, 2001. This document was obtained
5419 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5421 This document is only a draft and is subject to change. (So beware.)
5423 Details regarding the older, non-standard 64-bit format were
5424 determined empirically by examining 64-bit ELF files produced
5425 by the SGI toolchain on an IRIX 6.5 machine.
5427 - Kevin, July 16, 2002
5431 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
5436 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5438 if (retval
== 0xffffffff)
5440 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
5442 if (cu_header
!= NULL
)
5444 cu_header
->initial_length_size
= 12;
5445 cu_header
->offset_size
= 8;
5448 else if (retval
== 0)
5450 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
5452 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5454 if (cu_header
!= NULL
)
5456 cu_header
->initial_length_size
= 8;
5457 cu_header
->offset_size
= 8;
5463 if (cu_header
!= NULL
)
5465 cu_header
->initial_length_size
= 4;
5466 cu_header
->offset_size
= 4;
5473 /* Read an offset from the data stream. The size of the offset is
5474 given by cu_header->offset_size. */
5477 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
5482 switch (cu_header
->offset_size
)
5485 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
5489 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
5493 internal_error (__FILE__
, __LINE__
,
5494 "read_offset: bad switch [in module %s]",
5495 bfd_get_filename (abfd
));
5502 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
5504 /* If the size of a host char is 8 bits, we can return a pointer
5505 to the buffer, otherwise we have to copy the data to a buffer
5506 allocated on the temporary obstack. */
5507 gdb_assert (HOST_CHAR_BIT
== 8);
5512 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5514 /* If the size of a host char is 8 bits, we can return a pointer
5515 to the string, otherwise we have to copy the string to a buffer
5516 allocated on the temporary obstack. */
5517 gdb_assert (HOST_CHAR_BIT
== 8);
5520 *bytes_read_ptr
= 1;
5523 *bytes_read_ptr
= strlen (buf
) + 1;
5528 read_indirect_string (bfd
*abfd
, char *buf
,
5529 const struct comp_unit_head
*cu_header
,
5530 unsigned int *bytes_read_ptr
)
5532 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
5533 (int *) bytes_read_ptr
);
5535 if (dwarf2_per_objfile
->str_buffer
== NULL
)
5537 error ("DW_FORM_strp used without .debug_str section [in module %s]",
5538 bfd_get_filename (abfd
));
5541 if (str_offset
>= dwarf2_per_objfile
->str_size
)
5543 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
5544 bfd_get_filename (abfd
));
5547 gdb_assert (HOST_CHAR_BIT
== 8);
5548 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
5550 return dwarf2_per_objfile
->str_buffer
+ str_offset
;
5553 static unsigned long
5554 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5556 unsigned long result
;
5557 unsigned int num_read
;
5567 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
5570 result
|= ((unsigned long)(byte
& 127) << shift
);
5571 if ((byte
& 128) == 0)
5577 *bytes_read_ptr
= num_read
;
5582 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
5585 int i
, shift
, size
, num_read
;
5595 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
5598 result
|= ((long)(byte
& 127) << shift
);
5600 if ((byte
& 128) == 0)
5605 if ((shift
< size
) && (byte
& 0x40))
5607 result
|= -(1 << shift
);
5609 *bytes_read_ptr
= num_read
;
5613 /* Return a pointer to just past the end of an LEB128 number in BUF. */
5616 skip_leb128 (bfd
*abfd
, char *buf
)
5622 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
5624 if ((byte
& 128) == 0)
5630 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
5636 cu
->language
= language_c
;
5638 case DW_LANG_C_plus_plus
:
5639 cu
->language
= language_cplus
;
5641 case DW_LANG_Fortran77
:
5642 case DW_LANG_Fortran90
:
5643 case DW_LANG_Fortran95
:
5644 cu
->language
= language_fortran
;
5646 case DW_LANG_Mips_Assembler
:
5647 cu
->language
= language_asm
;
5650 cu
->language
= language_java
;
5654 case DW_LANG_Cobol74
:
5655 case DW_LANG_Cobol85
:
5656 case DW_LANG_Pascal83
:
5657 case DW_LANG_Modula2
:
5659 cu
->language
= language_minimal
;
5662 cu
->language_defn
= language_def (cu
->language
);
5665 /* Return the named attribute or NULL if not there. */
5667 static struct attribute
*
5668 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
5671 struct attribute
*spec
= NULL
;
5673 for (i
= 0; i
< die
->num_attrs
; ++i
)
5675 if (die
->attrs
[i
].name
== name
)
5677 return &die
->attrs
[i
];
5679 if (die
->attrs
[i
].name
== DW_AT_specification
5680 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
5681 spec
= &die
->attrs
[i
];
5685 struct die_info
*ref_die
=
5686 follow_die_ref (dwarf2_get_ref_die_offset (spec
, cu
));
5689 return dwarf2_attr (ref_die
, name
, cu
);
5695 /* Return non-zero iff the attribute NAME is defined for the given DIE,
5696 and holds a non-zero value. This function should only be used for
5697 DW_FORM_flag attributes. */
5700 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
5702 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
5704 return (attr
&& DW_UNSND (attr
));
5708 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
5710 /* A DIE is a declaration if it has a DW_AT_declaration attribute
5711 which value is non-zero. However, we have to be careful with
5712 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
5713 (via dwarf2_flag_true_p) follows this attribute. So we may
5714 end up accidently finding a declaration attribute that belongs
5715 to a different DIE referenced by the specification attribute,
5716 even though the given DIE does not have a declaration attribute. */
5717 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
5718 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
5721 /* Return the die giving the specification for DIE, if there is
5724 static struct die_info
*
5725 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
5727 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
5729 if (spec_attr
== NULL
)
5732 return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr
, cu
));
5735 /* Free the line_header structure *LH, and any arrays and strings it
5738 free_line_header (struct line_header
*lh
)
5740 if (lh
->standard_opcode_lengths
)
5741 xfree (lh
->standard_opcode_lengths
);
5743 /* Remember that all the lh->file_names[i].name pointers are
5744 pointers into debug_line_buffer, and don't need to be freed. */
5746 xfree (lh
->file_names
);
5748 /* Similarly for the include directory names. */
5749 if (lh
->include_dirs
)
5750 xfree (lh
->include_dirs
);
5756 /* Add an entry to LH's include directory table. */
5758 add_include_dir (struct line_header
*lh
, char *include_dir
)
5760 /* Grow the array if necessary. */
5761 if (lh
->include_dirs_size
== 0)
5763 lh
->include_dirs_size
= 1; /* for testing */
5764 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
5765 * sizeof (*lh
->include_dirs
));
5767 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
5769 lh
->include_dirs_size
*= 2;
5770 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
5771 (lh
->include_dirs_size
5772 * sizeof (*lh
->include_dirs
)));
5775 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
5779 /* Add an entry to LH's file name table. */
5781 add_file_name (struct line_header
*lh
,
5783 unsigned int dir_index
,
5784 unsigned int mod_time
,
5785 unsigned int length
)
5787 struct file_entry
*fe
;
5789 /* Grow the array if necessary. */
5790 if (lh
->file_names_size
== 0)
5792 lh
->file_names_size
= 1; /* for testing */
5793 lh
->file_names
= xmalloc (lh
->file_names_size
5794 * sizeof (*lh
->file_names
));
5796 else if (lh
->num_file_names
>= lh
->file_names_size
)
5798 lh
->file_names_size
*= 2;
5799 lh
->file_names
= xrealloc (lh
->file_names
,
5800 (lh
->file_names_size
5801 * sizeof (*lh
->file_names
)));
5804 fe
= &lh
->file_names
[lh
->num_file_names
++];
5806 fe
->dir_index
= dir_index
;
5807 fe
->mod_time
= mod_time
;
5808 fe
->length
= length
;
5813 /* Read the statement program header starting at OFFSET in
5814 .debug_line, according to the endianness of ABFD. Return a pointer
5815 to a struct line_header, allocated using xmalloc.
5817 NOTE: the strings in the include directory and file name tables of
5818 the returned object point into debug_line_buffer, and must not be
5820 static struct line_header
*
5821 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
5822 struct dwarf2_cu
*cu
)
5824 struct cleanup
*back_to
;
5825 struct line_header
*lh
;
5829 char *cur_dir
, *cur_file
;
5831 if (dwarf2_per_objfile
->line_buffer
== NULL
)
5833 complaint (&symfile_complaints
, "missing .debug_line section");
5837 /* Make sure that at least there's room for the total_length field. That
5838 could be 12 bytes long, but we're just going to fudge that. */
5839 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
5841 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5845 lh
= xmalloc (sizeof (*lh
));
5846 memset (lh
, 0, sizeof (*lh
));
5847 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
5850 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
5852 /* read in the header */
5853 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
5854 line_ptr
+= bytes_read
;
5855 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
5856 + dwarf2_per_objfile
->line_size
))
5858 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5861 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
5862 lh
->version
= read_2_bytes (abfd
, line_ptr
);
5864 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
5865 line_ptr
+= bytes_read
;
5866 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
5868 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
5870 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
5872 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
5874 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
5876 lh
->standard_opcode_lengths
5877 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
5879 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
5880 for (i
= 1; i
< lh
->opcode_base
; ++i
)
5882 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
5886 /* Read directory table */
5887 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
5889 line_ptr
+= bytes_read
;
5890 add_include_dir (lh
, cur_dir
);
5892 line_ptr
+= bytes_read
;
5894 /* Read file name table */
5895 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
5897 unsigned int dir_index
, mod_time
, length
;
5899 line_ptr
+= bytes_read
;
5900 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5901 line_ptr
+= bytes_read
;
5902 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5903 line_ptr
+= bytes_read
;
5904 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5905 line_ptr
+= bytes_read
;
5907 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5909 line_ptr
+= bytes_read
;
5910 lh
->statement_program_start
= line_ptr
;
5912 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
5913 + dwarf2_per_objfile
->line_size
))
5914 complaint (&symfile_complaints
,
5915 "line number info header doesn't fit in `.debug_line' section");
5917 discard_cleanups (back_to
);
5921 /* This function exists to work around a bug in certain compilers
5922 (particularly GCC 2.95), in which the first line number marker of a
5923 function does not show up until after the prologue, right before
5924 the second line number marker. This function shifts ADDRESS down
5925 to the beginning of the function if necessary, and is called on
5926 addresses passed to record_line. */
5929 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
5931 struct function_range
*fn
;
5933 /* Find the function_range containing address. */
5938 cu
->cached_fn
= cu
->first_fn
;
5942 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5948 while (fn
&& fn
!= cu
->cached_fn
)
5949 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5959 if (address
!= fn
->lowpc
)
5960 complaint (&symfile_complaints
,
5961 "misplaced first line number at 0x%lx for '%s'",
5962 (unsigned long) address
, fn
->name
);
5967 /* Decode the Line Number Program (LNP) for the given line_header
5968 structure and CU. The actual information extracted and the type
5969 of structures created from the LNP depends on the value of PST.
5971 1. If PST is NULL, then this procedure uses the data from the program
5972 to create all necessary symbol tables, and their linetables.
5973 The compilation directory of the file is passed in COMP_DIR,
5974 and must not be NULL.
5976 2. If PST is not NULL, this procedure reads the program to determine
5977 the list of files included by the unit represented by PST, and
5978 builds all the associated partial symbol tables. In this case,
5979 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
5980 is not used to compute the full name of the symtab, and therefore
5981 omitting it when building the partial symtab does not introduce
5982 the potential for inconsistency - a partial symtab and its associated
5983 symbtab having a different fullname -). */
5986 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
5987 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
5991 unsigned int bytes_read
;
5992 unsigned char op_code
, extended_op
, adj_opcode
;
5994 struct objfile
*objfile
= cu
->objfile
;
5995 const int decode_for_pst_p
= (pst
!= NULL
);
5997 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5999 line_ptr
= lh
->statement_program_start
;
6000 line_end
= lh
->statement_program_end
;
6002 /* Read the statement sequences until there's nothing left. */
6003 while (line_ptr
< line_end
)
6005 /* state machine registers */
6006 CORE_ADDR address
= 0;
6007 unsigned int file
= 1;
6008 unsigned int line
= 1;
6009 unsigned int column
= 0;
6010 int is_stmt
= lh
->default_is_stmt
;
6011 int basic_block
= 0;
6012 int end_sequence
= 0;
6014 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6016 /* Start a subfile for the current file of the state machine. */
6017 /* lh->include_dirs and lh->file_names are 0-based, but the
6018 directory and file name numbers in the statement program
6020 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6023 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6026 dwarf2_start_subfile (fe
->name
, dir
);
6029 /* Decode the table. */
6030 while (!end_sequence
)
6032 op_code
= read_1_byte (abfd
, line_ptr
);
6035 if (op_code
>= lh
->opcode_base
)
6036 { /* Special operand. */
6037 adj_opcode
= op_code
- lh
->opcode_base
;
6038 address
+= (adj_opcode
/ lh
->line_range
)
6039 * lh
->minimum_instruction_length
;
6040 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6041 lh
->file_names
[file
- 1].included_p
= 1;
6042 if (!decode_for_pst_p
)
6044 /* append row to matrix using current values */
6045 record_line (current_subfile
, line
,
6046 check_cu_functions (address
, cu
));
6050 else switch (op_code
)
6052 case DW_LNS_extended_op
:
6053 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6054 line_ptr
+= bytes_read
;
6055 extended_op
= read_1_byte (abfd
, line_ptr
);
6057 switch (extended_op
)
6059 case DW_LNE_end_sequence
:
6061 lh
->file_names
[file
- 1].included_p
= 1;
6062 if (!decode_for_pst_p
)
6063 record_line (current_subfile
, 0, address
);
6065 case DW_LNE_set_address
:
6066 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6067 line_ptr
+= bytes_read
;
6068 address
+= baseaddr
;
6070 case DW_LNE_define_file
:
6073 unsigned int dir_index
, mod_time
, length
;
6075 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6076 line_ptr
+= bytes_read
;
6078 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6079 line_ptr
+= bytes_read
;
6081 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6082 line_ptr
+= bytes_read
;
6084 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6085 line_ptr
+= bytes_read
;
6086 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6090 complaint (&symfile_complaints
,
6091 "mangled .debug_line section");
6096 lh
->file_names
[file
- 1].included_p
= 1;
6097 if (!decode_for_pst_p
)
6098 record_line (current_subfile
, line
,
6099 check_cu_functions (address
, cu
));
6102 case DW_LNS_advance_pc
:
6103 address
+= lh
->minimum_instruction_length
6104 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6105 line_ptr
+= bytes_read
;
6107 case DW_LNS_advance_line
:
6108 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6109 line_ptr
+= bytes_read
;
6111 case DW_LNS_set_file
:
6113 /* lh->include_dirs and lh->file_names are 0-based,
6114 but the directory and file name numbers in the
6115 statement program are 1-based. */
6116 struct file_entry
*fe
;
6118 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6119 line_ptr
+= bytes_read
;
6120 fe
= &lh
->file_names
[file
- 1];
6122 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6125 if (!decode_for_pst_p
)
6126 dwarf2_start_subfile (fe
->name
, dir
);
6129 case DW_LNS_set_column
:
6130 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6131 line_ptr
+= bytes_read
;
6133 case DW_LNS_negate_stmt
:
6134 is_stmt
= (!is_stmt
);
6136 case DW_LNS_set_basic_block
:
6139 /* Add to the address register of the state machine the
6140 address increment value corresponding to special opcode
6141 255. Ie, this value is scaled by the minimum instruction
6142 length since special opcode 255 would have scaled the
6144 case DW_LNS_const_add_pc
:
6145 address
+= (lh
->minimum_instruction_length
6146 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6148 case DW_LNS_fixed_advance_pc
:
6149 address
+= read_2_bytes (abfd
, line_ptr
);
6153 { /* Unknown standard opcode, ignore it. */
6155 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6157 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6158 line_ptr
+= bytes_read
;
6165 if (decode_for_pst_p
)
6169 /* Now that we're done scanning the Line Header Program, we can
6170 create the psymtab of each included file. */
6171 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6172 if (lh
->file_names
[file_index
].included_p
== 1)
6174 char *include_name
= lh
->file_names
[file_index
].name
;
6176 if (strcmp (include_name
, pst
->filename
) != 0)
6177 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6182 /* Start a subfile for DWARF. FILENAME is the name of the file and
6183 DIRNAME the name of the source directory which contains FILENAME
6184 or NULL if not known.
6185 This routine tries to keep line numbers from identical absolute and
6186 relative file names in a common subfile.
6188 Using the `list' example from the GDB testsuite, which resides in
6189 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6190 of /srcdir/list0.c yields the following debugging information for list0.c:
6192 DW_AT_name: /srcdir/list0.c
6193 DW_AT_comp_dir: /compdir
6194 files.files[0].name: list0.h
6195 files.files[0].dir: /srcdir
6196 files.files[1].name: list0.c
6197 files.files[1].dir: /srcdir
6199 The line number information for list0.c has to end up in a single
6200 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6203 dwarf2_start_subfile (char *filename
, char *dirname
)
6205 /* If the filename isn't absolute, try to match an existing subfile
6206 with the full pathname. */
6208 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6210 struct subfile
*subfile
;
6211 char *fullname
= concat (dirname
, "/", filename
, NULL
);
6213 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
6215 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
6217 current_subfile
= subfile
;
6224 start_subfile (filename
, dirname
);
6228 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6229 struct dwarf2_cu
*cu
)
6231 struct objfile
*objfile
= cu
->objfile
;
6232 struct comp_unit_head
*cu_header
= &cu
->header
;
6234 /* NOTE drow/2003-01-30: There used to be a comment and some special
6235 code here to turn a symbol with DW_AT_external and a
6236 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6237 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6238 with some versions of binutils) where shared libraries could have
6239 relocations against symbols in their debug information - the
6240 minimal symbol would have the right address, but the debug info
6241 would not. It's no longer necessary, because we will explicitly
6242 apply relocations when we read in the debug information now. */
6244 /* A DW_AT_location attribute with no contents indicates that a
6245 variable has been optimized away. */
6246 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6248 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6252 /* Handle one degenerate form of location expression specially, to
6253 preserve GDB's previous behavior when section offsets are
6254 specified. If this is just a DW_OP_addr then mark this symbol
6257 if (attr_form_is_block (attr
)
6258 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6259 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6263 SYMBOL_VALUE_ADDRESS (sym
) =
6264 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6265 fixup_symbol_section (sym
, objfile
);
6266 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6267 SYMBOL_SECTION (sym
));
6268 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6272 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6273 expression evaluator, and use LOC_COMPUTED only when necessary
6274 (i.e. when the value of a register or memory location is
6275 referenced, or a thread-local block, etc.). Then again, it might
6276 not be worthwhile. I'm assuming that it isn't unless performance
6277 or memory numbers show me otherwise. */
6279 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6280 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6283 /* Given a pointer to a DWARF information entry, figure out if we need
6284 to make a symbol table entry for it, and if so, create a new entry
6285 and return a pointer to it.
6286 If TYPE is NULL, determine symbol type from the die, otherwise
6287 used the passed type. */
6289 static struct symbol
*
6290 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6292 struct objfile
*objfile
= cu
->objfile
;
6293 struct symbol
*sym
= NULL
;
6295 struct attribute
*attr
= NULL
;
6296 struct attribute
*attr2
= NULL
;
6299 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6301 if (die
->tag
!= DW_TAG_namespace
)
6302 name
= dwarf2_linkage_name (die
, cu
);
6304 name
= TYPE_NAME (type
);
6308 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6309 sizeof (struct symbol
));
6310 OBJSTAT (objfile
, n_syms
++);
6311 memset (sym
, 0, sizeof (struct symbol
));
6313 /* Cache this symbol's name and the name's demangled form (if any). */
6314 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6315 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6317 /* Default assumptions.
6318 Use the passed type or decode it from the die. */
6319 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6320 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6322 SYMBOL_TYPE (sym
) = type
;
6324 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6325 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6328 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6333 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6336 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6338 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6340 case DW_TAG_subprogram
:
6341 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6343 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6344 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6345 if (attr2
&& (DW_UNSND (attr2
) != 0))
6347 add_symbol_to_list (sym
, &global_symbols
);
6351 add_symbol_to_list (sym
, cu
->list_in_scope
);
6354 case DW_TAG_variable
:
6355 /* Compilation with minimal debug info may result in variables
6356 with missing type entries. Change the misleading `void' type
6357 to something sensible. */
6358 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6359 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6360 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6361 "<variable, no debug info>",
6363 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6366 dwarf2_const_value (attr
, sym
, cu
);
6367 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6368 if (attr2
&& (DW_UNSND (attr2
) != 0))
6369 add_symbol_to_list (sym
, &global_symbols
);
6371 add_symbol_to_list (sym
, cu
->list_in_scope
);
6374 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6377 var_decode_location (attr
, sym
, cu
);
6378 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6379 if (attr2
&& (DW_UNSND (attr2
) != 0))
6380 add_symbol_to_list (sym
, &global_symbols
);
6382 add_symbol_to_list (sym
, cu
->list_in_scope
);
6386 /* We do not know the address of this symbol.
6387 If it is an external symbol and we have type information
6388 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6389 The address of the variable will then be determined from
6390 the minimal symbol table whenever the variable is
6392 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6393 if (attr2
&& (DW_UNSND (attr2
) != 0)
6394 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6396 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6397 add_symbol_to_list (sym
, &global_symbols
);
6401 case DW_TAG_formal_parameter
:
6402 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6405 var_decode_location (attr
, sym
, cu
);
6406 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6407 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6408 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6410 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6413 dwarf2_const_value (attr
, sym
, cu
);
6415 add_symbol_to_list (sym
, cu
->list_in_scope
);
6417 case DW_TAG_unspecified_parameters
:
6418 /* From varargs functions; gdb doesn't seem to have any
6419 interest in this information, so just ignore it for now.
6422 case DW_TAG_class_type
:
6423 case DW_TAG_structure_type
:
6424 case DW_TAG_union_type
:
6425 case DW_TAG_enumeration_type
:
6426 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6427 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6429 /* Make sure that the symbol includes appropriate enclosing
6430 classes/namespaces in its name. These are calculated in
6431 read_structure_type, and the correct name is saved in
6434 if (cu
->language
== language_cplus
)
6436 struct type
*type
= SYMBOL_TYPE (sym
);
6438 if (TYPE_TAG_NAME (type
) != NULL
)
6440 /* FIXME: carlton/2003-11-10: Should this use
6441 SYMBOL_SET_NAMES instead? (The same problem also
6442 arises further down in this function.) */
6443 /* The type's name is already allocated along with
6444 this objfile, so we don't need to duplicate it
6446 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
6451 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
6452 really ever be static objects: otherwise, if you try
6453 to, say, break of a class's method and you're in a file
6454 which doesn't mention that class, it won't work unless
6455 the check for all static symbols in lookup_symbol_aux
6456 saves you. See the OtherFileClass tests in
6457 gdb.c++/namespace.exp. */
6459 struct pending
**list_to_add
;
6461 list_to_add
= (cu
->list_in_scope
== &file_symbols
6462 && cu
->language
== language_cplus
6463 ? &global_symbols
: cu
->list_in_scope
);
6465 add_symbol_to_list (sym
, list_to_add
);
6467 /* The semantics of C++ state that "struct foo { ... }" also
6468 defines a typedef for "foo". Synthesize a typedef symbol so
6469 that "ptype foo" works as expected. */
6470 if (cu
->language
== language_cplus
)
6472 struct symbol
*typedef_sym
= (struct symbol
*)
6473 obstack_alloc (&objfile
->objfile_obstack
,
6474 sizeof (struct symbol
));
6475 *typedef_sym
= *sym
;
6476 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
6477 /* The symbol's name is already allocated along with
6478 this objfile, so we don't need to duplicate it for
6480 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
6481 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NATURAL_NAME (sym
);
6482 add_symbol_to_list (typedef_sym
, list_to_add
);
6486 case DW_TAG_typedef
:
6487 if (processing_has_namespace_info
6488 && processing_current_prefix
[0] != '\0')
6490 SYMBOL_LINKAGE_NAME (sym
) = obconcat (&objfile
->objfile_obstack
,
6491 processing_current_prefix
,
6495 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6496 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6497 add_symbol_to_list (sym
, cu
->list_in_scope
);
6499 case DW_TAG_base_type
:
6500 case DW_TAG_subrange_type
:
6501 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6502 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6503 add_symbol_to_list (sym
, cu
->list_in_scope
);
6505 case DW_TAG_enumerator
:
6506 if (processing_has_namespace_info
6507 && processing_current_prefix
[0] != '\0')
6509 SYMBOL_LINKAGE_NAME (sym
) = obconcat (&objfile
->objfile_obstack
,
6510 processing_current_prefix
,
6514 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6517 dwarf2_const_value (attr
, sym
, cu
);
6520 /* NOTE: carlton/2003-11-10: See comment above in the
6521 DW_TAG_class_type, etc. block. */
6523 struct pending
**list_to_add
;
6525 list_to_add
= (cu
->list_in_scope
== &file_symbols
6526 && cu
->language
== language_cplus
6527 ? &global_symbols
: cu
->list_in_scope
);
6529 add_symbol_to_list (sym
, list_to_add
);
6532 case DW_TAG_namespace
:
6533 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6534 add_symbol_to_list (sym
, &global_symbols
);
6537 /* Not a tag we recognize. Hopefully we aren't processing
6538 trash data, but since we must specifically ignore things
6539 we don't recognize, there is nothing else we should do at
6541 complaint (&symfile_complaints
, "unsupported tag: '%s'",
6542 dwarf_tag_name (die
->tag
));
6549 /* Copy constant value from an attribute to a symbol. */
6552 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
6553 struct dwarf2_cu
*cu
)
6555 struct objfile
*objfile
= cu
->objfile
;
6556 struct comp_unit_head
*cu_header
= &cu
->header
;
6557 struct dwarf_block
*blk
;
6562 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
6563 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
6564 cu_header
->addr_size
,
6565 TYPE_LENGTH (SYMBOL_TYPE
6567 SYMBOL_VALUE_BYTES (sym
) = (char *)
6568 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
6569 /* NOTE: cagney/2003-05-09: In-lined store_address call with
6570 it's body - store_unsigned_integer. */
6571 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
6573 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
6575 case DW_FORM_block1
:
6576 case DW_FORM_block2
:
6577 case DW_FORM_block4
:
6579 blk
= DW_BLOCK (attr
);
6580 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
6581 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
6583 TYPE_LENGTH (SYMBOL_TYPE
6585 SYMBOL_VALUE_BYTES (sym
) = (char *)
6586 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
6587 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
6588 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
6591 /* The DW_AT_const_value attributes are supposed to carry the
6592 symbol's value "represented as it would be on the target
6593 architecture." By the time we get here, it's already been
6594 converted to host endianness, so we just need to sign- or
6595 zero-extend it as appropriate. */
6597 dwarf2_const_value_data (attr
, sym
, 8);
6600 dwarf2_const_value_data (attr
, sym
, 16);
6603 dwarf2_const_value_data (attr
, sym
, 32);
6606 dwarf2_const_value_data (attr
, sym
, 64);
6610 SYMBOL_VALUE (sym
) = DW_SND (attr
);
6611 SYMBOL_CLASS (sym
) = LOC_CONST
;
6615 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
6616 SYMBOL_CLASS (sym
) = LOC_CONST
;
6620 complaint (&symfile_complaints
,
6621 "unsupported const value attribute form: '%s'",
6622 dwarf_form_name (attr
->form
));
6623 SYMBOL_VALUE (sym
) = 0;
6624 SYMBOL_CLASS (sym
) = LOC_CONST
;
6630 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
6631 or zero-extend it as appropriate for the symbol's type. */
6633 dwarf2_const_value_data (struct attribute
*attr
,
6637 LONGEST l
= DW_UNSND (attr
);
6639 if (bits
< sizeof (l
) * 8)
6641 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
6642 l
&= ((LONGEST
) 1 << bits
) - 1;
6644 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
6647 SYMBOL_VALUE (sym
) = l
;
6648 SYMBOL_CLASS (sym
) = LOC_CONST
;
6652 /* Return the type of the die in question using its DW_AT_type attribute. */
6654 static struct type
*
6655 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6658 struct attribute
*type_attr
;
6659 struct die_info
*type_die
;
6662 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
6665 /* A missing DW_AT_type represents a void type. */
6666 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
6670 ref
= dwarf2_get_ref_die_offset (type_attr
, cu
);
6671 type_die
= follow_die_ref (ref
);
6674 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
6675 ref
, cu
->objfile
->name
);
6679 type
= tag_type_to_type (type_die
, cu
);
6682 dump_die (type_die
);
6683 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
6689 /* Return the containing type of the die in question using its
6690 DW_AT_containing_type attribute. */
6692 static struct type
*
6693 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6695 struct type
*type
= NULL
;
6696 struct attribute
*type_attr
;
6697 struct die_info
*type_die
= NULL
;
6700 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
6703 ref
= dwarf2_get_ref_die_offset (type_attr
, cu
);
6704 type_die
= follow_die_ref (ref
);
6707 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref
,
6711 type
= tag_type_to_type (type_die
, cu
);
6716 dump_die (type_die
);
6717 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
6724 static struct type
*
6725 type_at_offset (unsigned int offset
, struct dwarf2_cu
*cu
)
6727 struct die_info
*die
;
6730 die
= follow_die_ref (offset
);
6733 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
6736 type
= tag_type_to_type (die
, cu
);
6741 static struct type
*
6742 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6750 read_type_die (die
, cu
);
6754 error ("Dwarf Error: Cannot find type of die [in module %s]",
6762 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
6764 char *prefix
= determine_prefix (die
, cu
);
6765 const char *old_prefix
= processing_current_prefix
;
6766 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
6767 processing_current_prefix
= prefix
;
6771 case DW_TAG_class_type
:
6772 case DW_TAG_structure_type
:
6773 case DW_TAG_union_type
:
6774 read_structure_type (die
, cu
);
6776 case DW_TAG_enumeration_type
:
6777 read_enumeration_type (die
, cu
);
6779 case DW_TAG_subprogram
:
6780 case DW_TAG_subroutine_type
:
6781 read_subroutine_type (die
, cu
);
6783 case DW_TAG_array_type
:
6784 read_array_type (die
, cu
);
6786 case DW_TAG_pointer_type
:
6787 read_tag_pointer_type (die
, cu
);
6789 case DW_TAG_ptr_to_member_type
:
6790 read_tag_ptr_to_member_type (die
, cu
);
6792 case DW_TAG_reference_type
:
6793 read_tag_reference_type (die
, cu
);
6795 case DW_TAG_const_type
:
6796 read_tag_const_type (die
, cu
);
6798 case DW_TAG_volatile_type
:
6799 read_tag_volatile_type (die
, cu
);
6801 case DW_TAG_string_type
:
6802 read_tag_string_type (die
, cu
);
6804 case DW_TAG_typedef
:
6805 read_typedef (die
, cu
);
6807 case DW_TAG_subrange_type
:
6808 read_subrange_type (die
, cu
);
6810 case DW_TAG_base_type
:
6811 read_base_type (die
, cu
);
6814 complaint (&symfile_complaints
, "unexepected tag in read_type_die: '%s'",
6815 dwarf_tag_name (die
->tag
));
6819 processing_current_prefix
= old_prefix
;
6820 do_cleanups (back_to
);
6823 /* Return the name of the namespace/class that DIE is defined within,
6824 or "" if we can't tell. The caller should xfree the result. */
6826 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
6827 therein) for an example of how to use this function to deal with
6828 DW_AT_specification. */
6831 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
6833 struct die_info
*parent
;
6835 if (cu
->language
!= language_cplus
)
6838 parent
= die
->parent
;
6842 return xstrdup ("");
6846 switch (parent
->tag
) {
6847 case DW_TAG_namespace
:
6849 /* FIXME: carlton/2004-03-05: Should I follow extension dies
6850 before doing this check? */
6851 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
6853 return xstrdup (TYPE_TAG_NAME (parent
->type
));
6858 char *parent_prefix
= determine_prefix (parent
, cu
);
6859 char *retval
= typename_concat (parent_prefix
,
6860 namespace_name (parent
, &dummy
,
6862 xfree (parent_prefix
);
6867 case DW_TAG_class_type
:
6868 case DW_TAG_structure_type
:
6870 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
6872 return xstrdup (TYPE_TAG_NAME (parent
->type
));
6876 const char *old_prefix
= processing_current_prefix
;
6877 char *new_prefix
= determine_prefix (parent
, cu
);
6880 processing_current_prefix
= new_prefix
;
6881 retval
= determine_class_name (parent
, cu
);
6882 processing_current_prefix
= old_prefix
;
6889 return determine_prefix (parent
, cu
);
6894 /* Return a newly-allocated string formed by concatenating PREFIX,
6895 "::", and SUFFIX, except that if PREFIX is NULL or the empty
6896 string, just return a copy of SUFFIX. */
6899 typename_concat (const char *prefix
, const char *suffix
)
6901 if (prefix
== NULL
|| prefix
[0] == '\0')
6902 return xstrdup (suffix
);
6905 char *retval
= xmalloc (strlen (prefix
) + 2 + strlen (suffix
) + 1);
6907 strcpy (retval
, prefix
);
6908 strcat (retval
, "::");
6909 strcat (retval
, suffix
);
6915 static struct type
*
6916 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
6918 struct objfile
*objfile
= cu
->objfile
;
6920 /* FIXME - this should not produce a new (struct type *)
6921 every time. It should cache base types. */
6925 case DW_ATE_address
:
6926 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
6928 case DW_ATE_boolean
:
6929 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
6931 case DW_ATE_complex_float
:
6934 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
6938 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
6944 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
6948 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
6955 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
6958 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
6962 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
6966 case DW_ATE_signed_char
:
6967 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
6969 case DW_ATE_unsigned
:
6973 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
6976 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
6980 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
6984 case DW_ATE_unsigned_char
:
6985 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
6988 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
6995 copy_die (struct die_info
*old_die
)
6997 struct die_info
*new_die
;
7000 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7001 memset (new_die
, 0, sizeof (struct die_info
));
7003 new_die
->tag
= old_die
->tag
;
7004 new_die
->has_children
= old_die
->has_children
;
7005 new_die
->abbrev
= old_die
->abbrev
;
7006 new_die
->offset
= old_die
->offset
;
7007 new_die
->type
= NULL
;
7009 num_attrs
= old_die
->num_attrs
;
7010 new_die
->num_attrs
= num_attrs
;
7011 new_die
->attrs
= (struct attribute
*)
7012 xmalloc (num_attrs
* sizeof (struct attribute
));
7014 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7016 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7017 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7018 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7021 new_die
->next
= NULL
;
7026 /* Return sibling of die, NULL if no sibling. */
7028 static struct die_info
*
7029 sibling_die (struct die_info
*die
)
7031 return die
->sibling
;
7034 /* Get linkage name of a die, return NULL if not found. */
7037 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7039 struct attribute
*attr
;
7041 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7042 if (attr
&& DW_STRING (attr
))
7043 return DW_STRING (attr
);
7044 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7045 if (attr
&& DW_STRING (attr
))
7046 return DW_STRING (attr
);
7050 /* Get name of a die, return NULL if not found. */
7053 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7055 struct attribute
*attr
;
7057 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7058 if (attr
&& DW_STRING (attr
))
7059 return DW_STRING (attr
);
7063 /* Return the die that this die in an extension of, or NULL if there
7066 static struct die_info
*
7067 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7069 struct attribute
*attr
;
7070 struct die_info
*extension_die
;
7073 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7077 ref
= dwarf2_get_ref_die_offset (attr
, cu
);
7078 extension_die
= follow_die_ref (ref
);
7081 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
7084 return extension_die
;
7087 /* Convert a DIE tag into its string name. */
7090 dwarf_tag_name (unsigned tag
)
7094 case DW_TAG_padding
:
7095 return "DW_TAG_padding";
7096 case DW_TAG_array_type
:
7097 return "DW_TAG_array_type";
7098 case DW_TAG_class_type
:
7099 return "DW_TAG_class_type";
7100 case DW_TAG_entry_point
:
7101 return "DW_TAG_entry_point";
7102 case DW_TAG_enumeration_type
:
7103 return "DW_TAG_enumeration_type";
7104 case DW_TAG_formal_parameter
:
7105 return "DW_TAG_formal_parameter";
7106 case DW_TAG_imported_declaration
:
7107 return "DW_TAG_imported_declaration";
7109 return "DW_TAG_label";
7110 case DW_TAG_lexical_block
:
7111 return "DW_TAG_lexical_block";
7113 return "DW_TAG_member";
7114 case DW_TAG_pointer_type
:
7115 return "DW_TAG_pointer_type";
7116 case DW_TAG_reference_type
:
7117 return "DW_TAG_reference_type";
7118 case DW_TAG_compile_unit
:
7119 return "DW_TAG_compile_unit";
7120 case DW_TAG_string_type
:
7121 return "DW_TAG_string_type";
7122 case DW_TAG_structure_type
:
7123 return "DW_TAG_structure_type";
7124 case DW_TAG_subroutine_type
:
7125 return "DW_TAG_subroutine_type";
7126 case DW_TAG_typedef
:
7127 return "DW_TAG_typedef";
7128 case DW_TAG_union_type
:
7129 return "DW_TAG_union_type";
7130 case DW_TAG_unspecified_parameters
:
7131 return "DW_TAG_unspecified_parameters";
7132 case DW_TAG_variant
:
7133 return "DW_TAG_variant";
7134 case DW_TAG_common_block
:
7135 return "DW_TAG_common_block";
7136 case DW_TAG_common_inclusion
:
7137 return "DW_TAG_common_inclusion";
7138 case DW_TAG_inheritance
:
7139 return "DW_TAG_inheritance";
7140 case DW_TAG_inlined_subroutine
:
7141 return "DW_TAG_inlined_subroutine";
7143 return "DW_TAG_module";
7144 case DW_TAG_ptr_to_member_type
:
7145 return "DW_TAG_ptr_to_member_type";
7146 case DW_TAG_set_type
:
7147 return "DW_TAG_set_type";
7148 case DW_TAG_subrange_type
:
7149 return "DW_TAG_subrange_type";
7150 case DW_TAG_with_stmt
:
7151 return "DW_TAG_with_stmt";
7152 case DW_TAG_access_declaration
:
7153 return "DW_TAG_access_declaration";
7154 case DW_TAG_base_type
:
7155 return "DW_TAG_base_type";
7156 case DW_TAG_catch_block
:
7157 return "DW_TAG_catch_block";
7158 case DW_TAG_const_type
:
7159 return "DW_TAG_const_type";
7160 case DW_TAG_constant
:
7161 return "DW_TAG_constant";
7162 case DW_TAG_enumerator
:
7163 return "DW_TAG_enumerator";
7164 case DW_TAG_file_type
:
7165 return "DW_TAG_file_type";
7167 return "DW_TAG_friend";
7168 case DW_TAG_namelist
:
7169 return "DW_TAG_namelist";
7170 case DW_TAG_namelist_item
:
7171 return "DW_TAG_namelist_item";
7172 case DW_TAG_packed_type
:
7173 return "DW_TAG_packed_type";
7174 case DW_TAG_subprogram
:
7175 return "DW_TAG_subprogram";
7176 case DW_TAG_template_type_param
:
7177 return "DW_TAG_template_type_param";
7178 case DW_TAG_template_value_param
:
7179 return "DW_TAG_template_value_param";
7180 case DW_TAG_thrown_type
:
7181 return "DW_TAG_thrown_type";
7182 case DW_TAG_try_block
:
7183 return "DW_TAG_try_block";
7184 case DW_TAG_variant_part
:
7185 return "DW_TAG_variant_part";
7186 case DW_TAG_variable
:
7187 return "DW_TAG_variable";
7188 case DW_TAG_volatile_type
:
7189 return "DW_TAG_volatile_type";
7190 case DW_TAG_dwarf_procedure
:
7191 return "DW_TAG_dwarf_procedure";
7192 case DW_TAG_restrict_type
:
7193 return "DW_TAG_restrict_type";
7194 case DW_TAG_interface_type
:
7195 return "DW_TAG_interface_type";
7196 case DW_TAG_namespace
:
7197 return "DW_TAG_namespace";
7198 case DW_TAG_imported_module
:
7199 return "DW_TAG_imported_module";
7200 case DW_TAG_unspecified_type
:
7201 return "DW_TAG_unspecified_type";
7202 case DW_TAG_partial_unit
:
7203 return "DW_TAG_partial_unit";
7204 case DW_TAG_imported_unit
:
7205 return "DW_TAG_imported_unit";
7206 case DW_TAG_MIPS_loop
:
7207 return "DW_TAG_MIPS_loop";
7208 case DW_TAG_format_label
:
7209 return "DW_TAG_format_label";
7210 case DW_TAG_function_template
:
7211 return "DW_TAG_function_template";
7212 case DW_TAG_class_template
:
7213 return "DW_TAG_class_template";
7215 return "DW_TAG_<unknown>";
7219 /* Convert a DWARF attribute code into its string name. */
7222 dwarf_attr_name (unsigned attr
)
7227 return "DW_AT_sibling";
7228 case DW_AT_location
:
7229 return "DW_AT_location";
7231 return "DW_AT_name";
7232 case DW_AT_ordering
:
7233 return "DW_AT_ordering";
7234 case DW_AT_subscr_data
:
7235 return "DW_AT_subscr_data";
7236 case DW_AT_byte_size
:
7237 return "DW_AT_byte_size";
7238 case DW_AT_bit_offset
:
7239 return "DW_AT_bit_offset";
7240 case DW_AT_bit_size
:
7241 return "DW_AT_bit_size";
7242 case DW_AT_element_list
:
7243 return "DW_AT_element_list";
7244 case DW_AT_stmt_list
:
7245 return "DW_AT_stmt_list";
7247 return "DW_AT_low_pc";
7249 return "DW_AT_high_pc";
7250 case DW_AT_language
:
7251 return "DW_AT_language";
7253 return "DW_AT_member";
7255 return "DW_AT_discr";
7256 case DW_AT_discr_value
:
7257 return "DW_AT_discr_value";
7258 case DW_AT_visibility
:
7259 return "DW_AT_visibility";
7261 return "DW_AT_import";
7262 case DW_AT_string_length
:
7263 return "DW_AT_string_length";
7264 case DW_AT_common_reference
:
7265 return "DW_AT_common_reference";
7266 case DW_AT_comp_dir
:
7267 return "DW_AT_comp_dir";
7268 case DW_AT_const_value
:
7269 return "DW_AT_const_value";
7270 case DW_AT_containing_type
:
7271 return "DW_AT_containing_type";
7272 case DW_AT_default_value
:
7273 return "DW_AT_default_value";
7275 return "DW_AT_inline";
7276 case DW_AT_is_optional
:
7277 return "DW_AT_is_optional";
7278 case DW_AT_lower_bound
:
7279 return "DW_AT_lower_bound";
7280 case DW_AT_producer
:
7281 return "DW_AT_producer";
7282 case DW_AT_prototyped
:
7283 return "DW_AT_prototyped";
7284 case DW_AT_return_addr
:
7285 return "DW_AT_return_addr";
7286 case DW_AT_start_scope
:
7287 return "DW_AT_start_scope";
7288 case DW_AT_stride_size
:
7289 return "DW_AT_stride_size";
7290 case DW_AT_upper_bound
:
7291 return "DW_AT_upper_bound";
7292 case DW_AT_abstract_origin
:
7293 return "DW_AT_abstract_origin";
7294 case DW_AT_accessibility
:
7295 return "DW_AT_accessibility";
7296 case DW_AT_address_class
:
7297 return "DW_AT_address_class";
7298 case DW_AT_artificial
:
7299 return "DW_AT_artificial";
7300 case DW_AT_base_types
:
7301 return "DW_AT_base_types";
7302 case DW_AT_calling_convention
:
7303 return "DW_AT_calling_convention";
7305 return "DW_AT_count";
7306 case DW_AT_data_member_location
:
7307 return "DW_AT_data_member_location";
7308 case DW_AT_decl_column
:
7309 return "DW_AT_decl_column";
7310 case DW_AT_decl_file
:
7311 return "DW_AT_decl_file";
7312 case DW_AT_decl_line
:
7313 return "DW_AT_decl_line";
7314 case DW_AT_declaration
:
7315 return "DW_AT_declaration";
7316 case DW_AT_discr_list
:
7317 return "DW_AT_discr_list";
7318 case DW_AT_encoding
:
7319 return "DW_AT_encoding";
7320 case DW_AT_external
:
7321 return "DW_AT_external";
7322 case DW_AT_frame_base
:
7323 return "DW_AT_frame_base";
7325 return "DW_AT_friend";
7326 case DW_AT_identifier_case
:
7327 return "DW_AT_identifier_case";
7328 case DW_AT_macro_info
:
7329 return "DW_AT_macro_info";
7330 case DW_AT_namelist_items
:
7331 return "DW_AT_namelist_items";
7332 case DW_AT_priority
:
7333 return "DW_AT_priority";
7335 return "DW_AT_segment";
7336 case DW_AT_specification
:
7337 return "DW_AT_specification";
7338 case DW_AT_static_link
:
7339 return "DW_AT_static_link";
7341 return "DW_AT_type";
7342 case DW_AT_use_location
:
7343 return "DW_AT_use_location";
7344 case DW_AT_variable_parameter
:
7345 return "DW_AT_variable_parameter";
7346 case DW_AT_virtuality
:
7347 return "DW_AT_virtuality";
7348 case DW_AT_vtable_elem_location
:
7349 return "DW_AT_vtable_elem_location";
7350 case DW_AT_allocated
:
7351 return "DW_AT_allocated";
7352 case DW_AT_associated
:
7353 return "DW_AT_associated";
7354 case DW_AT_data_location
:
7355 return "DW_AT_data_location";
7357 return "DW_AT_stride";
7358 case DW_AT_entry_pc
:
7359 return "DW_AT_entry_pc";
7360 case DW_AT_use_UTF8
:
7361 return "DW_AT_use_UTF8";
7362 case DW_AT_extension
:
7363 return "DW_AT_extension";
7365 return "DW_AT_ranges";
7366 case DW_AT_trampoline
:
7367 return "DW_AT_trampoline";
7368 case DW_AT_call_column
:
7369 return "DW_AT_call_column";
7370 case DW_AT_call_file
:
7371 return "DW_AT_call_file";
7372 case DW_AT_call_line
:
7373 return "DW_AT_call_line";
7375 case DW_AT_MIPS_fde
:
7376 return "DW_AT_MIPS_fde";
7377 case DW_AT_MIPS_loop_begin
:
7378 return "DW_AT_MIPS_loop_begin";
7379 case DW_AT_MIPS_tail_loop_begin
:
7380 return "DW_AT_MIPS_tail_loop_begin";
7381 case DW_AT_MIPS_epilog_begin
:
7382 return "DW_AT_MIPS_epilog_begin";
7383 case DW_AT_MIPS_loop_unroll_factor
:
7384 return "DW_AT_MIPS_loop_unroll_factor";
7385 case DW_AT_MIPS_software_pipeline_depth
:
7386 return "DW_AT_MIPS_software_pipeline_depth";
7388 case DW_AT_MIPS_linkage_name
:
7389 return "DW_AT_MIPS_linkage_name";
7391 case DW_AT_sf_names
:
7392 return "DW_AT_sf_names";
7393 case DW_AT_src_info
:
7394 return "DW_AT_src_info";
7395 case DW_AT_mac_info
:
7396 return "DW_AT_mac_info";
7397 case DW_AT_src_coords
:
7398 return "DW_AT_src_coords";
7399 case DW_AT_body_begin
:
7400 return "DW_AT_body_begin";
7401 case DW_AT_body_end
:
7402 return "DW_AT_body_end";
7403 case DW_AT_GNU_vector
:
7404 return "DW_AT_GNU_vector";
7406 return "DW_AT_<unknown>";
7410 /* Convert a DWARF value form code into its string name. */
7413 dwarf_form_name (unsigned form
)
7418 return "DW_FORM_addr";
7419 case DW_FORM_block2
:
7420 return "DW_FORM_block2";
7421 case DW_FORM_block4
:
7422 return "DW_FORM_block4";
7424 return "DW_FORM_data2";
7426 return "DW_FORM_data4";
7428 return "DW_FORM_data8";
7429 case DW_FORM_string
:
7430 return "DW_FORM_string";
7432 return "DW_FORM_block";
7433 case DW_FORM_block1
:
7434 return "DW_FORM_block1";
7436 return "DW_FORM_data1";
7438 return "DW_FORM_flag";
7440 return "DW_FORM_sdata";
7442 return "DW_FORM_strp";
7444 return "DW_FORM_udata";
7445 case DW_FORM_ref_addr
:
7446 return "DW_FORM_ref_addr";
7448 return "DW_FORM_ref1";
7450 return "DW_FORM_ref2";
7452 return "DW_FORM_ref4";
7454 return "DW_FORM_ref8";
7455 case DW_FORM_ref_udata
:
7456 return "DW_FORM_ref_udata";
7457 case DW_FORM_indirect
:
7458 return "DW_FORM_indirect";
7460 return "DW_FORM_<unknown>";
7464 /* Convert a DWARF stack opcode into its string name. */
7467 dwarf_stack_op_name (unsigned op
)
7472 return "DW_OP_addr";
7474 return "DW_OP_deref";
7476 return "DW_OP_const1u";
7478 return "DW_OP_const1s";
7480 return "DW_OP_const2u";
7482 return "DW_OP_const2s";
7484 return "DW_OP_const4u";
7486 return "DW_OP_const4s";
7488 return "DW_OP_const8u";
7490 return "DW_OP_const8s";
7492 return "DW_OP_constu";
7494 return "DW_OP_consts";
7498 return "DW_OP_drop";
7500 return "DW_OP_over";
7502 return "DW_OP_pick";
7504 return "DW_OP_swap";
7508 return "DW_OP_xderef";
7516 return "DW_OP_minus";
7528 return "DW_OP_plus";
7529 case DW_OP_plus_uconst
:
7530 return "DW_OP_plus_uconst";
7536 return "DW_OP_shra";
7554 return "DW_OP_skip";
7556 return "DW_OP_lit0";
7558 return "DW_OP_lit1";
7560 return "DW_OP_lit2";
7562 return "DW_OP_lit3";
7564 return "DW_OP_lit4";
7566 return "DW_OP_lit5";
7568 return "DW_OP_lit6";
7570 return "DW_OP_lit7";
7572 return "DW_OP_lit8";
7574 return "DW_OP_lit9";
7576 return "DW_OP_lit10";
7578 return "DW_OP_lit11";
7580 return "DW_OP_lit12";
7582 return "DW_OP_lit13";
7584 return "DW_OP_lit14";
7586 return "DW_OP_lit15";
7588 return "DW_OP_lit16";
7590 return "DW_OP_lit17";
7592 return "DW_OP_lit18";
7594 return "DW_OP_lit19";
7596 return "DW_OP_lit20";
7598 return "DW_OP_lit21";
7600 return "DW_OP_lit22";
7602 return "DW_OP_lit23";
7604 return "DW_OP_lit24";
7606 return "DW_OP_lit25";
7608 return "DW_OP_lit26";
7610 return "DW_OP_lit27";
7612 return "DW_OP_lit28";
7614 return "DW_OP_lit29";
7616 return "DW_OP_lit30";
7618 return "DW_OP_lit31";
7620 return "DW_OP_reg0";
7622 return "DW_OP_reg1";
7624 return "DW_OP_reg2";
7626 return "DW_OP_reg3";
7628 return "DW_OP_reg4";
7630 return "DW_OP_reg5";
7632 return "DW_OP_reg6";
7634 return "DW_OP_reg7";
7636 return "DW_OP_reg8";
7638 return "DW_OP_reg9";
7640 return "DW_OP_reg10";
7642 return "DW_OP_reg11";
7644 return "DW_OP_reg12";
7646 return "DW_OP_reg13";
7648 return "DW_OP_reg14";
7650 return "DW_OP_reg15";
7652 return "DW_OP_reg16";
7654 return "DW_OP_reg17";
7656 return "DW_OP_reg18";
7658 return "DW_OP_reg19";
7660 return "DW_OP_reg20";
7662 return "DW_OP_reg21";
7664 return "DW_OP_reg22";
7666 return "DW_OP_reg23";
7668 return "DW_OP_reg24";
7670 return "DW_OP_reg25";
7672 return "DW_OP_reg26";
7674 return "DW_OP_reg27";
7676 return "DW_OP_reg28";
7678 return "DW_OP_reg29";
7680 return "DW_OP_reg30";
7682 return "DW_OP_reg31";
7684 return "DW_OP_breg0";
7686 return "DW_OP_breg1";
7688 return "DW_OP_breg2";
7690 return "DW_OP_breg3";
7692 return "DW_OP_breg4";
7694 return "DW_OP_breg5";
7696 return "DW_OP_breg6";
7698 return "DW_OP_breg7";
7700 return "DW_OP_breg8";
7702 return "DW_OP_breg9";
7704 return "DW_OP_breg10";
7706 return "DW_OP_breg11";
7708 return "DW_OP_breg12";
7710 return "DW_OP_breg13";
7712 return "DW_OP_breg14";
7714 return "DW_OP_breg15";
7716 return "DW_OP_breg16";
7718 return "DW_OP_breg17";
7720 return "DW_OP_breg18";
7722 return "DW_OP_breg19";
7724 return "DW_OP_breg20";
7726 return "DW_OP_breg21";
7728 return "DW_OP_breg22";
7730 return "DW_OP_breg23";
7732 return "DW_OP_breg24";
7734 return "DW_OP_breg25";
7736 return "DW_OP_breg26";
7738 return "DW_OP_breg27";
7740 return "DW_OP_breg28";
7742 return "DW_OP_breg29";
7744 return "DW_OP_breg30";
7746 return "DW_OP_breg31";
7748 return "DW_OP_regx";
7750 return "DW_OP_fbreg";
7752 return "DW_OP_bregx";
7754 return "DW_OP_piece";
7755 case DW_OP_deref_size
:
7756 return "DW_OP_deref_size";
7757 case DW_OP_xderef_size
:
7758 return "DW_OP_xderef_size";
7761 /* DWARF 3 extensions. */
7762 case DW_OP_push_object_address
:
7763 return "DW_OP_push_object_address";
7765 return "DW_OP_call2";
7767 return "DW_OP_call4";
7768 case DW_OP_call_ref
:
7769 return "DW_OP_call_ref";
7770 /* GNU extensions. */
7771 case DW_OP_GNU_push_tls_address
:
7772 return "DW_OP_GNU_push_tls_address";
7774 return "OP_<unknown>";
7779 dwarf_bool_name (unsigned mybool
)
7787 /* Convert a DWARF type code into its string name. */
7790 dwarf_type_encoding_name (unsigned enc
)
7794 case DW_ATE_address
:
7795 return "DW_ATE_address";
7796 case DW_ATE_boolean
:
7797 return "DW_ATE_boolean";
7798 case DW_ATE_complex_float
:
7799 return "DW_ATE_complex_float";
7801 return "DW_ATE_float";
7803 return "DW_ATE_signed";
7804 case DW_ATE_signed_char
:
7805 return "DW_ATE_signed_char";
7806 case DW_ATE_unsigned
:
7807 return "DW_ATE_unsigned";
7808 case DW_ATE_unsigned_char
:
7809 return "DW_ATE_unsigned_char";
7810 case DW_ATE_imaginary_float
:
7811 return "DW_ATE_imaginary_float";
7813 return "DW_ATE_<unknown>";
7817 /* Convert a DWARF call frame info operation to its string name. */
7821 dwarf_cfi_name (unsigned cfi_opc
)
7825 case DW_CFA_advance_loc
:
7826 return "DW_CFA_advance_loc";
7828 return "DW_CFA_offset";
7829 case DW_CFA_restore
:
7830 return "DW_CFA_restore";
7832 return "DW_CFA_nop";
7833 case DW_CFA_set_loc
:
7834 return "DW_CFA_set_loc";
7835 case DW_CFA_advance_loc1
:
7836 return "DW_CFA_advance_loc1";
7837 case DW_CFA_advance_loc2
:
7838 return "DW_CFA_advance_loc2";
7839 case DW_CFA_advance_loc4
:
7840 return "DW_CFA_advance_loc4";
7841 case DW_CFA_offset_extended
:
7842 return "DW_CFA_offset_extended";
7843 case DW_CFA_restore_extended
:
7844 return "DW_CFA_restore_extended";
7845 case DW_CFA_undefined
:
7846 return "DW_CFA_undefined";
7847 case DW_CFA_same_value
:
7848 return "DW_CFA_same_value";
7849 case DW_CFA_register
:
7850 return "DW_CFA_register";
7851 case DW_CFA_remember_state
:
7852 return "DW_CFA_remember_state";
7853 case DW_CFA_restore_state
:
7854 return "DW_CFA_restore_state";
7855 case DW_CFA_def_cfa
:
7856 return "DW_CFA_def_cfa";
7857 case DW_CFA_def_cfa_register
:
7858 return "DW_CFA_def_cfa_register";
7859 case DW_CFA_def_cfa_offset
:
7860 return "DW_CFA_def_cfa_offset";
7863 case DW_CFA_def_cfa_expression
:
7864 return "DW_CFA_def_cfa_expression";
7865 case DW_CFA_expression
:
7866 return "DW_CFA_expression";
7867 case DW_CFA_offset_extended_sf
:
7868 return "DW_CFA_offset_extended_sf";
7869 case DW_CFA_def_cfa_sf
:
7870 return "DW_CFA_def_cfa_sf";
7871 case DW_CFA_def_cfa_offset_sf
:
7872 return "DW_CFA_def_cfa_offset_sf";
7874 /* SGI/MIPS specific */
7875 case DW_CFA_MIPS_advance_loc8
:
7876 return "DW_CFA_MIPS_advance_loc8";
7878 /* GNU extensions */
7879 case DW_CFA_GNU_window_save
:
7880 return "DW_CFA_GNU_window_save";
7881 case DW_CFA_GNU_args_size
:
7882 return "DW_CFA_GNU_args_size";
7883 case DW_CFA_GNU_negative_offset_extended
:
7884 return "DW_CFA_GNU_negative_offset_extended";
7887 return "DW_CFA_<unknown>";
7893 dump_die (struct die_info
*die
)
7897 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
7898 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
7899 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
7900 dwarf_bool_name (die
->child
!= NULL
));
7902 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
7903 for (i
= 0; i
< die
->num_attrs
; ++i
)
7905 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
7906 dwarf_attr_name (die
->attrs
[i
].name
),
7907 dwarf_form_name (die
->attrs
[i
].form
));
7908 switch (die
->attrs
[i
].form
)
7910 case DW_FORM_ref_addr
:
7912 fprintf_unfiltered (gdb_stderr
, "address: ");
7913 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
7915 case DW_FORM_block2
:
7916 case DW_FORM_block4
:
7918 case DW_FORM_block1
:
7919 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
7930 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
7932 case DW_FORM_string
:
7934 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
7935 DW_STRING (&die
->attrs
[i
])
7936 ? DW_STRING (&die
->attrs
[i
]) : "");
7939 if (DW_UNSND (&die
->attrs
[i
]))
7940 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
7942 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
7944 case DW_FORM_indirect
:
7945 /* the reader will have reduced the indirect form to
7946 the "base form" so this form should not occur */
7947 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
7950 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
7951 die
->attrs
[i
].form
);
7953 fprintf_unfiltered (gdb_stderr
, "\n");
7958 dump_die_list (struct die_info
*die
)
7963 if (die
->child
!= NULL
)
7964 dump_die_list (die
->child
);
7965 if (die
->sibling
!= NULL
)
7966 dump_die_list (die
->sibling
);
7971 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
7974 struct die_info
*old
;
7976 h
= (offset
% REF_HASH_SIZE
);
7977 old
= die_ref_table
[h
];
7978 die
->next_ref
= old
;
7979 die_ref_table
[h
] = die
;
7984 dwarf2_empty_hash_tables (void)
7986 memset (die_ref_table
, 0, sizeof (die_ref_table
));
7990 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
7992 unsigned int result
= 0;
7996 case DW_FORM_ref_addr
:
7997 result
= DW_ADDR (attr
);
8003 case DW_FORM_ref_udata
:
8004 result
= cu
->header
.offset
+ DW_UNSND (attr
);
8007 complaint (&symfile_complaints
,
8008 "unsupported die ref attribute form: '%s'",
8009 dwarf_form_name (attr
->form
));
8014 /* Return the constant value held by the given attribute. Return -1
8015 if the value held by the attribute is not constant. */
8018 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8020 if (attr
->form
== DW_FORM_sdata
)
8021 return DW_SND (attr
);
8022 else if (attr
->form
== DW_FORM_udata
8023 || attr
->form
== DW_FORM_data1
8024 || attr
->form
== DW_FORM_data2
8025 || attr
->form
== DW_FORM_data4
8026 || attr
->form
== DW_FORM_data8
)
8027 return DW_UNSND (attr
);
8030 complaint (&symfile_complaints
, "Attribute value is not a constant (%s)",
8031 dwarf_form_name (attr
->form
));
8032 return default_value
;
8036 static struct die_info
*
8037 follow_die_ref (unsigned int offset
)
8039 struct die_info
*die
;
8042 h
= (offset
% REF_HASH_SIZE
);
8043 die
= die_ref_table
[h
];
8046 if (die
->offset
== offset
)
8050 die
= die
->next_ref
;
8055 static struct type
*
8056 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8057 struct dwarf2_cu
*cu
)
8059 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8061 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
8062 typeid, objfile
->name
);
8065 /* Look for this particular type in the fundamental type vector. If
8066 one is not found, create and install one appropriate for the
8067 current language and the current target machine. */
8069 if (cu
->ftypes
[typeid] == NULL
)
8071 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8074 return (cu
->ftypes
[typeid]);
8077 /* Decode simple location descriptions.
8078 Given a pointer to a dwarf block that defines a location, compute
8079 the location and return the value.
8081 NOTE drow/2003-11-18: This function is called in two situations
8082 now: for the address of static or global variables (partial symbols
8083 only) and for offsets into structures which are expected to be
8084 (more or less) constant. The partial symbol case should go away,
8085 and only the constant case should remain. That will let this
8086 function complain more accurately. A few special modes are allowed
8087 without complaint for global variables (for instance, global
8088 register values and thread-local values).
8090 A location description containing no operations indicates that the
8091 object is optimized out. The return value is 0 for that case.
8092 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8093 callers will only want a very basic result and this can become a
8096 When the result is a register number, the global isreg flag is set,
8097 otherwise it is cleared.
8099 Note that stack[0] is unused except as a default error return.
8100 Note that stack overflow is not yet handled. */
8103 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8105 struct objfile
*objfile
= cu
->objfile
;
8106 struct comp_unit_head
*cu_header
= &cu
->header
;
8108 int size
= blk
->size
;
8109 char *data
= blk
->data
;
8110 CORE_ADDR stack
[64];
8112 unsigned int bytes_read
, unsnd
;
8157 stack
[++stacki
] = op
- DW_OP_lit0
;
8193 stack
[++stacki
] = op
- DW_OP_reg0
;
8195 dwarf2_complex_location_expr_complaint ();
8200 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8202 stack
[++stacki
] = unsnd
;
8204 dwarf2_complex_location_expr_complaint ();
8208 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8214 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8219 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8224 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8229 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8234 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8239 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8244 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8250 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8255 stack
[stacki
+ 1] = stack
[stacki
];
8260 stack
[stacki
- 1] += stack
[stacki
];
8264 case DW_OP_plus_uconst
:
8265 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8270 stack
[stacki
- 1] -= stack
[stacki
];
8275 /* If we're not the last op, then we definitely can't encode
8276 this using GDB's address_class enum. This is valid for partial
8277 global symbols, although the variable's address will be bogus
8280 dwarf2_complex_location_expr_complaint ();
8283 case DW_OP_GNU_push_tls_address
:
8284 /* The top of the stack has the offset from the beginning
8285 of the thread control block at which the variable is located. */
8286 /* Nothing should follow this operator, so the top of stack would
8288 /* This is valid for partial global symbols, but the variable's
8289 address will be bogus in the psymtab. */
8291 dwarf2_complex_location_expr_complaint ();
8295 complaint (&symfile_complaints
, "unsupported stack op: '%s'",
8296 dwarf_stack_op_name (op
));
8297 return (stack
[stacki
]);
8300 return (stack
[stacki
]);
8303 /* memory allocation interface */
8305 static struct dwarf_block
*
8306 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8308 struct dwarf_block
*blk
;
8310 blk
= (struct dwarf_block
*)
8311 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8315 static struct abbrev_info
*
8316 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8318 struct abbrev_info
*abbrev
;
8320 abbrev
= (struct abbrev_info
*)
8321 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8322 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8326 static struct die_info
*
8327 dwarf_alloc_die (void)
8329 struct die_info
*die
;
8331 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8332 memset (die
, 0, sizeof (struct die_info
));
8337 /* Macro support. */
8340 /* Return the full name of file number I in *LH's file name table.
8341 Use COMP_DIR as the name of the current directory of the
8342 compilation. The result is allocated using xmalloc; the caller is
8343 responsible for freeing it. */
8345 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8347 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8349 if (IS_ABSOLUTE_PATH (fe
->name
))
8350 return xstrdup (fe
->name
);
8358 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8364 dir_len
= strlen (dir
);
8365 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8366 strcpy (full_name
, dir
);
8367 full_name
[dir_len
] = '/';
8368 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8372 return xstrdup (fe
->name
);
8377 static struct macro_source_file
*
8378 macro_start_file (int file
, int line
,
8379 struct macro_source_file
*current_file
,
8380 const char *comp_dir
,
8381 struct line_header
*lh
, struct objfile
*objfile
)
8383 /* The full name of this source file. */
8384 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8386 /* We don't create a macro table for this compilation unit
8387 at all until we actually get a filename. */
8388 if (! pending_macros
)
8389 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8390 objfile
->macro_cache
);
8393 /* If we have no current file, then this must be the start_file
8394 directive for the compilation unit's main source file. */
8395 current_file
= macro_set_main (pending_macros
, full_name
);
8397 current_file
= macro_include (current_file
, line
, full_name
);
8401 return current_file
;
8405 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8406 followed by a null byte. */
8408 copy_string (const char *buf
, int len
)
8410 char *s
= xmalloc (len
+ 1);
8411 memcpy (s
, buf
, len
);
8419 consume_improper_spaces (const char *p
, const char *body
)
8423 complaint (&symfile_complaints
,
8424 "macro definition contains spaces in formal argument list:\n`%s'",
8436 parse_macro_definition (struct macro_source_file
*file
, int line
,
8441 /* The body string takes one of two forms. For object-like macro
8442 definitions, it should be:
8444 <macro name> " " <definition>
8446 For function-like macro definitions, it should be:
8448 <macro name> "() " <definition>
8450 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8452 Spaces may appear only where explicitly indicated, and in the
8455 The Dwarf 2 spec says that an object-like macro's name is always
8456 followed by a space, but versions of GCC around March 2002 omit
8457 the space when the macro's definition is the empty string.
8459 The Dwarf 2 spec says that there should be no spaces between the
8460 formal arguments in a function-like macro's formal argument list,
8461 but versions of GCC around March 2002 include spaces after the
8465 /* Find the extent of the macro name. The macro name is terminated
8466 by either a space or null character (for an object-like macro) or
8467 an opening paren (for a function-like macro). */
8468 for (p
= body
; *p
; p
++)
8469 if (*p
== ' ' || *p
== '(')
8472 if (*p
== ' ' || *p
== '\0')
8474 /* It's an object-like macro. */
8475 int name_len
= p
- body
;
8476 char *name
= copy_string (body
, name_len
);
8477 const char *replacement
;
8480 replacement
= body
+ name_len
+ 1;
8483 dwarf2_macro_malformed_definition_complaint (body
);
8484 replacement
= body
+ name_len
;
8487 macro_define_object (file
, line
, name
, replacement
);
8493 /* It's a function-like macro. */
8494 char *name
= copy_string (body
, p
- body
);
8497 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
8501 p
= consume_improper_spaces (p
, body
);
8503 /* Parse the formal argument list. */
8504 while (*p
&& *p
!= ')')
8506 /* Find the extent of the current argument name. */
8507 const char *arg_start
= p
;
8509 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
8512 if (! *p
|| p
== arg_start
)
8513 dwarf2_macro_malformed_definition_complaint (body
);
8516 /* Make sure argv has room for the new argument. */
8517 if (argc
>= argv_size
)
8520 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
8523 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
8526 p
= consume_improper_spaces (p
, body
);
8528 /* Consume the comma, if present. */
8533 p
= consume_improper_spaces (p
, body
);
8542 /* Perfectly formed definition, no complaints. */
8543 macro_define_function (file
, line
, name
,
8544 argc
, (const char **) argv
,
8546 else if (*p
== '\0')
8548 /* Complain, but do define it. */
8549 dwarf2_macro_malformed_definition_complaint (body
);
8550 macro_define_function (file
, line
, name
,
8551 argc
, (const char **) argv
,
8555 /* Just complain. */
8556 dwarf2_macro_malformed_definition_complaint (body
);
8559 /* Just complain. */
8560 dwarf2_macro_malformed_definition_complaint (body
);
8566 for (i
= 0; i
< argc
; i
++)
8572 dwarf2_macro_malformed_definition_complaint (body
);
8577 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
8578 char *comp_dir
, bfd
*abfd
,
8579 struct dwarf2_cu
*cu
)
8581 char *mac_ptr
, *mac_end
;
8582 struct macro_source_file
*current_file
= 0;
8584 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
8586 complaint (&symfile_complaints
, "missing .debug_macinfo section");
8590 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
8591 mac_end
= dwarf2_per_objfile
->macinfo_buffer
8592 + dwarf2_per_objfile
->macinfo_size
;
8596 enum dwarf_macinfo_record_type macinfo_type
;
8598 /* Do we at least have room for a macinfo type byte? */
8599 if (mac_ptr
>= mac_end
)
8601 dwarf2_macros_too_long_complaint ();
8605 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
8608 switch (macinfo_type
)
8610 /* A zero macinfo type indicates the end of the macro
8615 case DW_MACINFO_define
:
8616 case DW_MACINFO_undef
:
8622 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
8623 mac_ptr
+= bytes_read
;
8624 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
8625 mac_ptr
+= bytes_read
;
8628 complaint (&symfile_complaints
,
8629 "debug info gives macro %s outside of any file: %s",
8631 DW_MACINFO_define
? "definition" : macinfo_type
==
8632 DW_MACINFO_undef
? "undefinition" :
8633 "something-or-other", body
);
8636 if (macinfo_type
== DW_MACINFO_define
)
8637 parse_macro_definition (current_file
, line
, body
);
8638 else if (macinfo_type
== DW_MACINFO_undef
)
8639 macro_undef (current_file
, line
, body
);
8644 case DW_MACINFO_start_file
:
8649 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
8650 mac_ptr
+= bytes_read
;
8651 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
8652 mac_ptr
+= bytes_read
;
8654 current_file
= macro_start_file (file
, line
,
8655 current_file
, comp_dir
,
8660 case DW_MACINFO_end_file
:
8662 complaint (&symfile_complaints
,
8663 "macro debug info has an unmatched `close_file' directive");
8666 current_file
= current_file
->included_by
;
8669 enum dwarf_macinfo_record_type next_type
;
8671 /* GCC circa March 2002 doesn't produce the zero
8672 type byte marking the end of the compilation
8673 unit. Complain if it's not there, but exit no
8676 /* Do we at least have room for a macinfo type byte? */
8677 if (mac_ptr
>= mac_end
)
8679 dwarf2_macros_too_long_complaint ();
8683 /* We don't increment mac_ptr here, so this is just
8685 next_type
= read_1_byte (abfd
, mac_ptr
);
8687 complaint (&symfile_complaints
,
8688 "no terminating 0-type entry for macros in `.debug_macinfo' section");
8695 case DW_MACINFO_vendor_ext
:
8701 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
8702 mac_ptr
+= bytes_read
;
8703 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
8704 mac_ptr
+= bytes_read
;
8706 /* We don't recognize any vendor extensions. */
8713 /* Check if the attribute's form is a DW_FORM_block*
8714 if so return true else false. */
8716 attr_form_is_block (struct attribute
*attr
)
8718 return (attr
== NULL
? 0 :
8719 attr
->form
== DW_FORM_block1
8720 || attr
->form
== DW_FORM_block2
8721 || attr
->form
== DW_FORM_block4
8722 || attr
->form
== DW_FORM_block
);
8726 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
8727 struct dwarf2_cu
*cu
)
8729 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
8731 struct dwarf2_loclist_baton
*baton
;
8733 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
8734 sizeof (struct dwarf2_loclist_baton
));
8735 baton
->objfile
= cu
->objfile
;
8737 /* We don't know how long the location list is, but make sure we
8738 don't run off the edge of the section. */
8739 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
8740 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
8741 baton
->base_address
= cu
->header
.base_address
;
8742 if (cu
->header
.base_known
== 0)
8743 complaint (&symfile_complaints
,
8744 "Location list used without specifying the CU base address.");
8746 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
8747 SYMBOL_LOCATION_BATON (sym
) = baton
;
8751 struct dwarf2_locexpr_baton
*baton
;
8753 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
8754 sizeof (struct dwarf2_locexpr_baton
));
8755 baton
->objfile
= cu
->objfile
;
8757 if (attr_form_is_block (attr
))
8759 /* Note that we're just copying the block's data pointer
8760 here, not the actual data. We're still pointing into the
8761 info_buffer for SYM's objfile; right now we never release
8762 that buffer, but when we do clean up properly this may
8764 baton
->size
= DW_BLOCK (attr
)->size
;
8765 baton
->data
= DW_BLOCK (attr
)->data
;
8769 dwarf2_invalid_attrib_class_complaint ("location description",
8770 SYMBOL_NATURAL_NAME (sym
));
8775 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
8776 SYMBOL_LOCATION_BATON (sym
) = baton
;
8780 /* This cleanup function is passed the address of a dwarf2_cu on the stack
8781 when we're finished with it. We can't free the pointer itself, but
8782 release any associated storage.
8784 Only used during partial symbol parsing. */
8787 free_stack_comp_unit (void *data
)
8789 struct dwarf2_cu
*cu
= data
;
8791 obstack_free (&cu
->comp_unit_obstack
, NULL
);
8792 cu
->partial_dies
= NULL
;
8795 /* Allocation function for the libiberty hash table which uses an
8799 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
8801 unsigned int total
= size
* count
;
8802 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
8803 memset (ptr
, 0, total
);
8807 /* Trivial deallocation function for the libiberty splay tree and hash
8808 table - don't deallocate anything. Rely on later deletion of the
8812 dummy_obstack_deallocate (void *object
, void *data
)
8817 /* Trivial hash function for partial_die_info: the hash value of a DIE
8818 is its offset in .debug_info for this objfile. */
8821 partial_die_hash (const void *item
)
8823 const struct partial_die_info
*part_die
= item
;
8824 return part_die
->offset
;
8827 /* Trivial comparison function for partial_die_info structures: two DIEs
8828 are equal if they have the same offset. */
8831 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
8833 const struct partial_die_info
*part_die_lhs
= item_lhs
;
8834 const struct partial_die_info
*part_die_rhs
= item_rhs
;
8835 return part_die_lhs
->offset
== part_die_rhs
->offset
;
8838 void _initialize_dwarf2_read (void);
8841 _initialize_dwarf2_read (void)
8843 dwarf2_objfile_data_key
= register_objfile_data ();