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. */
36 #include "elf/dwarf2.h"
39 #include "expression.h"
40 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
45 #include "dwarf2expr.h"
46 #include "dwarf2loc.h"
47 #include "cp-support.h"
50 #include "gdb_string.h"
51 #include "gdb_assert.h"
52 #include <sys/types.h>
54 #ifndef DWARF2_REG_TO_REGNUM
55 #define DWARF2_REG_TO_REGNUM(REG) (REG)
59 /* .debug_info header for a compilation unit
60 Because of alignment constraints, this structure has padding and cannot
61 be mapped directly onto the beginning of the .debug_info section. */
62 typedef struct comp_unit_header
64 unsigned int length
; /* length of the .debug_info
66 unsigned short version
; /* version number -- 2 for DWARF
68 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
69 unsigned char addr_size
; /* byte size of an address -- 4 */
72 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
75 /* .debug_pubnames header
76 Because of alignment constraints, this structure has padding and cannot
77 be mapped directly onto the beginning of the .debug_info section. */
78 typedef struct pubnames_header
80 unsigned int length
; /* length of the .debug_pubnames
82 unsigned char version
; /* version number -- 2 for DWARF
84 unsigned int info_offset
; /* offset into .debug_info section */
85 unsigned int info_size
; /* byte size of .debug_info section
89 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
91 /* .debug_pubnames header
92 Because of alignment constraints, this structure has padding and cannot
93 be mapped directly onto the beginning of the .debug_info section. */
94 typedef struct aranges_header
96 unsigned int length
; /* byte len of the .debug_aranges
98 unsigned short version
; /* version number -- 2 for DWARF
100 unsigned int info_offset
; /* offset into .debug_info section */
101 unsigned char addr_size
; /* byte size of an address */
102 unsigned char seg_size
; /* byte size of segment descriptor */
105 #define _ACTUAL_ARANGES_HEADER_SIZE 12
107 /* .debug_line statement program prologue
108 Because of alignment constraints, this structure has padding and cannot
109 be mapped directly onto the beginning of the .debug_info section. */
110 typedef struct statement_prologue
112 unsigned int total_length
; /* byte length of the statement
114 unsigned short version
; /* version number -- 2 for DWARF
116 unsigned int prologue_length
; /* # bytes between prologue &
118 unsigned char minimum_instruction_length
; /* byte size of
120 unsigned char default_is_stmt
; /* initial value of is_stmt
123 unsigned char line_range
;
124 unsigned char opcode_base
; /* number assigned to first special
126 unsigned char *standard_opcode_lengths
;
130 /* offsets and sizes of debugging sections */
132 static unsigned int dwarf_info_size
;
133 static unsigned int dwarf_abbrev_size
;
134 static unsigned int dwarf_line_size
;
135 static unsigned int dwarf_pubnames_size
;
136 static unsigned int dwarf_aranges_size
;
137 static unsigned int dwarf_loc_size
;
138 static unsigned int dwarf_macinfo_size
;
139 static unsigned int dwarf_str_size
;
140 static unsigned int dwarf_ranges_size
;
141 unsigned int dwarf_frame_size
;
142 unsigned int dwarf_eh_frame_size
;
144 static asection
*dwarf_info_section
;
145 static asection
*dwarf_abbrev_section
;
146 static asection
*dwarf_line_section
;
147 static asection
*dwarf_pubnames_section
;
148 static asection
*dwarf_aranges_section
;
149 static asection
*dwarf_loc_section
;
150 static asection
*dwarf_macinfo_section
;
151 static asection
*dwarf_str_section
;
152 static asection
*dwarf_ranges_section
;
153 asection
*dwarf_frame_section
;
154 asection
*dwarf_eh_frame_section
;
156 /* names of the debugging sections */
158 #define INFO_SECTION ".debug_info"
159 #define ABBREV_SECTION ".debug_abbrev"
160 #define LINE_SECTION ".debug_line"
161 #define PUBNAMES_SECTION ".debug_pubnames"
162 #define ARANGES_SECTION ".debug_aranges"
163 #define LOC_SECTION ".debug_loc"
164 #define MACINFO_SECTION ".debug_macinfo"
165 #define STR_SECTION ".debug_str"
166 #define RANGES_SECTION ".debug_ranges"
167 #define FRAME_SECTION ".debug_frame"
168 #define EH_FRAME_SECTION ".eh_frame"
170 /* local data types */
172 /* We hold several abbreviation tables in memory at the same time. */
173 #ifndef ABBREV_HASH_SIZE
174 #define ABBREV_HASH_SIZE 121
177 /* The data in a compilation unit header, after target2host
178 translation, looks like this. */
179 struct comp_unit_head
181 unsigned long length
;
183 unsigned int abbrev_offset
;
184 unsigned char addr_size
;
185 unsigned char signed_addr_p
;
186 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
187 unsigned int initial_length_size
; /* size of the length field; either
190 /* Offset to the first byte of this compilation unit header in the
191 * .debug_info section, for resolving relative reference dies. */
195 /* Pointer to this compilation unit header in the .debug_info
200 /* Pointer to the first die of this compilatio unit. This will
201 * be the first byte following the compilation unit header. */
205 /* Pointer to the next compilation unit header in the program. */
207 struct comp_unit_head
*next
;
209 /* DWARF abbreviation table associated with this compilation unit */
211 struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
213 /* Base address of this compilation unit. */
215 CORE_ADDR base_address
;
217 /* Non-zero if base_address has been set. */
222 /* Internal state when decoding a particular compilation unit. */
225 /* The objfile containing this compilation unit. */
226 struct objfile
*objfile
;
228 /* The header of the compilation unit.
230 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
231 should be moved to the dwarf2_cu structure; for instance the abbrevs
233 struct comp_unit_head header
;
236 /* The line number information for a compilation unit (found in the
237 .debug_line section) begins with a "statement program header",
238 which contains the following information. */
241 unsigned int total_length
;
242 unsigned short version
;
243 unsigned int header_length
;
244 unsigned char minimum_instruction_length
;
245 unsigned char default_is_stmt
;
247 unsigned char line_range
;
248 unsigned char opcode_base
;
250 /* standard_opcode_lengths[i] is the number of operands for the
251 standard opcode whose value is i. This means that
252 standard_opcode_lengths[0] is unused, and the last meaningful
253 element is standard_opcode_lengths[opcode_base - 1]. */
254 unsigned char *standard_opcode_lengths
;
256 /* The include_directories table. NOTE! These strings are not
257 allocated with xmalloc; instead, they are pointers into
258 debug_line_buffer. If you try to free them, `free' will get
260 unsigned int num_include_dirs
, include_dirs_size
;
263 /* The file_names table. NOTE! These strings are not allocated
264 with xmalloc; instead, they are pointers into debug_line_buffer.
265 Don't try to free them directly. */
266 unsigned int num_file_names
, file_names_size
;
270 unsigned int dir_index
;
271 unsigned int mod_time
;
275 /* The start and end of the statement program following this
276 header. These point into dwarf_line_buffer. */
277 char *statement_program_start
, *statement_program_end
;
280 /* When we construct a partial symbol table entry we only
281 need this much information. */
282 struct partial_die_info
285 unsigned char has_children
;
286 unsigned char is_external
;
287 unsigned char is_declaration
;
288 unsigned char has_type
;
295 struct dwarf_block
*locdesc
;
296 unsigned int language
;
300 /* This data structure holds the information of an abbrev. */
303 unsigned int number
; /* number identifying abbrev */
304 enum dwarf_tag tag
; /* dwarf tag */
305 int has_children
; /* boolean */
306 unsigned int num_attrs
; /* number of attributes */
307 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
308 struct abbrev_info
*next
; /* next in chain */
313 enum dwarf_attribute name
;
314 enum dwarf_form form
;
317 /* This data structure holds a complete die structure. */
320 enum dwarf_tag tag
; /* Tag indicating type of die */
321 unsigned int abbrev
; /* Abbrev number */
322 unsigned int offset
; /* Offset in .debug_info section */
323 unsigned int num_attrs
; /* Number of attributes */
324 struct attribute
*attrs
; /* An array of attributes */
325 struct die_info
*next_ref
; /* Next die in ref hash table */
327 /* The dies in a compilation unit form an n-ary tree. PARENT
328 points to this die's parent; CHILD points to the first child of
329 this node; and all the children of a given node are chained
330 together via their SIBLING fields, terminated by a die whose
332 struct die_info
*child
; /* Its first child, if any. */
333 struct die_info
*sibling
; /* Its next sibling, if any. */
334 struct die_info
*parent
; /* Its parent, if any. */
336 struct type
*type
; /* Cached type information */
339 /* Attributes have a name and a value */
342 enum dwarf_attribute name
;
343 enum dwarf_form form
;
347 struct dwarf_block
*blk
;
355 struct function_range
358 CORE_ADDR lowpc
, highpc
;
360 struct function_range
*next
;
363 static struct function_range
*cu_first_fn
, *cu_last_fn
, *cu_cached_fn
;
365 /* Get at parts of an attribute structure */
367 #define DW_STRING(attr) ((attr)->u.str)
368 #define DW_UNSND(attr) ((attr)->u.unsnd)
369 #define DW_BLOCK(attr) ((attr)->u.blk)
370 #define DW_SND(attr) ((attr)->u.snd)
371 #define DW_ADDR(attr) ((attr)->u.addr)
373 /* Blocks are a bunch of untyped bytes. */
380 #ifndef ATTR_ALLOC_CHUNK
381 #define ATTR_ALLOC_CHUNK 4
384 /* A hash table of die offsets for following references. */
385 #ifndef REF_HASH_SIZE
386 #define REF_HASH_SIZE 1021
389 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
391 /* Obstack for allocating temporary storage used during symbol reading. */
392 static struct obstack dwarf2_tmp_obstack
;
394 /* Offset to the first byte of the current compilation unit header,
395 for resolving relative reference dies. */
396 static unsigned int cu_header_offset
;
398 /* Allocate fields for structs, unions and enums in this size. */
399 #ifndef DW_FIELD_ALLOC_CHUNK
400 #define DW_FIELD_ALLOC_CHUNK 4
403 /* The language we are debugging. */
404 static enum language cu_language
;
405 static const struct language_defn
*cu_language_defn
;
407 /* Actually data from the sections. */
408 static char *dwarf_info_buffer
;
409 static char *dwarf_abbrev_buffer
;
410 static char *dwarf_line_buffer
;
411 static char *dwarf_str_buffer
;
412 static char *dwarf_macinfo_buffer
;
413 static char *dwarf_ranges_buffer
;
414 static char *dwarf_loc_buffer
;
416 /* A zeroed version of a partial die for initialization purposes. */
417 static struct partial_die_info zeroed_partial_die
;
419 /* The generic symbol table building routines have separate lists for
420 file scope symbols and all all other scopes (local scopes). So
421 we need to select the right one to pass to add_symbol_to_list().
422 We do it by keeping a pointer to the correct list in list_in_scope.
424 FIXME: The original dwarf code just treated the file scope as the first
425 local scope, and all other local scopes as nested local scopes, and worked
426 fine. Check to see if we really need to distinguish these
428 static struct pending
**list_in_scope
= &file_symbols
;
430 /* FIXME: decode_locdesc sets these variables to describe the location
431 to the caller. These ought to be a structure or something. If
432 none of the flags are set, the object lives at the address returned
433 by decode_locdesc. */
435 static int isreg
; /* Object lives in register.
436 decode_locdesc's return value is
437 the register number. */
439 /* This value is added to each symbol value. FIXME: Generalize to
440 the section_offsets structure used by dbxread (once this is done,
441 pass the appropriate section number to end_symtab). */
442 static CORE_ADDR baseaddr
; /* Add to each symbol value */
444 /* We put a pointer to this structure in the read_symtab_private field
446 The complete dwarf information for an objfile is kept in the
447 psymbol_obstack, so that absolute die references can be handled.
448 Most of the information in this structure is related to an entire
449 object file and could be passed via the sym_private field of the objfile.
450 It is however conceivable that dwarf2 might not be the only type
451 of symbols read from an object file. */
455 /* Pointer to start of dwarf info buffer for the objfile. */
457 char *dwarf_info_buffer
;
459 /* Offset in dwarf_info_buffer for this compilation unit. */
461 unsigned long dwarf_info_offset
;
463 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
465 char *dwarf_abbrev_buffer
;
467 /* Size of dwarf abbreviation section for the objfile. */
469 unsigned int dwarf_abbrev_size
;
471 /* Pointer to start of dwarf line buffer for the objfile. */
473 char *dwarf_line_buffer
;
475 /* Size of dwarf_line_buffer, in bytes. */
477 unsigned int dwarf_line_size
;
479 /* Pointer to start of dwarf string buffer for the objfile. */
481 char *dwarf_str_buffer
;
483 /* Size of dwarf string section for the objfile. */
485 unsigned int dwarf_str_size
;
487 /* Pointer to start of dwarf macro buffer for the objfile. */
489 char *dwarf_macinfo_buffer
;
491 /* Size of dwarf macinfo section for the objfile. */
493 unsigned int dwarf_macinfo_size
;
495 /* Pointer to start of dwarf ranges buffer for the objfile. */
497 char *dwarf_ranges_buffer
;
499 /* Size of dwarf ranges buffer for the objfile. */
501 unsigned int dwarf_ranges_size
;
503 /* Pointer to start of dwarf locations buffer for the objfile. */
505 char *dwarf_loc_buffer
;
507 /* Size of dwarf locations buffer for the objfile. */
509 unsigned int dwarf_loc_size
;
512 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
513 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
514 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
515 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
516 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
517 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
518 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
519 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
520 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
521 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
522 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
523 #define DWARF_RANGES_BUFFER(p) (PST_PRIVATE(p)->dwarf_ranges_buffer)
524 #define DWARF_RANGES_SIZE(p) (PST_PRIVATE(p)->dwarf_ranges_size)
525 #define DWARF_LOC_BUFFER(p) (PST_PRIVATE(p)->dwarf_loc_buffer)
526 #define DWARF_LOC_SIZE(p) (PST_PRIVATE(p)->dwarf_loc_size)
528 /* Maintain an array of referenced fundamental types for the current
529 compilation unit being read. For DWARF version 1, we have to construct
530 the fundamental types on the fly, since no information about the
531 fundamental types is supplied. Each such fundamental type is created by
532 calling a language dependent routine to create the type, and then a
533 pointer to that type is then placed in the array at the index specified
534 by it's FT_<TYPENAME> value. The array has a fixed size set by the
535 FT_NUM_MEMBERS compile time constant, which is the number of predefined
536 fundamental types gdb knows how to construct. */
537 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
539 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
540 but this would require a corresponding change in unpack_field_as_long
542 static int bits_per_byte
= 8;
544 /* The routines that read and process dies for a C struct or C++ class
545 pass lists of data member fields and lists of member function fields
546 in an instance of a field_info structure, as defined below. */
549 /* List of data member and baseclasses fields. */
552 struct nextfield
*next
;
559 /* Number of fields. */
562 /* Number of baseclasses. */
565 /* Set if the accesibility of one of the fields is not public. */
566 int non_public_fields
;
568 /* Member function fields array, entries are allocated in the order they
569 are encountered in the object file. */
572 struct nextfnfield
*next
;
573 struct fn_field fnfield
;
577 /* Member function fieldlist array, contains name of possibly overloaded
578 member function, number of overloaded member functions and a pointer
579 to the head of the member function field chain. */
584 struct nextfnfield
*head
;
588 /* Number of entries in the fnfieldlists array. */
592 /* Various complaints about symbol reading that don't abort the process */
595 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
597 complaint (&symfile_complaints
,
598 "statement list doesn't fit in .debug_line section");
602 dwarf2_complex_location_expr_complaint (void)
604 complaint (&symfile_complaints
, "location expression too complex");
608 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
611 complaint (&symfile_complaints
,
612 "const value length mismatch for '%s', got %d, expected %d", arg1
,
617 dwarf2_macros_too_long_complaint (void)
619 complaint (&symfile_complaints
,
620 "macro info runs off end of `.debug_macinfo' section");
624 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
626 complaint (&symfile_complaints
,
627 "macro debug info contains a malformed macro definition:\n`%s'",
632 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
634 complaint (&symfile_complaints
,
635 "invalid attribute class or form for '%s' in '%s'", arg1
, arg2
);
638 /* local function prototypes */
640 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
643 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
646 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
648 static char *scan_partial_symbols (char *, CORE_ADDR
*, CORE_ADDR
*,
650 const char *namespace);
652 static void add_partial_symbol (struct partial_die_info
*, struct dwarf2_cu
*,
653 const char *namespace);
655 static int pdi_needs_namespace (enum dwarf_tag tag
, const char *namespace);
657 static char *add_partial_namespace (struct partial_die_info
*pdi
,
659 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
660 struct dwarf2_cu
*cu
,
661 const char *namespace);
663 static char *add_partial_structure (struct partial_die_info
*struct_pdi
,
665 struct dwarf2_cu
*cu
,
666 const char *namespace);
668 static char *add_partial_enumeration (struct partial_die_info
*enum_pdi
,
670 struct dwarf2_cu
*cu
,
671 const char *namespace);
673 static char *locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
676 struct dwarf2_cu
*cu
);
678 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
680 static void psymtab_to_symtab_1 (struct partial_symtab
*);
682 char *dwarf2_read_section (struct objfile
*, asection
*);
684 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
686 static void dwarf2_empty_abbrev_table (void *);
688 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
691 static char *read_partial_die (struct partial_die_info
*,
692 bfd
*, char *, struct dwarf2_cu
*);
694 static char *read_full_die (struct die_info
**, bfd
*, char *,
695 struct dwarf2_cu
*, int *);
697 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
698 bfd
*, char *, struct dwarf2_cu
*);
700 static char *read_attribute_value (struct attribute
*, unsigned,
701 bfd
*, char *, struct dwarf2_cu
*);
703 static unsigned int read_1_byte (bfd
*, char *);
705 static int read_1_signed_byte (bfd
*, char *);
707 static unsigned int read_2_bytes (bfd
*, char *);
709 static unsigned int read_4_bytes (bfd
*, char *);
711 static unsigned long read_8_bytes (bfd
*, char *);
713 static CORE_ADDR
read_address (bfd
*, char *ptr
, struct dwarf2_cu
*,
716 static LONGEST
read_initial_length (bfd
*, char *,
717 struct comp_unit_head
*, int *bytes_read
);
719 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
722 static char *read_n_bytes (bfd
*, char *, unsigned int);
724 static char *read_string (bfd
*, char *, unsigned int *);
726 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
729 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
731 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
733 static void set_cu_language (unsigned int);
735 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
737 static int die_is_declaration (struct die_info
*);
739 static struct die_info
*die_specification (struct die_info
*die
);
741 static void free_line_header (struct line_header
*lh
);
743 static struct line_header
*(dwarf_decode_line_header
744 (unsigned int offset
,
745 bfd
*abfd
, struct dwarf2_cu
*cu
));
747 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
750 static void dwarf2_start_subfile (char *, char *);
752 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
755 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
758 static void dwarf2_const_value_data (struct attribute
*attr
,
762 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
764 static struct type
*die_containing_type (struct die_info
*,
768 static struct type
*type_at_offset (unsigned int, struct objfile
*);
771 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
773 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
775 static char *determine_prefix (struct die_info
*die
);
777 static char *determine_prefix_aux (struct die_info
*die
);
779 static char *typename_concat (const char *prefix
, const char *suffix
);
781 static char *class_name (struct die_info
*die
);
783 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
785 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
787 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
789 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
791 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
793 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
795 static int dwarf2_get_pc_bounds (struct die_info
*,
796 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
798 static void get_scope_pc_bounds (struct die_info
*,
799 CORE_ADDR
*, CORE_ADDR
*,
802 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
805 static void dwarf2_attach_fields_to_type (struct field_info
*,
806 struct type
*, struct dwarf2_cu
*);
808 static void dwarf2_add_member_fn (struct field_info
*,
809 struct die_info
*, struct type
*,
812 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
813 struct type
*, struct dwarf2_cu
*);
815 static void read_structure_scope (struct die_info
*, struct dwarf2_cu
*);
817 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
819 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
821 static const char *namespace_name (struct die_info
*die
,
824 static void read_enumeration (struct die_info
*, struct dwarf2_cu
*);
826 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
828 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
830 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
832 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
834 static void read_tag_ptr_to_member_type (struct die_info
*,
837 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
839 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
841 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
843 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
845 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
847 static struct die_info
*read_comp_unit (char *, bfd
*, struct dwarf2_cu
*);
849 static struct die_info
*read_die_and_children (char *info_ptr
, bfd
*abfd
,
852 struct die_info
*parent
);
854 static struct die_info
*read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
857 struct die_info
*parent
);
859 static void free_die_list (struct die_info
*);
861 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
863 static void process_die (struct die_info
*, struct dwarf2_cu
*);
865 static char *dwarf2_linkage_name (struct die_info
*);
867 static char *dwarf2_name (struct die_info
*die
);
869 static struct die_info
*dwarf2_extension (struct die_info
*die
);
871 static char *dwarf_tag_name (unsigned int);
873 static char *dwarf_attr_name (unsigned int);
875 static char *dwarf_form_name (unsigned int);
877 static char *dwarf_stack_op_name (unsigned int);
879 static char *dwarf_bool_name (unsigned int);
881 static char *dwarf_type_encoding_name (unsigned int);
884 static char *dwarf_cfi_name (unsigned int);
886 struct die_info
*copy_die (struct die_info
*);
889 static struct die_info
*sibling_die (struct die_info
*);
891 static void dump_die (struct die_info
*);
893 static void dump_die_list (struct die_info
*);
895 static void store_in_ref_table (unsigned int, struct die_info
*);
897 static void dwarf2_empty_hash_tables (void);
899 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
901 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
903 static struct die_info
*follow_die_ref (unsigned int);
905 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
907 /* memory allocation interface */
909 static void dwarf2_free_tmp_obstack (void *);
911 static struct dwarf_block
*dwarf_alloc_block (void);
913 static struct abbrev_info
*dwarf_alloc_abbrev (void);
915 static struct die_info
*dwarf_alloc_die (void);
917 static void initialize_cu_func_list (void);
919 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
921 static void dwarf_decode_macros (struct line_header
*, unsigned int,
922 char *, bfd
*, struct dwarf2_cu
*);
924 static int attr_form_is_block (struct attribute
*);
927 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
928 struct dwarf2_cu
*cu
);
930 /* Try to locate the sections we need for DWARF 2 debugging
931 information and return true if we have enough to do something. */
934 dwarf2_has_info (bfd
*abfd
)
936 dwarf_info_section
= 0;
937 dwarf_abbrev_section
= 0;
938 dwarf_line_section
= 0;
939 dwarf_str_section
= 0;
940 dwarf_macinfo_section
= 0;
941 dwarf_frame_section
= 0;
942 dwarf_eh_frame_section
= 0;
943 dwarf_ranges_section
= 0;
944 dwarf_loc_section
= 0;
946 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
947 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
950 /* This function is mapped across the sections and remembers the
951 offset and size of each of the debugging sections we are interested
955 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
957 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
959 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
960 dwarf_info_section
= sectp
;
962 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
964 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
965 dwarf_abbrev_section
= sectp
;
967 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
969 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
970 dwarf_line_section
= sectp
;
972 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
974 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
975 dwarf_pubnames_section
= sectp
;
977 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
979 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
980 dwarf_aranges_section
= sectp
;
982 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
984 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
985 dwarf_loc_section
= sectp
;
987 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
989 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
990 dwarf_macinfo_section
= sectp
;
992 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
994 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
995 dwarf_str_section
= sectp
;
997 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
999 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1000 dwarf_frame_section
= sectp
;
1002 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1004 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1005 if (aflag
& SEC_HAS_CONTENTS
)
1007 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1008 dwarf_eh_frame_section
= sectp
;
1011 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1013 dwarf_ranges_size
= bfd_get_section_size_before_reloc (sectp
);
1014 dwarf_ranges_section
= sectp
;
1018 /* Build a partial symbol table. */
1021 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1024 /* We definitely need the .debug_info and .debug_abbrev sections */
1026 dwarf_info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1027 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1029 if (dwarf_line_section
)
1030 dwarf_line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1032 dwarf_line_buffer
= NULL
;
1034 if (dwarf_str_section
)
1035 dwarf_str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1037 dwarf_str_buffer
= NULL
;
1039 if (dwarf_macinfo_section
)
1040 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1041 dwarf_macinfo_section
);
1043 dwarf_macinfo_buffer
= NULL
;
1045 if (dwarf_ranges_section
)
1046 dwarf_ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1048 dwarf_ranges_buffer
= NULL
;
1050 if (dwarf_loc_section
)
1051 dwarf_loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1053 dwarf_loc_buffer
= NULL
;
1056 || (objfile
->global_psymbols
.size
== 0
1057 && objfile
->static_psymbols
.size
== 0))
1059 init_psymbol_list (objfile
, 1024);
1063 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1065 /* Things are significantly easier if we have .debug_aranges and
1066 .debug_pubnames sections */
1068 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1072 /* only test this case for now */
1074 /* In this case we have to work a bit harder */
1075 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1080 /* Build the partial symbol table from the information in the
1081 .debug_pubnames and .debug_aranges sections. */
1084 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1086 bfd
*abfd
= objfile
->obfd
;
1087 char *aranges_buffer
, *pubnames_buffer
;
1088 char *aranges_ptr
, *pubnames_ptr
;
1089 unsigned int entry_length
, version
, info_offset
, info_size
;
1091 pubnames_buffer
= dwarf2_read_section (objfile
,
1092 dwarf_pubnames_section
);
1093 pubnames_ptr
= pubnames_buffer
;
1094 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1096 struct comp_unit_head cu_header
;
1099 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1101 pubnames_ptr
+= bytes_read
;
1102 version
= read_1_byte (abfd
, pubnames_ptr
);
1104 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1106 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1110 aranges_buffer
= dwarf2_read_section (objfile
,
1111 dwarf_aranges_section
);
1116 /* Read in the comp unit header information from the debug_info at
1120 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1121 char *info_ptr
, bfd
*abfd
)
1125 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1127 info_ptr
+= bytes_read
;
1128 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1130 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1132 info_ptr
+= bytes_read
;
1133 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1135 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1136 if (signed_addr
< 0)
1137 internal_error (__FILE__
, __LINE__
,
1138 "read_comp_unit_head: dwarf from non elf file");
1139 cu_header
->signed_addr_p
= signed_addr
;
1143 /* Build the partial symbol table by doing a quick pass through the
1144 .debug_info and .debug_abbrev sections. */
1147 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1149 /* Instead of reading this into a big buffer, we should probably use
1150 mmap() on architectures that support it. (FIXME) */
1151 bfd
*abfd
= objfile
->obfd
;
1152 char *info_ptr
, *abbrev_ptr
;
1153 char *beg_of_comp_unit
;
1154 struct partial_die_info comp_unit_die
;
1155 struct partial_symtab
*pst
;
1156 struct cleanup
*back_to
;
1157 CORE_ADDR lowpc
, highpc
;
1159 info_ptr
= dwarf_info_buffer
;
1160 abbrev_ptr
= dwarf_abbrev_buffer
;
1162 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1163 the partial symbol scan, like attribute values.
1165 We could reduce our peak memory consumption during partial symbol
1166 table construction by freeing stuff from this obstack more often
1167 --- say, after processing each compilation unit, or each die ---
1168 but it turns out that this saves almost nothing. For an
1169 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1170 on dwarf2_tmp_obstack. Some investigation showed:
1172 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1173 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1174 all fixed-length values not requiring dynamic allocation.
1176 2) 30% of the attributes used the form DW_FORM_string. For
1177 DW_FORM_string, read_attribute simply hands back a pointer to
1178 the null-terminated string in dwarf_info_buffer, so no dynamic
1179 allocation is needed there either.
1181 3) The remaining 1% of the attributes all used DW_FORM_block1.
1182 75% of those were DW_AT_frame_base location lists for
1183 functions; the rest were DW_AT_location attributes, probably
1184 for the global variables.
1186 Anyway, what this all means is that the memory the dwarf2
1187 reader uses as temporary space reading partial symbols is about
1188 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1190 obstack_init (&dwarf2_tmp_obstack
);
1191 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1193 /* Since the objects we're extracting from dwarf_info_buffer vary in
1194 length, only the individual functions to extract them (like
1195 read_comp_unit_head and read_partial_die) can really know whether
1196 the buffer is large enough to hold another complete object.
1198 At the moment, they don't actually check that. If
1199 dwarf_info_buffer holds just one extra byte after the last
1200 compilation unit's dies, then read_comp_unit_head will happily
1201 read off the end of the buffer. read_partial_die is similarly
1202 casual. Those functions should be fixed.
1204 For this loop condition, simply checking whether there's any data
1205 left at all should be sufficient. */
1206 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1208 struct dwarf2_cu cu
;
1209 beg_of_comp_unit
= info_ptr
;
1211 cu
.objfile
= objfile
;
1212 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1214 if (cu
.header
.version
!= 2)
1216 error ("Dwarf Error: wrong version in compilation unit header (is %d, should be %d) [in module %s]", cu
.header
.version
, 2, bfd_get_filename (abfd
));
1219 if (cu
.header
.abbrev_offset
>= dwarf_abbrev_size
)
1221 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1222 (long) cu
.header
.abbrev_offset
,
1223 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1224 bfd_get_filename (abfd
));
1227 if (beg_of_comp_unit
+ cu
.header
.length
+ cu
.header
.initial_length_size
1228 > dwarf_info_buffer
+ dwarf_info_size
)
1230 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1231 (long) cu
.header
.length
,
1232 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1233 bfd_get_filename (abfd
));
1236 /* Complete the cu_header */
1237 cu
.header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1238 cu
.header
.first_die_ptr
= info_ptr
;
1239 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1241 /* Read the abbrevs for this compilation unit into a table */
1242 dwarf2_read_abbrevs (abfd
, &cu
);
1243 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1245 /* Read the compilation unit die */
1246 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1249 /* Set the language we're debugging */
1250 set_cu_language (comp_unit_die
.language
);
1252 /* Allocate a new partial symbol table structure */
1253 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1254 comp_unit_die
.name
? comp_unit_die
.name
: "",
1255 comp_unit_die
.lowpc
,
1256 objfile
->global_psymbols
.next
,
1257 objfile
->static_psymbols
.next
);
1259 pst
->read_symtab_private
= (char *)
1260 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1261 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1262 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1263 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1264 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1265 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1266 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1267 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1268 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1269 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1270 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1271 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1272 DWARF_RANGES_BUFFER (pst
) = dwarf_ranges_buffer
;
1273 DWARF_RANGES_SIZE (pst
) = dwarf_ranges_size
;
1274 DWARF_LOC_BUFFER (pst
) = dwarf_loc_buffer
;
1275 DWARF_LOC_SIZE (pst
) = dwarf_loc_size
;
1276 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1278 /* Store the function that reads in the rest of the symbol table */
1279 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1281 /* Check if comp unit has_children.
1282 If so, read the rest of the partial symbols from this comp unit.
1283 If not, there's no more debug_info for this comp unit. */
1284 if (comp_unit_die
.has_children
)
1286 lowpc
= ((CORE_ADDR
) -1);
1287 highpc
= ((CORE_ADDR
) 0);
1289 info_ptr
= scan_partial_symbols (info_ptr
, &lowpc
, &highpc
,
1292 /* If we didn't find a lowpc, set it to highpc to avoid
1293 complaints from `maint check'. */
1294 if (lowpc
== ((CORE_ADDR
) -1))
1297 /* If the compilation unit didn't have an explicit address range,
1298 then use the information extracted from its child dies. */
1299 if (! comp_unit_die
.has_pc_info
)
1301 comp_unit_die
.lowpc
= lowpc
;
1302 comp_unit_die
.highpc
= highpc
;
1305 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1306 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1308 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1309 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1310 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1311 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1312 sort_pst_symbols (pst
);
1314 /* If there is already a psymtab or symtab for a file of this
1315 name, remove it. (If there is a symtab, more drastic things
1316 also happen.) This happens in VxWorks. */
1317 free_named_symtabs (pst
->filename
);
1319 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1320 + cu
.header
.initial_length_size
;
1322 do_cleanups (back_to
);
1325 /* Read in all interesting dies to the end of the compilation unit or
1326 to the end of the current namespace. NAMESPACE is NULL if we
1327 haven't yet encountered any DW_TAG_namespace entries; otherwise,
1328 it's the name of the current namespace. In particular, it's the
1329 empty string if we're currently in the global namespace but have
1330 previously encountered a DW_TAG_namespace. */
1333 scan_partial_symbols (char *info_ptr
, CORE_ADDR
*lowpc
,
1334 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
1335 const char *namespace)
1337 struct objfile
*objfile
= cu
->objfile
;
1338 bfd
*abfd
= objfile
->obfd
;
1339 struct partial_die_info pdi
;
1341 /* Now, march along the PDI's, descending into ones which have
1342 interesting children but skipping the children of the other ones,
1343 until we reach the end of the compilation unit. */
1347 /* This flag tells whether or not info_ptr has gotten updated
1349 int info_ptr_updated
= 0;
1351 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1353 /* Anonymous namespaces have no name but have interesting
1354 children, so we need to look at them. Ditto for anonymous
1357 if (pdi
.name
!= NULL
|| pdi
.tag
== DW_TAG_namespace
1358 || pdi
.tag
== DW_TAG_enumeration_type
)
1362 case DW_TAG_subprogram
:
1363 if (pdi
.has_pc_info
)
1365 if (pdi
.lowpc
< *lowpc
)
1369 if (pdi
.highpc
> *highpc
)
1371 *highpc
= pdi
.highpc
;
1373 if (!pdi
.is_declaration
)
1375 add_partial_symbol (&pdi
, cu
, namespace);
1379 case DW_TAG_variable
:
1380 case DW_TAG_typedef
:
1381 case DW_TAG_union_type
:
1382 if (!pdi
.is_declaration
)
1384 add_partial_symbol (&pdi
, cu
, namespace);
1387 case DW_TAG_class_type
:
1388 case DW_TAG_structure_type
:
1389 if (!pdi
.is_declaration
)
1391 info_ptr
= add_partial_structure (&pdi
, info_ptr
, cu
,
1393 info_ptr_updated
= 1;
1396 case DW_TAG_enumeration_type
:
1397 if (!pdi
.is_declaration
)
1399 info_ptr
= add_partial_enumeration (&pdi
, info_ptr
, cu
,
1401 info_ptr_updated
= 1;
1404 case DW_TAG_base_type
:
1405 case DW_TAG_subrange_type
:
1406 /* File scope base type definitions are added to the partial
1408 add_partial_symbol (&pdi
, cu
, namespace);
1410 case DW_TAG_namespace
:
1411 /* We've hit a DW_TAG_namespace entry, so we know this
1412 file has been compiled using a compiler that
1413 generates them; update NAMESPACE to reflect that. */
1414 if (namespace == NULL
)
1416 info_ptr
= add_partial_namespace (&pdi
, info_ptr
, lowpc
, highpc
,
1418 info_ptr_updated
= 1;
1428 /* If the die has a sibling, skip to the sibling, unless another
1429 function has already updated info_ptr for us. */
1431 /* NOTE: carlton/2003-06-16: This is a bit hackish, but whether
1432 or not we want to update this depends on enough stuff (not
1433 only pdi.tag but also whether or not pdi.name is NULL) that
1434 this seems like the easiest way to handle the issue. */
1436 if (!info_ptr_updated
)
1437 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1444 add_partial_symbol (struct partial_die_info
*pdi
,
1445 struct dwarf2_cu
*cu
, const char *namespace)
1447 struct objfile
*objfile
= cu
->objfile
;
1449 char *actual_name
= pdi
->name
;
1450 const struct partial_symbol
*psym
= NULL
;
1452 /* If we're not in the global namespace and if the namespace name
1453 isn't encoded in a mangled actual_name, add it. */
1455 if (pdi_needs_namespace (pdi
->tag
, namespace))
1457 actual_name
= alloca (strlen (pdi
->name
) + 2 + strlen (namespace) + 1);
1458 strcpy (actual_name
, namespace);
1459 strcat (actual_name
, "::");
1460 strcat (actual_name
, pdi
->name
);
1465 case DW_TAG_subprogram
:
1466 if (pdi
->is_external
)
1468 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1469 mst_text, objfile); */
1470 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1471 VAR_DOMAIN
, LOC_BLOCK
,
1472 &objfile
->global_psymbols
,
1473 0, pdi
->lowpc
+ baseaddr
,
1474 cu_language
, objfile
);
1478 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1479 mst_file_text, objfile); */
1480 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1481 VAR_DOMAIN
, LOC_BLOCK
,
1482 &objfile
->static_psymbols
,
1483 0, pdi
->lowpc
+ baseaddr
,
1484 cu_language
, objfile
);
1487 case DW_TAG_variable
:
1488 if (pdi
->is_external
)
1491 Don't enter into the minimal symbol tables as there is
1492 a minimal symbol table entry from the ELF symbols already.
1493 Enter into partial symbol table if it has a location
1494 descriptor or a type.
1495 If the location descriptor is missing, new_symbol will create
1496 a LOC_UNRESOLVED symbol, the address of the variable will then
1497 be determined from the minimal symbol table whenever the variable
1499 The address for the partial symbol table entry is not
1500 used by GDB, but it comes in handy for debugging partial symbol
1504 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1505 if (pdi
->locdesc
|| pdi
->has_type
)
1506 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1507 VAR_DOMAIN
, LOC_STATIC
,
1508 &objfile
->global_psymbols
,
1510 cu_language
, objfile
);
1514 /* Static Variable. Skip symbols without location descriptors. */
1515 if (pdi
->locdesc
== NULL
)
1517 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1518 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1519 mst_file_data, objfile); */
1520 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1521 VAR_DOMAIN
, LOC_STATIC
,
1522 &objfile
->static_psymbols
,
1524 cu_language
, objfile
);
1527 case DW_TAG_typedef
:
1528 case DW_TAG_base_type
:
1529 case DW_TAG_subrange_type
:
1530 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1531 VAR_DOMAIN
, LOC_TYPEDEF
,
1532 &objfile
->static_psymbols
,
1533 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1535 case DW_TAG_class_type
:
1536 case DW_TAG_structure_type
:
1537 case DW_TAG_union_type
:
1538 case DW_TAG_enumeration_type
:
1539 /* Skip aggregate types without children, these are external
1541 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1542 static vs. global. */
1543 if (pdi
->has_children
== 0)
1545 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1546 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1547 cu_language
== language_cplus
1548 ? &objfile
->global_psymbols
1549 : &objfile
->static_psymbols
,
1550 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1552 if (cu_language
== language_cplus
)
1554 /* For C++, these implicitly act as typedefs as well. */
1555 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1556 VAR_DOMAIN
, LOC_TYPEDEF
,
1557 &objfile
->global_psymbols
,
1558 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1561 case DW_TAG_enumerator
:
1562 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1563 VAR_DOMAIN
, LOC_CONST
,
1564 cu_language
== language_cplus
1565 ? &objfile
->static_psymbols
1566 : &objfile
->global_psymbols
,
1567 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1573 /* Check to see if we should scan the name for possible namespace
1574 info. Only do this if this is C++, if we don't have namespace
1575 debugging info in the file, if the psym is of an appropriate type
1576 (otherwise we'll have psym == NULL), and if we actually had a
1577 mangled name to begin with. */
1579 if (cu_language
== language_cplus
1580 && namespace == NULL
1582 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
1583 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
1587 /* Determine whether a die of type TAG living in the C++ namespace
1588 NAMESPACE needs to have the name of the namespace prepended to the
1589 name listed in the die. */
1592 pdi_needs_namespace (enum dwarf_tag tag
, const char *namespace)
1594 if (namespace == NULL
|| namespace[0] == '\0')
1599 case DW_TAG_typedef
:
1600 case DW_TAG_class_type
:
1601 case DW_TAG_structure_type
:
1602 case DW_TAG_union_type
:
1603 case DW_TAG_enumeration_type
:
1604 case DW_TAG_enumerator
:
1611 /* Read a partial die corresponding to a namespace; also, add a symbol
1612 corresponding to that namespace to the symbol table. NAMESPACE is
1613 the name of the enclosing namespace. */
1616 add_partial_namespace (struct partial_die_info
*pdi
, char *info_ptr
,
1617 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1618 struct dwarf2_cu
*cu
, const char *namespace)
1620 struct objfile
*objfile
= cu
->objfile
;
1621 const char *new_name
= pdi
->name
;
1624 /* Calculate the full name of the namespace that we just entered. */
1626 if (new_name
== NULL
)
1627 new_name
= "(anonymous namespace)";
1628 full_name
= alloca (strlen (namespace) + 2 + strlen (new_name
) + 1);
1629 strcpy (full_name
, namespace);
1630 if (*namespace != '\0')
1631 strcat (full_name
, "::");
1632 strcat (full_name
, new_name
);
1634 /* FIXME: carlton/2003-10-07: We can't just replace this by a call
1635 to add_partial_symbol, because we don't have a way to pass in the
1636 full name to that function; that might be a flaw in
1637 add_partial_symbol's interface. */
1639 add_psymbol_to_list (full_name
, strlen (full_name
),
1640 VAR_DOMAIN
, LOC_TYPEDEF
,
1641 &objfile
->global_psymbols
,
1642 0, 0, cu_language
, objfile
);
1644 /* Now scan partial symbols in that namespace. */
1646 if (pdi
->has_children
)
1647 info_ptr
= scan_partial_symbols (info_ptr
, lowpc
, highpc
, cu
, full_name
);
1652 /* Read a partial die corresponding to a class or structure. */
1655 add_partial_structure (struct partial_die_info
*struct_pdi
, char *info_ptr
,
1656 struct dwarf2_cu
*cu
,
1657 const char *namespace)
1659 bfd
*abfd
= cu
->objfile
->obfd
;
1660 char *actual_class_name
= NULL
;
1662 if (cu_language
== language_cplus
1663 && namespace == NULL
1664 && struct_pdi
->name
!= NULL
1665 && struct_pdi
->has_children
)
1667 /* We don't have namespace debugging information, so see if we
1668 can figure out if this structure lives in a namespace. Look
1669 for a member function; its demangled name will contain
1670 namespace info, if there is any. */
1672 /* NOTE: carlton/2003-10-07: Getting the info this way changes
1673 what template types look like, because the demangler
1674 frequently doesn't give the same name as the debug info. We
1675 could fix this by only using the demangled name to get the
1676 prefix (but see comment in read_structure_scope). */
1678 char *next_child
= info_ptr
;
1682 struct partial_die_info child_pdi
;
1684 next_child
= read_partial_die (&child_pdi
, abfd
, next_child
,
1688 if (child_pdi
.tag
== DW_TAG_subprogram
)
1690 actual_class_name
= class_name_from_physname (child_pdi
.name
);
1691 if (actual_class_name
!= NULL
)
1692 struct_pdi
->name
= actual_class_name
;
1697 next_child
= locate_pdi_sibling (&child_pdi
, next_child
,
1703 add_partial_symbol (struct_pdi
, cu
, namespace);
1704 xfree(actual_class_name
);
1706 return locate_pdi_sibling (struct_pdi
, info_ptr
, abfd
, cu
);
1709 /* Read a partial die corresponding to an enumeration type. */
1712 add_partial_enumeration (struct partial_die_info
*enum_pdi
, char *info_ptr
,
1713 struct dwarf2_cu
*cu
, const char *namespace)
1715 struct objfile
*objfile
= cu
->objfile
;
1716 bfd
*abfd
= objfile
->obfd
;
1717 struct partial_die_info pdi
;
1719 if (enum_pdi
->name
!= NULL
)
1720 add_partial_symbol (enum_pdi
, cu
, namespace);
1724 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1727 if (pdi
.tag
!= DW_TAG_enumerator
|| pdi
.name
== NULL
)
1728 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
1730 add_partial_symbol (&pdi
, cu
, namespace);
1736 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the next DIE
1740 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
1741 bfd
*abfd
, struct dwarf2_cu
*cu
)
1743 /* Do we know the sibling already? */
1745 if (orig_pdi
->sibling
)
1746 return orig_pdi
->sibling
;
1748 /* Are there any children to deal with? */
1750 if (!orig_pdi
->has_children
)
1753 /* Okay, we don't know the sibling, but we have children that we
1754 want to skip. So read children until we run into one without a
1755 tag; return whatever follows it. */
1759 struct partial_die_info pdi
;
1761 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1766 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1770 /* Expand this partial symbol table into a full symbol table. */
1773 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1775 /* FIXME: This is barely more than a stub. */
1780 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1786 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1787 gdb_flush (gdb_stdout
);
1790 psymtab_to_symtab_1 (pst
);
1792 /* Finish up the debug error message. */
1794 printf_filtered ("done.\n");
1800 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1802 struct objfile
*objfile
= pst
->objfile
;
1803 bfd
*abfd
= objfile
->obfd
;
1804 struct dwarf2_cu cu
;
1805 struct die_info
*dies
;
1806 unsigned long offset
;
1807 CORE_ADDR lowpc
, highpc
;
1808 struct die_info
*child_die
;
1810 struct symtab
*symtab
;
1811 struct cleanup
*back_to
;
1812 struct attribute
*attr
;
1814 /* Set local variables from the partial symbol table info. */
1815 offset
= DWARF_INFO_OFFSET (pst
);
1816 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1817 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1818 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1819 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1820 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1821 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1822 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1823 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1824 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1825 dwarf_ranges_buffer
= DWARF_RANGES_BUFFER (pst
);
1826 dwarf_ranges_size
= DWARF_RANGES_SIZE (pst
);
1827 dwarf_loc_buffer
= DWARF_LOC_BUFFER (pst
);
1828 dwarf_loc_size
= DWARF_LOC_SIZE (pst
);
1829 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1830 cu_header_offset
= offset
;
1831 info_ptr
= dwarf_info_buffer
+ offset
;
1833 /* We're in the global namespace. */
1834 processing_current_prefix
= "";
1836 obstack_init (&dwarf2_tmp_obstack
);
1837 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1840 make_cleanup (really_free_pendings
, NULL
);
1842 cu
.objfile
= objfile
;
1844 /* read in the comp_unit header */
1845 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1847 /* Read the abbrevs for this compilation unit */
1848 dwarf2_read_abbrevs (abfd
, &cu
);
1849 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1851 dies
= read_comp_unit (info_ptr
, abfd
, &cu
);
1853 make_cleanup_free_die_list (dies
);
1855 /* Find the base address of the compilation unit for range lists and
1856 location lists. It will normally be specified by DW_AT_low_pc.
1857 In DWARF-3 draft 4, the base address could be overridden by
1858 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1859 compilation units with discontinuous ranges. */
1861 cu
.header
.base_known
= 0;
1862 cu
.header
.base_address
= 0;
1864 attr
= dwarf_attr (dies
, DW_AT_entry_pc
);
1867 cu
.header
.base_address
= DW_ADDR (attr
);
1868 cu
.header
.base_known
= 1;
1872 attr
= dwarf_attr (dies
, DW_AT_low_pc
);
1875 cu
.header
.base_address
= DW_ADDR (attr
);
1876 cu
.header
.base_known
= 1;
1880 /* Do line number decoding in read_file_scope () */
1881 process_die (dies
, &cu
);
1883 /* Some compilers don't define a DW_AT_high_pc attribute for the
1884 compilation unit. If the DW_AT_high_pc is missing, synthesize
1885 it, by scanning the DIE's below the compilation unit. */
1886 get_scope_pc_bounds (dies
, &lowpc
, &highpc
, &cu
);
1888 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1890 /* Set symtab language to language from DW_AT_language.
1891 If the compilation is from a C file generated by language preprocessors,
1892 do not set the language if it was already deduced by start_subfile. */
1894 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1896 symtab
->language
= cu_language
;
1898 pst
->symtab
= symtab
;
1901 do_cleanups (back_to
);
1904 /* Process a die and its children. */
1907 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
1911 case DW_TAG_padding
:
1913 case DW_TAG_compile_unit
:
1914 read_file_scope (die
, cu
);
1916 case DW_TAG_subprogram
:
1917 read_subroutine_type (die
, cu
);
1918 read_func_scope (die
, cu
);
1920 case DW_TAG_inlined_subroutine
:
1921 /* FIXME: These are ignored for now.
1922 They could be used to set breakpoints on all inlined instances
1923 of a function and make GDB `next' properly over inlined functions. */
1925 case DW_TAG_lexical_block
:
1926 case DW_TAG_try_block
:
1927 case DW_TAG_catch_block
:
1928 read_lexical_block_scope (die
, cu
);
1930 case DW_TAG_class_type
:
1931 case DW_TAG_structure_type
:
1932 case DW_TAG_union_type
:
1933 read_structure_scope (die
, cu
);
1935 case DW_TAG_enumeration_type
:
1936 read_enumeration (die
, cu
);
1938 case DW_TAG_subroutine_type
:
1939 read_subroutine_type (die
, cu
);
1941 case DW_TAG_array_type
:
1942 read_array_type (die
, cu
);
1944 case DW_TAG_pointer_type
:
1945 read_tag_pointer_type (die
, cu
);
1947 case DW_TAG_ptr_to_member_type
:
1948 read_tag_ptr_to_member_type (die
, cu
);
1950 case DW_TAG_reference_type
:
1951 read_tag_reference_type (die
, cu
);
1953 case DW_TAG_string_type
:
1954 read_tag_string_type (die
, cu
);
1956 case DW_TAG_base_type
:
1957 read_base_type (die
, cu
);
1958 if (dwarf_attr (die
, DW_AT_name
))
1960 /* Add a typedef symbol for the base type definition. */
1961 new_symbol (die
, die
->type
, cu
);
1964 case DW_TAG_subrange_type
:
1965 read_subrange_type (die
, cu
);
1966 if (dwarf_attr (die
, DW_AT_name
))
1968 /* Add a typedef symbol for the base type definition. */
1969 new_symbol (die
, die
->type
, cu
);
1972 case DW_TAG_common_block
:
1973 read_common_block (die
, cu
);
1975 case DW_TAG_common_inclusion
:
1977 case DW_TAG_namespace
:
1978 processing_has_namespace_info
= 1;
1979 read_namespace (die
, cu
);
1981 case DW_TAG_imported_declaration
:
1982 case DW_TAG_imported_module
:
1983 /* FIXME: carlton/2002-10-16: Eventually, we should use the
1984 information contained in these. DW_TAG_imported_declaration
1985 dies shouldn't have children; DW_TAG_imported_module dies
1986 shouldn't in the C++ case, but conceivably could in the
1987 Fortran case, so we'll have to replace this gdb_assert if
1988 Fortran compilers start generating that info. */
1989 processing_has_namespace_info
= 1;
1990 gdb_assert (die
->child
== NULL
);
1993 new_symbol (die
, NULL
, cu
);
1999 initialize_cu_func_list (void)
2001 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
2005 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2007 struct objfile
*objfile
= cu
->objfile
;
2008 struct comp_unit_head
*cu_header
= &cu
->header
;
2009 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2010 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2011 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2012 struct attribute
*attr
;
2013 char *name
= "<unknown>";
2014 char *comp_dir
= NULL
;
2015 struct die_info
*child_die
;
2016 bfd
*abfd
= objfile
->obfd
;
2017 struct line_header
*line_header
= 0;
2019 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2021 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2022 from finish_block. */
2023 if (lowpc
== ((CORE_ADDR
) -1))
2028 attr
= dwarf_attr (die
, DW_AT_name
);
2031 name
= DW_STRING (attr
);
2033 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
2036 comp_dir
= DW_STRING (attr
);
2039 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2040 directory, get rid of it. */
2041 char *cp
= strchr (comp_dir
, ':');
2043 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2048 if (objfile
->ei
.entry_point
>= lowpc
&&
2049 objfile
->ei
.entry_point
< highpc
)
2051 objfile
->ei
.deprecated_entry_file_lowpc
= lowpc
;
2052 objfile
->ei
.deprecated_entry_file_highpc
= highpc
;
2055 attr
= dwarf_attr (die
, DW_AT_language
);
2058 set_cu_language (DW_UNSND (attr
));
2061 /* We assume that we're processing GCC output. */
2062 processing_gcc_compilation
= 2;
2064 /* FIXME:Do something here. */
2065 if (dip
->at_producer
!= NULL
)
2067 handle_producer (dip
->at_producer
);
2071 /* The compilation unit may be in a different language or objfile,
2072 zero out all remembered fundamental types. */
2073 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2075 start_symtab (name
, comp_dir
, lowpc
);
2076 record_debugformat ("DWARF 2");
2078 initialize_cu_func_list ();
2080 /* Process all dies in compilation unit. */
2081 if (die
->child
!= NULL
)
2083 child_die
= die
->child
;
2084 while (child_die
&& child_die
->tag
)
2086 process_die (child_die
, cu
);
2087 child_die
= sibling_die (child_die
);
2091 /* Decode line number information if present. */
2092 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
2095 unsigned int line_offset
= DW_UNSND (attr
);
2096 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2099 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2100 (void *) line_header
);
2101 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
);
2105 /* Decode macro information, if present. Dwarf 2 macro information
2106 refers to information in the line number info statement program
2107 header, so we can only read it if we've read the header
2109 attr
= dwarf_attr (die
, DW_AT_macro_info
);
2110 if (attr
&& line_header
)
2112 unsigned int macro_offset
= DW_UNSND (attr
);
2113 dwarf_decode_macros (line_header
, macro_offset
,
2114 comp_dir
, abfd
, cu
);
2116 do_cleanups (back_to
);
2120 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
2122 struct function_range
*thisfn
;
2124 thisfn
= (struct function_range
*)
2125 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
2126 thisfn
->name
= name
;
2127 thisfn
->lowpc
= lowpc
;
2128 thisfn
->highpc
= highpc
;
2129 thisfn
->seen_line
= 0;
2130 thisfn
->next
= NULL
;
2132 if (cu_last_fn
== NULL
)
2133 cu_first_fn
= thisfn
;
2135 cu_last_fn
->next
= thisfn
;
2137 cu_last_fn
= thisfn
;
2141 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2143 struct objfile
*objfile
= cu
->objfile
;
2144 struct context_stack
*new;
2147 struct die_info
*child_die
;
2148 struct attribute
*attr
;
2150 const char *previous_prefix
= processing_current_prefix
;
2151 struct cleanup
*back_to
= NULL
;
2153 name
= dwarf2_linkage_name (die
);
2155 /* Ignore functions with missing or empty names and functions with
2156 missing or invalid low and high pc attributes. */
2157 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2160 if (cu_language
== language_cplus
)
2162 struct die_info
*spec_die
= die_specification (die
);
2164 /* NOTE: carlton/2004-01-23: We have to be careful in the
2165 presence of DW_AT_specification. For example, with GCC
2170 // Definition of N::foo.
2174 then we'll have a tree of DIEs like this:
2176 1: DW_TAG_compile_unit
2177 2: DW_TAG_namespace // N
2178 3: DW_TAG_subprogram // declaration of N::foo
2179 4: DW_TAG_subprogram // definition of N::foo
2180 DW_AT_specification // refers to die #3
2182 Thus, when processing die #4, we have to pretend that
2183 we're in the context of its DW_AT_specification, namely
2184 the contex of die #3. */
2186 if (spec_die
!= NULL
)
2188 char *specification_prefix
= determine_prefix (spec_die
);
2189 processing_current_prefix
= specification_prefix
;
2190 back_to
= make_cleanup (xfree
, specification_prefix
);
2197 /* Record the function range for dwarf_decode_lines. */
2198 add_to_cu_func_list (name
, lowpc
, highpc
);
2200 if (objfile
->ei
.entry_point
>= lowpc
&&
2201 objfile
->ei
.entry_point
< highpc
)
2203 objfile
->ei
.entry_func_lowpc
= lowpc
;
2204 objfile
->ei
.entry_func_highpc
= highpc
;
2207 new = push_context (0, lowpc
);
2208 new->name
= new_symbol (die
, die
->type
, cu
);
2210 /* If there is a location expression for DW_AT_frame_base, record
2212 attr
= dwarf_attr (die
, DW_AT_frame_base
);
2214 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2216 list_in_scope
= &local_symbols
;
2218 if (die
->child
!= NULL
)
2220 child_die
= die
->child
;
2221 while (child_die
&& child_die
->tag
)
2223 process_die (child_die
, cu
);
2224 child_die
= sibling_die (child_die
);
2228 new = pop_context ();
2229 /* Make a block for the local symbols within. */
2230 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2231 lowpc
, highpc
, objfile
);
2233 /* In C++, we can have functions nested inside functions (e.g., when
2234 a function declares a class that has methods). This means that
2235 when we finish processing a function scope, we may need to go
2236 back to building a containing block's symbol lists. */
2237 local_symbols
= new->locals
;
2238 param_symbols
= new->params
;
2240 /* If we've finished processing a top-level function, subsequent
2241 symbols go in the file symbol list. */
2242 if (outermost_context_p ())
2243 list_in_scope
= &file_symbols
;
2245 processing_current_prefix
= previous_prefix
;
2246 if (back_to
!= NULL
)
2247 do_cleanups (back_to
);
2250 /* Process all the DIES contained within a lexical block scope. Start
2251 a new scope, process the dies, and then close the scope. */
2254 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2256 struct objfile
*objfile
= cu
->objfile
;
2257 struct context_stack
*new;
2258 CORE_ADDR lowpc
, highpc
;
2259 struct die_info
*child_die
;
2261 /* Ignore blocks with missing or invalid low and high pc attributes. */
2262 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2263 as multiple lexical blocks? Handling children in a sane way would
2264 be nasty. Might be easier to properly extend generic blocks to
2266 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2271 push_context (0, lowpc
);
2272 if (die
->child
!= NULL
)
2274 child_die
= die
->child
;
2275 while (child_die
&& child_die
->tag
)
2277 process_die (child_die
, cu
);
2278 child_die
= sibling_die (child_die
);
2281 new = pop_context ();
2283 if (local_symbols
!= NULL
)
2285 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2288 local_symbols
= new->locals
;
2291 /* Get low and high pc attributes from a die. Return 1 if the attributes
2292 are present and valid, otherwise, return 0. Return -1 if the range is
2293 discontinuous, i.e. derived from DW_AT_ranges information. */
2295 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
2296 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
2298 struct objfile
*objfile
= cu
->objfile
;
2299 struct comp_unit_head
*cu_header
= &cu
->header
;
2300 struct attribute
*attr
;
2301 bfd
*obfd
= objfile
->obfd
;
2306 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2309 high
= DW_ADDR (attr
);
2310 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2312 low
= DW_ADDR (attr
);
2314 /* Found high w/o low attribute. */
2317 /* Found consecutive range of addresses. */
2322 attr
= dwarf_attr (die
, DW_AT_ranges
);
2325 unsigned int addr_size
= cu_header
->addr_size
;
2326 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2327 /* Value of the DW_AT_ranges attribute is the offset in the
2328 .debug_ranges section. */
2329 unsigned int offset
= DW_UNSND (attr
);
2330 /* Base address selection entry. */
2338 found_base
= cu_header
->base_known
;
2339 base
= cu_header
->base_address
;
2341 if (offset
>= dwarf_ranges_size
)
2343 complaint (&symfile_complaints
,
2344 "Offset %d out of bounds for DW_AT_ranges attribute",
2348 buffer
= dwarf_ranges_buffer
+ offset
;
2350 /* Read in the largest possible address. */
2351 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
2352 if ((marker
& mask
) == mask
)
2354 /* If we found the largest possible address, then
2355 read the base address. */
2356 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2357 buffer
+= 2 * addr_size
;
2358 offset
+= 2 * addr_size
;
2366 CORE_ADDR range_beginning
, range_end
;
2368 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
2369 buffer
+= addr_size
;
2370 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
2371 buffer
+= addr_size
;
2372 offset
+= 2 * addr_size
;
2374 /* An end of list marker is a pair of zero addresses. */
2375 if (range_beginning
== 0 && range_end
== 0)
2376 /* Found the end of list entry. */
2379 /* Each base address selection entry is a pair of 2 values.
2380 The first is the largest possible address, the second is
2381 the base address. Check for a base address here. */
2382 if ((range_beginning
& mask
) == mask
)
2384 /* If we found the largest possible address, then
2385 read the base address. */
2386 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2393 /* We have no valid base address for the ranges
2395 complaint (&symfile_complaints
,
2396 "Invalid .debug_ranges data (no base address)");
2400 range_beginning
+= base
;
2403 /* FIXME: This is recording everything as a low-high
2404 segment of consecutive addresses. We should have a
2405 data structure for discontiguous block ranges
2409 low
= range_beginning
;
2415 if (range_beginning
< low
)
2416 low
= range_beginning
;
2417 if (range_end
> high
)
2423 /* If the first entry is an end-of-list marker, the range
2424 describes an empty scope, i.e. no instructions. */
2434 /* When using the GNU linker, .gnu.linkonce. sections are used to
2435 eliminate duplicate copies of functions and vtables and such.
2436 The linker will arbitrarily choose one and discard the others.
2437 The AT_*_pc values for such functions refer to local labels in
2438 these sections. If the section from that file was discarded, the
2439 labels are not in the output, so the relocs get a value of 0.
2440 If this is a discarded function, mark the pc bounds as invalid,
2441 so that GDB will ignore it. */
2442 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
2450 /* Get the low and high pc's represented by the scope DIE, and store
2451 them in *LOWPC and *HIGHPC. If the correct values can't be
2452 determined, set *LOWPC to -1 and *HIGHPC to 0. */
2455 get_scope_pc_bounds (struct die_info
*die
,
2456 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2457 struct dwarf2_cu
*cu
)
2459 CORE_ADDR best_low
= (CORE_ADDR
) -1;
2460 CORE_ADDR best_high
= (CORE_ADDR
) 0;
2461 CORE_ADDR current_low
, current_high
;
2463 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
2465 best_low
= current_low
;
2466 best_high
= current_high
;
2470 struct die_info
*child
= die
->child
;
2472 while (child
&& child
->tag
)
2474 switch (child
->tag
) {
2475 case DW_TAG_subprogram
:
2476 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
2478 best_low
= min (best_low
, current_low
);
2479 best_high
= max (best_high
, current_high
);
2482 case DW_TAG_namespace
:
2483 /* FIXME: carlton/2004-01-16: Should we do this for
2484 DW_TAG_class_type/DW_TAG_structure_type, too? I think
2485 that current GCC's always emit the DIEs corresponding
2486 to definitions of methods of classes as children of a
2487 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
2488 the DIEs giving the declarations, which could be
2489 anywhere). But I don't see any reason why the
2490 standards says that they have to be there. */
2491 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
2493 if (current_low
!= ((CORE_ADDR
) -1))
2495 best_low
= min (best_low
, current_low
);
2496 best_high
= max (best_high
, current_high
);
2504 child
= sibling_die (child
);
2509 *highpc
= best_high
;
2512 /* Add an aggregate field to the field list. */
2515 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2516 struct dwarf2_cu
*cu
)
2518 struct objfile
*objfile
= cu
->objfile
;
2519 struct nextfield
*new_field
;
2520 struct attribute
*attr
;
2522 char *fieldname
= "";
2524 /* Allocate a new field list entry and link it in. */
2525 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2526 make_cleanup (xfree
, new_field
);
2527 memset (new_field
, 0, sizeof (struct nextfield
));
2528 new_field
->next
= fip
->fields
;
2529 fip
->fields
= new_field
;
2532 /* Handle accessibility and virtuality of field.
2533 The default accessibility for members is public, the default
2534 accessibility for inheritance is private. */
2535 if (die
->tag
!= DW_TAG_inheritance
)
2536 new_field
->accessibility
= DW_ACCESS_public
;
2538 new_field
->accessibility
= DW_ACCESS_private
;
2539 new_field
->virtuality
= DW_VIRTUALITY_none
;
2541 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2543 new_field
->accessibility
= DW_UNSND (attr
);
2544 if (new_field
->accessibility
!= DW_ACCESS_public
)
2545 fip
->non_public_fields
= 1;
2546 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2548 new_field
->virtuality
= DW_UNSND (attr
);
2550 fp
= &new_field
->field
;
2552 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
))
2554 /* Data member other than a C++ static data member. */
2556 /* Get type of field. */
2557 fp
->type
= die_type (die
, cu
);
2559 FIELD_STATIC_KIND (*fp
) = 0;
2561 /* Get bit size of field (zero if none). */
2562 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2565 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2569 FIELD_BITSIZE (*fp
) = 0;
2572 /* Get bit offset of field. */
2573 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2576 FIELD_BITPOS (*fp
) =
2577 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
2580 FIELD_BITPOS (*fp
) = 0;
2581 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2584 if (BITS_BIG_ENDIAN
)
2586 /* For big endian bits, the DW_AT_bit_offset gives the
2587 additional bit offset from the MSB of the containing
2588 anonymous object to the MSB of the field. We don't
2589 have to do anything special since we don't need to
2590 know the size of the anonymous object. */
2591 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2595 /* For little endian bits, compute the bit offset to the
2596 MSB of the anonymous object, subtract off the number of
2597 bits from the MSB of the field to the MSB of the
2598 object, and then subtract off the number of bits of
2599 the field itself. The result is the bit offset of
2600 the LSB of the field. */
2602 int bit_offset
= DW_UNSND (attr
);
2604 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2607 /* The size of the anonymous object containing
2608 the bit field is explicit, so use the
2609 indicated size (in bytes). */
2610 anonymous_size
= DW_UNSND (attr
);
2614 /* The size of the anonymous object containing
2615 the bit field must be inferred from the type
2616 attribute of the data member containing the
2618 anonymous_size
= TYPE_LENGTH (fp
->type
);
2620 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2621 - bit_offset
- FIELD_BITSIZE (*fp
);
2625 /* Get name of field. */
2626 attr
= dwarf_attr (die
, DW_AT_name
);
2627 if (attr
&& DW_STRING (attr
))
2628 fieldname
= DW_STRING (attr
);
2629 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2630 &objfile
->type_obstack
);
2632 /* Change accessibility for artificial fields (e.g. virtual table
2633 pointer or virtual base class pointer) to private. */
2634 if (dwarf_attr (die
, DW_AT_artificial
))
2636 new_field
->accessibility
= DW_ACCESS_private
;
2637 fip
->non_public_fields
= 1;
2640 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
2642 /* C++ static member. */
2644 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2645 is a declaration, but all versions of G++ as of this writing
2646 (so through at least 3.2.1) incorrectly generate
2647 DW_TAG_variable tags. */
2651 /* Get name of field. */
2652 attr
= dwarf_attr (die
, DW_AT_name
);
2653 if (attr
&& DW_STRING (attr
))
2654 fieldname
= DW_STRING (attr
);
2658 /* Get physical name. */
2659 physname
= dwarf2_linkage_name (die
);
2661 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2662 &objfile
->type_obstack
));
2663 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2664 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2665 &objfile
->type_obstack
);
2667 else if (die
->tag
== DW_TAG_inheritance
)
2669 /* C++ base class field. */
2670 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2672 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
2674 FIELD_BITSIZE (*fp
) = 0;
2675 FIELD_STATIC_KIND (*fp
) = 0;
2676 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2677 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2678 fip
->nbaseclasses
++;
2682 /* Create the vector of fields, and attach it to the type. */
2685 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2686 struct dwarf2_cu
*cu
)
2688 int nfields
= fip
->nfields
;
2690 /* Record the field count, allocate space for the array of fields,
2691 and create blank accessibility bitfields if necessary. */
2692 TYPE_NFIELDS (type
) = nfields
;
2693 TYPE_FIELDS (type
) = (struct field
*)
2694 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2695 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2697 if (fip
->non_public_fields
)
2699 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2701 TYPE_FIELD_PRIVATE_BITS (type
) =
2702 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2703 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2705 TYPE_FIELD_PROTECTED_BITS (type
) =
2706 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2707 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2709 TYPE_FIELD_IGNORE_BITS (type
) =
2710 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2711 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2714 /* If the type has baseclasses, allocate and clear a bit vector for
2715 TYPE_FIELD_VIRTUAL_BITS. */
2716 if (fip
->nbaseclasses
)
2718 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2721 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2722 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2723 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2724 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2725 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2728 /* Copy the saved-up fields into the field vector. Start from the head
2729 of the list, adding to the tail of the field array, so that they end
2730 up in the same order in the array in which they were added to the list. */
2731 while (nfields
-- > 0)
2733 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2734 switch (fip
->fields
->accessibility
)
2736 case DW_ACCESS_private
:
2737 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2740 case DW_ACCESS_protected
:
2741 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2744 case DW_ACCESS_public
:
2748 /* Unknown accessibility. Complain and treat it as public. */
2750 complaint (&symfile_complaints
, "unsupported accessibility %d",
2751 fip
->fields
->accessibility
);
2755 if (nfields
< fip
->nbaseclasses
)
2757 switch (fip
->fields
->virtuality
)
2759 case DW_VIRTUALITY_virtual
:
2760 case DW_VIRTUALITY_pure_virtual
:
2761 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2765 fip
->fields
= fip
->fields
->next
;
2769 /* Add a member function to the proper fieldlist. */
2772 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2773 struct type
*type
, struct dwarf2_cu
*cu
)
2775 struct objfile
*objfile
= cu
->objfile
;
2776 struct attribute
*attr
;
2777 struct fnfieldlist
*flp
;
2779 struct fn_field
*fnp
;
2782 struct nextfnfield
*new_fnfield
;
2784 /* Get name of member function. */
2785 attr
= dwarf_attr (die
, DW_AT_name
);
2786 if (attr
&& DW_STRING (attr
))
2787 fieldname
= DW_STRING (attr
);
2791 /* Get the mangled name. */
2792 physname
= dwarf2_linkage_name (die
);
2794 /* Look up member function name in fieldlist. */
2795 for (i
= 0; i
< fip
->nfnfields
; i
++)
2797 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
2801 /* Create new list element if necessary. */
2802 if (i
< fip
->nfnfields
)
2803 flp
= &fip
->fnfieldlists
[i
];
2806 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2808 fip
->fnfieldlists
= (struct fnfieldlist
*)
2809 xrealloc (fip
->fnfieldlists
,
2810 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2811 * sizeof (struct fnfieldlist
));
2812 if (fip
->nfnfields
== 0)
2813 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2815 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2816 flp
->name
= fieldname
;
2822 /* Create a new member function field and chain it to the field list
2824 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2825 make_cleanup (xfree
, new_fnfield
);
2826 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2827 new_fnfield
->next
= flp
->head
;
2828 flp
->head
= new_fnfield
;
2831 /* Fill in the member function field info. */
2832 fnp
= &new_fnfield
->fnfield
;
2833 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2834 &objfile
->type_obstack
);
2835 fnp
->type
= alloc_type (objfile
);
2836 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2838 int nparams
= TYPE_NFIELDS (die
->type
);
2840 /* TYPE is the domain of this method, and DIE->TYPE is the type
2841 of the method itself (TYPE_CODE_METHOD). */
2842 smash_to_method_type (fnp
->type
, type
,
2843 TYPE_TARGET_TYPE (die
->type
),
2844 TYPE_FIELDS (die
->type
),
2845 TYPE_NFIELDS (die
->type
),
2846 TYPE_VARARGS (die
->type
));
2848 /* Handle static member functions.
2849 Dwarf2 has no clean way to discern C++ static and non-static
2850 member functions. G++ helps GDB by marking the first
2851 parameter for non-static member functions (which is the
2852 this pointer) as artificial. We obtain this information
2853 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2854 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2855 fnp
->voffset
= VOFFSET_STATIC
;
2858 complaint (&symfile_complaints
, "member function type missing for '%s'",
2861 /* Get fcontext from DW_AT_containing_type if present. */
2862 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2863 fnp
->fcontext
= die_containing_type (die
, cu
);
2865 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2866 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2868 /* Get accessibility. */
2869 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2872 switch (DW_UNSND (attr
))
2874 case DW_ACCESS_private
:
2875 fnp
->is_private
= 1;
2877 case DW_ACCESS_protected
:
2878 fnp
->is_protected
= 1;
2883 /* Check for artificial methods. */
2884 attr
= dwarf_attr (die
, DW_AT_artificial
);
2885 if (attr
&& DW_UNSND (attr
) != 0)
2886 fnp
->is_artificial
= 1;
2888 /* Get index in virtual function table if it is a virtual member function. */
2889 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2892 /* Support the .debug_loc offsets */
2893 if (attr_form_is_block (attr
))
2895 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
2897 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2899 dwarf2_complex_location_expr_complaint ();
2903 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2909 /* Create the vector of member function fields, and attach it to the type. */
2912 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2913 struct dwarf2_cu
*cu
)
2915 struct fnfieldlist
*flp
;
2916 int total_length
= 0;
2919 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2920 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2921 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2923 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2925 struct nextfnfield
*nfp
= flp
->head
;
2926 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2929 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2930 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2931 fn_flp
->fn_fields
= (struct fn_field
*)
2932 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2933 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2934 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2936 total_length
+= flp
->length
;
2939 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2940 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2943 /* Called when we find the DIE that starts a structure or union scope
2944 (definition) to process all dies that define the members of the
2947 NOTE: we need to call struct_type regardless of whether or not the
2948 DIE has an at_name attribute, since it might be an anonymous
2949 structure or union. This gets the type entered into our set of
2952 However, if the structure is incomplete (an opaque struct/union)
2953 then suppress creating a symbol table entry for it since gdb only
2954 wants to find the one with the complete definition. Note that if
2955 it is complete, we just call new_symbol, which does it's own
2956 checking about whether the struct/union is anonymous or not (and
2957 suppresses creating a symbol table entry itself). */
2960 read_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2962 struct objfile
*objfile
= cu
->objfile
;
2964 struct attribute
*attr
;
2965 const char *name
= NULL
;
2966 const char *previous_prefix
= processing_current_prefix
;
2967 struct cleanup
*back_to
= NULL
;
2968 /* This says whether or not we want to try to update the structure's
2969 name to include enclosing namespace/class information, if
2971 int need_to_update_name
= 0;
2973 type
= alloc_type (objfile
);
2975 INIT_CPLUS_SPECIFIC (type
);
2976 attr
= dwarf_attr (die
, DW_AT_name
);
2977 if (attr
&& DW_STRING (attr
))
2979 name
= DW_STRING (attr
);
2981 if (cu_language
== language_cplus
)
2983 struct die_info
*spec_die
= die_specification (die
);
2985 if (spec_die
!= NULL
)
2987 char *specification_prefix
= determine_prefix (spec_die
);
2988 processing_current_prefix
= specification_prefix
;
2989 back_to
= make_cleanup (xfree
, specification_prefix
);
2993 if (processing_has_namespace_info
)
2995 /* FIXME: carlton/2003-11-10: This variable exists only for
2996 const-correctness reasons. When I tried to change
2997 TYPE_TAG_NAME to be a const char *, I ran into a cascade
2998 of changes which would have forced decode_line_1 to take
3000 char *new_prefix
= obconcat (&objfile
->type_obstack
,
3001 processing_current_prefix
,
3002 processing_current_prefix
[0] == '\0'
3005 TYPE_TAG_NAME (type
) = new_prefix
;
3006 processing_current_prefix
= new_prefix
;
3010 TYPE_TAG_NAME (type
) = obsavestring (name
, strlen (name
),
3011 &objfile
->type_obstack
);
3012 need_to_update_name
= (cu_language
== language_cplus
);
3016 if (die
->tag
== DW_TAG_structure_type
)
3018 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3020 else if (die
->tag
== DW_TAG_union_type
)
3022 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3026 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3028 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3031 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3034 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3038 TYPE_LENGTH (type
) = 0;
3041 /* We need to add the type field to the die immediately so we don't
3042 infinitely recurse when dealing with pointers to the structure
3043 type within the structure itself. */
3046 if (die
->child
!= NULL
&& ! die_is_declaration (die
))
3048 struct field_info fi
;
3049 struct die_info
*child_die
;
3050 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3052 memset (&fi
, 0, sizeof (struct field_info
));
3054 child_die
= die
->child
;
3056 while (child_die
&& child_die
->tag
)
3058 if (child_die
->tag
== DW_TAG_member
3059 || child_die
->tag
== DW_TAG_variable
)
3061 /* NOTE: carlton/2002-11-05: A C++ static data member
3062 should be a DW_TAG_member that is a declaration, but
3063 all versions of G++ as of this writing (so through at
3064 least 3.2.1) incorrectly generate DW_TAG_variable
3065 tags for them instead. */
3066 dwarf2_add_field (&fi
, child_die
, cu
);
3068 else if (child_die
->tag
== DW_TAG_subprogram
)
3070 /* C++ member function. */
3071 process_die (child_die
, cu
);
3072 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3073 if (need_to_update_name
)
3075 /* The demangled names of member functions contain
3076 information about enclosing namespaces/classes,
3079 /* FIXME: carlton/2003-11-10: The excessive
3080 demangling here is a bit wasteful, as is the
3081 memory usage for names. */
3083 /* NOTE: carlton/2003-11-10: As commented in
3084 add_partial_structure, the demangler sometimes
3085 prints the type info in a different form from the
3086 debug info. We could solve this by using the
3087 demangled name to get the prefix; if doing so,
3088 however, we'd need to be careful when reading a
3089 class that's nested inside a template class.
3090 That would also cause problems when trying to
3091 determine RTTI information, since we use the
3092 demangler to determine the appropriate class
3094 char *actual_class_name
3095 = class_name_from_physname (dwarf2_linkage_name
3097 if (actual_class_name
!= NULL
3098 && strcmp (actual_class_name
, name
) != 0)
3100 TYPE_TAG_NAME (type
)
3101 = obsavestring (actual_class_name
,
3102 strlen (actual_class_name
),
3103 &objfile
->type_obstack
);
3105 xfree (actual_class_name
);
3106 need_to_update_name
= 0;
3109 else if (child_die
->tag
== DW_TAG_inheritance
)
3111 /* C++ base class field. */
3112 dwarf2_add_field (&fi
, child_die
, cu
);
3116 process_die (child_die
, cu
);
3118 child_die
= sibling_die (child_die
);
3121 /* Attach fields and member functions to the type. */
3123 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3126 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3128 /* Get the type which refers to the base class (possibly this
3129 class itself) which contains the vtable pointer for the current
3130 class from the DW_AT_containing_type attribute. */
3132 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
3134 struct type
*t
= die_containing_type (die
, cu
);
3136 TYPE_VPTR_BASETYPE (type
) = t
;
3139 static const char vptr_name
[] =
3140 {'_', 'v', 'p', 't', 'r', '\0'};
3143 /* Our own class provides vtbl ptr. */
3144 for (i
= TYPE_NFIELDS (t
) - 1;
3145 i
>= TYPE_N_BASECLASSES (t
);
3148 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3150 if ((strncmp (fieldname
, vptr_name
,
3151 strlen (vptr_name
) - 1)
3153 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
3155 TYPE_VPTR_FIELDNO (type
) = i
;
3160 /* Complain if virtual function table field not found. */
3161 if (i
< TYPE_N_BASECLASSES (t
))
3162 complaint (&symfile_complaints
,
3163 "virtual function table pointer not found when defining class '%s'",
3164 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3169 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3174 new_symbol (die
, type
, cu
);
3176 do_cleanups (back_to
);
3180 /* No children, must be stub. */
3181 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3184 processing_current_prefix
= previous_prefix
;
3185 if (back_to
!= NULL
)
3186 do_cleanups (back_to
);
3189 /* Given a pointer to a die which begins an enumeration, process all
3190 the dies that define the members of the enumeration.
3192 This will be much nicer in draft 6 of the DWARF spec when our
3193 members will be dies instead squished into the DW_AT_element_list
3196 NOTE: We reverse the order of the element list. */
3199 read_enumeration (struct die_info
*die
, struct dwarf2_cu
*cu
)
3201 struct objfile
*objfile
= cu
->objfile
;
3202 struct die_info
*child_die
;
3204 struct field
*fields
;
3205 struct attribute
*attr
;
3208 int unsigned_enum
= 1;
3210 type
= alloc_type (objfile
);
3212 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3213 attr
= dwarf_attr (die
, DW_AT_name
);
3214 if (attr
&& DW_STRING (attr
))
3216 const char *name
= DW_STRING (attr
);
3218 if (processing_has_namespace_info
)
3220 TYPE_TAG_NAME (type
) = obconcat (&objfile
->type_obstack
,
3221 processing_current_prefix
,
3222 processing_current_prefix
[0] == '\0'
3228 TYPE_TAG_NAME (type
) = obsavestring (name
, strlen (name
),
3229 &objfile
->type_obstack
);
3233 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3236 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3240 TYPE_LENGTH (type
) = 0;
3245 if (die
->child
!= NULL
)
3247 child_die
= die
->child
;
3248 while (child_die
&& child_die
->tag
)
3250 if (child_die
->tag
!= DW_TAG_enumerator
)
3252 process_die (child_die
, cu
);
3256 attr
= dwarf_attr (child_die
, DW_AT_name
);
3259 sym
= new_symbol (child_die
, type
, cu
);
3260 if (SYMBOL_VALUE (sym
) < 0)
3263 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3265 fields
= (struct field
*)
3267 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
3268 * sizeof (struct field
));
3271 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
3272 FIELD_TYPE (fields
[num_fields
]) = NULL
;
3273 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
3274 FIELD_BITSIZE (fields
[num_fields
]) = 0;
3275 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
3281 child_die
= sibling_die (child_die
);
3286 TYPE_NFIELDS (type
) = num_fields
;
3287 TYPE_FIELDS (type
) = (struct field
*)
3288 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
3289 memcpy (TYPE_FIELDS (type
), fields
,
3290 sizeof (struct field
) * num_fields
);
3294 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
3297 new_symbol (die
, type
, cu
);
3300 /* Extract all information from a DW_TAG_array_type DIE and put it in
3301 the DIE's type field. For now, this only handles one dimensional
3305 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3307 struct objfile
*objfile
= cu
->objfile
;
3308 struct die_info
*child_die
;
3309 struct type
*type
= NULL
;
3310 struct type
*element_type
, *range_type
, *index_type
;
3311 struct type
**range_types
= NULL
;
3312 struct attribute
*attr
;
3314 struct cleanup
*back_to
;
3316 /* Return if we've already decoded this type. */
3322 element_type
= die_type (die
, cu
);
3324 /* Irix 6.2 native cc creates array types without children for
3325 arrays with unspecified length. */
3326 if (die
->child
== NULL
)
3328 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3329 range_type
= create_range_type (NULL
, index_type
, 0, -1);
3330 die
->type
= create_array_type (NULL
, element_type
, range_type
);
3334 back_to
= make_cleanup (null_cleanup
, NULL
);
3335 child_die
= die
->child
;
3336 while (child_die
&& child_die
->tag
)
3338 if (child_die
->tag
== DW_TAG_subrange_type
)
3340 read_subrange_type (child_die
, cu
);
3342 if (child_die
->type
!= NULL
)
3344 /* The range type was succesfully read. Save it for
3345 the array type creation. */
3346 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
3348 range_types
= (struct type
**)
3349 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
3350 * sizeof (struct type
*));
3352 make_cleanup (free_current_contents
, &range_types
);
3354 range_types
[ndim
++] = child_die
->type
;
3357 child_die
= sibling_die (child_die
);
3360 /* Dwarf2 dimensions are output from left to right, create the
3361 necessary array types in backwards order. */
3362 type
= element_type
;
3364 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
3366 /* Understand Dwarf2 support for vector types (like they occur on
3367 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3368 array type. This is not part of the Dwarf2/3 standard yet, but a
3369 custom vendor extension. The main difference between a regular
3370 array and the vector variant is that vectors are passed by value
3372 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
3374 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
3376 do_cleanups (back_to
);
3378 /* Install the type in the die. */
3382 /* First cut: install each common block member as a global variable. */
3385 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
3387 struct die_info
*child_die
;
3388 struct attribute
*attr
;
3390 CORE_ADDR base
= (CORE_ADDR
) 0;
3392 attr
= dwarf_attr (die
, DW_AT_location
);
3395 /* Support the .debug_loc offsets */
3396 if (attr_form_is_block (attr
))
3398 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
3400 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3402 dwarf2_complex_location_expr_complaint ();
3406 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3407 "common block member");
3410 if (die
->child
!= NULL
)
3412 child_die
= die
->child
;
3413 while (child_die
&& child_die
->tag
)
3415 sym
= new_symbol (child_die
, NULL
, cu
);
3416 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
3419 SYMBOL_VALUE_ADDRESS (sym
) =
3420 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
3421 add_symbol_to_list (sym
, &global_symbols
);
3423 child_die
= sibling_die (child_die
);
3428 /* Read a C++ namespace. */
3431 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
3433 struct objfile
*objfile
= cu
->objfile
;
3434 const char *previous_prefix
= processing_current_prefix
;
3437 struct die_info
*current_die
;
3439 name
= namespace_name (die
, &is_anonymous
);
3441 /* Now build the name of the current namespace. */
3443 if (previous_prefix
[0] == '\0')
3445 processing_current_prefix
= name
;
3449 /* We need temp_name around because processing_current_prefix
3450 is a const char *. */
3451 char *temp_name
= alloca (strlen (previous_prefix
)
3452 + 2 + strlen(name
) + 1);
3453 strcpy (temp_name
, previous_prefix
);
3454 strcat (temp_name
, "::");
3455 strcat (temp_name
, name
);
3457 processing_current_prefix
= temp_name
;
3460 /* Add a symbol associated to this if we haven't seen the namespace
3461 before. Also, add a using directive if it's an anonymous
3464 if (dwarf2_extension (die
) == NULL
)
3468 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3469 this cast will hopefully become unnecessary. */
3470 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
3471 (char *) processing_current_prefix
,
3473 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
3475 new_symbol (die
, type
, cu
);
3478 cp_add_using_directive (processing_current_prefix
,
3479 strlen (previous_prefix
),
3480 strlen (processing_current_prefix
));
3483 if (die
->child
!= NULL
)
3485 struct die_info
*child_die
= die
->child
;
3487 while (child_die
&& child_die
->tag
)
3489 process_die (child_die
, cu
);
3490 child_die
= sibling_die (child_die
);
3494 processing_current_prefix
= previous_prefix
;
3497 /* Return the name of the namespace represented by DIE. Set
3498 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
3502 namespace_name (struct die_info
*die
, int *is_anonymous
)
3504 struct die_info
*current_die
;
3505 const char *name
= NULL
;
3507 /* Loop through the extensions until we find a name. */
3509 for (current_die
= die
;
3510 current_die
!= NULL
;
3511 current_die
= dwarf2_extension (die
))
3513 name
= dwarf2_name (current_die
);
3518 /* Is it an anonymous namespace? */
3520 *is_anonymous
= (name
== NULL
);
3522 name
= "(anonymous namespace)";
3527 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3528 the user defined type vector. */
3531 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3533 struct comp_unit_head
*cu_header
= &cu
->header
;
3535 struct attribute
*attr_byte_size
;
3536 struct attribute
*attr_address_class
;
3537 int byte_size
, addr_class
;
3544 type
= lookup_pointer_type (die_type (die
, cu
));
3546 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
3548 byte_size
= DW_UNSND (attr_byte_size
);
3550 byte_size
= cu_header
->addr_size
;
3552 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
3553 if (attr_address_class
)
3554 addr_class
= DW_UNSND (attr_address_class
);
3556 addr_class
= DW_ADDR_none
;
3558 /* If the pointer size or address class is different than the
3559 default, create a type variant marked as such and set the
3560 length accordingly. */
3561 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3563 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3567 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3568 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3569 type
= make_type_with_address_space (type
, type_flags
);
3571 else if (TYPE_LENGTH (type
) != byte_size
)
3573 complaint (&symfile_complaints
, "invalid pointer size %d", byte_size
);
3576 /* Should we also complain about unhandled address classes? */
3580 TYPE_LENGTH (type
) = byte_size
;
3584 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3585 the user defined type vector. */
3588 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3590 struct objfile
*objfile
= cu
->objfile
;
3592 struct type
*to_type
;
3593 struct type
*domain
;
3600 type
= alloc_type (objfile
);
3601 to_type
= die_type (die
, cu
);
3602 domain
= die_containing_type (die
, cu
);
3603 smash_to_member_type (type
, domain
, to_type
);
3608 /* Extract all information from a DW_TAG_reference_type DIE and add to
3609 the user defined type vector. */
3612 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3614 struct comp_unit_head
*cu_header
= &cu
->header
;
3616 struct attribute
*attr
;
3623 type
= lookup_reference_type (die_type (die
, cu
));
3624 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3627 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3631 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3637 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3639 struct type
*base_type
;
3646 base_type
= die_type (die
, cu
);
3647 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3651 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3653 struct type
*base_type
;
3660 base_type
= die_type (die
, cu
);
3661 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3664 /* Extract all information from a DW_TAG_string_type DIE and add to
3665 the user defined type vector. It isn't really a user defined type,
3666 but it behaves like one, with other DIE's using an AT_user_def_type
3667 attribute to reference it. */
3670 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3672 struct objfile
*objfile
= cu
->objfile
;
3673 struct type
*type
, *range_type
, *index_type
, *char_type
;
3674 struct attribute
*attr
;
3675 unsigned int length
;
3682 attr
= dwarf_attr (die
, DW_AT_string_length
);
3685 length
= DW_UNSND (attr
);
3689 /* check for the DW_AT_byte_size attribute */
3690 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3693 length
= DW_UNSND (attr
);
3700 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3701 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3702 if (cu_language
== language_fortran
)
3704 /* Need to create a unique string type for bounds
3706 type
= create_string_type (0, range_type
);
3710 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3711 type
= create_string_type (char_type
, range_type
);
3716 /* Handle DIES due to C code like:
3720 int (*funcp)(int a, long l);
3724 ('funcp' generates a DW_TAG_subroutine_type DIE)
3728 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3730 struct type
*type
; /* Type that this function returns */
3731 struct type
*ftype
; /* Function that returns above type */
3732 struct attribute
*attr
;
3734 /* Decode the type that this subroutine returns */
3739 type
= die_type (die
, cu
);
3740 ftype
= lookup_function_type (type
);
3742 /* All functions in C++ have prototypes. */
3743 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3744 if ((attr
&& (DW_UNSND (attr
) != 0))
3745 || cu_language
== language_cplus
)
3746 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3748 if (die
->child
!= NULL
)
3750 struct die_info
*child_die
;
3754 /* Count the number of parameters.
3755 FIXME: GDB currently ignores vararg functions, but knows about
3756 vararg member functions. */
3757 child_die
= die
->child
;
3758 while (child_die
&& child_die
->tag
)
3760 if (child_die
->tag
== DW_TAG_formal_parameter
)
3762 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3763 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3764 child_die
= sibling_die (child_die
);
3767 /* Allocate storage for parameters and fill them in. */
3768 TYPE_NFIELDS (ftype
) = nparams
;
3769 TYPE_FIELDS (ftype
) = (struct field
*)
3770 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3772 child_die
= die
->child
;
3773 while (child_die
&& child_die
->tag
)
3775 if (child_die
->tag
== DW_TAG_formal_parameter
)
3777 /* Dwarf2 has no clean way to discern C++ static and non-static
3778 member functions. G++ helps GDB by marking the first
3779 parameter for non-static member functions (which is the
3780 this pointer) as artificial. We pass this information
3781 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3782 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3784 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3786 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3787 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
3790 child_die
= sibling_die (child_die
);
3798 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
3800 struct objfile
*objfile
= cu
->objfile
;
3801 struct attribute
*attr
;
3806 attr
= dwarf_attr (die
, DW_AT_name
);
3807 if (attr
&& DW_STRING (attr
))
3809 name
= DW_STRING (attr
);
3811 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3812 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
3816 /* Find a representation of a given base type and install
3817 it in the TYPE field of the die. */
3820 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3822 struct objfile
*objfile
= cu
->objfile
;
3824 struct attribute
*attr
;
3825 int encoding
= 0, size
= 0;
3827 /* If we've already decoded this die, this is a no-op. */
3833 attr
= dwarf_attr (die
, DW_AT_encoding
);
3836 encoding
= DW_UNSND (attr
);
3838 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3841 size
= DW_UNSND (attr
);
3843 attr
= dwarf_attr (die
, DW_AT_name
);
3844 if (attr
&& DW_STRING (attr
))
3846 enum type_code code
= TYPE_CODE_INT
;
3851 case DW_ATE_address
:
3852 /* Turn DW_ATE_address into a void * pointer. */
3853 code
= TYPE_CODE_PTR
;
3854 type_flags
|= TYPE_FLAG_UNSIGNED
;
3856 case DW_ATE_boolean
:
3857 code
= TYPE_CODE_BOOL
;
3858 type_flags
|= TYPE_FLAG_UNSIGNED
;
3860 case DW_ATE_complex_float
:
3861 code
= TYPE_CODE_COMPLEX
;
3864 code
= TYPE_CODE_FLT
;
3867 case DW_ATE_signed_char
:
3869 case DW_ATE_unsigned
:
3870 case DW_ATE_unsigned_char
:
3871 type_flags
|= TYPE_FLAG_UNSIGNED
;
3874 complaint (&symfile_complaints
, "unsupported DW_AT_encoding: '%s'",
3875 dwarf_type_encoding_name (encoding
));
3878 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3879 if (encoding
== DW_ATE_address
)
3880 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3881 else if (encoding
== DW_ATE_complex_float
)
3884 TYPE_TARGET_TYPE (type
)
3885 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3886 else if (size
== 16)
3887 TYPE_TARGET_TYPE (type
)
3888 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3890 TYPE_TARGET_TYPE (type
)
3891 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3896 type
= dwarf_base_type (encoding
, size
, cu
);
3901 /* Read the given DW_AT_subrange DIE. */
3904 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3906 struct type
*base_type
;
3907 struct type
*range_type
;
3908 struct attribute
*attr
;
3912 /* If we have already decoded this die, then nothing more to do. */
3916 base_type
= die_type (die
, cu
);
3917 if (base_type
== NULL
)
3919 complaint (&symfile_complaints
,
3920 "DW_AT_type missing from DW_TAG_subrange_type");
3924 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
3925 base_type
= alloc_type (NULL
);
3927 if (cu_language
== language_fortran
)
3929 /* FORTRAN implies a lower bound of 1, if not given. */
3933 attr
= dwarf_attr (die
, DW_AT_lower_bound
);
3935 low
= dwarf2_get_attr_constant_value (attr
, 0);
3937 attr
= dwarf_attr (die
, DW_AT_upper_bound
);
3940 if (attr
->form
== DW_FORM_block1
)
3942 /* GCC encodes arrays with unspecified or dynamic length
3943 with a DW_FORM_block1 attribute.
3944 FIXME: GDB does not yet know how to handle dynamic
3945 arrays properly, treat them as arrays with unspecified
3948 FIXME: jimb/2003-09-22: GDB does not really know
3949 how to handle arrays of unspecified length
3950 either; we just represent them as zero-length
3951 arrays. Choose an appropriate upper bound given
3952 the lower bound we've computed above. */
3956 high
= dwarf2_get_attr_constant_value (attr
, 1);
3959 range_type
= create_range_type (NULL
, base_type
, low
, high
);
3961 attr
= dwarf_attr (die
, DW_AT_name
);
3962 if (attr
&& DW_STRING (attr
))
3963 TYPE_NAME (range_type
) = DW_STRING (attr
);
3965 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3967 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
3969 die
->type
= range_type
;
3973 /* Read a whole compilation unit into a linked list of dies. */
3975 static struct die_info
*
3976 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
3978 /* Reset die reference table; we are
3979 building new ones now. */
3980 dwarf2_empty_hash_tables ();
3982 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
3985 /* Read a single die and all its descendents. Set the die's sibling
3986 field to NULL; set other fields in the die correctly, and set all
3987 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
3988 location of the info_ptr after reading all of those dies. PARENT
3989 is the parent of the die in question. */
3991 static struct die_info
*
3992 read_die_and_children (char *info_ptr
, bfd
*abfd
,
3993 struct dwarf2_cu
*cu
,
3994 char **new_info_ptr
,
3995 struct die_info
*parent
)
3997 struct die_info
*die
;
4001 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4002 store_in_ref_table (die
->offset
, die
);
4006 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4012 *new_info_ptr
= cur_ptr
;
4015 die
->sibling
= NULL
;
4016 die
->parent
= parent
;
4020 /* Read a die, all of its descendents, and all of its siblings; set
4021 all of the fields of all of the dies correctly. Arguments are as
4022 in read_die_and_children. */
4024 static struct die_info
*
4025 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
4026 struct dwarf2_cu
*cu
,
4027 char **new_info_ptr
,
4028 struct die_info
*parent
)
4030 struct die_info
*first_die
, *last_sibling
;
4034 first_die
= last_sibling
= NULL
;
4038 struct die_info
*die
4039 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4047 last_sibling
->sibling
= die
;
4052 *new_info_ptr
= cur_ptr
;
4062 /* Free a linked list of dies. */
4065 free_die_list (struct die_info
*dies
)
4067 struct die_info
*die
, *next
;
4072 if (die
->child
!= NULL
)
4073 free_die_list (die
->child
);
4074 next
= die
->sibling
;
4082 do_free_die_list_cleanup (void *dies
)
4084 free_die_list (dies
);
4087 static struct cleanup
*
4088 make_cleanup_free_die_list (struct die_info
*dies
)
4090 return make_cleanup (do_free_die_list_cleanup
, dies
);
4094 /* Read the contents of the section at OFFSET and of size SIZE from the
4095 object file specified by OBJFILE into the psymbol_obstack and return it. */
4098 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4100 bfd
*abfd
= objfile
->obfd
;
4102 bfd_size_type size
= bfd_get_section_size_before_reloc (sectp
);
4107 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
4109 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
4113 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4114 || bfd_bread (buf
, size
, abfd
) != size
)
4115 error ("Dwarf Error: Can't read DWARF data from '%s'",
4116 bfd_get_filename (abfd
));
4121 /* In DWARF version 2, the description of the debugging information is
4122 stored in a separate .debug_abbrev section. Before we read any
4123 dies from a section we read in all abbreviations and install them
4127 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4129 struct comp_unit_head
*cu_header
= &cu
->header
;
4131 struct abbrev_info
*cur_abbrev
;
4132 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4133 unsigned int abbrev_form
, hash_number
;
4135 /* Initialize dwarf2 abbrevs */
4136 memset (cu_header
->dwarf2_abbrevs
, 0,
4137 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
4139 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
4140 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4141 abbrev_ptr
+= bytes_read
;
4143 /* loop until we reach an abbrev number of 0 */
4144 while (abbrev_number
)
4146 cur_abbrev
= dwarf_alloc_abbrev ();
4148 /* read in abbrev header */
4149 cur_abbrev
->number
= abbrev_number
;
4150 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4151 abbrev_ptr
+= bytes_read
;
4152 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
4155 /* now read in declarations */
4156 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4157 abbrev_ptr
+= bytes_read
;
4158 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4159 abbrev_ptr
+= bytes_read
;
4162 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
4164 cur_abbrev
->attrs
= (struct attr_abbrev
*)
4165 xrealloc (cur_abbrev
->attrs
,
4166 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
4167 * sizeof (struct attr_abbrev
));
4169 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
4170 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
4171 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4172 abbrev_ptr
+= bytes_read
;
4173 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4174 abbrev_ptr
+= bytes_read
;
4177 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
4178 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
4179 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
4181 /* Get next abbreviation.
4182 Under Irix6 the abbreviations for a compilation unit are not
4183 always properly terminated with an abbrev number of 0.
4184 Exit loop if we encounter an abbreviation which we have
4185 already read (which means we are about to read the abbreviations
4186 for the next compile unit) or if the end of the abbreviation
4187 table is reached. */
4188 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
4189 >= dwarf_abbrev_size
)
4191 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4192 abbrev_ptr
+= bytes_read
;
4193 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
4198 /* Empty the abbrev table for a new compilation unit. */
4201 dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table
)
4204 struct abbrev_info
*abbrev
, *next
;
4205 struct abbrev_info
**abbrevs
;
4207 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
4209 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
4212 abbrev
= abbrevs
[i
];
4215 next
= abbrev
->next
;
4216 xfree (abbrev
->attrs
);
4224 /* Lookup an abbrev_info structure in the abbrev hash table. */
4226 static struct abbrev_info
*
4227 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
4229 struct comp_unit_head
*cu_header
= &cu
->header
;
4230 unsigned int hash_number
;
4231 struct abbrev_info
*abbrev
;
4233 hash_number
= number
% ABBREV_HASH_SIZE
;
4234 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
4238 if (abbrev
->number
== number
)
4241 abbrev
= abbrev
->next
;
4246 /* Read a minimal amount of information into the minimal die structure. */
4249 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
4250 char *info_ptr
, struct dwarf2_cu
*cu
)
4252 unsigned int abbrev_number
, bytes_read
, i
;
4253 struct abbrev_info
*abbrev
;
4254 struct attribute attr
;
4255 struct attribute spec_attr
;
4256 int found_spec_attr
= 0;
4257 int has_low_pc_attr
= 0;
4258 int has_high_pc_attr
= 0;
4260 *part_die
= zeroed_partial_die
;
4261 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4262 info_ptr
+= bytes_read
;
4266 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4269 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number
,
4270 bfd_get_filename (abfd
));
4272 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
4273 part_die
->tag
= abbrev
->tag
;
4274 part_die
->has_children
= abbrev
->has_children
;
4275 part_die
->abbrev
= abbrev_number
;
4277 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4279 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
4281 /* Store the data if it is of an attribute we want to keep in a
4282 partial symbol table. */
4287 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
4288 if (part_die
->name
== NULL
)
4289 part_die
->name
= DW_STRING (&attr
);
4291 case DW_AT_MIPS_linkage_name
:
4292 part_die
->name
= DW_STRING (&attr
);
4295 has_low_pc_attr
= 1;
4296 part_die
->lowpc
= DW_ADDR (&attr
);
4299 has_high_pc_attr
= 1;
4300 part_die
->highpc
= DW_ADDR (&attr
);
4302 case DW_AT_location
:
4303 /* Support the .debug_loc offsets */
4304 if (attr_form_is_block (&attr
))
4306 part_die
->locdesc
= DW_BLOCK (&attr
);
4308 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
4310 dwarf2_complex_location_expr_complaint ();
4314 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4315 "partial symbol information");
4318 case DW_AT_language
:
4319 part_die
->language
= DW_UNSND (&attr
);
4321 case DW_AT_external
:
4322 part_die
->is_external
= DW_UNSND (&attr
);
4324 case DW_AT_declaration
:
4325 part_die
->is_declaration
= DW_UNSND (&attr
);
4328 part_die
->has_type
= 1;
4330 case DW_AT_abstract_origin
:
4331 case DW_AT_specification
:
4332 found_spec_attr
= 1;
4336 /* Ignore absolute siblings, they might point outside of
4337 the current compile unit. */
4338 if (attr
.form
== DW_FORM_ref_addr
)
4339 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
4342 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
4349 /* If we found a reference attribute and the die has no name, try
4350 to find a name in the referred to die. */
4352 if (found_spec_attr
&& part_die
->name
== NULL
)
4354 struct partial_die_info spec_die
;
4357 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
4358 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu
);
4361 part_die
->name
= spec_die
.name
;
4363 /* Copy DW_AT_external attribute if it is set. */
4364 if (spec_die
.is_external
)
4365 part_die
->is_external
= spec_die
.is_external
;
4369 /* When using the GNU linker, .gnu.linkonce. sections are used to
4370 eliminate duplicate copies of functions and vtables and such.
4371 The linker will arbitrarily choose one and discard the others.
4372 The AT_*_pc values for such functions refer to local labels in
4373 these sections. If the section from that file was discarded, the
4374 labels are not in the output, so the relocs get a value of 0.
4375 If this is a discarded function, mark the pc bounds as invalid,
4376 so that GDB will ignore it. */
4377 if (has_low_pc_attr
&& has_high_pc_attr
4378 && part_die
->lowpc
< part_die
->highpc
4379 && (part_die
->lowpc
!= 0
4380 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
4381 part_die
->has_pc_info
= 1;
4385 /* Read the die from the .debug_info section buffer. Set DIEP to
4386 point to a newly allocated die with its information, except for its
4387 child, sibling, and parent fields. Set HAS_CHILDREN to tell
4388 whether the die has children or not. */
4391 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
4392 struct dwarf2_cu
*cu
, int *has_children
)
4394 unsigned int abbrev_number
, bytes_read
, i
, offset
;
4395 struct abbrev_info
*abbrev
;
4396 struct die_info
*die
;
4398 offset
= info_ptr
- dwarf_info_buffer
;
4399 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4400 info_ptr
+= bytes_read
;
4403 die
= dwarf_alloc_die ();
4405 die
->abbrev
= abbrev_number
;
4412 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4415 error ("Dwarf Error: could not find abbrev number %d [in module %s]",
4417 bfd_get_filename (abfd
));
4419 die
= dwarf_alloc_die ();
4420 die
->offset
= offset
;
4421 die
->tag
= abbrev
->tag
;
4422 die
->abbrev
= abbrev_number
;
4425 die
->num_attrs
= abbrev
->num_attrs
;
4426 die
->attrs
= (struct attribute
*)
4427 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
4429 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4431 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
4432 abfd
, info_ptr
, cu
);
4436 *has_children
= abbrev
->has_children
;
4440 /* Read an attribute value described by an attribute form. */
4443 read_attribute_value (struct attribute
*attr
, unsigned form
,
4444 bfd
*abfd
, char *info_ptr
,
4445 struct dwarf2_cu
*cu
)
4447 struct comp_unit_head
*cu_header
= &cu
->header
;
4448 unsigned int bytes_read
;
4449 struct dwarf_block
*blk
;
4455 case DW_FORM_ref_addr
:
4456 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
4457 info_ptr
+= bytes_read
;
4459 case DW_FORM_block2
:
4460 blk
= dwarf_alloc_block ();
4461 blk
->size
= read_2_bytes (abfd
, info_ptr
);
4463 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4464 info_ptr
+= blk
->size
;
4465 DW_BLOCK (attr
) = blk
;
4467 case DW_FORM_block4
:
4468 blk
= dwarf_alloc_block ();
4469 blk
->size
= read_4_bytes (abfd
, info_ptr
);
4471 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4472 info_ptr
+= blk
->size
;
4473 DW_BLOCK (attr
) = blk
;
4476 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4480 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4484 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4487 case DW_FORM_string
:
4488 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
4489 info_ptr
+= bytes_read
;
4492 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
4494 info_ptr
+= bytes_read
;
4497 blk
= dwarf_alloc_block ();
4498 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4499 info_ptr
+= bytes_read
;
4500 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4501 info_ptr
+= blk
->size
;
4502 DW_BLOCK (attr
) = blk
;
4504 case DW_FORM_block1
:
4505 blk
= dwarf_alloc_block ();
4506 blk
->size
= read_1_byte (abfd
, info_ptr
);
4508 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4509 info_ptr
+= blk
->size
;
4510 DW_BLOCK (attr
) = blk
;
4513 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4517 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4521 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
4522 info_ptr
+= bytes_read
;
4525 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4526 info_ptr
+= bytes_read
;
4529 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4533 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4537 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4541 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4544 case DW_FORM_ref_udata
:
4545 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4546 info_ptr
+= bytes_read
;
4548 case DW_FORM_indirect
:
4549 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4550 info_ptr
+= bytes_read
;
4551 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
4554 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4555 dwarf_form_name (form
),
4556 bfd_get_filename (abfd
));
4561 /* Read an attribute described by an abbreviated attribute. */
4564 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
4565 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
4567 attr
->name
= abbrev
->name
;
4568 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
4571 /* read dwarf information from a buffer */
4574 read_1_byte (bfd
*abfd
, char *buf
)
4576 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4580 read_1_signed_byte (bfd
*abfd
, char *buf
)
4582 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
4586 read_2_bytes (bfd
*abfd
, char *buf
)
4588 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4592 read_2_signed_bytes (bfd
*abfd
, char *buf
)
4594 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4598 read_4_bytes (bfd
*abfd
, char *buf
)
4600 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4604 read_4_signed_bytes (bfd
*abfd
, char *buf
)
4606 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4609 static unsigned long
4610 read_8_bytes (bfd
*abfd
, char *buf
)
4612 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4616 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
4618 struct comp_unit_head
*cu_header
= &cu
->header
;
4619 CORE_ADDR retval
= 0;
4621 if (cu_header
->signed_addr_p
)
4623 switch (cu_header
->addr_size
)
4626 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4629 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4632 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
4635 internal_error (__FILE__
, __LINE__
,
4636 "read_address: bad switch, signed [in module %s]",
4637 bfd_get_filename (abfd
));
4642 switch (cu_header
->addr_size
)
4645 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4648 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4651 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4654 internal_error (__FILE__
, __LINE__
,
4655 "read_address: bad switch, unsigned [in module %s]",
4656 bfd_get_filename (abfd
));
4660 *bytes_read
= cu_header
->addr_size
;
4664 /* Read the initial length from a section. The (draft) DWARF 3
4665 specification allows the initial length to take up either 4 bytes
4666 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4667 bytes describe the length and all offsets will be 8 bytes in length
4670 An older, non-standard 64-bit format is also handled by this
4671 function. The older format in question stores the initial length
4672 as an 8-byte quantity without an escape value. Lengths greater
4673 than 2^32 aren't very common which means that the initial 4 bytes
4674 is almost always zero. Since a length value of zero doesn't make
4675 sense for the 32-bit format, this initial zero can be considered to
4676 be an escape value which indicates the presence of the older 64-bit
4677 format. As written, the code can't detect (old format) lengths
4678 greater than 4GB. If it becomes necessary to handle lengths somewhat
4679 larger than 4GB, we could allow other small values (such as the
4680 non-sensical values of 1, 2, and 3) to also be used as escape values
4681 indicating the presence of the old format.
4683 The value returned via bytes_read should be used to increment
4684 the relevant pointer after calling read_initial_length().
4686 As a side effect, this function sets the fields initial_length_size
4687 and offset_size in cu_header to the values appropriate for the
4688 length field. (The format of the initial length field determines
4689 the width of file offsets to be fetched later with fetch_offset().)
4691 [ Note: read_initial_length() and read_offset() are based on the
4692 document entitled "DWARF Debugging Information Format", revision
4693 3, draft 8, dated November 19, 2001. This document was obtained
4696 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4698 This document is only a draft and is subject to change. (So beware.)
4700 Details regarding the older, non-standard 64-bit format were
4701 determined empirically by examining 64-bit ELF files produced
4702 by the SGI toolchain on an IRIX 6.5 machine.
4704 - Kevin, July 16, 2002
4708 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4713 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4715 if (retval
== 0xffffffff)
4717 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4719 if (cu_header
!= NULL
)
4721 cu_header
->initial_length_size
= 12;
4722 cu_header
->offset_size
= 8;
4725 else if (retval
== 0)
4727 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4729 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4731 if (cu_header
!= NULL
)
4733 cu_header
->initial_length_size
= 8;
4734 cu_header
->offset_size
= 8;
4740 if (cu_header
!= NULL
)
4742 cu_header
->initial_length_size
= 4;
4743 cu_header
->offset_size
= 4;
4750 /* Read an offset from the data stream. The size of the offset is
4751 given by cu_header->offset_size. */
4754 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4759 switch (cu_header
->offset_size
)
4762 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4766 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4770 internal_error (__FILE__
, __LINE__
,
4771 "read_offset: bad switch [in module %s]",
4772 bfd_get_filename (abfd
));
4779 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4781 /* If the size of a host char is 8 bits, we can return a pointer
4782 to the buffer, otherwise we have to copy the data to a buffer
4783 allocated on the temporary obstack. */
4784 gdb_assert (HOST_CHAR_BIT
== 8);
4789 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4791 /* If the size of a host char is 8 bits, we can return a pointer
4792 to the string, otherwise we have to copy the string to a buffer
4793 allocated on the temporary obstack. */
4794 gdb_assert (HOST_CHAR_BIT
== 8);
4797 *bytes_read_ptr
= 1;
4800 *bytes_read_ptr
= strlen (buf
) + 1;
4805 read_indirect_string (bfd
*abfd
, char *buf
,
4806 const struct comp_unit_head
*cu_header
,
4807 unsigned int *bytes_read_ptr
)
4809 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4810 (int *) bytes_read_ptr
);
4812 if (dwarf_str_buffer
== NULL
)
4814 error ("DW_FORM_strp used without .debug_str section [in module %s]",
4815 bfd_get_filename (abfd
));
4818 if (str_offset
>= dwarf_str_size
)
4820 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4821 bfd_get_filename (abfd
));
4824 gdb_assert (HOST_CHAR_BIT
== 8);
4825 if (dwarf_str_buffer
[str_offset
] == '\0')
4827 return dwarf_str_buffer
+ str_offset
;
4830 static unsigned long
4831 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4833 unsigned long result
;
4834 unsigned int num_read
;
4844 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4847 result
|= ((unsigned long)(byte
& 127) << shift
);
4848 if ((byte
& 128) == 0)
4854 *bytes_read_ptr
= num_read
;
4859 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4862 int i
, shift
, size
, num_read
;
4872 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4875 result
|= ((long)(byte
& 127) << shift
);
4877 if ((byte
& 128) == 0)
4882 if ((shift
< size
) && (byte
& 0x40))
4884 result
|= -(1 << shift
);
4886 *bytes_read_ptr
= num_read
;
4891 set_cu_language (unsigned int lang
)
4897 cu_language
= language_c
;
4899 case DW_LANG_C_plus_plus
:
4900 cu_language
= language_cplus
;
4902 case DW_LANG_Fortran77
:
4903 case DW_LANG_Fortran90
:
4904 case DW_LANG_Fortran95
:
4905 cu_language
= language_fortran
;
4907 case DW_LANG_Mips_Assembler
:
4908 cu_language
= language_asm
;
4911 cu_language
= language_java
;
4915 case DW_LANG_Cobol74
:
4916 case DW_LANG_Cobol85
:
4917 case DW_LANG_Pascal83
:
4918 case DW_LANG_Modula2
:
4920 cu_language
= language_minimal
;
4923 cu_language_defn
= language_def (cu_language
);
4926 /* Return the named attribute or NULL if not there. */
4928 static struct attribute
*
4929 dwarf_attr (struct die_info
*die
, unsigned int name
)
4932 struct attribute
*spec
= NULL
;
4934 for (i
= 0; i
< die
->num_attrs
; ++i
)
4936 if (die
->attrs
[i
].name
== name
)
4938 return &die
->attrs
[i
];
4940 if (die
->attrs
[i
].name
== DW_AT_specification
4941 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4942 spec
= &die
->attrs
[i
];
4946 struct die_info
*ref_die
=
4947 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4950 return dwarf_attr (ref_die
, name
);
4957 die_is_declaration (struct die_info
*die
)
4959 return (dwarf_attr (die
, DW_AT_declaration
)
4960 && ! dwarf_attr (die
, DW_AT_specification
));
4963 /* Return the die giving the specification for DIE, if there is
4966 static struct die_info
*
4967 die_specification (struct die_info
*die
)
4969 struct attribute
*spec_attr
= dwarf_attr (die
, DW_AT_specification
);
4971 if (spec_attr
== NULL
)
4974 return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr
));
4977 /* Free the line_header structure *LH, and any arrays and strings it
4980 free_line_header (struct line_header
*lh
)
4982 if (lh
->standard_opcode_lengths
)
4983 xfree (lh
->standard_opcode_lengths
);
4985 /* Remember that all the lh->file_names[i].name pointers are
4986 pointers into debug_line_buffer, and don't need to be freed. */
4988 xfree (lh
->file_names
);
4990 /* Similarly for the include directory names. */
4991 if (lh
->include_dirs
)
4992 xfree (lh
->include_dirs
);
4998 /* Add an entry to LH's include directory table. */
5000 add_include_dir (struct line_header
*lh
, char *include_dir
)
5002 /* Grow the array if necessary. */
5003 if (lh
->include_dirs_size
== 0)
5005 lh
->include_dirs_size
= 1; /* for testing */
5006 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
5007 * sizeof (*lh
->include_dirs
));
5009 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
5011 lh
->include_dirs_size
*= 2;
5012 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
5013 (lh
->include_dirs_size
5014 * sizeof (*lh
->include_dirs
)));
5017 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
5021 /* Add an entry to LH's file name table. */
5023 add_file_name (struct line_header
*lh
,
5025 unsigned int dir_index
,
5026 unsigned int mod_time
,
5027 unsigned int length
)
5029 struct file_entry
*fe
;
5031 /* Grow the array if necessary. */
5032 if (lh
->file_names_size
== 0)
5034 lh
->file_names_size
= 1; /* for testing */
5035 lh
->file_names
= xmalloc (lh
->file_names_size
5036 * sizeof (*lh
->file_names
));
5038 else if (lh
->num_file_names
>= lh
->file_names_size
)
5040 lh
->file_names_size
*= 2;
5041 lh
->file_names
= xrealloc (lh
->file_names
,
5042 (lh
->file_names_size
5043 * sizeof (*lh
->file_names
)));
5046 fe
= &lh
->file_names
[lh
->num_file_names
++];
5048 fe
->dir_index
= dir_index
;
5049 fe
->mod_time
= mod_time
;
5050 fe
->length
= length
;
5054 /* Read the statement program header starting at OFFSET in
5055 dwarf_line_buffer, according to the endianness of ABFD. Return a
5056 pointer to a struct line_header, allocated using xmalloc.
5058 NOTE: the strings in the include directory and file name tables of
5059 the returned object point into debug_line_buffer, and must not be
5061 static struct line_header
*
5062 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
5063 struct dwarf2_cu
*cu
)
5065 struct cleanup
*back_to
;
5066 struct line_header
*lh
;
5070 char *cur_dir
, *cur_file
;
5072 if (dwarf_line_buffer
== NULL
)
5074 complaint (&symfile_complaints
, "missing .debug_line section");
5078 /* Make sure that at least there's room for the total_length field. That
5079 could be 12 bytes long, but we're just going to fudge that. */
5080 if (offset
+ 4 >= dwarf_line_size
)
5082 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5086 lh
= xmalloc (sizeof (*lh
));
5087 memset (lh
, 0, sizeof (*lh
));
5088 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
5091 line_ptr
= dwarf_line_buffer
+ offset
;
5093 /* read in the header */
5094 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
5095 line_ptr
+= bytes_read
;
5096 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
5098 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5101 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
5102 lh
->version
= read_2_bytes (abfd
, line_ptr
);
5104 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
5105 line_ptr
+= bytes_read
;
5106 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
5108 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
5110 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
5112 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
5114 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
5116 lh
->standard_opcode_lengths
5117 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
5119 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
5120 for (i
= 1; i
< lh
->opcode_base
; ++i
)
5122 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
5126 /* Read directory table */
5127 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
5129 line_ptr
+= bytes_read
;
5130 add_include_dir (lh
, cur_dir
);
5132 line_ptr
+= bytes_read
;
5134 /* Read file name table */
5135 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
5137 unsigned int dir_index
, mod_time
, length
;
5139 line_ptr
+= bytes_read
;
5140 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5141 line_ptr
+= bytes_read
;
5142 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5143 line_ptr
+= bytes_read
;
5144 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5145 line_ptr
+= bytes_read
;
5147 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5149 line_ptr
+= bytes_read
;
5150 lh
->statement_program_start
= line_ptr
;
5152 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
5153 complaint (&symfile_complaints
,
5154 "line number info header doesn't fit in `.debug_line' section");
5156 discard_cleanups (back_to
);
5160 /* This function exists to work around a bug in certain compilers
5161 (particularly GCC 2.95), in which the first line number marker of a
5162 function does not show up until after the prologue, right before
5163 the second line number marker. This function shifts ADDRESS down
5164 to the beginning of the function if necessary, and is called on
5165 addresses passed to record_line. */
5168 check_cu_functions (CORE_ADDR address
)
5170 struct function_range
*fn
;
5172 /* Find the function_range containing address. */
5177 cu_cached_fn
= cu_first_fn
;
5181 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5187 while (fn
&& fn
!= cu_cached_fn
)
5188 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5198 if (address
!= fn
->lowpc
)
5199 complaint (&symfile_complaints
,
5200 "misplaced first line number at 0x%lx for '%s'",
5201 (unsigned long) address
, fn
->name
);
5206 /* Decode the line number information for the compilation unit whose
5207 line number info is at OFFSET in the .debug_line section.
5208 The compilation directory of the file is passed in COMP_DIR. */
5211 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
5212 struct dwarf2_cu
*cu
)
5216 unsigned int bytes_read
;
5217 unsigned char op_code
, extended_op
, adj_opcode
;
5219 line_ptr
= lh
->statement_program_start
;
5220 line_end
= lh
->statement_program_end
;
5222 /* Read the statement sequences until there's nothing left. */
5223 while (line_ptr
< line_end
)
5225 /* state machine registers */
5226 CORE_ADDR address
= 0;
5227 unsigned int file
= 1;
5228 unsigned int line
= 1;
5229 unsigned int column
= 0;
5230 int is_stmt
= lh
->default_is_stmt
;
5231 int basic_block
= 0;
5232 int end_sequence
= 0;
5234 /* Start a subfile for the current file of the state machine. */
5235 if (lh
->num_file_names
>= file
)
5237 /* lh->include_dirs and lh->file_names are 0-based, but the
5238 directory and file name numbers in the statement program
5240 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
5243 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5246 dwarf2_start_subfile (fe
->name
, dir
);
5249 /* Decode the table. */
5250 while (!end_sequence
)
5252 op_code
= read_1_byte (abfd
, line_ptr
);
5255 if (op_code
>= lh
->opcode_base
)
5256 { /* Special operand. */
5257 adj_opcode
= op_code
- lh
->opcode_base
;
5258 address
+= (adj_opcode
/ lh
->line_range
)
5259 * lh
->minimum_instruction_length
;
5260 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
5261 /* append row to matrix using current values */
5262 record_line (current_subfile
, line
,
5263 check_cu_functions (address
));
5266 else switch (op_code
)
5268 case DW_LNS_extended_op
:
5269 line_ptr
+= 1; /* ignore length */
5270 extended_op
= read_1_byte (abfd
, line_ptr
);
5272 switch (extended_op
)
5274 case DW_LNE_end_sequence
:
5276 record_line (current_subfile
, 0, address
);
5278 case DW_LNE_set_address
:
5279 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
5280 line_ptr
+= bytes_read
;
5281 address
+= baseaddr
;
5283 case DW_LNE_define_file
:
5286 unsigned int dir_index
, mod_time
, length
;
5288 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
5289 line_ptr
+= bytes_read
;
5291 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5292 line_ptr
+= bytes_read
;
5294 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5295 line_ptr
+= bytes_read
;
5297 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5298 line_ptr
+= bytes_read
;
5299 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5303 complaint (&symfile_complaints
,
5304 "mangled .debug_line section");
5309 record_line (current_subfile
, line
,
5310 check_cu_functions (address
));
5313 case DW_LNS_advance_pc
:
5314 address
+= lh
->minimum_instruction_length
5315 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5316 line_ptr
+= bytes_read
;
5318 case DW_LNS_advance_line
:
5319 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
5320 line_ptr
+= bytes_read
;
5322 case DW_LNS_set_file
:
5324 /* lh->include_dirs and lh->file_names are 0-based,
5325 but the directory and file name numbers in the
5326 statement program are 1-based. */
5327 struct file_entry
*fe
;
5329 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5330 line_ptr
+= bytes_read
;
5331 fe
= &lh
->file_names
[file
- 1];
5333 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5336 dwarf2_start_subfile (fe
->name
, dir
);
5339 case DW_LNS_set_column
:
5340 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5341 line_ptr
+= bytes_read
;
5343 case DW_LNS_negate_stmt
:
5344 is_stmt
= (!is_stmt
);
5346 case DW_LNS_set_basic_block
:
5349 /* Add to the address register of the state machine the
5350 address increment value corresponding to special opcode
5351 255. Ie, this value is scaled by the minimum instruction
5352 length since special opcode 255 would have scaled the
5354 case DW_LNS_const_add_pc
:
5355 address
+= (lh
->minimum_instruction_length
5356 * ((255 - lh
->opcode_base
) / lh
->line_range
));
5358 case DW_LNS_fixed_advance_pc
:
5359 address
+= read_2_bytes (abfd
, line_ptr
);
5363 { /* Unknown standard opcode, ignore it. */
5365 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
5367 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5368 line_ptr
+= bytes_read
;
5376 /* Start a subfile for DWARF. FILENAME is the name of the file and
5377 DIRNAME the name of the source directory which contains FILENAME
5378 or NULL if not known.
5379 This routine tries to keep line numbers from identical absolute and
5380 relative file names in a common subfile.
5382 Using the `list' example from the GDB testsuite, which resides in
5383 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
5384 of /srcdir/list0.c yields the following debugging information for list0.c:
5386 DW_AT_name: /srcdir/list0.c
5387 DW_AT_comp_dir: /compdir
5388 files.files[0].name: list0.h
5389 files.files[0].dir: /srcdir
5390 files.files[1].name: list0.c
5391 files.files[1].dir: /srcdir
5393 The line number information for list0.c has to end up in a single
5394 subfile, so that `break /srcdir/list0.c:1' works as expected. */
5397 dwarf2_start_subfile (char *filename
, char *dirname
)
5399 /* If the filename isn't absolute, try to match an existing subfile
5400 with the full pathname. */
5402 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
5404 struct subfile
*subfile
;
5405 char *fullname
= concat (dirname
, "/", filename
, NULL
);
5407 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
5409 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
5411 current_subfile
= subfile
;
5418 start_subfile (filename
, dirname
);
5422 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
5423 struct dwarf2_cu
*cu
)
5425 struct objfile
*objfile
= cu
->objfile
;
5426 struct comp_unit_head
*cu_header
= &cu
->header
;
5428 /* NOTE drow/2003-01-30: There used to be a comment and some special
5429 code here to turn a symbol with DW_AT_external and a
5430 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
5431 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
5432 with some versions of binutils) where shared libraries could have
5433 relocations against symbols in their debug information - the
5434 minimal symbol would have the right address, but the debug info
5435 would not. It's no longer necessary, because we will explicitly
5436 apply relocations when we read in the debug information now. */
5438 /* A DW_AT_location attribute with no contents indicates that a
5439 variable has been optimized away. */
5440 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
5442 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
5446 /* Handle one degenerate form of location expression specially, to
5447 preserve GDB's previous behavior when section offsets are
5448 specified. If this is just a DW_OP_addr then mark this symbol
5451 if (attr_form_is_block (attr
)
5452 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
5453 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
5457 SYMBOL_VALUE_ADDRESS (sym
) =
5458 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
5459 fixup_symbol_section (sym
, objfile
);
5460 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
5461 SYMBOL_SECTION (sym
));
5462 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5466 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
5467 expression evaluator, and use LOC_COMPUTED only when necessary
5468 (i.e. when the value of a register or memory location is
5469 referenced, or a thread-local block, etc.). Then again, it might
5470 not be worthwhile. I'm assuming that it isn't unless performance
5471 or memory numbers show me otherwise. */
5473 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
5474 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
5477 /* Given a pointer to a DWARF information entry, figure out if we need
5478 to make a symbol table entry for it, and if so, create a new entry
5479 and return a pointer to it.
5480 If TYPE is NULL, determine symbol type from the die, otherwise
5481 used the passed type. */
5483 static struct symbol
*
5484 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
5486 struct objfile
*objfile
= cu
->objfile
;
5487 struct symbol
*sym
= NULL
;
5489 struct attribute
*attr
= NULL
;
5490 struct attribute
*attr2
= NULL
;
5492 if (die
->tag
!= DW_TAG_namespace
)
5493 name
= dwarf2_linkage_name (die
);
5495 name
= TYPE_NAME (type
);
5499 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
5500 sizeof (struct symbol
));
5501 OBJSTAT (objfile
, n_syms
++);
5502 memset (sym
, 0, sizeof (struct symbol
));
5504 /* Cache this symbol's name and the name's demangled form (if any). */
5505 SYMBOL_LANGUAGE (sym
) = cu_language
;
5506 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
5508 /* Default assumptions.
5509 Use the passed type or decode it from the die. */
5510 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5511 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5513 SYMBOL_TYPE (sym
) = type
;
5515 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
5516 attr
= dwarf_attr (die
, DW_AT_decl_line
);
5519 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
5524 attr
= dwarf_attr (die
, DW_AT_low_pc
);
5527 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
5529 SYMBOL_CLASS (sym
) = LOC_LABEL
;
5531 case DW_TAG_subprogram
:
5532 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
5534 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5535 attr2
= dwarf_attr (die
, DW_AT_external
);
5536 if (attr2
&& (DW_UNSND (attr2
) != 0))
5538 add_symbol_to_list (sym
, &global_symbols
);
5542 add_symbol_to_list (sym
, list_in_scope
);
5545 case DW_TAG_variable
:
5546 /* Compilation with minimal debug info may result in variables
5547 with missing type entries. Change the misleading `void' type
5548 to something sensible. */
5549 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
5550 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
5551 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
5552 "<variable, no debug info>",
5554 attr
= dwarf_attr (die
, DW_AT_const_value
);
5557 dwarf2_const_value (attr
, sym
, cu
);
5558 attr2
= dwarf_attr (die
, DW_AT_external
);
5559 if (attr2
&& (DW_UNSND (attr2
) != 0))
5560 add_symbol_to_list (sym
, &global_symbols
);
5562 add_symbol_to_list (sym
, list_in_scope
);
5565 attr
= dwarf_attr (die
, DW_AT_location
);
5568 var_decode_location (attr
, sym
, cu
);
5569 attr2
= dwarf_attr (die
, DW_AT_external
);
5570 if (attr2
&& (DW_UNSND (attr2
) != 0))
5571 add_symbol_to_list (sym
, &global_symbols
);
5573 add_symbol_to_list (sym
, list_in_scope
);
5577 /* We do not know the address of this symbol.
5578 If it is an external symbol and we have type information
5579 for it, enter the symbol as a LOC_UNRESOLVED symbol.
5580 The address of the variable will then be determined from
5581 the minimal symbol table whenever the variable is
5583 attr2
= dwarf_attr (die
, DW_AT_external
);
5584 if (attr2
&& (DW_UNSND (attr2
) != 0)
5585 && dwarf_attr (die
, DW_AT_type
) != NULL
)
5587 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
5588 add_symbol_to_list (sym
, &global_symbols
);
5592 case DW_TAG_formal_parameter
:
5593 attr
= dwarf_attr (die
, DW_AT_location
);
5596 var_decode_location (attr
, sym
, cu
);
5597 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
5598 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
5599 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
5601 attr
= dwarf_attr (die
, DW_AT_const_value
);
5604 dwarf2_const_value (attr
, sym
, cu
);
5606 add_symbol_to_list (sym
, list_in_scope
);
5608 case DW_TAG_unspecified_parameters
:
5609 /* From varargs functions; gdb doesn't seem to have any
5610 interest in this information, so just ignore it for now.
5613 case DW_TAG_class_type
:
5614 case DW_TAG_structure_type
:
5615 case DW_TAG_union_type
:
5616 case DW_TAG_enumeration_type
:
5617 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5618 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
5620 /* Make sure that the symbol includes appropriate enclosing
5621 classes/namespaces in its name. These are calculated in
5622 read_structure_scope, and the correct name is saved in
5625 if (cu_language
== language_cplus
)
5627 struct type
*type
= SYMBOL_TYPE (sym
);
5629 if (TYPE_TAG_NAME (type
) != NULL
)
5631 /* FIXME: carlton/2003-11-10: Should this use
5632 SYMBOL_SET_NAMES instead? (The same problem also
5633 arises a further down in the function.) */
5634 SYMBOL_LINKAGE_NAME (sym
)
5635 = obsavestring (TYPE_TAG_NAME (type
),
5636 strlen (TYPE_TAG_NAME (type
)),
5637 &objfile
->symbol_obstack
);
5642 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
5643 really ever be static objects: otherwise, if you try
5644 to, say, break of a class's method and you're in a file
5645 which doesn't mention that class, it won't work unless
5646 the check for all static symbols in lookup_symbol_aux
5647 saves you. See the OtherFileClass tests in
5648 gdb.c++/namespace.exp. */
5650 struct pending
**list_to_add
;
5652 list_to_add
= (list_in_scope
== &file_symbols
5653 && cu_language
== language_cplus
5654 ? &global_symbols
: list_in_scope
);
5656 add_symbol_to_list (sym
, list_to_add
);
5658 /* The semantics of C++ state that "struct foo { ... }" also
5659 defines a typedef for "foo". Synthesize a typedef symbol so
5660 that "ptype foo" works as expected. */
5661 if (cu_language
== language_cplus
)
5663 struct symbol
*typedef_sym
= (struct symbol
*)
5664 obstack_alloc (&objfile
->symbol_obstack
,
5665 sizeof (struct symbol
));
5666 *typedef_sym
= *sym
;
5667 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
5668 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5669 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5670 obsavestring (SYMBOL_NATURAL_NAME (sym
),
5671 strlen (SYMBOL_NATURAL_NAME (sym
)),
5672 &objfile
->type_obstack
);
5673 add_symbol_to_list (typedef_sym
, list_to_add
);
5677 case DW_TAG_typedef
:
5678 if (processing_has_namespace_info
5679 && processing_current_prefix
[0] != '\0')
5681 SYMBOL_LINKAGE_NAME (sym
) = obconcat (&objfile
->symbol_obstack
,
5682 processing_current_prefix
,
5686 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5687 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5688 add_symbol_to_list (sym
, list_in_scope
);
5690 case DW_TAG_base_type
:
5691 case DW_TAG_subrange_type
:
5692 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5693 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5694 add_symbol_to_list (sym
, list_in_scope
);
5696 case DW_TAG_enumerator
:
5697 if (processing_has_namespace_info
5698 && processing_current_prefix
[0] != '\0')
5700 SYMBOL_LINKAGE_NAME (sym
) = obconcat (&objfile
->symbol_obstack
,
5701 processing_current_prefix
,
5705 attr
= dwarf_attr (die
, DW_AT_const_value
);
5708 dwarf2_const_value (attr
, sym
, cu
);
5711 /* NOTE: carlton/2003-11-10: See comment above in the
5712 DW_TAG_class_type, etc. block. */
5714 struct pending
**list_to_add
;
5716 list_to_add
= (list_in_scope
== &file_symbols
5717 && cu_language
== language_cplus
5718 ? &global_symbols
: list_in_scope
);
5720 add_symbol_to_list (sym
, list_to_add
);
5723 case DW_TAG_namespace
:
5724 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5725 add_symbol_to_list (sym
, &global_symbols
);
5728 /* Not a tag we recognize. Hopefully we aren't processing
5729 trash data, but since we must specifically ignore things
5730 we don't recognize, there is nothing else we should do at
5732 complaint (&symfile_complaints
, "unsupported tag: '%s'",
5733 dwarf_tag_name (die
->tag
));
5740 /* Copy constant value from an attribute to a symbol. */
5743 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5744 struct dwarf2_cu
*cu
)
5746 struct objfile
*objfile
= cu
->objfile
;
5747 struct comp_unit_head
*cu_header
= &cu
->header
;
5748 struct dwarf_block
*blk
;
5753 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5754 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5755 cu_header
->addr_size
,
5756 TYPE_LENGTH (SYMBOL_TYPE
5758 SYMBOL_VALUE_BYTES (sym
) = (char *)
5759 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5760 /* NOTE: cagney/2003-05-09: In-lined store_address call with
5761 it's body - store_unsigned_integer. */
5762 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5764 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5766 case DW_FORM_block1
:
5767 case DW_FORM_block2
:
5768 case DW_FORM_block4
:
5770 blk
= DW_BLOCK (attr
);
5771 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5772 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5774 TYPE_LENGTH (SYMBOL_TYPE
5776 SYMBOL_VALUE_BYTES (sym
) = (char *)
5777 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5778 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5779 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5782 /* The DW_AT_const_value attributes are supposed to carry the
5783 symbol's value "represented as it would be on the target
5784 architecture." By the time we get here, it's already been
5785 converted to host endianness, so we just need to sign- or
5786 zero-extend it as appropriate. */
5788 dwarf2_const_value_data (attr
, sym
, 8);
5791 dwarf2_const_value_data (attr
, sym
, 16);
5794 dwarf2_const_value_data (attr
, sym
, 32);
5797 dwarf2_const_value_data (attr
, sym
, 64);
5801 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5802 SYMBOL_CLASS (sym
) = LOC_CONST
;
5806 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5807 SYMBOL_CLASS (sym
) = LOC_CONST
;
5811 complaint (&symfile_complaints
,
5812 "unsupported const value attribute form: '%s'",
5813 dwarf_form_name (attr
->form
));
5814 SYMBOL_VALUE (sym
) = 0;
5815 SYMBOL_CLASS (sym
) = LOC_CONST
;
5821 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5822 or zero-extend it as appropriate for the symbol's type. */
5824 dwarf2_const_value_data (struct attribute
*attr
,
5828 LONGEST l
= DW_UNSND (attr
);
5830 if (bits
< sizeof (l
) * 8)
5832 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5833 l
&= ((LONGEST
) 1 << bits
) - 1;
5835 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5838 SYMBOL_VALUE (sym
) = l
;
5839 SYMBOL_CLASS (sym
) = LOC_CONST
;
5843 /* Return the type of the die in question using its DW_AT_type attribute. */
5845 static struct type
*
5846 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5849 struct attribute
*type_attr
;
5850 struct die_info
*type_die
;
5853 type_attr
= dwarf_attr (die
, DW_AT_type
);
5856 /* A missing DW_AT_type represents a void type. */
5857 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
);
5861 ref
= dwarf2_get_ref_die_offset (type_attr
);
5862 type_die
= follow_die_ref (ref
);
5865 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5866 ref
, cu
->objfile
->name
);
5870 type
= tag_type_to_type (type_die
, cu
);
5873 dump_die (type_die
);
5874 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5880 /* Return the containing type of the die in question using its
5881 DW_AT_containing_type attribute. */
5883 static struct type
*
5884 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5886 struct type
*type
= NULL
;
5887 struct attribute
*type_attr
;
5888 struct die_info
*type_die
= NULL
;
5891 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5894 ref
= dwarf2_get_ref_die_offset (type_attr
);
5895 type_die
= follow_die_ref (ref
);
5898 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref
,
5902 type
= tag_type_to_type (type_die
, cu
);
5907 dump_die (type_die
);
5908 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
5915 static struct type
*
5916 type_at_offset (unsigned int offset
, struct dwarf2_cu
*cu
)
5918 struct die_info
*die
;
5921 die
= follow_die_ref (offset
);
5924 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5927 type
= tag_type_to_type (die
, cu
);
5932 static struct type
*
5933 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5941 read_type_die (die
, cu
);
5945 error ("Dwarf Error: Cannot find type of die [in module %s]",
5953 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
5955 char *prefix
= determine_prefix (die
);
5956 const char *old_prefix
= processing_current_prefix
;
5957 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
5958 processing_current_prefix
= prefix
;
5962 case DW_TAG_class_type
:
5963 case DW_TAG_structure_type
:
5964 case DW_TAG_union_type
:
5965 read_structure_scope (die
, cu
);
5967 case DW_TAG_enumeration_type
:
5968 read_enumeration (die
, cu
);
5970 case DW_TAG_subprogram
:
5971 case DW_TAG_subroutine_type
:
5972 read_subroutine_type (die
, cu
);
5974 case DW_TAG_array_type
:
5975 read_array_type (die
, cu
);
5977 case DW_TAG_pointer_type
:
5978 read_tag_pointer_type (die
, cu
);
5980 case DW_TAG_ptr_to_member_type
:
5981 read_tag_ptr_to_member_type (die
, cu
);
5983 case DW_TAG_reference_type
:
5984 read_tag_reference_type (die
, cu
);
5986 case DW_TAG_const_type
:
5987 read_tag_const_type (die
, cu
);
5989 case DW_TAG_volatile_type
:
5990 read_tag_volatile_type (die
, cu
);
5992 case DW_TAG_string_type
:
5993 read_tag_string_type (die
, cu
);
5995 case DW_TAG_typedef
:
5996 read_typedef (die
, cu
);
5998 case DW_TAG_subrange_type
:
5999 read_subrange_type (die
, cu
);
6001 case DW_TAG_base_type
:
6002 read_base_type (die
, cu
);
6005 complaint (&symfile_complaints
, "unexepected tag in read_type_die: '%s'",
6006 dwarf_tag_name (die
->tag
));
6010 processing_current_prefix
= old_prefix
;
6011 do_cleanups (back_to
);
6014 /* Return the name of the namespace/class that DIE is defined within,
6015 or "" if we can't tell. The caller should xfree the result. */
6017 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
6018 therein) for an example of how to use this function to deal with
6019 DW_AT_specification. */
6022 determine_prefix (struct die_info
*die
)
6024 char *prefix
= determine_prefix_aux (die
);
6026 return prefix
? prefix
: xstrdup ("");
6029 /* Return the name of the namespace/class that DIE is defined
6030 within, or NULL if we can't tell. The caller should xfree the
6034 determine_prefix_aux (struct die_info
*die
)
6036 struct die_info
*parent
;
6038 if (cu_language
!= language_cplus
)
6041 parent
= die
->parent
;
6045 return (processing_has_namespace_info
? xstrdup ("") : NULL
);
6049 char *parent_prefix
= determine_prefix_aux (parent
);
6052 switch (parent
->tag
) {
6053 case DW_TAG_namespace
:
6057 retval
= typename_concat (parent_prefix
,
6058 namespace_name (parent
, &dummy
));
6061 case DW_TAG_class_type
:
6062 case DW_TAG_structure_type
:
6064 if (parent_prefix
!= NULL
)
6066 const char *parent_name
= dwarf2_name (parent
);
6068 if (parent_name
!= NULL
)
6069 retval
= typename_concat (parent_prefix
, dwarf2_name (parent
));
6071 /* FIXME: carlton/2003-11-10: I'm not sure what the
6072 best thing to do here is. */
6073 retval
= typename_concat (parent_prefix
,
6074 "<<anonymous class>>");
6077 retval
= class_name (parent
);
6081 retval
= parent_prefix
;
6085 if (retval
!= parent_prefix
)
6086 xfree (parent_prefix
);
6091 /* Return a newly-allocated string formed by concatenating PREFIX,
6092 "::", and SUFFIX, except that if PREFIX is NULL or the empty
6093 string, just return a copy of SUFFIX. */
6096 typename_concat (const char *prefix
, const char *suffix
)
6098 if (prefix
== NULL
|| prefix
[0] == '\0')
6099 return xstrdup (suffix
);
6102 char *retval
= xmalloc (strlen (prefix
) + 2 + strlen (suffix
) + 1);
6104 strcpy (retval
, prefix
);
6105 strcat (retval
, "::");
6106 strcat (retval
, suffix
);
6112 /* Return a newly-allocated string giving the name of the class given
6116 class_name (struct die_info
*die
)
6118 struct die_info
*child
;
6121 for (child
= die
->child
; child
!= NULL
; child
= sibling_die (child
))
6123 if (child
->tag
== DW_TAG_subprogram
)
6124 return class_name_from_physname (dwarf2_linkage_name (child
));
6127 name
= dwarf2_name (die
);
6129 return xstrdup (name
);
6131 return xstrdup ("");
6134 static struct type
*
6135 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
6137 struct objfile
*objfile
= cu
->objfile
;
6139 /* FIXME - this should not produce a new (struct type *)
6140 every time. It should cache base types. */
6144 case DW_ATE_address
:
6145 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
6147 case DW_ATE_boolean
:
6148 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
6150 case DW_ATE_complex_float
:
6153 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
6157 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
6163 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
6167 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
6174 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
6177 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
6181 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
6185 case DW_ATE_signed_char
:
6186 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
6188 case DW_ATE_unsigned
:
6192 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
6195 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
6199 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
6203 case DW_ATE_unsigned_char
:
6204 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
6207 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
6214 copy_die (struct die_info
*old_die
)
6216 struct die_info
*new_die
;
6219 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6220 memset (new_die
, 0, sizeof (struct die_info
));
6222 new_die
->tag
= old_die
->tag
;
6223 new_die
->has_children
= old_die
->has_children
;
6224 new_die
->abbrev
= old_die
->abbrev
;
6225 new_die
->offset
= old_die
->offset
;
6226 new_die
->type
= NULL
;
6228 num_attrs
= old_die
->num_attrs
;
6229 new_die
->num_attrs
= num_attrs
;
6230 new_die
->attrs
= (struct attribute
*)
6231 xmalloc (num_attrs
* sizeof (struct attribute
));
6233 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
6235 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
6236 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
6237 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
6240 new_die
->next
= NULL
;
6245 /* Return sibling of die, NULL if no sibling. */
6247 static struct die_info
*
6248 sibling_die (struct die_info
*die
)
6250 return die
->sibling
;
6253 /* Get linkage name of a die, return NULL if not found. */
6256 dwarf2_linkage_name (struct die_info
*die
)
6258 struct attribute
*attr
;
6260 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
6261 if (attr
&& DW_STRING (attr
))
6262 return DW_STRING (attr
);
6263 attr
= dwarf_attr (die
, DW_AT_name
);
6264 if (attr
&& DW_STRING (attr
))
6265 return DW_STRING (attr
);
6269 /* Get name of a die, return NULL if not found. */
6272 dwarf2_name (struct die_info
*die
)
6274 struct attribute
*attr
;
6276 attr
= dwarf_attr (die
, DW_AT_name
);
6277 if (attr
&& DW_STRING (attr
))
6278 return DW_STRING (attr
);
6282 /* Return the die that this die in an extension of, or NULL if there
6285 static struct die_info
*
6286 dwarf2_extension (struct die_info
*die
)
6288 struct attribute
*attr
;
6289 struct die_info
*extension_die
;
6292 attr
= dwarf_attr (die
, DW_AT_extension
);
6296 ref
= dwarf2_get_ref_die_offset (attr
);
6297 extension_die
= follow_die_ref (ref
);
6300 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
6303 return extension_die
;
6306 /* Convert a DIE tag into its string name. */
6309 dwarf_tag_name (unsigned tag
)
6313 case DW_TAG_padding
:
6314 return "DW_TAG_padding";
6315 case DW_TAG_array_type
:
6316 return "DW_TAG_array_type";
6317 case DW_TAG_class_type
:
6318 return "DW_TAG_class_type";
6319 case DW_TAG_entry_point
:
6320 return "DW_TAG_entry_point";
6321 case DW_TAG_enumeration_type
:
6322 return "DW_TAG_enumeration_type";
6323 case DW_TAG_formal_parameter
:
6324 return "DW_TAG_formal_parameter";
6325 case DW_TAG_imported_declaration
:
6326 return "DW_TAG_imported_declaration";
6328 return "DW_TAG_label";
6329 case DW_TAG_lexical_block
:
6330 return "DW_TAG_lexical_block";
6332 return "DW_TAG_member";
6333 case DW_TAG_pointer_type
:
6334 return "DW_TAG_pointer_type";
6335 case DW_TAG_reference_type
:
6336 return "DW_TAG_reference_type";
6337 case DW_TAG_compile_unit
:
6338 return "DW_TAG_compile_unit";
6339 case DW_TAG_string_type
:
6340 return "DW_TAG_string_type";
6341 case DW_TAG_structure_type
:
6342 return "DW_TAG_structure_type";
6343 case DW_TAG_subroutine_type
:
6344 return "DW_TAG_subroutine_type";
6345 case DW_TAG_typedef
:
6346 return "DW_TAG_typedef";
6347 case DW_TAG_union_type
:
6348 return "DW_TAG_union_type";
6349 case DW_TAG_unspecified_parameters
:
6350 return "DW_TAG_unspecified_parameters";
6351 case DW_TAG_variant
:
6352 return "DW_TAG_variant";
6353 case DW_TAG_common_block
:
6354 return "DW_TAG_common_block";
6355 case DW_TAG_common_inclusion
:
6356 return "DW_TAG_common_inclusion";
6357 case DW_TAG_inheritance
:
6358 return "DW_TAG_inheritance";
6359 case DW_TAG_inlined_subroutine
:
6360 return "DW_TAG_inlined_subroutine";
6362 return "DW_TAG_module";
6363 case DW_TAG_ptr_to_member_type
:
6364 return "DW_TAG_ptr_to_member_type";
6365 case DW_TAG_set_type
:
6366 return "DW_TAG_set_type";
6367 case DW_TAG_subrange_type
:
6368 return "DW_TAG_subrange_type";
6369 case DW_TAG_with_stmt
:
6370 return "DW_TAG_with_stmt";
6371 case DW_TAG_access_declaration
:
6372 return "DW_TAG_access_declaration";
6373 case DW_TAG_base_type
:
6374 return "DW_TAG_base_type";
6375 case DW_TAG_catch_block
:
6376 return "DW_TAG_catch_block";
6377 case DW_TAG_const_type
:
6378 return "DW_TAG_const_type";
6379 case DW_TAG_constant
:
6380 return "DW_TAG_constant";
6381 case DW_TAG_enumerator
:
6382 return "DW_TAG_enumerator";
6383 case DW_TAG_file_type
:
6384 return "DW_TAG_file_type";
6386 return "DW_TAG_friend";
6387 case DW_TAG_namelist
:
6388 return "DW_TAG_namelist";
6389 case DW_TAG_namelist_item
:
6390 return "DW_TAG_namelist_item";
6391 case DW_TAG_packed_type
:
6392 return "DW_TAG_packed_type";
6393 case DW_TAG_subprogram
:
6394 return "DW_TAG_subprogram";
6395 case DW_TAG_template_type_param
:
6396 return "DW_TAG_template_type_param";
6397 case DW_TAG_template_value_param
:
6398 return "DW_TAG_template_value_param";
6399 case DW_TAG_thrown_type
:
6400 return "DW_TAG_thrown_type";
6401 case DW_TAG_try_block
:
6402 return "DW_TAG_try_block";
6403 case DW_TAG_variant_part
:
6404 return "DW_TAG_variant_part";
6405 case DW_TAG_variable
:
6406 return "DW_TAG_variable";
6407 case DW_TAG_volatile_type
:
6408 return "DW_TAG_volatile_type";
6409 case DW_TAG_dwarf_procedure
:
6410 return "DW_TAG_dwarf_procedure";
6411 case DW_TAG_restrict_type
:
6412 return "DW_TAG_restrict_type";
6413 case DW_TAG_interface_type
:
6414 return "DW_TAG_interface_type";
6415 case DW_TAG_namespace
:
6416 return "DW_TAG_namespace";
6417 case DW_TAG_imported_module
:
6418 return "DW_TAG_imported_module";
6419 case DW_TAG_unspecified_type
:
6420 return "DW_TAG_unspecified_type";
6421 case DW_TAG_partial_unit
:
6422 return "DW_TAG_partial_unit";
6423 case DW_TAG_imported_unit
:
6424 return "DW_TAG_imported_unit";
6425 case DW_TAG_MIPS_loop
:
6426 return "DW_TAG_MIPS_loop";
6427 case DW_TAG_format_label
:
6428 return "DW_TAG_format_label";
6429 case DW_TAG_function_template
:
6430 return "DW_TAG_function_template";
6431 case DW_TAG_class_template
:
6432 return "DW_TAG_class_template";
6434 return "DW_TAG_<unknown>";
6438 /* Convert a DWARF attribute code into its string name. */
6441 dwarf_attr_name (unsigned attr
)
6446 return "DW_AT_sibling";
6447 case DW_AT_location
:
6448 return "DW_AT_location";
6450 return "DW_AT_name";
6451 case DW_AT_ordering
:
6452 return "DW_AT_ordering";
6453 case DW_AT_subscr_data
:
6454 return "DW_AT_subscr_data";
6455 case DW_AT_byte_size
:
6456 return "DW_AT_byte_size";
6457 case DW_AT_bit_offset
:
6458 return "DW_AT_bit_offset";
6459 case DW_AT_bit_size
:
6460 return "DW_AT_bit_size";
6461 case DW_AT_element_list
:
6462 return "DW_AT_element_list";
6463 case DW_AT_stmt_list
:
6464 return "DW_AT_stmt_list";
6466 return "DW_AT_low_pc";
6468 return "DW_AT_high_pc";
6469 case DW_AT_language
:
6470 return "DW_AT_language";
6472 return "DW_AT_member";
6474 return "DW_AT_discr";
6475 case DW_AT_discr_value
:
6476 return "DW_AT_discr_value";
6477 case DW_AT_visibility
:
6478 return "DW_AT_visibility";
6480 return "DW_AT_import";
6481 case DW_AT_string_length
:
6482 return "DW_AT_string_length";
6483 case DW_AT_common_reference
:
6484 return "DW_AT_common_reference";
6485 case DW_AT_comp_dir
:
6486 return "DW_AT_comp_dir";
6487 case DW_AT_const_value
:
6488 return "DW_AT_const_value";
6489 case DW_AT_containing_type
:
6490 return "DW_AT_containing_type";
6491 case DW_AT_default_value
:
6492 return "DW_AT_default_value";
6494 return "DW_AT_inline";
6495 case DW_AT_is_optional
:
6496 return "DW_AT_is_optional";
6497 case DW_AT_lower_bound
:
6498 return "DW_AT_lower_bound";
6499 case DW_AT_producer
:
6500 return "DW_AT_producer";
6501 case DW_AT_prototyped
:
6502 return "DW_AT_prototyped";
6503 case DW_AT_return_addr
:
6504 return "DW_AT_return_addr";
6505 case DW_AT_start_scope
:
6506 return "DW_AT_start_scope";
6507 case DW_AT_stride_size
:
6508 return "DW_AT_stride_size";
6509 case DW_AT_upper_bound
:
6510 return "DW_AT_upper_bound";
6511 case DW_AT_abstract_origin
:
6512 return "DW_AT_abstract_origin";
6513 case DW_AT_accessibility
:
6514 return "DW_AT_accessibility";
6515 case DW_AT_address_class
:
6516 return "DW_AT_address_class";
6517 case DW_AT_artificial
:
6518 return "DW_AT_artificial";
6519 case DW_AT_base_types
:
6520 return "DW_AT_base_types";
6521 case DW_AT_calling_convention
:
6522 return "DW_AT_calling_convention";
6524 return "DW_AT_count";
6525 case DW_AT_data_member_location
:
6526 return "DW_AT_data_member_location";
6527 case DW_AT_decl_column
:
6528 return "DW_AT_decl_column";
6529 case DW_AT_decl_file
:
6530 return "DW_AT_decl_file";
6531 case DW_AT_decl_line
:
6532 return "DW_AT_decl_line";
6533 case DW_AT_declaration
:
6534 return "DW_AT_declaration";
6535 case DW_AT_discr_list
:
6536 return "DW_AT_discr_list";
6537 case DW_AT_encoding
:
6538 return "DW_AT_encoding";
6539 case DW_AT_external
:
6540 return "DW_AT_external";
6541 case DW_AT_frame_base
:
6542 return "DW_AT_frame_base";
6544 return "DW_AT_friend";
6545 case DW_AT_identifier_case
:
6546 return "DW_AT_identifier_case";
6547 case DW_AT_macro_info
:
6548 return "DW_AT_macro_info";
6549 case DW_AT_namelist_items
:
6550 return "DW_AT_namelist_items";
6551 case DW_AT_priority
:
6552 return "DW_AT_priority";
6554 return "DW_AT_segment";
6555 case DW_AT_specification
:
6556 return "DW_AT_specification";
6557 case DW_AT_static_link
:
6558 return "DW_AT_static_link";
6560 return "DW_AT_type";
6561 case DW_AT_use_location
:
6562 return "DW_AT_use_location";
6563 case DW_AT_variable_parameter
:
6564 return "DW_AT_variable_parameter";
6565 case DW_AT_virtuality
:
6566 return "DW_AT_virtuality";
6567 case DW_AT_vtable_elem_location
:
6568 return "DW_AT_vtable_elem_location";
6569 case DW_AT_allocated
:
6570 return "DW_AT_allocated";
6571 case DW_AT_associated
:
6572 return "DW_AT_associated";
6573 case DW_AT_data_location
:
6574 return "DW_AT_data_location";
6576 return "DW_AT_stride";
6577 case DW_AT_entry_pc
:
6578 return "DW_AT_entry_pc";
6579 case DW_AT_use_UTF8
:
6580 return "DW_AT_use_UTF8";
6581 case DW_AT_extension
:
6582 return "DW_AT_extension";
6584 return "DW_AT_ranges";
6585 case DW_AT_trampoline
:
6586 return "DW_AT_trampoline";
6587 case DW_AT_call_column
:
6588 return "DW_AT_call_column";
6589 case DW_AT_call_file
:
6590 return "DW_AT_call_file";
6591 case DW_AT_call_line
:
6592 return "DW_AT_call_line";
6594 case DW_AT_MIPS_fde
:
6595 return "DW_AT_MIPS_fde";
6596 case DW_AT_MIPS_loop_begin
:
6597 return "DW_AT_MIPS_loop_begin";
6598 case DW_AT_MIPS_tail_loop_begin
:
6599 return "DW_AT_MIPS_tail_loop_begin";
6600 case DW_AT_MIPS_epilog_begin
:
6601 return "DW_AT_MIPS_epilog_begin";
6602 case DW_AT_MIPS_loop_unroll_factor
:
6603 return "DW_AT_MIPS_loop_unroll_factor";
6604 case DW_AT_MIPS_software_pipeline_depth
:
6605 return "DW_AT_MIPS_software_pipeline_depth";
6607 case DW_AT_MIPS_linkage_name
:
6608 return "DW_AT_MIPS_linkage_name";
6610 case DW_AT_sf_names
:
6611 return "DW_AT_sf_names";
6612 case DW_AT_src_info
:
6613 return "DW_AT_src_info";
6614 case DW_AT_mac_info
:
6615 return "DW_AT_mac_info";
6616 case DW_AT_src_coords
:
6617 return "DW_AT_src_coords";
6618 case DW_AT_body_begin
:
6619 return "DW_AT_body_begin";
6620 case DW_AT_body_end
:
6621 return "DW_AT_body_end";
6622 case DW_AT_GNU_vector
:
6623 return "DW_AT_GNU_vector";
6625 return "DW_AT_<unknown>";
6629 /* Convert a DWARF value form code into its string name. */
6632 dwarf_form_name (unsigned form
)
6637 return "DW_FORM_addr";
6638 case DW_FORM_block2
:
6639 return "DW_FORM_block2";
6640 case DW_FORM_block4
:
6641 return "DW_FORM_block4";
6643 return "DW_FORM_data2";
6645 return "DW_FORM_data4";
6647 return "DW_FORM_data8";
6648 case DW_FORM_string
:
6649 return "DW_FORM_string";
6651 return "DW_FORM_block";
6652 case DW_FORM_block1
:
6653 return "DW_FORM_block1";
6655 return "DW_FORM_data1";
6657 return "DW_FORM_flag";
6659 return "DW_FORM_sdata";
6661 return "DW_FORM_strp";
6663 return "DW_FORM_udata";
6664 case DW_FORM_ref_addr
:
6665 return "DW_FORM_ref_addr";
6667 return "DW_FORM_ref1";
6669 return "DW_FORM_ref2";
6671 return "DW_FORM_ref4";
6673 return "DW_FORM_ref8";
6674 case DW_FORM_ref_udata
:
6675 return "DW_FORM_ref_udata";
6676 case DW_FORM_indirect
:
6677 return "DW_FORM_indirect";
6679 return "DW_FORM_<unknown>";
6683 /* Convert a DWARF stack opcode into its string name. */
6686 dwarf_stack_op_name (unsigned op
)
6691 return "DW_OP_addr";
6693 return "DW_OP_deref";
6695 return "DW_OP_const1u";
6697 return "DW_OP_const1s";
6699 return "DW_OP_const2u";
6701 return "DW_OP_const2s";
6703 return "DW_OP_const4u";
6705 return "DW_OP_const4s";
6707 return "DW_OP_const8u";
6709 return "DW_OP_const8s";
6711 return "DW_OP_constu";
6713 return "DW_OP_consts";
6717 return "DW_OP_drop";
6719 return "DW_OP_over";
6721 return "DW_OP_pick";
6723 return "DW_OP_swap";
6727 return "DW_OP_xderef";
6735 return "DW_OP_minus";
6747 return "DW_OP_plus";
6748 case DW_OP_plus_uconst
:
6749 return "DW_OP_plus_uconst";
6755 return "DW_OP_shra";
6773 return "DW_OP_skip";
6775 return "DW_OP_lit0";
6777 return "DW_OP_lit1";
6779 return "DW_OP_lit2";
6781 return "DW_OP_lit3";
6783 return "DW_OP_lit4";
6785 return "DW_OP_lit5";
6787 return "DW_OP_lit6";
6789 return "DW_OP_lit7";
6791 return "DW_OP_lit8";
6793 return "DW_OP_lit9";
6795 return "DW_OP_lit10";
6797 return "DW_OP_lit11";
6799 return "DW_OP_lit12";
6801 return "DW_OP_lit13";
6803 return "DW_OP_lit14";
6805 return "DW_OP_lit15";
6807 return "DW_OP_lit16";
6809 return "DW_OP_lit17";
6811 return "DW_OP_lit18";
6813 return "DW_OP_lit19";
6815 return "DW_OP_lit20";
6817 return "DW_OP_lit21";
6819 return "DW_OP_lit22";
6821 return "DW_OP_lit23";
6823 return "DW_OP_lit24";
6825 return "DW_OP_lit25";
6827 return "DW_OP_lit26";
6829 return "DW_OP_lit27";
6831 return "DW_OP_lit28";
6833 return "DW_OP_lit29";
6835 return "DW_OP_lit30";
6837 return "DW_OP_lit31";
6839 return "DW_OP_reg0";
6841 return "DW_OP_reg1";
6843 return "DW_OP_reg2";
6845 return "DW_OP_reg3";
6847 return "DW_OP_reg4";
6849 return "DW_OP_reg5";
6851 return "DW_OP_reg6";
6853 return "DW_OP_reg7";
6855 return "DW_OP_reg8";
6857 return "DW_OP_reg9";
6859 return "DW_OP_reg10";
6861 return "DW_OP_reg11";
6863 return "DW_OP_reg12";
6865 return "DW_OP_reg13";
6867 return "DW_OP_reg14";
6869 return "DW_OP_reg15";
6871 return "DW_OP_reg16";
6873 return "DW_OP_reg17";
6875 return "DW_OP_reg18";
6877 return "DW_OP_reg19";
6879 return "DW_OP_reg20";
6881 return "DW_OP_reg21";
6883 return "DW_OP_reg22";
6885 return "DW_OP_reg23";
6887 return "DW_OP_reg24";
6889 return "DW_OP_reg25";
6891 return "DW_OP_reg26";
6893 return "DW_OP_reg27";
6895 return "DW_OP_reg28";
6897 return "DW_OP_reg29";
6899 return "DW_OP_reg30";
6901 return "DW_OP_reg31";
6903 return "DW_OP_breg0";
6905 return "DW_OP_breg1";
6907 return "DW_OP_breg2";
6909 return "DW_OP_breg3";
6911 return "DW_OP_breg4";
6913 return "DW_OP_breg5";
6915 return "DW_OP_breg6";
6917 return "DW_OP_breg7";
6919 return "DW_OP_breg8";
6921 return "DW_OP_breg9";
6923 return "DW_OP_breg10";
6925 return "DW_OP_breg11";
6927 return "DW_OP_breg12";
6929 return "DW_OP_breg13";
6931 return "DW_OP_breg14";
6933 return "DW_OP_breg15";
6935 return "DW_OP_breg16";
6937 return "DW_OP_breg17";
6939 return "DW_OP_breg18";
6941 return "DW_OP_breg19";
6943 return "DW_OP_breg20";
6945 return "DW_OP_breg21";
6947 return "DW_OP_breg22";
6949 return "DW_OP_breg23";
6951 return "DW_OP_breg24";
6953 return "DW_OP_breg25";
6955 return "DW_OP_breg26";
6957 return "DW_OP_breg27";
6959 return "DW_OP_breg28";
6961 return "DW_OP_breg29";
6963 return "DW_OP_breg30";
6965 return "DW_OP_breg31";
6967 return "DW_OP_regx";
6969 return "DW_OP_fbreg";
6971 return "DW_OP_bregx";
6973 return "DW_OP_piece";
6974 case DW_OP_deref_size
:
6975 return "DW_OP_deref_size";
6976 case DW_OP_xderef_size
:
6977 return "DW_OP_xderef_size";
6980 /* DWARF 3 extensions. */
6981 case DW_OP_push_object_address
:
6982 return "DW_OP_push_object_address";
6984 return "DW_OP_call2";
6986 return "DW_OP_call4";
6987 case DW_OP_call_ref
:
6988 return "DW_OP_call_ref";
6989 /* GNU extensions. */
6990 case DW_OP_GNU_push_tls_address
:
6991 return "DW_OP_GNU_push_tls_address";
6993 return "OP_<unknown>";
6998 dwarf_bool_name (unsigned mybool
)
7006 /* Convert a DWARF type code into its string name. */
7009 dwarf_type_encoding_name (unsigned enc
)
7013 case DW_ATE_address
:
7014 return "DW_ATE_address";
7015 case DW_ATE_boolean
:
7016 return "DW_ATE_boolean";
7017 case DW_ATE_complex_float
:
7018 return "DW_ATE_complex_float";
7020 return "DW_ATE_float";
7022 return "DW_ATE_signed";
7023 case DW_ATE_signed_char
:
7024 return "DW_ATE_signed_char";
7025 case DW_ATE_unsigned
:
7026 return "DW_ATE_unsigned";
7027 case DW_ATE_unsigned_char
:
7028 return "DW_ATE_unsigned_char";
7029 case DW_ATE_imaginary_float
:
7030 return "DW_ATE_imaginary_float";
7032 return "DW_ATE_<unknown>";
7036 /* Convert a DWARF call frame info operation to its string name. */
7040 dwarf_cfi_name (unsigned cfi_opc
)
7044 case DW_CFA_advance_loc
:
7045 return "DW_CFA_advance_loc";
7047 return "DW_CFA_offset";
7048 case DW_CFA_restore
:
7049 return "DW_CFA_restore";
7051 return "DW_CFA_nop";
7052 case DW_CFA_set_loc
:
7053 return "DW_CFA_set_loc";
7054 case DW_CFA_advance_loc1
:
7055 return "DW_CFA_advance_loc1";
7056 case DW_CFA_advance_loc2
:
7057 return "DW_CFA_advance_loc2";
7058 case DW_CFA_advance_loc4
:
7059 return "DW_CFA_advance_loc4";
7060 case DW_CFA_offset_extended
:
7061 return "DW_CFA_offset_extended";
7062 case DW_CFA_restore_extended
:
7063 return "DW_CFA_restore_extended";
7064 case DW_CFA_undefined
:
7065 return "DW_CFA_undefined";
7066 case DW_CFA_same_value
:
7067 return "DW_CFA_same_value";
7068 case DW_CFA_register
:
7069 return "DW_CFA_register";
7070 case DW_CFA_remember_state
:
7071 return "DW_CFA_remember_state";
7072 case DW_CFA_restore_state
:
7073 return "DW_CFA_restore_state";
7074 case DW_CFA_def_cfa
:
7075 return "DW_CFA_def_cfa";
7076 case DW_CFA_def_cfa_register
:
7077 return "DW_CFA_def_cfa_register";
7078 case DW_CFA_def_cfa_offset
:
7079 return "DW_CFA_def_cfa_offset";
7082 case DW_CFA_def_cfa_expression
:
7083 return "DW_CFA_def_cfa_expression";
7084 case DW_CFA_expression
:
7085 return "DW_CFA_expression";
7086 case DW_CFA_offset_extended_sf
:
7087 return "DW_CFA_offset_extended_sf";
7088 case DW_CFA_def_cfa_sf
:
7089 return "DW_CFA_def_cfa_sf";
7090 case DW_CFA_def_cfa_offset_sf
:
7091 return "DW_CFA_def_cfa_offset_sf";
7093 /* SGI/MIPS specific */
7094 case DW_CFA_MIPS_advance_loc8
:
7095 return "DW_CFA_MIPS_advance_loc8";
7097 /* GNU extensions */
7098 case DW_CFA_GNU_window_save
:
7099 return "DW_CFA_GNU_window_save";
7100 case DW_CFA_GNU_args_size
:
7101 return "DW_CFA_GNU_args_size";
7102 case DW_CFA_GNU_negative_offset_extended
:
7103 return "DW_CFA_GNU_negative_offset_extended";
7106 return "DW_CFA_<unknown>";
7112 dump_die (struct die_info
*die
)
7116 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
7117 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
7118 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
7119 dwarf_bool_name (die
->child
!= NULL
));
7121 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
7122 for (i
= 0; i
< die
->num_attrs
; ++i
)
7124 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
7125 dwarf_attr_name (die
->attrs
[i
].name
),
7126 dwarf_form_name (die
->attrs
[i
].form
));
7127 switch (die
->attrs
[i
].form
)
7129 case DW_FORM_ref_addr
:
7131 fprintf_unfiltered (gdb_stderr
, "address: ");
7132 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
7134 case DW_FORM_block2
:
7135 case DW_FORM_block4
:
7137 case DW_FORM_block1
:
7138 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
7149 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
7151 case DW_FORM_string
:
7153 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
7154 DW_STRING (&die
->attrs
[i
])
7155 ? DW_STRING (&die
->attrs
[i
]) : "");
7158 if (DW_UNSND (&die
->attrs
[i
]))
7159 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
7161 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
7163 case DW_FORM_indirect
:
7164 /* the reader will have reduced the indirect form to
7165 the "base form" so this form should not occur */
7166 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
7169 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
7170 die
->attrs
[i
].form
);
7172 fprintf_unfiltered (gdb_stderr
, "\n");
7177 dump_die_list (struct die_info
*die
)
7182 if (die
->child
!= NULL
)
7183 dump_die_list (die
->child
);
7184 if (die
->sibling
!= NULL
)
7185 dump_die_list (die
->sibling
);
7190 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
7193 struct die_info
*old
;
7195 h
= (offset
% REF_HASH_SIZE
);
7196 old
= die_ref_table
[h
];
7197 die
->next_ref
= old
;
7198 die_ref_table
[h
] = die
;
7203 dwarf2_empty_hash_tables (void)
7205 memset (die_ref_table
, 0, sizeof (die_ref_table
));
7209 dwarf2_get_ref_die_offset (struct attribute
*attr
)
7211 unsigned int result
= 0;
7215 case DW_FORM_ref_addr
:
7216 result
= DW_ADDR (attr
);
7222 case DW_FORM_ref_udata
:
7223 result
= cu_header_offset
+ DW_UNSND (attr
);
7226 complaint (&symfile_complaints
,
7227 "unsupported die ref attribute form: '%s'",
7228 dwarf_form_name (attr
->form
));
7233 /* Return the constant value held by the given attribute. Return -1
7234 if the value held by the attribute is not constant. */
7237 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
7239 if (attr
->form
== DW_FORM_sdata
)
7240 return DW_SND (attr
);
7241 else if (attr
->form
== DW_FORM_udata
7242 || attr
->form
== DW_FORM_data1
7243 || attr
->form
== DW_FORM_data2
7244 || attr
->form
== DW_FORM_data4
7245 || attr
->form
== DW_FORM_data8
)
7246 return DW_UNSND (attr
);
7249 complaint (&symfile_complaints
, "Attribute value is not a constant (%s)",
7250 dwarf_form_name (attr
->form
));
7251 return default_value
;
7255 static struct die_info
*
7256 follow_die_ref (unsigned int offset
)
7258 struct die_info
*die
;
7261 h
= (offset
% REF_HASH_SIZE
);
7262 die
= die_ref_table
[h
];
7265 if (die
->offset
== offset
)
7269 die
= die
->next_ref
;
7274 static struct type
*
7275 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
7277 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
7279 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
7280 typeid, objfile
->name
);
7283 /* Look for this particular type in the fundamental type vector. If
7284 one is not found, create and install one appropriate for the
7285 current language and the current target machine. */
7287 if (ftypes
[typeid] == NULL
)
7289 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
7292 return (ftypes
[typeid]);
7295 /* Decode simple location descriptions.
7296 Given a pointer to a dwarf block that defines a location, compute
7297 the location and return the value.
7299 NOTE drow/2003-11-18: This function is called in two situations
7300 now: for the address of static or global variables (partial symbols
7301 only) and for offsets into structures which are expected to be
7302 (more or less) constant. The partial symbol case should go away,
7303 and only the constant case should remain. That will let this
7304 function complain more accurately. A few special modes are allowed
7305 without complaint for global variables (for instance, global
7306 register values and thread-local values).
7308 A location description containing no operations indicates that the
7309 object is optimized out. The return value is 0 for that case.
7310 FIXME drow/2003-11-16: No callers check for this case any more; soon all
7311 callers will only want a very basic result and this can become a
7314 When the result is a register number, the global isreg flag is set,
7315 otherwise it is cleared.
7317 Note that stack[0] is unused except as a default error return.
7318 Note that stack overflow is not yet handled. */
7321 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
7323 struct objfile
*objfile
= cu
->objfile
;
7324 struct comp_unit_head
*cu_header
= &cu
->header
;
7326 int size
= blk
->size
;
7327 char *data
= blk
->data
;
7328 CORE_ADDR stack
[64];
7330 unsigned int bytes_read
, unsnd
;
7375 stack
[++stacki
] = op
- DW_OP_lit0
;
7411 stack
[++stacki
] = op
- DW_OP_reg0
;
7413 dwarf2_complex_location_expr_complaint ();
7418 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7420 stack
[++stacki
] = unsnd
;
7422 dwarf2_complex_location_expr_complaint ();
7426 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
7432 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
7437 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
7442 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
7447 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
7452 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
7457 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
7462 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
7468 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7473 stack
[stacki
+ 1] = stack
[stacki
];
7478 stack
[stacki
- 1] += stack
[stacki
];
7482 case DW_OP_plus_uconst
:
7483 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7488 stack
[stacki
- 1] -= stack
[stacki
];
7493 /* If we're not the last op, then we definitely can't encode
7494 this using GDB's address_class enum. This is valid for partial
7495 global symbols, although the variable's address will be bogus
7498 dwarf2_complex_location_expr_complaint ();
7501 case DW_OP_GNU_push_tls_address
:
7502 /* The top of the stack has the offset from the beginning
7503 of the thread control block at which the variable is located. */
7504 /* Nothing should follow this operator, so the top of stack would
7506 /* This is valid for partial global symbols, but the variable's
7507 address will be bogus in the psymtab. */
7509 dwarf2_complex_location_expr_complaint ();
7513 complaint (&symfile_complaints
, "unsupported stack op: '%s'",
7514 dwarf_stack_op_name (op
));
7515 return (stack
[stacki
]);
7518 return (stack
[stacki
]);
7521 /* memory allocation interface */
7524 dwarf2_free_tmp_obstack (void *ignore
)
7526 obstack_free (&dwarf2_tmp_obstack
, NULL
);
7529 static struct dwarf_block
*
7530 dwarf_alloc_block (void)
7532 struct dwarf_block
*blk
;
7534 blk
= (struct dwarf_block
*)
7535 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
7539 static struct abbrev_info
*
7540 dwarf_alloc_abbrev (void)
7542 struct abbrev_info
*abbrev
;
7544 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
7545 memset (abbrev
, 0, sizeof (struct abbrev_info
));
7549 static struct die_info
*
7550 dwarf_alloc_die (void)
7552 struct die_info
*die
;
7554 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7555 memset (die
, 0, sizeof (struct die_info
));
7560 /* Macro support. */
7563 /* Return the full name of file number I in *LH's file name table.
7564 Use COMP_DIR as the name of the current directory of the
7565 compilation. The result is allocated using xmalloc; the caller is
7566 responsible for freeing it. */
7568 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
7570 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
7572 if (IS_ABSOLUTE_PATH (fe
->name
))
7573 return xstrdup (fe
->name
);
7581 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7587 dir_len
= strlen (dir
);
7588 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
7589 strcpy (full_name
, dir
);
7590 full_name
[dir_len
] = '/';
7591 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
7595 return xstrdup (fe
->name
);
7600 static struct macro_source_file
*
7601 macro_start_file (int file
, int line
,
7602 struct macro_source_file
*current_file
,
7603 const char *comp_dir
,
7604 struct line_header
*lh
, struct objfile
*objfile
)
7606 /* The full name of this source file. */
7607 char *full_name
= file_full_name (file
, lh
, comp_dir
);
7609 /* We don't create a macro table for this compilation unit
7610 at all until we actually get a filename. */
7611 if (! pending_macros
)
7612 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
7613 objfile
->macro_cache
);
7616 /* If we have no current file, then this must be the start_file
7617 directive for the compilation unit's main source file. */
7618 current_file
= macro_set_main (pending_macros
, full_name
);
7620 current_file
= macro_include (current_file
, line
, full_name
);
7624 return current_file
;
7628 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7629 followed by a null byte. */
7631 copy_string (const char *buf
, int len
)
7633 char *s
= xmalloc (len
+ 1);
7634 memcpy (s
, buf
, len
);
7642 consume_improper_spaces (const char *p
, const char *body
)
7646 complaint (&symfile_complaints
,
7647 "macro definition contains spaces in formal argument list:\n`%s'",
7659 parse_macro_definition (struct macro_source_file
*file
, int line
,
7664 /* The body string takes one of two forms. For object-like macro
7665 definitions, it should be:
7667 <macro name> " " <definition>
7669 For function-like macro definitions, it should be:
7671 <macro name> "() " <definition>
7673 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7675 Spaces may appear only where explicitly indicated, and in the
7678 The Dwarf 2 spec says that an object-like macro's name is always
7679 followed by a space, but versions of GCC around March 2002 omit
7680 the space when the macro's definition is the empty string.
7682 The Dwarf 2 spec says that there should be no spaces between the
7683 formal arguments in a function-like macro's formal argument list,
7684 but versions of GCC around March 2002 include spaces after the
7688 /* Find the extent of the macro name. The macro name is terminated
7689 by either a space or null character (for an object-like macro) or
7690 an opening paren (for a function-like macro). */
7691 for (p
= body
; *p
; p
++)
7692 if (*p
== ' ' || *p
== '(')
7695 if (*p
== ' ' || *p
== '\0')
7697 /* It's an object-like macro. */
7698 int name_len
= p
- body
;
7699 char *name
= copy_string (body
, name_len
);
7700 const char *replacement
;
7703 replacement
= body
+ name_len
+ 1;
7706 dwarf2_macro_malformed_definition_complaint (body
);
7707 replacement
= body
+ name_len
;
7710 macro_define_object (file
, line
, name
, replacement
);
7716 /* It's a function-like macro. */
7717 char *name
= copy_string (body
, p
- body
);
7720 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
7724 p
= consume_improper_spaces (p
, body
);
7726 /* Parse the formal argument list. */
7727 while (*p
&& *p
!= ')')
7729 /* Find the extent of the current argument name. */
7730 const char *arg_start
= p
;
7732 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
7735 if (! *p
|| p
== arg_start
)
7736 dwarf2_macro_malformed_definition_complaint (body
);
7739 /* Make sure argv has room for the new argument. */
7740 if (argc
>= argv_size
)
7743 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
7746 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
7749 p
= consume_improper_spaces (p
, body
);
7751 /* Consume the comma, if present. */
7756 p
= consume_improper_spaces (p
, body
);
7765 /* Perfectly formed definition, no complaints. */
7766 macro_define_function (file
, line
, name
,
7767 argc
, (const char **) argv
,
7769 else if (*p
== '\0')
7771 /* Complain, but do define it. */
7772 dwarf2_macro_malformed_definition_complaint (body
);
7773 macro_define_function (file
, line
, name
,
7774 argc
, (const char **) argv
,
7778 /* Just complain. */
7779 dwarf2_macro_malformed_definition_complaint (body
);
7782 /* Just complain. */
7783 dwarf2_macro_malformed_definition_complaint (body
);
7789 for (i
= 0; i
< argc
; i
++)
7795 dwarf2_macro_malformed_definition_complaint (body
);
7800 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7801 char *comp_dir
, bfd
*abfd
,
7802 struct dwarf2_cu
*cu
)
7804 char *mac_ptr
, *mac_end
;
7805 struct macro_source_file
*current_file
= 0;
7807 if (dwarf_macinfo_buffer
== NULL
)
7809 complaint (&symfile_complaints
, "missing .debug_macinfo section");
7813 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7814 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7818 enum dwarf_macinfo_record_type macinfo_type
;
7820 /* Do we at least have room for a macinfo type byte? */
7821 if (mac_ptr
>= mac_end
)
7823 dwarf2_macros_too_long_complaint ();
7827 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7830 switch (macinfo_type
)
7832 /* A zero macinfo type indicates the end of the macro
7837 case DW_MACINFO_define
:
7838 case DW_MACINFO_undef
:
7844 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7845 mac_ptr
+= bytes_read
;
7846 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7847 mac_ptr
+= bytes_read
;
7850 complaint (&symfile_complaints
,
7851 "debug info gives macro %s outside of any file: %s",
7853 DW_MACINFO_define
? "definition" : macinfo_type
==
7854 DW_MACINFO_undef
? "undefinition" :
7855 "something-or-other", body
);
7858 if (macinfo_type
== DW_MACINFO_define
)
7859 parse_macro_definition (current_file
, line
, body
);
7860 else if (macinfo_type
== DW_MACINFO_undef
)
7861 macro_undef (current_file
, line
, body
);
7866 case DW_MACINFO_start_file
:
7871 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7872 mac_ptr
+= bytes_read
;
7873 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7874 mac_ptr
+= bytes_read
;
7876 current_file
= macro_start_file (file
, line
,
7877 current_file
, comp_dir
,
7882 case DW_MACINFO_end_file
:
7884 complaint (&symfile_complaints
,
7885 "macro debug info has an unmatched `close_file' directive");
7888 current_file
= current_file
->included_by
;
7891 enum dwarf_macinfo_record_type next_type
;
7893 /* GCC circa March 2002 doesn't produce the zero
7894 type byte marking the end of the compilation
7895 unit. Complain if it's not there, but exit no
7898 /* Do we at least have room for a macinfo type byte? */
7899 if (mac_ptr
>= mac_end
)
7901 dwarf2_macros_too_long_complaint ();
7905 /* We don't increment mac_ptr here, so this is just
7907 next_type
= read_1_byte (abfd
, mac_ptr
);
7909 complaint (&symfile_complaints
,
7910 "no terminating 0-type entry for macros in `.debug_macinfo' section");
7917 case DW_MACINFO_vendor_ext
:
7923 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7924 mac_ptr
+= bytes_read
;
7925 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7926 mac_ptr
+= bytes_read
;
7928 /* We don't recognize any vendor extensions. */
7935 /* Check if the attribute's form is a DW_FORM_block*
7936 if so return true else false. */
7938 attr_form_is_block (struct attribute
*attr
)
7940 return (attr
== NULL
? 0 :
7941 attr
->form
== DW_FORM_block1
7942 || attr
->form
== DW_FORM_block2
7943 || attr
->form
== DW_FORM_block4
7944 || attr
->form
== DW_FORM_block
);
7948 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
7949 struct dwarf2_cu
*cu
)
7951 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
7953 struct dwarf2_loclist_baton
*baton
;
7955 baton
= obstack_alloc (&cu
->objfile
->symbol_obstack
,
7956 sizeof (struct dwarf2_loclist_baton
));
7957 baton
->objfile
= cu
->objfile
;
7959 /* We don't know how long the location list is, but make sure we
7960 don't run off the edge of the section. */
7961 baton
->size
= dwarf_loc_size
- DW_UNSND (attr
);
7962 baton
->data
= dwarf_loc_buffer
+ DW_UNSND (attr
);
7963 baton
->base_address
= cu
->header
.base_address
;
7964 if (cu
->header
.base_known
== 0)
7965 complaint (&symfile_complaints
,
7966 "Location list used without specifying the CU base address.");
7968 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_loclist_funcs
;
7969 SYMBOL_LOCATION_BATON (sym
) = baton
;
7973 struct dwarf2_locexpr_baton
*baton
;
7975 baton
= obstack_alloc (&cu
->objfile
->symbol_obstack
,
7976 sizeof (struct dwarf2_locexpr_baton
));
7977 baton
->objfile
= cu
->objfile
;
7979 if (attr_form_is_block (attr
))
7981 /* Note that we're just copying the block's data pointer
7982 here, not the actual data. We're still pointing into the
7983 dwarf_info_buffer for SYM's objfile; right now we never
7984 release that buffer, but when we do clean up properly
7985 this may need to change. */
7986 baton
->size
= DW_BLOCK (attr
)->size
;
7987 baton
->data
= DW_BLOCK (attr
)->data
;
7991 dwarf2_invalid_attrib_class_complaint ("location description",
7992 SYMBOL_NATURAL_NAME (sym
));
7997 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_locexpr_funcs
;
7998 SYMBOL_LOCATION_BATON (sym
) = baton
;