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_non_const_array_bound_ignored_complaint (const char *arg1
)
597 complaint (&symfile_complaints
, "non-constant array bounds form '%s' ignored",
602 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
604 complaint (&symfile_complaints
,
605 "statement list doesn't fit in .debug_line section");
609 dwarf2_complex_location_expr_complaint (void)
611 complaint (&symfile_complaints
, "location expression too complex");
615 dwarf2_unsupported_at_frame_base_complaint (const char *arg1
)
617 complaint (&symfile_complaints
,
618 "unsupported DW_AT_frame_base for function '%s'", arg1
);
622 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
625 complaint (&symfile_complaints
,
626 "const value length mismatch for '%s', got %d, expected %d", arg1
,
631 dwarf2_macros_too_long_complaint (void)
633 complaint (&symfile_complaints
,
634 "macro info runs off end of `.debug_macinfo' section");
638 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
640 complaint (&symfile_complaints
,
641 "macro debug info contains a malformed macro definition:\n`%s'",
646 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
648 complaint (&symfile_complaints
,
649 "invalid attribute class or form for '%s' in '%s'", arg1
, arg2
);
652 /* local function prototypes */
654 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
657 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
660 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
662 static char *scan_partial_symbols (char *, CORE_ADDR
*, CORE_ADDR
*,
664 const char *namespace);
666 static void add_partial_symbol (struct partial_die_info
*, struct dwarf2_cu
*,
667 const char *namespace);
669 static int pdi_needs_namespace (enum dwarf_tag tag
, const char *namespace);
671 static char *add_partial_namespace (struct partial_die_info
*pdi
,
673 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
674 struct dwarf2_cu
*cu
,
675 const char *namespace);
677 static char *add_partial_structure (struct partial_die_info
*struct_pdi
,
679 struct dwarf2_cu
*cu
,
680 const char *namespace);
682 static char *add_partial_enumeration (struct partial_die_info
*enum_pdi
,
684 struct dwarf2_cu
*cu
,
685 const char *namespace);
687 static char *locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
690 struct dwarf2_cu
*cu
);
692 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
694 static void psymtab_to_symtab_1 (struct partial_symtab
*);
696 char *dwarf2_read_section (struct objfile
*, asection
*);
698 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
700 static void dwarf2_empty_abbrev_table (void *);
702 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
705 static char *read_partial_die (struct partial_die_info
*,
706 bfd
*, char *, struct dwarf2_cu
*);
708 static char *read_full_die (struct die_info
**, bfd
*, char *,
709 struct dwarf2_cu
*, int *);
711 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
712 bfd
*, char *, struct dwarf2_cu
*);
714 static char *read_attribute_value (struct attribute
*, unsigned,
715 bfd
*, char *, struct dwarf2_cu
*);
717 static unsigned int read_1_byte (bfd
*, char *);
719 static int read_1_signed_byte (bfd
*, char *);
721 static unsigned int read_2_bytes (bfd
*, char *);
723 static unsigned int read_4_bytes (bfd
*, char *);
725 static unsigned long read_8_bytes (bfd
*, char *);
727 static CORE_ADDR
read_address (bfd
*, char *ptr
, struct dwarf2_cu
*,
730 static LONGEST
read_initial_length (bfd
*, char *,
731 struct comp_unit_head
*, int *bytes_read
);
733 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
736 static char *read_n_bytes (bfd
*, char *, unsigned int);
738 static char *read_string (bfd
*, char *, unsigned int *);
740 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
743 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
745 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
747 static void set_cu_language (unsigned int);
749 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
751 static int die_is_declaration (struct die_info
*);
753 static struct die_info
*die_specification (struct die_info
*die
);
755 static void free_line_header (struct line_header
*lh
);
757 static struct line_header
*(dwarf_decode_line_header
758 (unsigned int offset
,
759 bfd
*abfd
, struct dwarf2_cu
*cu
));
761 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
764 static void dwarf2_start_subfile (char *, char *);
766 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
769 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
772 static void dwarf2_const_value_data (struct attribute
*attr
,
776 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
778 static struct type
*die_containing_type (struct die_info
*,
782 static struct type
*type_at_offset (unsigned int, struct objfile
*);
785 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
787 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
789 static char *determine_prefix (struct die_info
*die
);
791 static char *typename_concat (const char *prefix
, const char *suffix
);
793 static char *class_name (struct die_info
*die
);
795 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
797 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
799 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
801 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
803 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
805 static int dwarf2_get_pc_bounds (struct die_info
*,
806 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
808 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
811 static void dwarf2_attach_fields_to_type (struct field_info
*,
812 struct type
*, struct dwarf2_cu
*);
814 static void dwarf2_add_member_fn (struct field_info
*,
815 struct die_info
*, struct type
*,
818 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
819 struct type
*, struct dwarf2_cu
*);
821 static void read_structure_scope (struct die_info
*, struct dwarf2_cu
*);
823 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
825 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
827 static const char *namespace_name (struct die_info
*die
,
830 static void read_enumeration (struct die_info
*, struct dwarf2_cu
*);
832 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
834 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
836 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
838 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
840 static void read_tag_ptr_to_member_type (struct die_info
*,
843 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
845 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
847 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
849 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
851 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
853 static struct die_info
*read_comp_unit (char *, bfd
*, struct dwarf2_cu
*);
855 static struct die_info
*read_die_and_children (char *info_ptr
, bfd
*abfd
,
858 struct die_info
*parent
);
860 static struct die_info
*read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
863 struct die_info
*parent
);
865 static void free_die_list (struct die_info
*);
867 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
869 static void process_die (struct die_info
*, struct dwarf2_cu
*);
871 static char *dwarf2_linkage_name (struct die_info
*);
873 static char *dwarf2_name (struct die_info
*die
);
875 static struct die_info
*dwarf2_extension (struct die_info
*die
);
877 static char *dwarf_tag_name (unsigned int);
879 static char *dwarf_attr_name (unsigned int);
881 static char *dwarf_form_name (unsigned int);
883 static char *dwarf_stack_op_name (unsigned int);
885 static char *dwarf_bool_name (unsigned int);
887 static char *dwarf_type_encoding_name (unsigned int);
890 static char *dwarf_cfi_name (unsigned int);
892 struct die_info
*copy_die (struct die_info
*);
895 static struct die_info
*sibling_die (struct die_info
*);
897 static void dump_die (struct die_info
*);
899 static void dump_die_list (struct die_info
*);
901 static void store_in_ref_table (unsigned int, struct die_info
*);
903 static void dwarf2_empty_hash_tables (void);
905 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
907 static struct die_info
*follow_die_ref (unsigned int);
909 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
911 /* memory allocation interface */
913 static void dwarf2_free_tmp_obstack (void *);
915 static struct dwarf_block
*dwarf_alloc_block (void);
917 static struct abbrev_info
*dwarf_alloc_abbrev (void);
919 static struct die_info
*dwarf_alloc_die (void);
921 static void initialize_cu_func_list (void);
923 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
925 static void dwarf_decode_macros (struct line_header
*, unsigned int,
926 char *, bfd
*, struct dwarf2_cu
*);
928 static int attr_form_is_block (struct attribute
*);
931 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
932 struct dwarf2_cu
*cu
);
934 /* Try to locate the sections we need for DWARF 2 debugging
935 information and return true if we have enough to do something. */
938 dwarf2_has_info (bfd
*abfd
)
940 dwarf_info_section
= 0;
941 dwarf_abbrev_section
= 0;
942 dwarf_line_section
= 0;
943 dwarf_str_section
= 0;
944 dwarf_macinfo_section
= 0;
945 dwarf_frame_section
= 0;
946 dwarf_eh_frame_section
= 0;
947 dwarf_ranges_section
= 0;
948 dwarf_loc_section
= 0;
950 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
951 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
954 /* This function is mapped across the sections and remembers the
955 offset and size of each of the debugging sections we are interested
959 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
961 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
963 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
964 dwarf_info_section
= sectp
;
966 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
968 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
969 dwarf_abbrev_section
= sectp
;
971 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
973 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
974 dwarf_line_section
= sectp
;
976 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
978 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
979 dwarf_pubnames_section
= sectp
;
981 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
983 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
984 dwarf_aranges_section
= sectp
;
986 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
988 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
989 dwarf_loc_section
= sectp
;
991 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
993 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
994 dwarf_macinfo_section
= sectp
;
996 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
998 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
999 dwarf_str_section
= sectp
;
1001 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1003 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1004 dwarf_frame_section
= sectp
;
1006 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1008 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1009 if (aflag
& SEC_HAS_CONTENTS
)
1011 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1012 dwarf_eh_frame_section
= sectp
;
1015 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1017 dwarf_ranges_size
= bfd_get_section_size_before_reloc (sectp
);
1018 dwarf_ranges_section
= sectp
;
1022 /* Build a partial symbol table. */
1025 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1028 /* We definitely need the .debug_info and .debug_abbrev sections */
1030 dwarf_info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1031 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1033 if (dwarf_line_section
)
1034 dwarf_line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1036 dwarf_line_buffer
= NULL
;
1038 if (dwarf_str_section
)
1039 dwarf_str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1041 dwarf_str_buffer
= NULL
;
1043 if (dwarf_macinfo_section
)
1044 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1045 dwarf_macinfo_section
);
1047 dwarf_macinfo_buffer
= NULL
;
1049 if (dwarf_ranges_section
)
1050 dwarf_ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1052 dwarf_ranges_buffer
= NULL
;
1054 if (dwarf_loc_section
)
1055 dwarf_loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1057 dwarf_loc_buffer
= NULL
;
1060 || (objfile
->global_psymbols
.size
== 0
1061 && objfile
->static_psymbols
.size
== 0))
1063 init_psymbol_list (objfile
, 1024);
1067 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1069 /* Things are significantly easier if we have .debug_aranges and
1070 .debug_pubnames sections */
1072 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1076 /* only test this case for now */
1078 /* In this case we have to work a bit harder */
1079 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1084 /* Build the partial symbol table from the information in the
1085 .debug_pubnames and .debug_aranges sections. */
1088 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1090 bfd
*abfd
= objfile
->obfd
;
1091 char *aranges_buffer
, *pubnames_buffer
;
1092 char *aranges_ptr
, *pubnames_ptr
;
1093 unsigned int entry_length
, version
, info_offset
, info_size
;
1095 pubnames_buffer
= dwarf2_read_section (objfile
,
1096 dwarf_pubnames_section
);
1097 pubnames_ptr
= pubnames_buffer
;
1098 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1100 struct comp_unit_head cu_header
;
1103 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1105 pubnames_ptr
+= bytes_read
;
1106 version
= read_1_byte (abfd
, pubnames_ptr
);
1108 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1110 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1114 aranges_buffer
= dwarf2_read_section (objfile
,
1115 dwarf_aranges_section
);
1120 /* Read in the comp unit header information from the debug_info at
1124 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1125 char *info_ptr
, bfd
*abfd
)
1129 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1131 info_ptr
+= bytes_read
;
1132 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1134 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1136 info_ptr
+= bytes_read
;
1137 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1139 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1140 if (signed_addr
< 0)
1141 internal_error (__FILE__
, __LINE__
,
1142 "read_comp_unit_head: dwarf from non elf file");
1143 cu_header
->signed_addr_p
= signed_addr
;
1147 /* Build the partial symbol table by doing a quick pass through the
1148 .debug_info and .debug_abbrev sections. */
1151 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1153 /* Instead of reading this into a big buffer, we should probably use
1154 mmap() on architectures that support it. (FIXME) */
1155 bfd
*abfd
= objfile
->obfd
;
1156 char *info_ptr
, *abbrev_ptr
;
1157 char *beg_of_comp_unit
;
1158 struct partial_die_info comp_unit_die
;
1159 struct partial_symtab
*pst
;
1160 struct cleanup
*back_to
;
1161 CORE_ADDR lowpc
, highpc
;
1163 info_ptr
= dwarf_info_buffer
;
1164 abbrev_ptr
= dwarf_abbrev_buffer
;
1166 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1167 the partial symbol scan, like attribute values.
1169 We could reduce our peak memory consumption during partial symbol
1170 table construction by freeing stuff from this obstack more often
1171 --- say, after processing each compilation unit, or each die ---
1172 but it turns out that this saves almost nothing. For an
1173 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1174 on dwarf2_tmp_obstack. Some investigation showed:
1176 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1177 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1178 all fixed-length values not requiring dynamic allocation.
1180 2) 30% of the attributes used the form DW_FORM_string. For
1181 DW_FORM_string, read_attribute simply hands back a pointer to
1182 the null-terminated string in dwarf_info_buffer, so no dynamic
1183 allocation is needed there either.
1185 3) The remaining 1% of the attributes all used DW_FORM_block1.
1186 75% of those were DW_AT_frame_base location lists for
1187 functions; the rest were DW_AT_location attributes, probably
1188 for the global variables.
1190 Anyway, what this all means is that the memory the dwarf2
1191 reader uses as temporary space reading partial symbols is about
1192 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1194 obstack_init (&dwarf2_tmp_obstack
);
1195 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1197 /* Since the objects we're extracting from dwarf_info_buffer vary in
1198 length, only the individual functions to extract them (like
1199 read_comp_unit_head and read_partial_die) can really know whether
1200 the buffer is large enough to hold another complete object.
1202 At the moment, they don't actually check that. If
1203 dwarf_info_buffer holds just one extra byte after the last
1204 compilation unit's dies, then read_comp_unit_head will happily
1205 read off the end of the buffer. read_partial_die is similarly
1206 casual. Those functions should be fixed.
1208 For this loop condition, simply checking whether there's any data
1209 left at all should be sufficient. */
1210 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1212 struct dwarf2_cu cu
;
1213 beg_of_comp_unit
= info_ptr
;
1215 cu
.objfile
= objfile
;
1216 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1218 if (cu
.header
.version
!= 2)
1220 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
));
1223 if (cu
.header
.abbrev_offset
>= dwarf_abbrev_size
)
1225 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1226 (long) cu
.header
.abbrev_offset
,
1227 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1228 bfd_get_filename (abfd
));
1231 if (beg_of_comp_unit
+ cu
.header
.length
+ cu
.header
.initial_length_size
1232 > dwarf_info_buffer
+ dwarf_info_size
)
1234 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1235 (long) cu
.header
.length
,
1236 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1237 bfd_get_filename (abfd
));
1240 /* Complete the cu_header */
1241 cu
.header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1242 cu
.header
.first_die_ptr
= info_ptr
;
1243 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1245 /* Read the abbrevs for this compilation unit into a table */
1246 dwarf2_read_abbrevs (abfd
, &cu
);
1247 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1249 /* Read the compilation unit die */
1250 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1253 /* Set the language we're debugging */
1254 set_cu_language (comp_unit_die
.language
);
1256 /* Allocate a new partial symbol table structure */
1257 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1258 comp_unit_die
.name
? comp_unit_die
.name
: "",
1259 comp_unit_die
.lowpc
,
1260 objfile
->global_psymbols
.next
,
1261 objfile
->static_psymbols
.next
);
1263 pst
->read_symtab_private
= (char *)
1264 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1265 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1266 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1267 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1268 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1269 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1270 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1271 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1272 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1273 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1274 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1275 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1276 DWARF_RANGES_BUFFER (pst
) = dwarf_ranges_buffer
;
1277 DWARF_RANGES_SIZE (pst
) = dwarf_ranges_size
;
1278 DWARF_LOC_BUFFER (pst
) = dwarf_loc_buffer
;
1279 DWARF_LOC_SIZE (pst
) = dwarf_loc_size
;
1280 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1282 /* Store the function that reads in the rest of the symbol table */
1283 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1285 /* Check if comp unit has_children.
1286 If so, read the rest of the partial symbols from this comp unit.
1287 If not, there's no more debug_info for this comp unit. */
1288 if (comp_unit_die
.has_children
)
1290 lowpc
= ((CORE_ADDR
) -1);
1291 highpc
= ((CORE_ADDR
) 0);
1293 info_ptr
= scan_partial_symbols (info_ptr
, &lowpc
, &highpc
,
1296 /* If we didn't find a lowpc, set it to highpc to avoid
1297 complaints from `maint check'. */
1298 if (lowpc
== ((CORE_ADDR
) -1))
1301 /* If the compilation unit didn't have an explicit address range,
1302 then use the information extracted from its child dies. */
1303 if (! comp_unit_die
.has_pc_info
)
1305 comp_unit_die
.lowpc
= lowpc
;
1306 comp_unit_die
.highpc
= highpc
;
1309 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1310 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1312 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1313 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1314 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1315 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1316 sort_pst_symbols (pst
);
1318 /* If there is already a psymtab or symtab for a file of this
1319 name, remove it. (If there is a symtab, more drastic things
1320 also happen.) This happens in VxWorks. */
1321 free_named_symtabs (pst
->filename
);
1323 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1324 + cu
.header
.initial_length_size
;
1326 do_cleanups (back_to
);
1329 /* Read in all interesting dies to the end of the compilation unit or
1330 to the end of the current namespace. NAMESPACE is NULL if we
1331 haven't yet encountered any DW_TAG_namespace entries; otherwise,
1332 it's the name of the current namespace. In particular, it's the
1333 empty string if we're currently in the global namespace but have
1334 previously encountered a DW_TAG_namespace. */
1337 scan_partial_symbols (char *info_ptr
, CORE_ADDR
*lowpc
,
1338 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
1339 const char *namespace)
1341 struct objfile
*objfile
= cu
->objfile
;
1342 bfd
*abfd
= objfile
->obfd
;
1343 struct partial_die_info pdi
;
1345 /* Now, march along the PDI's, descending into ones which have
1346 interesting children but skipping the children of the other ones,
1347 until we reach the end of the compilation unit. */
1351 /* This flag tells whether or not info_ptr has gotten updated
1353 int info_ptr_updated
= 0;
1355 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1357 /* Anonymous namespaces have no name but have interesting
1358 children, so we need to look at them. Ditto for anonymous
1361 if (pdi
.name
!= NULL
|| pdi
.tag
== DW_TAG_namespace
1362 || pdi
.tag
== DW_TAG_enumeration_type
)
1366 case DW_TAG_subprogram
:
1367 if (pdi
.has_pc_info
)
1369 if (pdi
.lowpc
< *lowpc
)
1373 if (pdi
.highpc
> *highpc
)
1375 *highpc
= pdi
.highpc
;
1377 if (!pdi
.is_declaration
)
1379 add_partial_symbol (&pdi
, cu
, namespace);
1383 case DW_TAG_variable
:
1384 case DW_TAG_typedef
:
1385 case DW_TAG_union_type
:
1386 if (!pdi
.is_declaration
)
1388 add_partial_symbol (&pdi
, cu
, namespace);
1391 case DW_TAG_class_type
:
1392 case DW_TAG_structure_type
:
1393 if (!pdi
.is_declaration
)
1395 info_ptr
= add_partial_structure (&pdi
, info_ptr
, cu
,
1397 info_ptr_updated
= 1;
1400 case DW_TAG_enumeration_type
:
1401 if (!pdi
.is_declaration
)
1403 info_ptr
= add_partial_enumeration (&pdi
, info_ptr
, cu
,
1405 info_ptr_updated
= 1;
1408 case DW_TAG_base_type
:
1409 /* File scope base type definitions are added to the partial
1411 add_partial_symbol (&pdi
, cu
, namespace);
1413 case DW_TAG_namespace
:
1414 /* We've hit a DW_TAG_namespace entry, so we know this
1415 file has been compiled using a compiler that
1416 generates them; update NAMESPACE to reflect that. */
1417 if (namespace == NULL
)
1419 info_ptr
= add_partial_namespace (&pdi
, info_ptr
, lowpc
, highpc
,
1421 info_ptr_updated
= 1;
1431 /* If the die has a sibling, skip to the sibling, unless another
1432 function has already updated info_ptr for us. */
1434 /* NOTE: carlton/2003-06-16: This is a bit hackish, but whether
1435 or not we want to update this depends on enough stuff (not
1436 only pdi.tag but also whether or not pdi.name is NULL) that
1437 this seems like the easiest way to handle the issue. */
1439 if (!info_ptr_updated
)
1440 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1447 add_partial_symbol (struct partial_die_info
*pdi
,
1448 struct dwarf2_cu
*cu
, const char *namespace)
1450 struct objfile
*objfile
= cu
->objfile
;
1452 char *actual_name
= pdi
->name
;
1453 const struct partial_symbol
*psym
= NULL
;
1455 /* If we're not in the global namespace and if the namespace name
1456 isn't encoded in a mangled actual_name, add it. */
1458 if (pdi_needs_namespace (pdi
->tag
, namespace))
1460 actual_name
= alloca (strlen (pdi
->name
) + 2 + strlen (namespace) + 1);
1461 strcpy (actual_name
, namespace);
1462 strcat (actual_name
, "::");
1463 strcat (actual_name
, pdi
->name
);
1468 case DW_TAG_subprogram
:
1469 if (pdi
->is_external
)
1471 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1472 mst_text, objfile); */
1473 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1474 VAR_DOMAIN
, LOC_BLOCK
,
1475 &objfile
->global_psymbols
,
1476 0, pdi
->lowpc
+ baseaddr
,
1477 cu_language
, objfile
);
1481 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1482 mst_file_text, objfile); */
1483 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1484 VAR_DOMAIN
, LOC_BLOCK
,
1485 &objfile
->static_psymbols
,
1486 0, pdi
->lowpc
+ baseaddr
,
1487 cu_language
, objfile
);
1490 case DW_TAG_variable
:
1491 if (pdi
->is_external
)
1494 Don't enter into the minimal symbol tables as there is
1495 a minimal symbol table entry from the ELF symbols already.
1496 Enter into partial symbol table if it has a location
1497 descriptor or a type.
1498 If the location descriptor is missing, new_symbol will create
1499 a LOC_UNRESOLVED symbol, the address of the variable will then
1500 be determined from the minimal symbol table whenever the variable
1502 The address for the partial symbol table entry is not
1503 used by GDB, but it comes in handy for debugging partial symbol
1507 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1508 if (pdi
->locdesc
|| pdi
->has_type
)
1509 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1510 VAR_DOMAIN
, LOC_STATIC
,
1511 &objfile
->global_psymbols
,
1513 cu_language
, objfile
);
1517 /* Static Variable. Skip symbols without location descriptors. */
1518 if (pdi
->locdesc
== NULL
)
1520 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1521 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1522 mst_file_data, objfile); */
1523 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1524 VAR_DOMAIN
, LOC_STATIC
,
1525 &objfile
->static_psymbols
,
1527 cu_language
, objfile
);
1530 case DW_TAG_typedef
:
1531 case DW_TAG_base_type
:
1532 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1533 VAR_DOMAIN
, LOC_TYPEDEF
,
1534 &objfile
->static_psymbols
,
1535 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1537 case DW_TAG_class_type
:
1538 case DW_TAG_structure_type
:
1539 case DW_TAG_union_type
:
1540 case DW_TAG_enumeration_type
:
1541 /* Skip aggregate types without children, these are external
1543 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1544 static vs. global. */
1545 if (pdi
->has_children
== 0)
1547 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1548 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1549 cu_language
== language_cplus
1550 ? &objfile
->global_psymbols
1551 : &objfile
->static_psymbols
,
1552 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1554 if (cu_language
== language_cplus
)
1556 /* For C++, these implicitly act as typedefs as well. */
1557 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1558 VAR_DOMAIN
, LOC_TYPEDEF
,
1559 &objfile
->global_psymbols
,
1560 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1563 case DW_TAG_enumerator
:
1564 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1565 VAR_DOMAIN
, LOC_CONST
,
1566 cu_language
== language_cplus
1567 ? &objfile
->static_psymbols
1568 : &objfile
->global_psymbols
,
1569 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1575 /* Check to see if we should scan the name for possible namespace
1576 info. Only do this if this is C++, if we don't have namespace
1577 debugging info in the file, if the psym is of an appropriate type
1578 (otherwise we'll have psym == NULL), and if we actually had a
1579 mangled name to begin with. */
1581 if (cu_language
== language_cplus
1582 && namespace == NULL
1584 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
1585 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
1589 /* Determine whether a die of type TAG living in the C++ namespace
1590 NAMESPACE needs to have the name of the namespace prepended to the
1591 name listed in the die. */
1594 pdi_needs_namespace (enum dwarf_tag tag
, const char *namespace)
1596 if (namespace == NULL
|| namespace[0] == '\0')
1601 case DW_TAG_typedef
:
1602 case DW_TAG_class_type
:
1603 case DW_TAG_structure_type
:
1604 case DW_TAG_union_type
:
1605 case DW_TAG_enumeration_type
:
1606 case DW_TAG_enumerator
:
1613 /* Read a partial die corresponding to a namespace; also, add a symbol
1614 corresponding to that namespace to the symbol table. NAMESPACE is
1615 the name of the enclosing namespace. */
1618 add_partial_namespace (struct partial_die_info
*pdi
, char *info_ptr
,
1619 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1620 struct dwarf2_cu
*cu
, const char *namespace)
1622 struct objfile
*objfile
= cu
->objfile
;
1623 const char *new_name
= pdi
->name
;
1626 /* Calculate the full name of the namespace that we just entered. */
1628 if (new_name
== NULL
)
1629 new_name
= "(anonymous namespace)";
1630 full_name
= alloca (strlen (namespace) + 2 + strlen (new_name
) + 1);
1631 strcpy (full_name
, namespace);
1632 if (*namespace != '\0')
1633 strcat (full_name
, "::");
1634 strcat (full_name
, new_name
);
1636 /* FIXME: carlton/2003-10-07: We can't just replace this by a call
1637 to add_partial_symbol, because we don't have a way to pass in the
1638 full name to that function; that might be a flaw in
1639 add_partial_symbol's interface. */
1641 add_psymbol_to_list (full_name
, strlen (full_name
),
1642 VAR_DOMAIN
, LOC_TYPEDEF
,
1643 &objfile
->global_psymbols
,
1644 0, 0, cu_language
, objfile
);
1646 /* Now scan partial symbols in that namespace. */
1648 if (pdi
->has_children
)
1649 info_ptr
= scan_partial_symbols (info_ptr
, lowpc
, highpc
, cu
, full_name
);
1654 /* Read a partial die corresponding to a class or structure. */
1657 add_partial_structure (struct partial_die_info
*struct_pdi
, char *info_ptr
,
1658 struct dwarf2_cu
*cu
,
1659 const char *namespace)
1661 bfd
*abfd
= cu
->objfile
->obfd
;
1662 char *actual_class_name
= NULL
;
1664 if (cu_language
== language_cplus
1665 && namespace == NULL
1666 && struct_pdi
->name
!= NULL
1667 && struct_pdi
->has_children
)
1669 /* We don't have namespace debugging information, so see if we
1670 can figure out if this structure lives in a namespace. Look
1671 for a member function; its demangled name will contain
1672 namespace info, if there is any. */
1674 /* NOTE: carlton/2003-10-07: Getting the info this way changes
1675 what template types look like, because the demangler
1676 frequently doesn't give the same name as the debug info. We
1677 could fix this by only using the demangled name to get the
1678 prefix (but see comment in read_structure_scope). */
1680 char *next_child
= info_ptr
;
1684 struct partial_die_info child_pdi
;
1686 next_child
= read_partial_die (&child_pdi
, abfd
, next_child
,
1690 if (child_pdi
.tag
== DW_TAG_subprogram
)
1692 actual_class_name
= class_name_from_physname (child_pdi
.name
);
1693 if (actual_class_name
!= NULL
)
1694 struct_pdi
->name
= actual_class_name
;
1699 next_child
= locate_pdi_sibling (&child_pdi
, next_child
,
1705 add_partial_symbol (struct_pdi
, cu
, namespace);
1706 xfree(actual_class_name
);
1708 return locate_pdi_sibling (struct_pdi
, info_ptr
, abfd
, cu
);
1711 /* Read a partial die corresponding to an enumeration type. */
1714 add_partial_enumeration (struct partial_die_info
*enum_pdi
, char *info_ptr
,
1715 struct dwarf2_cu
*cu
, const char *namespace)
1717 struct objfile
*objfile
= cu
->objfile
;
1718 bfd
*abfd
= objfile
->obfd
;
1719 struct partial_die_info pdi
;
1721 if (enum_pdi
->name
!= NULL
)
1722 add_partial_symbol (enum_pdi
, cu
, namespace);
1726 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1729 if (pdi
.tag
!= DW_TAG_enumerator
|| pdi
.name
== NULL
)
1730 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
1732 add_partial_symbol (&pdi
, cu
, namespace);
1738 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the next DIE
1742 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
1743 bfd
*abfd
, struct dwarf2_cu
*cu
)
1745 /* Do we know the sibling already? */
1747 if (orig_pdi
->sibling
)
1748 return orig_pdi
->sibling
;
1750 /* Are there any children to deal with? */
1752 if (!orig_pdi
->has_children
)
1755 /* Okay, we don't know the sibling, but we have children that we
1756 want to skip. So read children until we run into one without a
1757 tag; return whatever follows it. */
1761 struct partial_die_info pdi
;
1763 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1768 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1772 /* Expand this partial symbol table into a full symbol table. */
1775 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1777 /* FIXME: This is barely more than a stub. */
1782 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1788 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1789 gdb_flush (gdb_stdout
);
1792 psymtab_to_symtab_1 (pst
);
1794 /* Finish up the debug error message. */
1796 printf_filtered ("done.\n");
1802 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1804 struct objfile
*objfile
= pst
->objfile
;
1805 bfd
*abfd
= objfile
->obfd
;
1806 struct dwarf2_cu cu
;
1807 struct die_info
*dies
;
1808 unsigned long offset
;
1809 CORE_ADDR lowpc
, highpc
;
1810 struct die_info
*child_die
;
1812 struct symtab
*symtab
;
1813 struct cleanup
*back_to
;
1814 struct attribute
*attr
;
1816 /* Set local variables from the partial symbol table info. */
1817 offset
= DWARF_INFO_OFFSET (pst
);
1818 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1819 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1820 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1821 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1822 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1823 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1824 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1825 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1826 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1827 dwarf_ranges_buffer
= DWARF_RANGES_BUFFER (pst
);
1828 dwarf_ranges_size
= DWARF_RANGES_SIZE (pst
);
1829 dwarf_loc_buffer
= DWARF_LOC_BUFFER (pst
);
1830 dwarf_loc_size
= DWARF_LOC_SIZE (pst
);
1831 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1832 cu_header_offset
= offset
;
1833 info_ptr
= dwarf_info_buffer
+ offset
;
1835 /* We're in the global namespace. */
1836 processing_current_prefix
= "";
1838 obstack_init (&dwarf2_tmp_obstack
);
1839 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1842 make_cleanup (really_free_pendings
, NULL
);
1844 cu
.objfile
= objfile
;
1846 /* read in the comp_unit header */
1847 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1849 /* Read the abbrevs for this compilation unit */
1850 dwarf2_read_abbrevs (abfd
, &cu
);
1851 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1853 dies
= read_comp_unit (info_ptr
, abfd
, &cu
);
1855 make_cleanup_free_die_list (dies
);
1857 /* Find the base address of the compilation unit for range lists and
1858 location lists. It will normally be specified by DW_AT_low_pc.
1859 In DWARF-3 draft 4, the base address could be overridden by
1860 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1861 compilation units with discontinuous ranges. */
1863 cu
.header
.base_known
= 0;
1864 cu
.header
.base_address
= 0;
1866 attr
= dwarf_attr (dies
, DW_AT_entry_pc
);
1869 cu
.header
.base_address
= DW_ADDR (attr
);
1870 cu
.header
.base_known
= 1;
1874 attr
= dwarf_attr (dies
, DW_AT_low_pc
);
1877 cu
.header
.base_address
= DW_ADDR (attr
);
1878 cu
.header
.base_known
= 1;
1882 /* Do line number decoding in read_file_scope () */
1883 process_die (dies
, &cu
);
1885 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, &cu
))
1887 /* Some compilers don't define a DW_AT_high_pc attribute for
1888 the compilation unit. If the DW_AT_high_pc is missing,
1889 synthesize it, by scanning the DIE's below the compilation unit. */
1891 if (dies
->child
!= NULL
)
1893 child_die
= dies
->child
;
1894 while (child_die
&& child_die
->tag
)
1896 if (child_die
->tag
== DW_TAG_subprogram
)
1898 CORE_ADDR low
, high
;
1900 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, &cu
))
1902 highpc
= max (highpc
, high
);
1905 child_die
= sibling_die (child_die
);
1909 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1911 /* Set symtab language to language from DW_AT_language.
1912 If the compilation is from a C file generated by language preprocessors,
1913 do not set the language if it was already deduced by start_subfile. */
1915 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1917 symtab
->language
= cu_language
;
1919 pst
->symtab
= symtab
;
1922 do_cleanups (back_to
);
1925 /* Process a die and its children. */
1928 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
1932 case DW_TAG_padding
:
1934 case DW_TAG_compile_unit
:
1935 read_file_scope (die
, cu
);
1937 case DW_TAG_subprogram
:
1938 read_subroutine_type (die
, cu
);
1939 read_func_scope (die
, cu
);
1941 case DW_TAG_inlined_subroutine
:
1942 /* FIXME: These are ignored for now.
1943 They could be used to set breakpoints on all inlined instances
1944 of a function and make GDB `next' properly over inlined functions. */
1946 case DW_TAG_lexical_block
:
1947 case DW_TAG_try_block
:
1948 case DW_TAG_catch_block
:
1949 read_lexical_block_scope (die
, cu
);
1951 case DW_TAG_class_type
:
1952 case DW_TAG_structure_type
:
1953 case DW_TAG_union_type
:
1954 read_structure_scope (die
, cu
);
1956 case DW_TAG_enumeration_type
:
1957 read_enumeration (die
, cu
);
1959 case DW_TAG_subroutine_type
:
1960 read_subroutine_type (die
, cu
);
1962 case DW_TAG_array_type
:
1963 read_array_type (die
, cu
);
1965 case DW_TAG_pointer_type
:
1966 read_tag_pointer_type (die
, cu
);
1968 case DW_TAG_ptr_to_member_type
:
1969 read_tag_ptr_to_member_type (die
, cu
);
1971 case DW_TAG_reference_type
:
1972 read_tag_reference_type (die
, cu
);
1974 case DW_TAG_string_type
:
1975 read_tag_string_type (die
, cu
);
1977 case DW_TAG_base_type
:
1978 read_base_type (die
, cu
);
1979 if (dwarf_attr (die
, DW_AT_name
))
1981 /* Add a typedef symbol for the base type definition. */
1982 new_symbol (die
, die
->type
, cu
);
1985 case DW_TAG_common_block
:
1986 read_common_block (die
, cu
);
1988 case DW_TAG_common_inclusion
:
1990 case DW_TAG_namespace
:
1991 processing_has_namespace_info
= 1;
1992 read_namespace (die
, cu
);
1994 case DW_TAG_imported_declaration
:
1995 case DW_TAG_imported_module
:
1996 /* FIXME: carlton/2002-10-16: Eventually, we should use the
1997 information contained in these. DW_TAG_imported_declaration
1998 dies shouldn't have children; DW_TAG_imported_module dies
1999 shouldn't in the C++ case, but conceivably could in the
2000 Fortran case, so we'll have to replace this gdb_assert if
2001 Fortran compilers start generating that info. */
2002 processing_has_namespace_info
= 1;
2003 gdb_assert (die
->child
== NULL
);
2006 new_symbol (die
, NULL
, cu
);
2012 initialize_cu_func_list (void)
2014 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
2018 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2020 struct objfile
*objfile
= cu
->objfile
;
2021 struct comp_unit_head
*cu_header
= &cu
->header
;
2022 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2023 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2024 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2025 struct attribute
*attr
;
2026 char *name
= "<unknown>";
2027 char *comp_dir
= NULL
;
2028 struct die_info
*child_die
;
2029 bfd
*abfd
= objfile
->obfd
;
2030 struct line_header
*line_header
= 0;
2032 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2034 if (die
->child
!= NULL
)
2036 child_die
= die
->child
;
2037 while (child_die
&& child_die
->tag
)
2039 if (child_die
->tag
== DW_TAG_subprogram
)
2041 CORE_ADDR low
, high
;
2043 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, cu
))
2045 lowpc
= min (lowpc
, low
);
2046 highpc
= max (highpc
, high
);
2049 child_die
= sibling_die (child_die
);
2054 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2055 from finish_block. */
2056 if (lowpc
== ((CORE_ADDR
) -1))
2061 attr
= dwarf_attr (die
, DW_AT_name
);
2064 name
= DW_STRING (attr
);
2066 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
2069 comp_dir
= DW_STRING (attr
);
2072 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2073 directory, get rid of it. */
2074 char *cp
= strchr (comp_dir
, ':');
2076 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2081 if (objfile
->ei
.entry_point
>= lowpc
&&
2082 objfile
->ei
.entry_point
< highpc
)
2084 objfile
->ei
.deprecated_entry_file_lowpc
= lowpc
;
2085 objfile
->ei
.deprecated_entry_file_highpc
= highpc
;
2088 attr
= dwarf_attr (die
, DW_AT_language
);
2091 set_cu_language (DW_UNSND (attr
));
2094 /* We assume that we're processing GCC output. */
2095 processing_gcc_compilation
= 2;
2097 /* FIXME:Do something here. */
2098 if (dip
->at_producer
!= NULL
)
2100 handle_producer (dip
->at_producer
);
2104 /* The compilation unit may be in a different language or objfile,
2105 zero out all remembered fundamental types. */
2106 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2108 start_symtab (name
, comp_dir
, lowpc
);
2109 record_debugformat ("DWARF 2");
2111 initialize_cu_func_list ();
2113 /* Process all dies in compilation unit. */
2114 if (die
->child
!= NULL
)
2116 child_die
= die
->child
;
2117 while (child_die
&& child_die
->tag
)
2119 process_die (child_die
, cu
);
2120 child_die
= sibling_die (child_die
);
2124 /* Decode line number information if present. */
2125 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
2128 unsigned int line_offset
= DW_UNSND (attr
);
2129 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2132 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2133 (void *) line_header
);
2134 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
);
2138 /* Decode macro information, if present. Dwarf 2 macro information
2139 refers to information in the line number info statement program
2140 header, so we can only read it if we've read the header
2142 attr
= dwarf_attr (die
, DW_AT_macro_info
);
2143 if (attr
&& line_header
)
2145 unsigned int macro_offset
= DW_UNSND (attr
);
2146 dwarf_decode_macros (line_header
, macro_offset
,
2147 comp_dir
, abfd
, cu
);
2149 do_cleanups (back_to
);
2153 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
2155 struct function_range
*thisfn
;
2157 thisfn
= (struct function_range
*)
2158 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
2159 thisfn
->name
= name
;
2160 thisfn
->lowpc
= lowpc
;
2161 thisfn
->highpc
= highpc
;
2162 thisfn
->seen_line
= 0;
2163 thisfn
->next
= NULL
;
2165 if (cu_last_fn
== NULL
)
2166 cu_first_fn
= thisfn
;
2168 cu_last_fn
->next
= thisfn
;
2170 cu_last_fn
= thisfn
;
2174 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2176 struct objfile
*objfile
= cu
->objfile
;
2177 struct context_stack
*new;
2180 struct die_info
*child_die
;
2181 struct attribute
*attr
;
2184 name
= dwarf2_linkage_name (die
);
2186 /* Ignore functions with missing or empty names and functions with
2187 missing or invalid low and high pc attributes. */
2188 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2194 /* Record the function range for dwarf_decode_lines. */
2195 add_to_cu_func_list (name
, lowpc
, highpc
);
2197 if (objfile
->ei
.entry_point
>= lowpc
&&
2198 objfile
->ei
.entry_point
< highpc
)
2200 objfile
->ei
.entry_func_lowpc
= lowpc
;
2201 objfile
->ei
.entry_func_highpc
= highpc
;
2204 new = push_context (0, lowpc
);
2205 new->name
= new_symbol (die
, die
->type
, cu
);
2207 /* If there is a location expression for DW_AT_frame_base, record
2209 attr
= dwarf_attr (die
, DW_AT_frame_base
);
2211 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2213 list_in_scope
= &local_symbols
;
2215 if (die
->child
!= NULL
)
2217 child_die
= die
->child
;
2218 while (child_die
&& child_die
->tag
)
2220 process_die (child_die
, cu
);
2221 child_die
= sibling_die (child_die
);
2225 new = pop_context ();
2226 /* Make a block for the local symbols within. */
2227 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2228 lowpc
, highpc
, objfile
);
2230 /* In C++, we can have functions nested inside functions (e.g., when
2231 a function declares a class that has methods). This means that
2232 when we finish processing a function scope, we may need to go
2233 back to building a containing block's symbol lists. */
2234 local_symbols
= new->locals
;
2235 param_symbols
= new->params
;
2237 /* If we've finished processing a top-level function, subsequent
2238 symbols go in the file symbol list. */
2239 if (outermost_context_p ())
2240 list_in_scope
= &file_symbols
;
2243 /* Process all the DIES contained within a lexical block scope. Start
2244 a new scope, process the dies, and then close the scope. */
2247 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2249 struct objfile
*objfile
= cu
->objfile
;
2250 struct context_stack
*new;
2251 CORE_ADDR lowpc
, highpc
;
2252 struct die_info
*child_die
;
2254 /* Ignore blocks with missing or invalid low and high pc attributes. */
2255 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2256 as multiple lexical blocks? Handling children in a sane way would
2257 be nasty. Might be easier to properly extend generic blocks to
2259 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2264 push_context (0, lowpc
);
2265 if (die
->child
!= NULL
)
2267 child_die
= die
->child
;
2268 while (child_die
&& child_die
->tag
)
2270 process_die (child_die
, cu
);
2271 child_die
= sibling_die (child_die
);
2274 new = pop_context ();
2276 if (local_symbols
!= NULL
)
2278 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2281 local_symbols
= new->locals
;
2284 /* Get low and high pc attributes from a die. Return 1 if the attributes
2285 are present and valid, otherwise, return 0. Return -1 if the range is
2286 discontinuous, i.e. derived from DW_AT_ranges information. */
2288 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
2289 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
2291 struct objfile
*objfile
= cu
->objfile
;
2292 struct comp_unit_head
*cu_header
= &cu
->header
;
2293 struct attribute
*attr
;
2294 bfd
*obfd
= objfile
->obfd
;
2299 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2302 high
= DW_ADDR (attr
);
2303 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2305 low
= DW_ADDR (attr
);
2307 /* Found high w/o low attribute. */
2310 /* Found consecutive range of addresses. */
2315 attr
= dwarf_attr (die
, DW_AT_ranges
);
2318 unsigned int addr_size
= cu_header
->addr_size
;
2319 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2320 /* Value of the DW_AT_ranges attribute is the offset in the
2321 .debug_ranges section. */
2322 unsigned int offset
= DW_UNSND (attr
);
2323 /* Base address selection entry. */
2331 found_base
= cu_header
->base_known
;
2332 base
= cu_header
->base_address
;
2334 if (offset
>= dwarf_ranges_size
)
2336 complaint (&symfile_complaints
,
2337 "Offset %d out of bounds for DW_AT_ranges attribute",
2341 buffer
= dwarf_ranges_buffer
+ offset
;
2343 /* Read in the largest possible address. */
2344 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
2345 if ((marker
& mask
) == mask
)
2347 /* If we found the largest possible address, then
2348 read the base address. */
2349 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2350 buffer
+= 2 * addr_size
;
2351 offset
+= 2 * addr_size
;
2359 CORE_ADDR range_beginning
, range_end
;
2361 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
2362 buffer
+= addr_size
;
2363 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
2364 buffer
+= addr_size
;
2365 offset
+= 2 * addr_size
;
2367 /* An end of list marker is a pair of zero addresses. */
2368 if (range_beginning
== 0 && range_end
== 0)
2369 /* Found the end of list entry. */
2372 /* Each base address selection entry is a pair of 2 values.
2373 The first is the largest possible address, the second is
2374 the base address. Check for a base address here. */
2375 if ((range_beginning
& mask
) == mask
)
2377 /* If we found the largest possible address, then
2378 read the base address. */
2379 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2386 /* We have no valid base address for the ranges
2388 complaint (&symfile_complaints
,
2389 "Invalid .debug_ranges data (no base address)");
2393 range_beginning
+= base
;
2396 /* FIXME: This is recording everything as a low-high
2397 segment of consecutive addresses. We should have a
2398 data structure for discontiguous block ranges
2402 low
= range_beginning
;
2408 if (range_beginning
< low
)
2409 low
= range_beginning
;
2410 if (range_end
> high
)
2416 /* If the first entry is an end-of-list marker, the range
2417 describes an empty scope, i.e. no instructions. */
2427 /* When using the GNU linker, .gnu.linkonce. sections are used to
2428 eliminate duplicate copies of functions and vtables and such.
2429 The linker will arbitrarily choose one and discard the others.
2430 The AT_*_pc values for such functions refer to local labels in
2431 these sections. If the section from that file was discarded, the
2432 labels are not in the output, so the relocs get a value of 0.
2433 If this is a discarded function, mark the pc bounds as invalid,
2434 so that GDB will ignore it. */
2435 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
2443 /* Add an aggregate field to the field list. */
2446 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2447 struct dwarf2_cu
*cu
)
2449 struct objfile
*objfile
= cu
->objfile
;
2450 struct nextfield
*new_field
;
2451 struct attribute
*attr
;
2453 char *fieldname
= "";
2455 /* Allocate a new field list entry and link it in. */
2456 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2457 make_cleanup (xfree
, new_field
);
2458 memset (new_field
, 0, sizeof (struct nextfield
));
2459 new_field
->next
= fip
->fields
;
2460 fip
->fields
= new_field
;
2463 /* Handle accessibility and virtuality of field.
2464 The default accessibility for members is public, the default
2465 accessibility for inheritance is private. */
2466 if (die
->tag
!= DW_TAG_inheritance
)
2467 new_field
->accessibility
= DW_ACCESS_public
;
2469 new_field
->accessibility
= DW_ACCESS_private
;
2470 new_field
->virtuality
= DW_VIRTUALITY_none
;
2472 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2474 new_field
->accessibility
= DW_UNSND (attr
);
2475 if (new_field
->accessibility
!= DW_ACCESS_public
)
2476 fip
->non_public_fields
= 1;
2477 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2479 new_field
->virtuality
= DW_UNSND (attr
);
2481 fp
= &new_field
->field
;
2483 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
))
2485 /* Data member other than a C++ static data member. */
2487 /* Get type of field. */
2488 fp
->type
= die_type (die
, cu
);
2490 FIELD_STATIC_KIND (*fp
) = 0;
2492 /* Get bit size of field (zero if none). */
2493 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2496 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2500 FIELD_BITSIZE (*fp
) = 0;
2503 /* Get bit offset of field. */
2504 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2507 FIELD_BITPOS (*fp
) =
2508 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
2511 FIELD_BITPOS (*fp
) = 0;
2512 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2515 if (BITS_BIG_ENDIAN
)
2517 /* For big endian bits, the DW_AT_bit_offset gives the
2518 additional bit offset from the MSB of the containing
2519 anonymous object to the MSB of the field. We don't
2520 have to do anything special since we don't need to
2521 know the size of the anonymous object. */
2522 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2526 /* For little endian bits, compute the bit offset to the
2527 MSB of the anonymous object, subtract off the number of
2528 bits from the MSB of the field to the MSB of the
2529 object, and then subtract off the number of bits of
2530 the field itself. The result is the bit offset of
2531 the LSB of the field. */
2533 int bit_offset
= DW_UNSND (attr
);
2535 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2538 /* The size of the anonymous object containing
2539 the bit field is explicit, so use the
2540 indicated size (in bytes). */
2541 anonymous_size
= DW_UNSND (attr
);
2545 /* The size of the anonymous object containing
2546 the bit field must be inferred from the type
2547 attribute of the data member containing the
2549 anonymous_size
= TYPE_LENGTH (fp
->type
);
2551 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2552 - bit_offset
- FIELD_BITSIZE (*fp
);
2556 /* Get name of field. */
2557 attr
= dwarf_attr (die
, DW_AT_name
);
2558 if (attr
&& DW_STRING (attr
))
2559 fieldname
= DW_STRING (attr
);
2560 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2561 &objfile
->type_obstack
);
2563 /* Change accessibility for artificial fields (e.g. virtual table
2564 pointer or virtual base class pointer) to private. */
2565 if (dwarf_attr (die
, DW_AT_artificial
))
2567 new_field
->accessibility
= DW_ACCESS_private
;
2568 fip
->non_public_fields
= 1;
2571 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
2573 /* C++ static member. */
2575 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2576 is a declaration, but all versions of G++ as of this writing
2577 (so through at least 3.2.1) incorrectly generate
2578 DW_TAG_variable tags. */
2582 /* Get name of field. */
2583 attr
= dwarf_attr (die
, DW_AT_name
);
2584 if (attr
&& DW_STRING (attr
))
2585 fieldname
= DW_STRING (attr
);
2589 /* Get physical name. */
2590 physname
= dwarf2_linkage_name (die
);
2592 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2593 &objfile
->type_obstack
));
2594 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2595 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2596 &objfile
->type_obstack
);
2598 else if (die
->tag
== DW_TAG_inheritance
)
2600 /* C++ base class field. */
2601 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2603 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
2605 FIELD_BITSIZE (*fp
) = 0;
2606 FIELD_STATIC_KIND (*fp
) = 0;
2607 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2608 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2609 fip
->nbaseclasses
++;
2613 /* Create the vector of fields, and attach it to the type. */
2616 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2617 struct dwarf2_cu
*cu
)
2619 int nfields
= fip
->nfields
;
2621 /* Record the field count, allocate space for the array of fields,
2622 and create blank accessibility bitfields if necessary. */
2623 TYPE_NFIELDS (type
) = nfields
;
2624 TYPE_FIELDS (type
) = (struct field
*)
2625 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2626 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2628 if (fip
->non_public_fields
)
2630 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2632 TYPE_FIELD_PRIVATE_BITS (type
) =
2633 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2634 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2636 TYPE_FIELD_PROTECTED_BITS (type
) =
2637 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2638 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2640 TYPE_FIELD_IGNORE_BITS (type
) =
2641 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2642 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2645 /* If the type has baseclasses, allocate and clear a bit vector for
2646 TYPE_FIELD_VIRTUAL_BITS. */
2647 if (fip
->nbaseclasses
)
2649 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2652 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2653 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2654 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2655 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2656 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2659 /* Copy the saved-up fields into the field vector. Start from the head
2660 of the list, adding to the tail of the field array, so that they end
2661 up in the same order in the array in which they were added to the list. */
2662 while (nfields
-- > 0)
2664 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2665 switch (fip
->fields
->accessibility
)
2667 case DW_ACCESS_private
:
2668 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2671 case DW_ACCESS_protected
:
2672 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2675 case DW_ACCESS_public
:
2679 /* Unknown accessibility. Complain and treat it as public. */
2681 complaint (&symfile_complaints
, "unsupported accessibility %d",
2682 fip
->fields
->accessibility
);
2686 if (nfields
< fip
->nbaseclasses
)
2688 switch (fip
->fields
->virtuality
)
2690 case DW_VIRTUALITY_virtual
:
2691 case DW_VIRTUALITY_pure_virtual
:
2692 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2696 fip
->fields
= fip
->fields
->next
;
2700 /* Add a member function to the proper fieldlist. */
2703 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2704 struct type
*type
, struct dwarf2_cu
*cu
)
2706 struct objfile
*objfile
= cu
->objfile
;
2707 struct attribute
*attr
;
2708 struct fnfieldlist
*flp
;
2710 struct fn_field
*fnp
;
2713 struct nextfnfield
*new_fnfield
;
2715 /* Get name of member function. */
2716 attr
= dwarf_attr (die
, DW_AT_name
);
2717 if (attr
&& DW_STRING (attr
))
2718 fieldname
= DW_STRING (attr
);
2722 /* Get the mangled name. */
2723 physname
= dwarf2_linkage_name (die
);
2725 /* Look up member function name in fieldlist. */
2726 for (i
= 0; i
< fip
->nfnfields
; i
++)
2728 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
2732 /* Create new list element if necessary. */
2733 if (i
< fip
->nfnfields
)
2734 flp
= &fip
->fnfieldlists
[i
];
2737 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2739 fip
->fnfieldlists
= (struct fnfieldlist
*)
2740 xrealloc (fip
->fnfieldlists
,
2741 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2742 * sizeof (struct fnfieldlist
));
2743 if (fip
->nfnfields
== 0)
2744 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2746 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2747 flp
->name
= fieldname
;
2753 /* Create a new member function field and chain it to the field list
2755 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2756 make_cleanup (xfree
, new_fnfield
);
2757 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2758 new_fnfield
->next
= flp
->head
;
2759 flp
->head
= new_fnfield
;
2762 /* Fill in the member function field info. */
2763 fnp
= &new_fnfield
->fnfield
;
2764 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2765 &objfile
->type_obstack
);
2766 fnp
->type
= alloc_type (objfile
);
2767 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2769 int nparams
= TYPE_NFIELDS (die
->type
);
2771 /* TYPE is the domain of this method, and DIE->TYPE is the type
2772 of the method itself (TYPE_CODE_METHOD). */
2773 smash_to_method_type (fnp
->type
, type
,
2774 TYPE_TARGET_TYPE (die
->type
),
2775 TYPE_FIELDS (die
->type
),
2776 TYPE_NFIELDS (die
->type
),
2777 TYPE_VARARGS (die
->type
));
2779 /* Handle static member functions.
2780 Dwarf2 has no clean way to discern C++ static and non-static
2781 member functions. G++ helps GDB by marking the first
2782 parameter for non-static member functions (which is the
2783 this pointer) as artificial. We obtain this information
2784 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2785 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2786 fnp
->voffset
= VOFFSET_STATIC
;
2789 complaint (&symfile_complaints
, "member function type missing for '%s'",
2792 /* Get fcontext from DW_AT_containing_type if present. */
2793 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2794 fnp
->fcontext
= die_containing_type (die
, cu
);
2796 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2797 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2799 /* Get accessibility. */
2800 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2803 switch (DW_UNSND (attr
))
2805 case DW_ACCESS_private
:
2806 fnp
->is_private
= 1;
2808 case DW_ACCESS_protected
:
2809 fnp
->is_protected
= 1;
2814 /* Check for artificial methods. */
2815 attr
= dwarf_attr (die
, DW_AT_artificial
);
2816 if (attr
&& DW_UNSND (attr
) != 0)
2817 fnp
->is_artificial
= 1;
2819 /* Get index in virtual function table if it is a virtual member function. */
2820 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2823 /* Support the .debug_loc offsets */
2824 if (attr_form_is_block (attr
))
2826 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
2828 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2830 dwarf2_complex_location_expr_complaint ();
2834 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2840 /* Create the vector of member function fields, and attach it to the type. */
2843 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2844 struct dwarf2_cu
*cu
)
2846 struct fnfieldlist
*flp
;
2847 int total_length
= 0;
2850 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2851 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2852 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2854 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2856 struct nextfnfield
*nfp
= flp
->head
;
2857 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2860 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2861 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2862 fn_flp
->fn_fields
= (struct fn_field
*)
2863 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2864 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2865 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2867 total_length
+= flp
->length
;
2870 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2871 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2874 /* Called when we find the DIE that starts a structure or union scope
2875 (definition) to process all dies that define the members of the
2878 NOTE: we need to call struct_type regardless of whether or not the
2879 DIE has an at_name attribute, since it might be an anonymous
2880 structure or union. This gets the type entered into our set of
2883 However, if the structure is incomplete (an opaque struct/union)
2884 then suppress creating a symbol table entry for it since gdb only
2885 wants to find the one with the complete definition. Note that if
2886 it is complete, we just call new_symbol, which does it's own
2887 checking about whether the struct/union is anonymous or not (and
2888 suppresses creating a symbol table entry itself). */
2891 read_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2893 struct objfile
*objfile
= cu
->objfile
;
2895 struct attribute
*attr
;
2896 const char *name
= NULL
;
2897 const char *previous_prefix
= processing_current_prefix
;
2898 struct cleanup
*back_to
= NULL
;
2899 /* This says whether or not we want to try to update the structure's
2900 name to include enclosing namespace/class information, if
2902 int need_to_update_name
= 0;
2904 type
= alloc_type (objfile
);
2906 INIT_CPLUS_SPECIFIC (type
);
2907 attr
= dwarf_attr (die
, DW_AT_name
);
2908 if (attr
&& DW_STRING (attr
))
2910 name
= DW_STRING (attr
);
2912 if (cu_language
== language_cplus
)
2914 struct die_info
*spec_die
= die_specification (die
);
2916 if (spec_die
!= NULL
)
2918 char *specification_prefix
= determine_prefix (spec_die
);
2919 processing_current_prefix
= specification_prefix
;
2920 back_to
= make_cleanup (xfree
, specification_prefix
);
2924 if (processing_has_namespace_info
)
2926 /* FIXME: carlton/2003-11-10: This variable exists only for
2927 const-correctness reasons. When I tried to change
2928 TYPE_TAG_NAME to be a const char *, I ran into a cascade
2929 of changes which would have forced decode_line_1 to take
2931 char *new_prefix
= obconcat (&objfile
->type_obstack
,
2932 processing_current_prefix
,
2933 processing_current_prefix
[0] == '\0'
2936 TYPE_TAG_NAME (type
) = new_prefix
;
2937 processing_current_prefix
= new_prefix
;
2941 TYPE_TAG_NAME (type
) = obsavestring (name
, strlen (name
),
2942 &objfile
->type_obstack
);
2943 need_to_update_name
= (cu_language
== language_cplus
);
2947 if (die
->tag
== DW_TAG_structure_type
)
2949 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2951 else if (die
->tag
== DW_TAG_union_type
)
2953 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2957 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2959 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2962 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2965 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2969 TYPE_LENGTH (type
) = 0;
2972 /* We need to add the type field to the die immediately so we don't
2973 infinitely recurse when dealing with pointers to the structure
2974 type within the structure itself. */
2977 if (die
->child
!= NULL
&& ! die_is_declaration (die
))
2979 struct field_info fi
;
2980 struct die_info
*child_die
;
2981 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2983 memset (&fi
, 0, sizeof (struct field_info
));
2985 child_die
= die
->child
;
2987 while (child_die
&& child_die
->tag
)
2989 if (child_die
->tag
== DW_TAG_member
2990 || child_die
->tag
== DW_TAG_variable
)
2992 /* NOTE: carlton/2002-11-05: A C++ static data member
2993 should be a DW_TAG_member that is a declaration, but
2994 all versions of G++ as of this writing (so through at
2995 least 3.2.1) incorrectly generate DW_TAG_variable
2996 tags for them instead. */
2997 dwarf2_add_field (&fi
, child_die
, cu
);
2999 else if (child_die
->tag
== DW_TAG_subprogram
)
3001 /* C++ member function. */
3002 process_die (child_die
, cu
);
3003 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3004 if (need_to_update_name
)
3006 /* The demangled names of member functions contain
3007 information about enclosing namespaces/classes,
3010 /* FIXME: carlton/2003-11-10: The excessive
3011 demangling here is a bit wasteful, as is the
3012 memory usage for names. */
3014 /* NOTE: carlton/2003-11-10: As commented in
3015 add_partial_structure, the demangler sometimes
3016 prints the type info in a different form from the
3017 debug info. We could solve this by using the
3018 demangled name to get the prefix; if doing so,
3019 however, we'd need to be careful when reading a
3020 class that's nested inside a template class.
3021 That would also cause problems when trying to
3022 determine RTTI information, since we use the
3023 demangler to determine the appropriate class
3025 char *actual_class_name
3026 = class_name_from_physname (dwarf2_linkage_name
3028 if (actual_class_name
!= NULL
3029 && strcmp (actual_class_name
, name
) != 0)
3031 TYPE_TAG_NAME (type
)
3032 = obsavestring (actual_class_name
,
3033 strlen (actual_class_name
),
3034 &objfile
->type_obstack
);
3036 xfree (actual_class_name
);
3037 need_to_update_name
= 0;
3040 else if (child_die
->tag
== DW_TAG_inheritance
)
3042 /* C++ base class field. */
3043 dwarf2_add_field (&fi
, child_die
, cu
);
3047 process_die (child_die
, cu
);
3049 child_die
= sibling_die (child_die
);
3052 /* Attach fields and member functions to the type. */
3054 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3057 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3059 /* Get the type which refers to the base class (possibly this
3060 class itself) which contains the vtable pointer for the current
3061 class from the DW_AT_containing_type attribute. */
3063 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
3065 struct type
*t
= die_containing_type (die
, cu
);
3067 TYPE_VPTR_BASETYPE (type
) = t
;
3070 static const char vptr_name
[] =
3071 {'_', 'v', 'p', 't', 'r', '\0'};
3074 /* Our own class provides vtbl ptr. */
3075 for (i
= TYPE_NFIELDS (t
) - 1;
3076 i
>= TYPE_N_BASECLASSES (t
);
3079 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3081 if ((strncmp (fieldname
, vptr_name
,
3082 strlen (vptr_name
) - 1)
3084 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
3086 TYPE_VPTR_FIELDNO (type
) = i
;
3091 /* Complain if virtual function table field not found. */
3092 if (i
< TYPE_N_BASECLASSES (t
))
3093 complaint (&symfile_complaints
,
3094 "virtual function table pointer not found when defining class '%s'",
3095 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3100 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3105 new_symbol (die
, type
, cu
);
3107 do_cleanups (back_to
);
3111 /* No children, must be stub. */
3112 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3115 processing_current_prefix
= previous_prefix
;
3116 if (back_to
!= NULL
)
3117 do_cleanups (back_to
);
3120 /* Given a pointer to a die which begins an enumeration, process all
3121 the dies that define the members of the enumeration.
3123 This will be much nicer in draft 6 of the DWARF spec when our
3124 members will be dies instead squished into the DW_AT_element_list
3127 NOTE: We reverse the order of the element list. */
3130 read_enumeration (struct die_info
*die
, struct dwarf2_cu
*cu
)
3132 struct objfile
*objfile
= cu
->objfile
;
3133 struct die_info
*child_die
;
3135 struct field
*fields
;
3136 struct attribute
*attr
;
3139 int unsigned_enum
= 1;
3141 type
= alloc_type (objfile
);
3143 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3144 attr
= dwarf_attr (die
, DW_AT_name
);
3145 if (attr
&& DW_STRING (attr
))
3147 const char *name
= DW_STRING (attr
);
3149 if (processing_has_namespace_info
)
3151 TYPE_TAG_NAME (type
) = obconcat (&objfile
->type_obstack
,
3152 processing_current_prefix
,
3153 processing_current_prefix
[0] == '\0'
3159 TYPE_TAG_NAME (type
) = obsavestring (name
, strlen (name
),
3160 &objfile
->type_obstack
);
3164 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3167 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3171 TYPE_LENGTH (type
) = 0;
3176 if (die
->child
!= NULL
)
3178 child_die
= die
->child
;
3179 while (child_die
&& child_die
->tag
)
3181 if (child_die
->tag
!= DW_TAG_enumerator
)
3183 process_die (child_die
, cu
);
3187 attr
= dwarf_attr (child_die
, DW_AT_name
);
3190 sym
= new_symbol (child_die
, type
, cu
);
3191 if (SYMBOL_VALUE (sym
) < 0)
3194 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3196 fields
= (struct field
*)
3198 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
3199 * sizeof (struct field
));
3202 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
3203 FIELD_TYPE (fields
[num_fields
]) = NULL
;
3204 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
3205 FIELD_BITSIZE (fields
[num_fields
]) = 0;
3206 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
3212 child_die
= sibling_die (child_die
);
3217 TYPE_NFIELDS (type
) = num_fields
;
3218 TYPE_FIELDS (type
) = (struct field
*)
3219 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
3220 memcpy (TYPE_FIELDS (type
), fields
,
3221 sizeof (struct field
) * num_fields
);
3225 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
3228 new_symbol (die
, type
, cu
);
3231 /* Extract all information from a DW_TAG_array_type DIE and put it in
3232 the DIE's type field. For now, this only handles one dimensional
3236 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3238 struct objfile
*objfile
= cu
->objfile
;
3239 struct die_info
*child_die
;
3240 struct type
*type
= NULL
;
3241 struct type
*element_type
, *range_type
, *index_type
;
3242 struct type
**range_types
= NULL
;
3243 struct attribute
*attr
;
3245 struct cleanup
*back_to
;
3247 /* Return if we've already decoded this type. */
3253 element_type
= die_type (die
, cu
);
3255 /* Irix 6.2 native cc creates array types without children for
3256 arrays with unspecified length. */
3257 if (die
->child
== NULL
)
3259 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3260 range_type
= create_range_type (NULL
, index_type
, 0, -1);
3261 die
->type
= create_array_type (NULL
, element_type
, range_type
);
3265 back_to
= make_cleanup (null_cleanup
, NULL
);
3266 child_die
= die
->child
;
3267 while (child_die
&& child_die
->tag
)
3269 if (child_die
->tag
== DW_TAG_subrange_type
)
3271 unsigned int low
, high
;
3273 /* Default bounds to an array with unspecified length. */
3276 if (cu_language
== language_fortran
)
3278 /* FORTRAN implies a lower bound of 1, if not given. */
3282 index_type
= die_type (child_die
, cu
);
3283 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
3286 if (attr
->form
== DW_FORM_sdata
)
3288 low
= DW_SND (attr
);
3290 else if (attr
->form
== DW_FORM_udata
3291 || attr
->form
== DW_FORM_data1
3292 || attr
->form
== DW_FORM_data2
3293 || attr
->form
== DW_FORM_data4
3294 || attr
->form
== DW_FORM_data8
)
3296 low
= DW_UNSND (attr
);
3300 dwarf2_non_const_array_bound_ignored_complaint
3301 (dwarf_form_name (attr
->form
));
3305 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
3308 if (attr
->form
== DW_FORM_sdata
)
3310 high
= DW_SND (attr
);
3312 else if (attr
->form
== DW_FORM_udata
3313 || attr
->form
== DW_FORM_data1
3314 || attr
->form
== DW_FORM_data2
3315 || attr
->form
== DW_FORM_data4
3316 || attr
->form
== DW_FORM_data8
)
3318 high
= DW_UNSND (attr
);
3320 else if (attr
->form
== DW_FORM_block1
)
3322 /* GCC encodes arrays with unspecified or dynamic length
3323 with a DW_FORM_block1 attribute.
3324 FIXME: GDB does not yet know how to handle dynamic
3325 arrays properly, treat them as arrays with unspecified
3328 FIXME: jimb/2003-09-22: GDB does not really know
3329 how to handle arrays of unspecified length
3330 either; we just represent them as zero-length
3331 arrays. Choose an appropriate upper bound given
3332 the lower bound we've computed above. */
3337 dwarf2_non_const_array_bound_ignored_complaint
3338 (dwarf_form_name (attr
->form
));
3343 /* Create a range type and save it for array type creation. */
3344 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
3346 range_types
= (struct type
**)
3347 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
3348 * sizeof (struct type
*));
3350 make_cleanup (free_current_contents
, &range_types
);
3352 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
3354 child_die
= sibling_die (child_die
);
3357 /* Dwarf2 dimensions are output from left to right, create the
3358 necessary array types in backwards order. */
3359 type
= element_type
;
3361 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
3363 /* Understand Dwarf2 support for vector types (like they occur on
3364 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3365 array type. This is not part of the Dwarf2/3 standard yet, but a
3366 custom vendor extension. The main difference between a regular
3367 array and the vector variant is that vectors are passed by value
3369 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
3371 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
3373 do_cleanups (back_to
);
3375 /* Install the type in the die. */
3379 /* First cut: install each common block member as a global variable. */
3382 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
3384 struct die_info
*child_die
;
3385 struct attribute
*attr
;
3387 CORE_ADDR base
= (CORE_ADDR
) 0;
3389 attr
= dwarf_attr (die
, DW_AT_location
);
3392 /* Support the .debug_loc offsets */
3393 if (attr_form_is_block (attr
))
3395 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
3397 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3399 dwarf2_complex_location_expr_complaint ();
3403 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3404 "common block member");
3407 if (die
->child
!= NULL
)
3409 child_die
= die
->child
;
3410 while (child_die
&& child_die
->tag
)
3412 sym
= new_symbol (child_die
, NULL
, cu
);
3413 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
3416 SYMBOL_VALUE_ADDRESS (sym
) =
3417 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
3418 add_symbol_to_list (sym
, &global_symbols
);
3420 child_die
= sibling_die (child_die
);
3425 /* Read a C++ namespace. */
3428 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
3430 struct objfile
*objfile
= cu
->objfile
;
3431 const char *previous_prefix
= processing_current_prefix
;
3434 struct die_info
*current_die
;
3436 name
= namespace_name (die
, &is_anonymous
);
3438 /* Now build the name of the current namespace. */
3440 if (previous_prefix
[0] == '\0')
3442 processing_current_prefix
= name
;
3446 /* We need temp_name around because processing_current_prefix
3447 is a const char *. */
3448 char *temp_name
= alloca (strlen (previous_prefix
)
3449 + 2 + strlen(name
) + 1);
3450 strcpy (temp_name
, previous_prefix
);
3451 strcat (temp_name
, "::");
3452 strcat (temp_name
, name
);
3454 processing_current_prefix
= temp_name
;
3457 /* Add a symbol associated to this if we haven't seen the namespace
3458 before. Also, add a using directive if it's an anonymous
3461 if (dwarf2_extension (die
) == NULL
)
3465 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3466 this cast will hopefully become unnecessary. */
3467 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
3468 (char *) processing_current_prefix
,
3470 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
3472 new_symbol (die
, type
, cu
);
3475 cp_add_using_directive (processing_current_prefix
,
3476 strlen (previous_prefix
),
3477 strlen (processing_current_prefix
));
3480 if (die
->child
!= NULL
)
3482 struct die_info
*child_die
= die
->child
;
3484 while (child_die
&& child_die
->tag
)
3486 process_die (child_die
, cu
);
3487 child_die
= sibling_die (child_die
);
3491 processing_current_prefix
= previous_prefix
;
3494 /* Return the name of the namespace represented by DIE. Set
3495 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
3499 namespace_name (struct die_info
*die
, int *is_anonymous
)
3501 struct die_info
*current_die
;
3502 const char *name
= NULL
;
3504 /* Loop through the extensions until we find a name. */
3506 for (current_die
= die
;
3507 current_die
!= NULL
;
3508 current_die
= dwarf2_extension (die
))
3510 name
= dwarf2_name (current_die
);
3515 /* Is it an anonymous namespace? */
3517 *is_anonymous
= (name
== NULL
);
3519 name
= "(anonymous namespace)";
3524 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3525 the user defined type vector. */
3528 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3530 struct comp_unit_head
*cu_header
= &cu
->header
;
3532 struct attribute
*attr_byte_size
;
3533 struct attribute
*attr_address_class
;
3534 int byte_size
, addr_class
;
3541 type
= lookup_pointer_type (die_type (die
, cu
));
3543 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
3545 byte_size
= DW_UNSND (attr_byte_size
);
3547 byte_size
= cu_header
->addr_size
;
3549 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
3550 if (attr_address_class
)
3551 addr_class
= DW_UNSND (attr_address_class
);
3553 addr_class
= DW_ADDR_none
;
3555 /* If the pointer size or address class is different than the
3556 default, create a type variant marked as such and set the
3557 length accordingly. */
3558 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3560 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3564 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3565 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3566 type
= make_type_with_address_space (type
, type_flags
);
3568 else if (TYPE_LENGTH (type
) != byte_size
)
3570 complaint (&symfile_complaints
, "invalid pointer size %d", byte_size
);
3573 /* Should we also complain about unhandled address classes? */
3577 TYPE_LENGTH (type
) = byte_size
;
3581 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3582 the user defined type vector. */
3585 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3587 struct objfile
*objfile
= cu
->objfile
;
3589 struct type
*to_type
;
3590 struct type
*domain
;
3597 type
= alloc_type (objfile
);
3598 to_type
= die_type (die
, cu
);
3599 domain
= die_containing_type (die
, cu
);
3600 smash_to_member_type (type
, domain
, to_type
);
3605 /* Extract all information from a DW_TAG_reference_type DIE and add to
3606 the user defined type vector. */
3609 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3611 struct comp_unit_head
*cu_header
= &cu
->header
;
3613 struct attribute
*attr
;
3620 type
= lookup_reference_type (die_type (die
, cu
));
3621 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3624 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3628 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3634 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3636 struct type
*base_type
;
3643 base_type
= die_type (die
, cu
);
3644 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3648 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3650 struct type
*base_type
;
3657 base_type
= die_type (die
, cu
);
3658 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3661 /* Extract all information from a DW_TAG_string_type DIE and add to
3662 the user defined type vector. It isn't really a user defined type,
3663 but it behaves like one, with other DIE's using an AT_user_def_type
3664 attribute to reference it. */
3667 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3669 struct objfile
*objfile
= cu
->objfile
;
3670 struct type
*type
, *range_type
, *index_type
, *char_type
;
3671 struct attribute
*attr
;
3672 unsigned int length
;
3679 attr
= dwarf_attr (die
, DW_AT_string_length
);
3682 length
= DW_UNSND (attr
);
3686 /* check for the DW_AT_byte_size attribute */
3687 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3690 length
= DW_UNSND (attr
);
3697 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3698 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3699 if (cu_language
== language_fortran
)
3701 /* Need to create a unique string type for bounds
3703 type
= create_string_type (0, range_type
);
3707 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3708 type
= create_string_type (char_type
, range_type
);
3713 /* Handle DIES due to C code like:
3717 int (*funcp)(int a, long l);
3721 ('funcp' generates a DW_TAG_subroutine_type DIE)
3725 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3727 struct type
*type
; /* Type that this function returns */
3728 struct type
*ftype
; /* Function that returns above type */
3729 struct attribute
*attr
;
3731 /* Decode the type that this subroutine returns */
3736 type
= die_type (die
, cu
);
3737 ftype
= lookup_function_type (type
);
3739 /* All functions in C++ have prototypes. */
3740 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3741 if ((attr
&& (DW_UNSND (attr
) != 0))
3742 || cu_language
== language_cplus
)
3743 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3745 if (die
->child
!= NULL
)
3747 struct die_info
*child_die
;
3751 /* Count the number of parameters.
3752 FIXME: GDB currently ignores vararg functions, but knows about
3753 vararg member functions. */
3754 child_die
= die
->child
;
3755 while (child_die
&& child_die
->tag
)
3757 if (child_die
->tag
== DW_TAG_formal_parameter
)
3759 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3760 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3761 child_die
= sibling_die (child_die
);
3764 /* Allocate storage for parameters and fill them in. */
3765 TYPE_NFIELDS (ftype
) = nparams
;
3766 TYPE_FIELDS (ftype
) = (struct field
*)
3767 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3769 child_die
= die
->child
;
3770 while (child_die
&& child_die
->tag
)
3772 if (child_die
->tag
== DW_TAG_formal_parameter
)
3774 /* Dwarf2 has no clean way to discern C++ static and non-static
3775 member functions. G++ helps GDB by marking the first
3776 parameter for non-static member functions (which is the
3777 this pointer) as artificial. We pass this information
3778 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3779 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3781 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3783 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3784 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
3787 child_die
= sibling_die (child_die
);
3795 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
3797 struct objfile
*objfile
= cu
->objfile
;
3798 struct attribute
*attr
;
3803 attr
= dwarf_attr (die
, DW_AT_name
);
3804 if (attr
&& DW_STRING (attr
))
3806 name
= DW_STRING (attr
);
3808 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3809 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
3813 /* Find a representation of a given base type and install
3814 it in the TYPE field of the die. */
3817 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3819 struct objfile
*objfile
= cu
->objfile
;
3821 struct attribute
*attr
;
3822 int encoding
= 0, size
= 0;
3824 /* If we've already decoded this die, this is a no-op. */
3830 attr
= dwarf_attr (die
, DW_AT_encoding
);
3833 encoding
= DW_UNSND (attr
);
3835 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3838 size
= DW_UNSND (attr
);
3840 attr
= dwarf_attr (die
, DW_AT_name
);
3841 if (attr
&& DW_STRING (attr
))
3843 enum type_code code
= TYPE_CODE_INT
;
3848 case DW_ATE_address
:
3849 /* Turn DW_ATE_address into a void * pointer. */
3850 code
= TYPE_CODE_PTR
;
3851 type_flags
|= TYPE_FLAG_UNSIGNED
;
3853 case DW_ATE_boolean
:
3854 code
= TYPE_CODE_BOOL
;
3855 type_flags
|= TYPE_FLAG_UNSIGNED
;
3857 case DW_ATE_complex_float
:
3858 code
= TYPE_CODE_COMPLEX
;
3861 code
= TYPE_CODE_FLT
;
3864 case DW_ATE_signed_char
:
3866 case DW_ATE_unsigned
:
3867 case DW_ATE_unsigned_char
:
3868 type_flags
|= TYPE_FLAG_UNSIGNED
;
3871 complaint (&symfile_complaints
, "unsupported DW_AT_encoding: '%s'",
3872 dwarf_type_encoding_name (encoding
));
3875 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3876 if (encoding
== DW_ATE_address
)
3877 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3878 else if (encoding
== DW_ATE_complex_float
)
3881 TYPE_TARGET_TYPE (type
)
3882 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3883 else if (size
== 16)
3884 TYPE_TARGET_TYPE (type
)
3885 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3887 TYPE_TARGET_TYPE (type
)
3888 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3893 type
= dwarf_base_type (encoding
, size
, cu
);
3898 /* Read a whole compilation unit into a linked list of dies. */
3900 static struct die_info
*
3901 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
3903 /* Reset die reference table; we are
3904 building new ones now. */
3905 dwarf2_empty_hash_tables ();
3907 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
3910 /* Read a single die and all its descendents. Set the die's sibling
3911 field to NULL; set other fields in the die correctly, and set all
3912 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
3913 location of the info_ptr after reading all of those dies. PARENT
3914 is the parent of the die in question. */
3916 static struct die_info
*
3917 read_die_and_children (char *info_ptr
, bfd
*abfd
,
3918 struct dwarf2_cu
*cu
,
3919 char **new_info_ptr
,
3920 struct die_info
*parent
)
3922 struct die_info
*die
;
3926 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
3927 store_in_ref_table (die
->offset
, die
);
3931 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
3937 *new_info_ptr
= cur_ptr
;
3940 die
->sibling
= NULL
;
3941 die
->parent
= parent
;
3945 /* Read a die, all of its descendents, and all of its siblings; set
3946 all of the fields of all of the dies correctly. Arguments are as
3947 in read_die_and_children. */
3949 static struct die_info
*
3950 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
3951 struct dwarf2_cu
*cu
,
3952 char **new_info_ptr
,
3953 struct die_info
*parent
)
3955 struct die_info
*first_die
, *last_sibling
;
3959 first_die
= last_sibling
= NULL
;
3963 struct die_info
*die
3964 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
3972 last_sibling
->sibling
= die
;
3977 *new_info_ptr
= cur_ptr
;
3987 /* Free a linked list of dies. */
3990 free_die_list (struct die_info
*dies
)
3992 struct die_info
*die
, *next
;
3997 if (die
->child
!= NULL
)
3998 free_die_list (die
->child
);
3999 next
= die
->sibling
;
4007 do_free_die_list_cleanup (void *dies
)
4009 free_die_list (dies
);
4012 static struct cleanup
*
4013 make_cleanup_free_die_list (struct die_info
*dies
)
4015 return make_cleanup (do_free_die_list_cleanup
, dies
);
4019 /* Read the contents of the section at OFFSET and of size SIZE from the
4020 object file specified by OBJFILE into the psymbol_obstack and return it. */
4023 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4025 bfd
*abfd
= objfile
->obfd
;
4027 bfd_size_type size
= bfd_get_section_size_before_reloc (sectp
);
4032 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
4034 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
4038 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4039 || bfd_bread (buf
, size
, abfd
) != size
)
4040 error ("Dwarf Error: Can't read DWARF data from '%s'",
4041 bfd_get_filename (abfd
));
4046 /* In DWARF version 2, the description of the debugging information is
4047 stored in a separate .debug_abbrev section. Before we read any
4048 dies from a section we read in all abbreviations and install them
4052 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4054 struct comp_unit_head
*cu_header
= &cu
->header
;
4056 struct abbrev_info
*cur_abbrev
;
4057 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4058 unsigned int abbrev_form
, hash_number
;
4060 /* Initialize dwarf2 abbrevs */
4061 memset (cu_header
->dwarf2_abbrevs
, 0,
4062 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
4064 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
4065 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4066 abbrev_ptr
+= bytes_read
;
4068 /* loop until we reach an abbrev number of 0 */
4069 while (abbrev_number
)
4071 cur_abbrev
= dwarf_alloc_abbrev ();
4073 /* read in abbrev header */
4074 cur_abbrev
->number
= abbrev_number
;
4075 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4076 abbrev_ptr
+= bytes_read
;
4077 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
4080 /* now read in declarations */
4081 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4082 abbrev_ptr
+= bytes_read
;
4083 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4084 abbrev_ptr
+= bytes_read
;
4087 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
4089 cur_abbrev
->attrs
= (struct attr_abbrev
*)
4090 xrealloc (cur_abbrev
->attrs
,
4091 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
4092 * sizeof (struct attr_abbrev
));
4094 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
4095 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
4096 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4097 abbrev_ptr
+= bytes_read
;
4098 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4099 abbrev_ptr
+= bytes_read
;
4102 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
4103 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
4104 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
4106 /* Get next abbreviation.
4107 Under Irix6 the abbreviations for a compilation unit are not
4108 always properly terminated with an abbrev number of 0.
4109 Exit loop if we encounter an abbreviation which we have
4110 already read (which means we are about to read the abbreviations
4111 for the next compile unit) or if the end of the abbreviation
4112 table is reached. */
4113 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
4114 >= dwarf_abbrev_size
)
4116 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4117 abbrev_ptr
+= bytes_read
;
4118 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
4123 /* Empty the abbrev table for a new compilation unit. */
4126 dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table
)
4129 struct abbrev_info
*abbrev
, *next
;
4130 struct abbrev_info
**abbrevs
;
4132 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
4134 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
4137 abbrev
= abbrevs
[i
];
4140 next
= abbrev
->next
;
4141 xfree (abbrev
->attrs
);
4149 /* Lookup an abbrev_info structure in the abbrev hash table. */
4151 static struct abbrev_info
*
4152 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
4154 struct comp_unit_head
*cu_header
= &cu
->header
;
4155 unsigned int hash_number
;
4156 struct abbrev_info
*abbrev
;
4158 hash_number
= number
% ABBREV_HASH_SIZE
;
4159 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
4163 if (abbrev
->number
== number
)
4166 abbrev
= abbrev
->next
;
4171 /* Read a minimal amount of information into the minimal die structure. */
4174 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
4175 char *info_ptr
, struct dwarf2_cu
*cu
)
4177 unsigned int abbrev_number
, bytes_read
, i
;
4178 struct abbrev_info
*abbrev
;
4179 struct attribute attr
;
4180 struct attribute spec_attr
;
4181 int found_spec_attr
= 0;
4182 int has_low_pc_attr
= 0;
4183 int has_high_pc_attr
= 0;
4185 *part_die
= zeroed_partial_die
;
4186 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4187 info_ptr
+= bytes_read
;
4191 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4194 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number
,
4195 bfd_get_filename (abfd
));
4197 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
4198 part_die
->tag
= abbrev
->tag
;
4199 part_die
->has_children
= abbrev
->has_children
;
4200 part_die
->abbrev
= abbrev_number
;
4202 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4204 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
4206 /* Store the data if it is of an attribute we want to keep in a
4207 partial symbol table. */
4212 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
4213 if (part_die
->name
== NULL
)
4214 part_die
->name
= DW_STRING (&attr
);
4216 case DW_AT_MIPS_linkage_name
:
4217 part_die
->name
= DW_STRING (&attr
);
4220 has_low_pc_attr
= 1;
4221 part_die
->lowpc
= DW_ADDR (&attr
);
4224 has_high_pc_attr
= 1;
4225 part_die
->highpc
= DW_ADDR (&attr
);
4227 case DW_AT_location
:
4228 /* Support the .debug_loc offsets */
4229 if (attr_form_is_block (&attr
))
4231 part_die
->locdesc
= DW_BLOCK (&attr
);
4233 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
4235 dwarf2_complex_location_expr_complaint ();
4239 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4240 "partial symbol information");
4243 case DW_AT_language
:
4244 part_die
->language
= DW_UNSND (&attr
);
4246 case DW_AT_external
:
4247 part_die
->is_external
= DW_UNSND (&attr
);
4249 case DW_AT_declaration
:
4250 part_die
->is_declaration
= DW_UNSND (&attr
);
4253 part_die
->has_type
= 1;
4255 case DW_AT_abstract_origin
:
4256 case DW_AT_specification
:
4257 found_spec_attr
= 1;
4261 /* Ignore absolute siblings, they might point outside of
4262 the current compile unit. */
4263 if (attr
.form
== DW_FORM_ref_addr
)
4264 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
4267 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
4274 /* If we found a reference attribute and the die has no name, try
4275 to find a name in the referred to die. */
4277 if (found_spec_attr
&& part_die
->name
== NULL
)
4279 struct partial_die_info spec_die
;
4282 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
4283 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu
);
4286 part_die
->name
= spec_die
.name
;
4288 /* Copy DW_AT_external attribute if it is set. */
4289 if (spec_die
.is_external
)
4290 part_die
->is_external
= spec_die
.is_external
;
4294 /* When using the GNU linker, .gnu.linkonce. sections are used to
4295 eliminate duplicate copies of functions and vtables and such.
4296 The linker will arbitrarily choose one and discard the others.
4297 The AT_*_pc values for such functions refer to local labels in
4298 these sections. If the section from that file was discarded, the
4299 labels are not in the output, so the relocs get a value of 0.
4300 If this is a discarded function, mark the pc bounds as invalid,
4301 so that GDB will ignore it. */
4302 if (has_low_pc_attr
&& has_high_pc_attr
4303 && part_die
->lowpc
< part_die
->highpc
4304 && (part_die
->lowpc
!= 0
4305 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
4306 part_die
->has_pc_info
= 1;
4310 /* Read the die from the .debug_info section buffer. Set DIEP to
4311 point to a newly allocated die with its information, except for its
4312 child, sibling, and parent fields. Set HAS_CHILDREN to tell
4313 whether the die has children or not. */
4316 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
4317 struct dwarf2_cu
*cu
, int *has_children
)
4319 unsigned int abbrev_number
, bytes_read
, i
, offset
;
4320 struct abbrev_info
*abbrev
;
4321 struct die_info
*die
;
4323 offset
= info_ptr
- dwarf_info_buffer
;
4324 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4325 info_ptr
+= bytes_read
;
4328 die
= dwarf_alloc_die ();
4330 die
->abbrev
= abbrev_number
;
4337 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4340 error ("Dwarf Error: could not find abbrev number %d [in module %s]",
4342 bfd_get_filename (abfd
));
4344 die
= dwarf_alloc_die ();
4345 die
->offset
= offset
;
4346 die
->tag
= abbrev
->tag
;
4347 die
->abbrev
= abbrev_number
;
4350 die
->num_attrs
= abbrev
->num_attrs
;
4351 die
->attrs
= (struct attribute
*)
4352 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
4354 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4356 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
4357 abfd
, info_ptr
, cu
);
4361 *has_children
= abbrev
->has_children
;
4365 /* Read an attribute value described by an attribute form. */
4368 read_attribute_value (struct attribute
*attr
, unsigned form
,
4369 bfd
*abfd
, char *info_ptr
,
4370 struct dwarf2_cu
*cu
)
4372 struct comp_unit_head
*cu_header
= &cu
->header
;
4373 unsigned int bytes_read
;
4374 struct dwarf_block
*blk
;
4380 case DW_FORM_ref_addr
:
4381 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
4382 info_ptr
+= bytes_read
;
4384 case DW_FORM_block2
:
4385 blk
= dwarf_alloc_block ();
4386 blk
->size
= read_2_bytes (abfd
, info_ptr
);
4388 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4389 info_ptr
+= blk
->size
;
4390 DW_BLOCK (attr
) = blk
;
4392 case DW_FORM_block4
:
4393 blk
= dwarf_alloc_block ();
4394 blk
->size
= read_4_bytes (abfd
, info_ptr
);
4396 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4397 info_ptr
+= blk
->size
;
4398 DW_BLOCK (attr
) = blk
;
4401 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4405 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4409 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4412 case DW_FORM_string
:
4413 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
4414 info_ptr
+= bytes_read
;
4417 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
4419 info_ptr
+= bytes_read
;
4422 blk
= dwarf_alloc_block ();
4423 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4424 info_ptr
+= bytes_read
;
4425 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4426 info_ptr
+= blk
->size
;
4427 DW_BLOCK (attr
) = blk
;
4429 case DW_FORM_block1
:
4430 blk
= dwarf_alloc_block ();
4431 blk
->size
= read_1_byte (abfd
, info_ptr
);
4433 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4434 info_ptr
+= blk
->size
;
4435 DW_BLOCK (attr
) = blk
;
4438 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4442 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4446 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
4447 info_ptr
+= bytes_read
;
4450 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4451 info_ptr
+= bytes_read
;
4454 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4458 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4462 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4466 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4469 case DW_FORM_ref_udata
:
4470 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4471 info_ptr
+= bytes_read
;
4473 case DW_FORM_indirect
:
4474 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4475 info_ptr
+= bytes_read
;
4476 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
4479 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4480 dwarf_form_name (form
),
4481 bfd_get_filename (abfd
));
4486 /* Read an attribute described by an abbreviated attribute. */
4489 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
4490 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
4492 attr
->name
= abbrev
->name
;
4493 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
4496 /* read dwarf information from a buffer */
4499 read_1_byte (bfd
*abfd
, char *buf
)
4501 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4505 read_1_signed_byte (bfd
*abfd
, char *buf
)
4507 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
4511 read_2_bytes (bfd
*abfd
, char *buf
)
4513 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4517 read_2_signed_bytes (bfd
*abfd
, char *buf
)
4519 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4523 read_4_bytes (bfd
*abfd
, char *buf
)
4525 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4529 read_4_signed_bytes (bfd
*abfd
, char *buf
)
4531 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4534 static unsigned long
4535 read_8_bytes (bfd
*abfd
, char *buf
)
4537 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4541 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
4543 struct comp_unit_head
*cu_header
= &cu
->header
;
4544 CORE_ADDR retval
= 0;
4546 if (cu_header
->signed_addr_p
)
4548 switch (cu_header
->addr_size
)
4551 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4554 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4557 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
4560 internal_error (__FILE__
, __LINE__
,
4561 "read_address: bad switch, signed [in module %s]",
4562 bfd_get_filename (abfd
));
4567 switch (cu_header
->addr_size
)
4570 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4573 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4576 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4579 internal_error (__FILE__
, __LINE__
,
4580 "read_address: bad switch, unsigned [in module %s]",
4581 bfd_get_filename (abfd
));
4585 *bytes_read
= cu_header
->addr_size
;
4589 /* Read the initial length from a section. The (draft) DWARF 3
4590 specification allows the initial length to take up either 4 bytes
4591 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4592 bytes describe the length and all offsets will be 8 bytes in length
4595 An older, non-standard 64-bit format is also handled by this
4596 function. The older format in question stores the initial length
4597 as an 8-byte quantity without an escape value. Lengths greater
4598 than 2^32 aren't very common which means that the initial 4 bytes
4599 is almost always zero. Since a length value of zero doesn't make
4600 sense for the 32-bit format, this initial zero can be considered to
4601 be an escape value which indicates the presence of the older 64-bit
4602 format. As written, the code can't detect (old format) lengths
4603 greater than 4GB. If it becomes necessary to handle lengths somewhat
4604 larger than 4GB, we could allow other small values (such as the
4605 non-sensical values of 1, 2, and 3) to also be used as escape values
4606 indicating the presence of the old format.
4608 The value returned via bytes_read should be used to increment
4609 the relevant pointer after calling read_initial_length().
4611 As a side effect, this function sets the fields initial_length_size
4612 and offset_size in cu_header to the values appropriate for the
4613 length field. (The format of the initial length field determines
4614 the width of file offsets to be fetched later with fetch_offset().)
4616 [ Note: read_initial_length() and read_offset() are based on the
4617 document entitled "DWARF Debugging Information Format", revision
4618 3, draft 8, dated November 19, 2001. This document was obtained
4621 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4623 This document is only a draft and is subject to change. (So beware.)
4625 Details regarding the older, non-standard 64-bit format were
4626 determined empirically by examining 64-bit ELF files produced
4627 by the SGI toolchain on an IRIX 6.5 machine.
4629 - Kevin, July 16, 2002
4633 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4638 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4640 if (retval
== 0xffffffff)
4642 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4644 if (cu_header
!= NULL
)
4646 cu_header
->initial_length_size
= 12;
4647 cu_header
->offset_size
= 8;
4650 else if (retval
== 0)
4652 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4654 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4656 if (cu_header
!= NULL
)
4658 cu_header
->initial_length_size
= 8;
4659 cu_header
->offset_size
= 8;
4665 if (cu_header
!= NULL
)
4667 cu_header
->initial_length_size
= 4;
4668 cu_header
->offset_size
= 4;
4675 /* Read an offset from the data stream. The size of the offset is
4676 given by cu_header->offset_size. */
4679 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4684 switch (cu_header
->offset_size
)
4687 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4691 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4695 internal_error (__FILE__
, __LINE__
,
4696 "read_offset: bad switch [in module %s]",
4697 bfd_get_filename (abfd
));
4704 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4706 /* If the size of a host char is 8 bits, we can return a pointer
4707 to the buffer, otherwise we have to copy the data to a buffer
4708 allocated on the temporary obstack. */
4709 gdb_assert (HOST_CHAR_BIT
== 8);
4714 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4716 /* If the size of a host char is 8 bits, we can return a pointer
4717 to the string, otherwise we have to copy the string to a buffer
4718 allocated on the temporary obstack. */
4719 gdb_assert (HOST_CHAR_BIT
== 8);
4722 *bytes_read_ptr
= 1;
4725 *bytes_read_ptr
= strlen (buf
) + 1;
4730 read_indirect_string (bfd
*abfd
, char *buf
,
4731 const struct comp_unit_head
*cu_header
,
4732 unsigned int *bytes_read_ptr
)
4734 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4735 (int *) bytes_read_ptr
);
4737 if (dwarf_str_buffer
== NULL
)
4739 error ("DW_FORM_strp used without .debug_str section [in module %s]",
4740 bfd_get_filename (abfd
));
4743 if (str_offset
>= dwarf_str_size
)
4745 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4746 bfd_get_filename (abfd
));
4749 gdb_assert (HOST_CHAR_BIT
== 8);
4750 if (dwarf_str_buffer
[str_offset
] == '\0')
4752 return dwarf_str_buffer
+ str_offset
;
4755 static unsigned long
4756 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4758 unsigned long result
;
4759 unsigned int num_read
;
4769 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4772 result
|= ((unsigned long)(byte
& 127) << shift
);
4773 if ((byte
& 128) == 0)
4779 *bytes_read_ptr
= num_read
;
4784 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4787 int i
, shift
, size
, num_read
;
4797 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4800 result
|= ((long)(byte
& 127) << shift
);
4802 if ((byte
& 128) == 0)
4807 if ((shift
< size
) && (byte
& 0x40))
4809 result
|= -(1 << shift
);
4811 *bytes_read_ptr
= num_read
;
4816 set_cu_language (unsigned int lang
)
4822 cu_language
= language_c
;
4824 case DW_LANG_C_plus_plus
:
4825 cu_language
= language_cplus
;
4827 case DW_LANG_Fortran77
:
4828 case DW_LANG_Fortran90
:
4829 case DW_LANG_Fortran95
:
4830 cu_language
= language_fortran
;
4832 case DW_LANG_Mips_Assembler
:
4833 cu_language
= language_asm
;
4836 cu_language
= language_java
;
4840 case DW_LANG_Cobol74
:
4841 case DW_LANG_Cobol85
:
4842 case DW_LANG_Pascal83
:
4843 case DW_LANG_Modula2
:
4845 cu_language
= language_minimal
;
4848 cu_language_defn
= language_def (cu_language
);
4851 /* Return the named attribute or NULL if not there. */
4853 static struct attribute
*
4854 dwarf_attr (struct die_info
*die
, unsigned int name
)
4857 struct attribute
*spec
= NULL
;
4859 for (i
= 0; i
< die
->num_attrs
; ++i
)
4861 if (die
->attrs
[i
].name
== name
)
4863 return &die
->attrs
[i
];
4865 if (die
->attrs
[i
].name
== DW_AT_specification
4866 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4867 spec
= &die
->attrs
[i
];
4871 struct die_info
*ref_die
=
4872 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4875 return dwarf_attr (ref_die
, name
);
4882 die_is_declaration (struct die_info
*die
)
4884 return (dwarf_attr (die
, DW_AT_declaration
)
4885 && ! dwarf_attr (die
, DW_AT_specification
));
4888 /* Return the die giving the specification for DIE, if there is
4891 static struct die_info
*
4892 die_specification (struct die_info
*die
)
4894 struct attribute
*spec_attr
= dwarf_attr (die
, DW_AT_specification
);
4896 if (spec_attr
== NULL
)
4899 return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr
));
4902 /* Free the line_header structure *LH, and any arrays and strings it
4905 free_line_header (struct line_header
*lh
)
4907 if (lh
->standard_opcode_lengths
)
4908 xfree (lh
->standard_opcode_lengths
);
4910 /* Remember that all the lh->file_names[i].name pointers are
4911 pointers into debug_line_buffer, and don't need to be freed. */
4913 xfree (lh
->file_names
);
4915 /* Similarly for the include directory names. */
4916 if (lh
->include_dirs
)
4917 xfree (lh
->include_dirs
);
4923 /* Add an entry to LH's include directory table. */
4925 add_include_dir (struct line_header
*lh
, char *include_dir
)
4927 /* Grow the array if necessary. */
4928 if (lh
->include_dirs_size
== 0)
4930 lh
->include_dirs_size
= 1; /* for testing */
4931 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4932 * sizeof (*lh
->include_dirs
));
4934 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4936 lh
->include_dirs_size
*= 2;
4937 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4938 (lh
->include_dirs_size
4939 * sizeof (*lh
->include_dirs
)));
4942 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4946 /* Add an entry to LH's file name table. */
4948 add_file_name (struct line_header
*lh
,
4950 unsigned int dir_index
,
4951 unsigned int mod_time
,
4952 unsigned int length
)
4954 struct file_entry
*fe
;
4956 /* Grow the array if necessary. */
4957 if (lh
->file_names_size
== 0)
4959 lh
->file_names_size
= 1; /* for testing */
4960 lh
->file_names
= xmalloc (lh
->file_names_size
4961 * sizeof (*lh
->file_names
));
4963 else if (lh
->num_file_names
>= lh
->file_names_size
)
4965 lh
->file_names_size
*= 2;
4966 lh
->file_names
= xrealloc (lh
->file_names
,
4967 (lh
->file_names_size
4968 * sizeof (*lh
->file_names
)));
4971 fe
= &lh
->file_names
[lh
->num_file_names
++];
4973 fe
->dir_index
= dir_index
;
4974 fe
->mod_time
= mod_time
;
4975 fe
->length
= length
;
4979 /* Read the statement program header starting at OFFSET in
4980 dwarf_line_buffer, according to the endianness of ABFD. Return a
4981 pointer to a struct line_header, allocated using xmalloc.
4983 NOTE: the strings in the include directory and file name tables of
4984 the returned object point into debug_line_buffer, and must not be
4986 static struct line_header
*
4987 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4988 struct dwarf2_cu
*cu
)
4990 struct cleanup
*back_to
;
4991 struct line_header
*lh
;
4995 char *cur_dir
, *cur_file
;
4997 if (dwarf_line_buffer
== NULL
)
4999 complaint (&symfile_complaints
, "missing .debug_line section");
5003 /* Make sure that at least there's room for the total_length field. That
5004 could be 12 bytes long, but we're just going to fudge that. */
5005 if (offset
+ 4 >= dwarf_line_size
)
5007 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5011 lh
= xmalloc (sizeof (*lh
));
5012 memset (lh
, 0, sizeof (*lh
));
5013 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
5016 line_ptr
= dwarf_line_buffer
+ offset
;
5018 /* read in the header */
5019 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
5020 line_ptr
+= bytes_read
;
5021 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
5023 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5026 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
5027 lh
->version
= read_2_bytes (abfd
, line_ptr
);
5029 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
5030 line_ptr
+= bytes_read
;
5031 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
5033 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
5035 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
5037 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
5039 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
5041 lh
->standard_opcode_lengths
5042 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
5044 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
5045 for (i
= 1; i
< lh
->opcode_base
; ++i
)
5047 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
5051 /* Read directory table */
5052 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
5054 line_ptr
+= bytes_read
;
5055 add_include_dir (lh
, cur_dir
);
5057 line_ptr
+= bytes_read
;
5059 /* Read file name table */
5060 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
5062 unsigned int dir_index
, mod_time
, length
;
5064 line_ptr
+= bytes_read
;
5065 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5066 line_ptr
+= bytes_read
;
5067 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5068 line_ptr
+= bytes_read
;
5069 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5070 line_ptr
+= bytes_read
;
5072 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5074 line_ptr
+= bytes_read
;
5075 lh
->statement_program_start
= line_ptr
;
5077 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
5078 complaint (&symfile_complaints
,
5079 "line number info header doesn't fit in `.debug_line' section");
5081 discard_cleanups (back_to
);
5085 /* This function exists to work around a bug in certain compilers
5086 (particularly GCC 2.95), in which the first line number marker of a
5087 function does not show up until after the prologue, right before
5088 the second line number marker. This function shifts ADDRESS down
5089 to the beginning of the function if necessary, and is called on
5090 addresses passed to record_line. */
5093 check_cu_functions (CORE_ADDR address
)
5095 struct function_range
*fn
;
5097 /* Find the function_range containing address. */
5102 cu_cached_fn
= cu_first_fn
;
5106 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5112 while (fn
&& fn
!= cu_cached_fn
)
5113 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5123 if (address
!= fn
->lowpc
)
5124 complaint (&symfile_complaints
,
5125 "misplaced first line number at 0x%lx for '%s'",
5126 (unsigned long) address
, fn
->name
);
5131 /* Decode the line number information for the compilation unit whose
5132 line number info is at OFFSET in the .debug_line section.
5133 The compilation directory of the file is passed in COMP_DIR. */
5136 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
5137 struct dwarf2_cu
*cu
)
5141 unsigned int bytes_read
;
5142 unsigned char op_code
, extended_op
, adj_opcode
;
5144 line_ptr
= lh
->statement_program_start
;
5145 line_end
= lh
->statement_program_end
;
5147 /* Read the statement sequences until there's nothing left. */
5148 while (line_ptr
< line_end
)
5150 /* state machine registers */
5151 CORE_ADDR address
= 0;
5152 unsigned int file
= 1;
5153 unsigned int line
= 1;
5154 unsigned int column
= 0;
5155 int is_stmt
= lh
->default_is_stmt
;
5156 int basic_block
= 0;
5157 int end_sequence
= 0;
5159 /* Start a subfile for the current file of the state machine. */
5160 if (lh
->num_file_names
>= file
)
5162 /* lh->include_dirs and lh->file_names are 0-based, but the
5163 directory and file name numbers in the statement program
5165 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
5168 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5171 dwarf2_start_subfile (fe
->name
, dir
);
5174 /* Decode the table. */
5175 while (!end_sequence
)
5177 op_code
= read_1_byte (abfd
, line_ptr
);
5180 if (op_code
>= lh
->opcode_base
)
5181 { /* Special operand. */
5182 adj_opcode
= op_code
- lh
->opcode_base
;
5183 address
+= (adj_opcode
/ lh
->line_range
)
5184 * lh
->minimum_instruction_length
;
5185 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
5186 /* append row to matrix using current values */
5187 record_line (current_subfile
, line
,
5188 check_cu_functions (address
));
5191 else switch (op_code
)
5193 case DW_LNS_extended_op
:
5194 line_ptr
+= 1; /* ignore length */
5195 extended_op
= read_1_byte (abfd
, line_ptr
);
5197 switch (extended_op
)
5199 case DW_LNE_end_sequence
:
5201 record_line (current_subfile
, 0, address
);
5203 case DW_LNE_set_address
:
5204 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
5205 line_ptr
+= bytes_read
;
5206 address
+= baseaddr
;
5208 case DW_LNE_define_file
:
5211 unsigned int dir_index
, mod_time
, length
;
5213 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
5214 line_ptr
+= bytes_read
;
5216 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5217 line_ptr
+= bytes_read
;
5219 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5220 line_ptr
+= bytes_read
;
5222 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5223 line_ptr
+= bytes_read
;
5224 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5228 complaint (&symfile_complaints
,
5229 "mangled .debug_line section");
5234 record_line (current_subfile
, line
,
5235 check_cu_functions (address
));
5238 case DW_LNS_advance_pc
:
5239 address
+= lh
->minimum_instruction_length
5240 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5241 line_ptr
+= bytes_read
;
5243 case DW_LNS_advance_line
:
5244 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
5245 line_ptr
+= bytes_read
;
5247 case DW_LNS_set_file
:
5249 /* lh->include_dirs and lh->file_names are 0-based,
5250 but the directory and file name numbers in the
5251 statement program are 1-based. */
5252 struct file_entry
*fe
;
5254 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5255 line_ptr
+= bytes_read
;
5256 fe
= &lh
->file_names
[file
- 1];
5258 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5261 dwarf2_start_subfile (fe
->name
, dir
);
5264 case DW_LNS_set_column
:
5265 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5266 line_ptr
+= bytes_read
;
5268 case DW_LNS_negate_stmt
:
5269 is_stmt
= (!is_stmt
);
5271 case DW_LNS_set_basic_block
:
5274 /* Add to the address register of the state machine the
5275 address increment value corresponding to special opcode
5276 255. Ie, this value is scaled by the minimum instruction
5277 length since special opcode 255 would have scaled the
5279 case DW_LNS_const_add_pc
:
5280 address
+= (lh
->minimum_instruction_length
5281 * ((255 - lh
->opcode_base
) / lh
->line_range
));
5283 case DW_LNS_fixed_advance_pc
:
5284 address
+= read_2_bytes (abfd
, line_ptr
);
5288 { /* Unknown standard opcode, ignore it. */
5290 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
5292 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5293 line_ptr
+= bytes_read
;
5301 /* Start a subfile for DWARF. FILENAME is the name of the file and
5302 DIRNAME the name of the source directory which contains FILENAME
5303 or NULL if not known.
5304 This routine tries to keep line numbers from identical absolute and
5305 relative file names in a common subfile.
5307 Using the `list' example from the GDB testsuite, which resides in
5308 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
5309 of /srcdir/list0.c yields the following debugging information for list0.c:
5311 DW_AT_name: /srcdir/list0.c
5312 DW_AT_comp_dir: /compdir
5313 files.files[0].name: list0.h
5314 files.files[0].dir: /srcdir
5315 files.files[1].name: list0.c
5316 files.files[1].dir: /srcdir
5318 The line number information for list0.c has to end up in a single
5319 subfile, so that `break /srcdir/list0.c:1' works as expected. */
5322 dwarf2_start_subfile (char *filename
, char *dirname
)
5324 /* If the filename isn't absolute, try to match an existing subfile
5325 with the full pathname. */
5327 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
5329 struct subfile
*subfile
;
5330 char *fullname
= concat (dirname
, "/", filename
, NULL
);
5332 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
5334 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
5336 current_subfile
= subfile
;
5343 start_subfile (filename
, dirname
);
5347 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
5348 struct dwarf2_cu
*cu
)
5350 struct objfile
*objfile
= cu
->objfile
;
5351 struct comp_unit_head
*cu_header
= &cu
->header
;
5353 /* NOTE drow/2003-01-30: There used to be a comment and some special
5354 code here to turn a symbol with DW_AT_external and a
5355 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
5356 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
5357 with some versions of binutils) where shared libraries could have
5358 relocations against symbols in their debug information - the
5359 minimal symbol would have the right address, but the debug info
5360 would not. It's no longer necessary, because we will explicitly
5361 apply relocations when we read in the debug information now. */
5363 /* A DW_AT_location attribute with no contents indicates that a
5364 variable has been optimized away. */
5365 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
5367 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
5371 /* Handle one degenerate form of location expression specially, to
5372 preserve GDB's previous behavior when section offsets are
5373 specified. If this is just a DW_OP_addr then mark this symbol
5376 if (attr_form_is_block (attr
)
5377 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
5378 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
5382 SYMBOL_VALUE_ADDRESS (sym
) =
5383 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
5384 fixup_symbol_section (sym
, objfile
);
5385 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
5386 SYMBOL_SECTION (sym
));
5387 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5391 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
5392 expression evaluator, and use LOC_COMPUTED only when necessary
5393 (i.e. when the value of a register or memory location is
5394 referenced, or a thread-local block, etc.). Then again, it might
5395 not be worthwhile. I'm assuming that it isn't unless performance
5396 or memory numbers show me otherwise. */
5398 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
5399 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
5402 /* Given a pointer to a DWARF information entry, figure out if we need
5403 to make a symbol table entry for it, and if so, create a new entry
5404 and return a pointer to it.
5405 If TYPE is NULL, determine symbol type from the die, otherwise
5406 used the passed type. */
5408 static struct symbol
*
5409 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
5411 struct objfile
*objfile
= cu
->objfile
;
5412 struct symbol
*sym
= NULL
;
5414 struct attribute
*attr
= NULL
;
5415 struct attribute
*attr2
= NULL
;
5417 if (die
->tag
!= DW_TAG_namespace
)
5418 name
= dwarf2_linkage_name (die
);
5420 name
= TYPE_NAME (type
);
5424 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
5425 sizeof (struct symbol
));
5426 OBJSTAT (objfile
, n_syms
++);
5427 memset (sym
, 0, sizeof (struct symbol
));
5429 /* Cache this symbol's name and the name's demangled form (if any). */
5430 SYMBOL_LANGUAGE (sym
) = cu_language
;
5431 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
5433 /* Default assumptions.
5434 Use the passed type or decode it from the die. */
5435 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5436 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5438 SYMBOL_TYPE (sym
) = type
;
5440 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
5441 attr
= dwarf_attr (die
, DW_AT_decl_line
);
5444 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
5449 attr
= dwarf_attr (die
, DW_AT_low_pc
);
5452 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
5454 SYMBOL_CLASS (sym
) = LOC_LABEL
;
5456 case DW_TAG_subprogram
:
5457 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
5459 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5460 attr2
= dwarf_attr (die
, DW_AT_external
);
5461 if (attr2
&& (DW_UNSND (attr2
) != 0))
5463 add_symbol_to_list (sym
, &global_symbols
);
5467 add_symbol_to_list (sym
, list_in_scope
);
5470 case DW_TAG_variable
:
5471 /* Compilation with minimal debug info may result in variables
5472 with missing type entries. Change the misleading `void' type
5473 to something sensible. */
5474 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
5475 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
5476 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
5477 "<variable, no debug info>",
5479 attr
= dwarf_attr (die
, DW_AT_const_value
);
5482 dwarf2_const_value (attr
, sym
, cu
);
5483 attr2
= dwarf_attr (die
, DW_AT_external
);
5484 if (attr2
&& (DW_UNSND (attr2
) != 0))
5485 add_symbol_to_list (sym
, &global_symbols
);
5487 add_symbol_to_list (sym
, list_in_scope
);
5490 attr
= dwarf_attr (die
, DW_AT_location
);
5493 var_decode_location (attr
, sym
, cu
);
5494 attr2
= dwarf_attr (die
, DW_AT_external
);
5495 if (attr2
&& (DW_UNSND (attr2
) != 0))
5496 add_symbol_to_list (sym
, &global_symbols
);
5498 add_symbol_to_list (sym
, list_in_scope
);
5502 /* We do not know the address of this symbol.
5503 If it is an external symbol and we have type information
5504 for it, enter the symbol as a LOC_UNRESOLVED symbol.
5505 The address of the variable will then be determined from
5506 the minimal symbol table whenever the variable is
5508 attr2
= dwarf_attr (die
, DW_AT_external
);
5509 if (attr2
&& (DW_UNSND (attr2
) != 0)
5510 && dwarf_attr (die
, DW_AT_type
) != NULL
)
5512 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
5513 add_symbol_to_list (sym
, &global_symbols
);
5517 case DW_TAG_formal_parameter
:
5518 attr
= dwarf_attr (die
, DW_AT_location
);
5521 var_decode_location (attr
, sym
, cu
);
5522 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
5523 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
5524 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
5526 attr
= dwarf_attr (die
, DW_AT_const_value
);
5529 dwarf2_const_value (attr
, sym
, cu
);
5531 add_symbol_to_list (sym
, list_in_scope
);
5533 case DW_TAG_unspecified_parameters
:
5534 /* From varargs functions; gdb doesn't seem to have any
5535 interest in this information, so just ignore it for now.
5538 case DW_TAG_class_type
:
5539 case DW_TAG_structure_type
:
5540 case DW_TAG_union_type
:
5541 case DW_TAG_enumeration_type
:
5542 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5543 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
5545 /* Make sure that the symbol includes appropriate enclosing
5546 classes/namespaces in its name. These are calculated in
5547 read_structure_scope, and the correct name is saved in
5550 if (cu_language
== language_cplus
)
5552 struct type
*type
= SYMBOL_TYPE (sym
);
5554 if (TYPE_TAG_NAME (type
) != NULL
)
5556 /* FIXME: carlton/2003-11-10: Should this use
5557 SYMBOL_SET_NAMES instead? (The same problem also
5558 arises a further down in the function.) */
5559 SYMBOL_LINKAGE_NAME (sym
)
5560 = obsavestring (TYPE_TAG_NAME (type
),
5561 strlen (TYPE_TAG_NAME (type
)),
5562 &objfile
->symbol_obstack
);
5567 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
5568 really ever be static objects: otherwise, if you try
5569 to, say, break of a class's method and you're in a file
5570 which doesn't mention that class, it won't work unless
5571 the check for all static symbols in lookup_symbol_aux
5572 saves you. See the OtherFileClass tests in
5573 gdb.c++/namespace.exp. */
5575 struct pending
**list_to_add
;
5577 list_to_add
= (list_in_scope
== &file_symbols
5578 && cu_language
== language_cplus
5579 ? &global_symbols
: list_in_scope
);
5581 add_symbol_to_list (sym
, list_to_add
);
5583 /* The semantics of C++ state that "struct foo { ... }" also
5584 defines a typedef for "foo". Synthesize a typedef symbol so
5585 that "ptype foo" works as expected. */
5586 if (cu_language
== language_cplus
)
5588 struct symbol
*typedef_sym
= (struct symbol
*)
5589 obstack_alloc (&objfile
->symbol_obstack
,
5590 sizeof (struct symbol
));
5591 *typedef_sym
= *sym
;
5592 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
5593 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5594 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5595 obsavestring (SYMBOL_NATURAL_NAME (sym
),
5596 strlen (SYMBOL_NATURAL_NAME (sym
)),
5597 &objfile
->type_obstack
);
5598 add_symbol_to_list (typedef_sym
, list_to_add
);
5602 case DW_TAG_typedef
:
5603 if (processing_has_namespace_info
5604 && processing_current_prefix
[0] != '\0')
5606 SYMBOL_LINKAGE_NAME (sym
) = obconcat (&objfile
->symbol_obstack
,
5607 processing_current_prefix
,
5611 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5612 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5613 add_symbol_to_list (sym
, list_in_scope
);
5615 case DW_TAG_base_type
:
5616 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5617 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5618 add_symbol_to_list (sym
, list_in_scope
);
5620 case DW_TAG_enumerator
:
5621 if (processing_has_namespace_info
5622 && processing_current_prefix
[0] != '\0')
5624 SYMBOL_LINKAGE_NAME (sym
) = obconcat (&objfile
->symbol_obstack
,
5625 processing_current_prefix
,
5629 attr
= dwarf_attr (die
, DW_AT_const_value
);
5632 dwarf2_const_value (attr
, sym
, cu
);
5635 /* NOTE: carlton/2003-11-10: See comment above in the
5636 DW_TAG_class_type, etc. block. */
5638 struct pending
**list_to_add
;
5640 list_to_add
= (list_in_scope
== &file_symbols
5641 && cu_language
== language_cplus
5642 ? &global_symbols
: list_in_scope
);
5644 add_symbol_to_list (sym
, list_to_add
);
5647 case DW_TAG_namespace
:
5648 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5649 add_symbol_to_list (sym
, &global_symbols
);
5652 /* Not a tag we recognize. Hopefully we aren't processing
5653 trash data, but since we must specifically ignore things
5654 we don't recognize, there is nothing else we should do at
5656 complaint (&symfile_complaints
, "unsupported tag: '%s'",
5657 dwarf_tag_name (die
->tag
));
5664 /* Copy constant value from an attribute to a symbol. */
5667 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5668 struct dwarf2_cu
*cu
)
5670 struct objfile
*objfile
= cu
->objfile
;
5671 struct comp_unit_head
*cu_header
= &cu
->header
;
5672 struct dwarf_block
*blk
;
5677 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5678 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5679 cu_header
->addr_size
,
5680 TYPE_LENGTH (SYMBOL_TYPE
5682 SYMBOL_VALUE_BYTES (sym
) = (char *)
5683 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5684 /* NOTE: cagney/2003-05-09: In-lined store_address call with
5685 it's body - store_unsigned_integer. */
5686 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5688 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5690 case DW_FORM_block1
:
5691 case DW_FORM_block2
:
5692 case DW_FORM_block4
:
5694 blk
= DW_BLOCK (attr
);
5695 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5696 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5698 TYPE_LENGTH (SYMBOL_TYPE
5700 SYMBOL_VALUE_BYTES (sym
) = (char *)
5701 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5702 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5703 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5706 /* The DW_AT_const_value attributes are supposed to carry the
5707 symbol's value "represented as it would be on the target
5708 architecture." By the time we get here, it's already been
5709 converted to host endianness, so we just need to sign- or
5710 zero-extend it as appropriate. */
5712 dwarf2_const_value_data (attr
, sym
, 8);
5715 dwarf2_const_value_data (attr
, sym
, 16);
5718 dwarf2_const_value_data (attr
, sym
, 32);
5721 dwarf2_const_value_data (attr
, sym
, 64);
5725 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5726 SYMBOL_CLASS (sym
) = LOC_CONST
;
5730 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5731 SYMBOL_CLASS (sym
) = LOC_CONST
;
5735 complaint (&symfile_complaints
,
5736 "unsupported const value attribute form: '%s'",
5737 dwarf_form_name (attr
->form
));
5738 SYMBOL_VALUE (sym
) = 0;
5739 SYMBOL_CLASS (sym
) = LOC_CONST
;
5745 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5746 or zero-extend it as appropriate for the symbol's type. */
5748 dwarf2_const_value_data (struct attribute
*attr
,
5752 LONGEST l
= DW_UNSND (attr
);
5754 if (bits
< sizeof (l
) * 8)
5756 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5757 l
&= ((LONGEST
) 1 << bits
) - 1;
5759 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5762 SYMBOL_VALUE (sym
) = l
;
5763 SYMBOL_CLASS (sym
) = LOC_CONST
;
5767 /* Return the type of the die in question using its DW_AT_type attribute. */
5769 static struct type
*
5770 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5773 struct attribute
*type_attr
;
5774 struct die_info
*type_die
;
5777 type_attr
= dwarf_attr (die
, DW_AT_type
);
5780 /* A missing DW_AT_type represents a void type. */
5781 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
);
5785 ref
= dwarf2_get_ref_die_offset (type_attr
);
5786 type_die
= follow_die_ref (ref
);
5789 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5790 ref
, cu
->objfile
->name
);
5794 type
= tag_type_to_type (type_die
, cu
);
5797 dump_die (type_die
);
5798 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5804 /* Return the containing type of the die in question using its
5805 DW_AT_containing_type attribute. */
5807 static struct type
*
5808 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5810 struct type
*type
= NULL
;
5811 struct attribute
*type_attr
;
5812 struct die_info
*type_die
= NULL
;
5815 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5818 ref
= dwarf2_get_ref_die_offset (type_attr
);
5819 type_die
= follow_die_ref (ref
);
5822 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref
,
5826 type
= tag_type_to_type (type_die
, cu
);
5831 dump_die (type_die
);
5832 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
5839 static struct type
*
5840 type_at_offset (unsigned int offset
, struct dwarf2_cu
*cu
)
5842 struct die_info
*die
;
5845 die
= follow_die_ref (offset
);
5848 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5851 type
= tag_type_to_type (die
, cu
);
5856 static struct type
*
5857 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5865 read_type_die (die
, cu
);
5869 error ("Dwarf Error: Cannot find type of die [in module %s]",
5877 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
5879 char *prefix
= determine_prefix (die
);
5880 const char *old_prefix
= processing_current_prefix
;
5881 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
5882 processing_current_prefix
= prefix
;
5886 case DW_TAG_class_type
:
5887 case DW_TAG_structure_type
:
5888 case DW_TAG_union_type
:
5889 read_structure_scope (die
, cu
);
5891 case DW_TAG_enumeration_type
:
5892 read_enumeration (die
, cu
);
5894 case DW_TAG_subprogram
:
5895 case DW_TAG_subroutine_type
:
5896 read_subroutine_type (die
, cu
);
5898 case DW_TAG_array_type
:
5899 read_array_type (die
, cu
);
5901 case DW_TAG_pointer_type
:
5902 read_tag_pointer_type (die
, cu
);
5904 case DW_TAG_ptr_to_member_type
:
5905 read_tag_ptr_to_member_type (die
, cu
);
5907 case DW_TAG_reference_type
:
5908 read_tag_reference_type (die
, cu
);
5910 case DW_TAG_const_type
:
5911 read_tag_const_type (die
, cu
);
5913 case DW_TAG_volatile_type
:
5914 read_tag_volatile_type (die
, cu
);
5916 case DW_TAG_string_type
:
5917 read_tag_string_type (die
, cu
);
5919 case DW_TAG_typedef
:
5920 read_typedef (die
, cu
);
5922 case DW_TAG_base_type
:
5923 read_base_type (die
, cu
);
5926 complaint (&symfile_complaints
, "unexepected tag in read_type_die: '%s'",
5927 dwarf_tag_name (die
->tag
));
5931 processing_current_prefix
= old_prefix
;
5932 do_cleanups (back_to
);
5935 /* Return the name of the namespace/class that DIE is defined
5936 within, or NULL if we can't tell. The caller should xfree the
5940 determine_prefix (struct die_info
*die
)
5942 struct die_info
*parent
;
5944 if (cu_language
!= language_cplus
)
5947 parent
= die
->parent
;
5951 return (processing_has_namespace_info
? xstrdup ("") : NULL
);
5955 char *parent_prefix
= determine_prefix (parent
);
5958 switch (parent
->tag
) {
5959 case DW_TAG_namespace
:
5963 retval
= typename_concat (parent_prefix
,
5964 namespace_name (parent
, &dummy
));
5967 case DW_TAG_class_type
:
5968 case DW_TAG_structure_type
:
5970 if (parent_prefix
!= NULL
)
5972 const char *parent_name
= dwarf2_name (parent
);
5974 if (parent_name
!= NULL
)
5975 retval
= typename_concat (parent_prefix
, dwarf2_name (parent
));
5977 /* FIXME: carlton/2003-11-10: I'm not sure what the
5978 best thing to do here is. */
5979 retval
= typename_concat (parent_prefix
,
5980 "<<anonymous class>>");
5983 retval
= class_name (parent
);
5987 retval
= parent_prefix
;
5991 if (retval
!= parent_prefix
)
5992 xfree (parent_prefix
);
5997 /* Return a newly-allocated string formed by concatenating PREFIX,
5998 "::", and SUFFIX, except that if PREFIX is NULL or the empty
5999 string, just return a copy of SUFFIX. */
6002 typename_concat (const char *prefix
, const char *suffix
)
6004 if (prefix
== NULL
|| prefix
[0] == '\0')
6005 return xstrdup (suffix
);
6008 char *retval
= xmalloc (strlen (prefix
) + 2 + strlen (suffix
) + 1);
6010 strcpy (retval
, prefix
);
6011 strcat (retval
, "::");
6012 strcat (retval
, suffix
);
6018 /* Return a newly-allocated string giving the name of the class given
6022 class_name (struct die_info
*die
)
6024 struct die_info
*child
;
6027 for (child
= die
->child
; child
!= NULL
; child
= sibling_die (child
))
6029 if (child
->tag
== DW_TAG_subprogram
)
6030 return class_name_from_physname (dwarf2_linkage_name (child
));
6033 name
= dwarf2_name (die
);
6035 return xstrdup (name
);
6037 return xstrdup ("");
6040 static struct type
*
6041 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
6043 struct objfile
*objfile
= cu
->objfile
;
6045 /* FIXME - this should not produce a new (struct type *)
6046 every time. It should cache base types. */
6050 case DW_ATE_address
:
6051 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
6053 case DW_ATE_boolean
:
6054 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
6056 case DW_ATE_complex_float
:
6059 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
6063 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
6069 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
6073 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
6080 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
6083 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
6087 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
6091 case DW_ATE_signed_char
:
6092 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
6094 case DW_ATE_unsigned
:
6098 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
6101 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
6105 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
6109 case DW_ATE_unsigned_char
:
6110 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
6113 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
6120 copy_die (struct die_info
*old_die
)
6122 struct die_info
*new_die
;
6125 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6126 memset (new_die
, 0, sizeof (struct die_info
));
6128 new_die
->tag
= old_die
->tag
;
6129 new_die
->has_children
= old_die
->has_children
;
6130 new_die
->abbrev
= old_die
->abbrev
;
6131 new_die
->offset
= old_die
->offset
;
6132 new_die
->type
= NULL
;
6134 num_attrs
= old_die
->num_attrs
;
6135 new_die
->num_attrs
= num_attrs
;
6136 new_die
->attrs
= (struct attribute
*)
6137 xmalloc (num_attrs
* sizeof (struct attribute
));
6139 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
6141 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
6142 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
6143 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
6146 new_die
->next
= NULL
;
6151 /* Return sibling of die, NULL if no sibling. */
6153 static struct die_info
*
6154 sibling_die (struct die_info
*die
)
6156 return die
->sibling
;
6159 /* Get linkage name of a die, return NULL if not found. */
6162 dwarf2_linkage_name (struct die_info
*die
)
6164 struct attribute
*attr
;
6166 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
6167 if (attr
&& DW_STRING (attr
))
6168 return DW_STRING (attr
);
6169 attr
= dwarf_attr (die
, DW_AT_name
);
6170 if (attr
&& DW_STRING (attr
))
6171 return DW_STRING (attr
);
6175 /* Get name of a die, return NULL if not found. */
6178 dwarf2_name (struct die_info
*die
)
6180 struct attribute
*attr
;
6182 attr
= dwarf_attr (die
, DW_AT_name
);
6183 if (attr
&& DW_STRING (attr
))
6184 return DW_STRING (attr
);
6188 /* Return the die that this die in an extension of, or NULL if there
6191 static struct die_info
*
6192 dwarf2_extension (struct die_info
*die
)
6194 struct attribute
*attr
;
6195 struct die_info
*extension_die
;
6198 attr
= dwarf_attr (die
, DW_AT_extension
);
6202 ref
= dwarf2_get_ref_die_offset (attr
);
6203 extension_die
= follow_die_ref (ref
);
6206 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
6209 return extension_die
;
6212 /* Convert a DIE tag into its string name. */
6215 dwarf_tag_name (unsigned tag
)
6219 case DW_TAG_padding
:
6220 return "DW_TAG_padding";
6221 case DW_TAG_array_type
:
6222 return "DW_TAG_array_type";
6223 case DW_TAG_class_type
:
6224 return "DW_TAG_class_type";
6225 case DW_TAG_entry_point
:
6226 return "DW_TAG_entry_point";
6227 case DW_TAG_enumeration_type
:
6228 return "DW_TAG_enumeration_type";
6229 case DW_TAG_formal_parameter
:
6230 return "DW_TAG_formal_parameter";
6231 case DW_TAG_imported_declaration
:
6232 return "DW_TAG_imported_declaration";
6234 return "DW_TAG_label";
6235 case DW_TAG_lexical_block
:
6236 return "DW_TAG_lexical_block";
6238 return "DW_TAG_member";
6239 case DW_TAG_pointer_type
:
6240 return "DW_TAG_pointer_type";
6241 case DW_TAG_reference_type
:
6242 return "DW_TAG_reference_type";
6243 case DW_TAG_compile_unit
:
6244 return "DW_TAG_compile_unit";
6245 case DW_TAG_string_type
:
6246 return "DW_TAG_string_type";
6247 case DW_TAG_structure_type
:
6248 return "DW_TAG_structure_type";
6249 case DW_TAG_subroutine_type
:
6250 return "DW_TAG_subroutine_type";
6251 case DW_TAG_typedef
:
6252 return "DW_TAG_typedef";
6253 case DW_TAG_union_type
:
6254 return "DW_TAG_union_type";
6255 case DW_TAG_unspecified_parameters
:
6256 return "DW_TAG_unspecified_parameters";
6257 case DW_TAG_variant
:
6258 return "DW_TAG_variant";
6259 case DW_TAG_common_block
:
6260 return "DW_TAG_common_block";
6261 case DW_TAG_common_inclusion
:
6262 return "DW_TAG_common_inclusion";
6263 case DW_TAG_inheritance
:
6264 return "DW_TAG_inheritance";
6265 case DW_TAG_inlined_subroutine
:
6266 return "DW_TAG_inlined_subroutine";
6268 return "DW_TAG_module";
6269 case DW_TAG_ptr_to_member_type
:
6270 return "DW_TAG_ptr_to_member_type";
6271 case DW_TAG_set_type
:
6272 return "DW_TAG_set_type";
6273 case DW_TAG_subrange_type
:
6274 return "DW_TAG_subrange_type";
6275 case DW_TAG_with_stmt
:
6276 return "DW_TAG_with_stmt";
6277 case DW_TAG_access_declaration
:
6278 return "DW_TAG_access_declaration";
6279 case DW_TAG_base_type
:
6280 return "DW_TAG_base_type";
6281 case DW_TAG_catch_block
:
6282 return "DW_TAG_catch_block";
6283 case DW_TAG_const_type
:
6284 return "DW_TAG_const_type";
6285 case DW_TAG_constant
:
6286 return "DW_TAG_constant";
6287 case DW_TAG_enumerator
:
6288 return "DW_TAG_enumerator";
6289 case DW_TAG_file_type
:
6290 return "DW_TAG_file_type";
6292 return "DW_TAG_friend";
6293 case DW_TAG_namelist
:
6294 return "DW_TAG_namelist";
6295 case DW_TAG_namelist_item
:
6296 return "DW_TAG_namelist_item";
6297 case DW_TAG_packed_type
:
6298 return "DW_TAG_packed_type";
6299 case DW_TAG_subprogram
:
6300 return "DW_TAG_subprogram";
6301 case DW_TAG_template_type_param
:
6302 return "DW_TAG_template_type_param";
6303 case DW_TAG_template_value_param
:
6304 return "DW_TAG_template_value_param";
6305 case DW_TAG_thrown_type
:
6306 return "DW_TAG_thrown_type";
6307 case DW_TAG_try_block
:
6308 return "DW_TAG_try_block";
6309 case DW_TAG_variant_part
:
6310 return "DW_TAG_variant_part";
6311 case DW_TAG_variable
:
6312 return "DW_TAG_variable";
6313 case DW_TAG_volatile_type
:
6314 return "DW_TAG_volatile_type";
6315 case DW_TAG_dwarf_procedure
:
6316 return "DW_TAG_dwarf_procedure";
6317 case DW_TAG_restrict_type
:
6318 return "DW_TAG_restrict_type";
6319 case DW_TAG_interface_type
:
6320 return "DW_TAG_interface_type";
6321 case DW_TAG_namespace
:
6322 return "DW_TAG_namespace";
6323 case DW_TAG_imported_module
:
6324 return "DW_TAG_imported_module";
6325 case DW_TAG_unspecified_type
:
6326 return "DW_TAG_unspecified_type";
6327 case DW_TAG_partial_unit
:
6328 return "DW_TAG_partial_unit";
6329 case DW_TAG_imported_unit
:
6330 return "DW_TAG_imported_unit";
6331 case DW_TAG_MIPS_loop
:
6332 return "DW_TAG_MIPS_loop";
6333 case DW_TAG_format_label
:
6334 return "DW_TAG_format_label";
6335 case DW_TAG_function_template
:
6336 return "DW_TAG_function_template";
6337 case DW_TAG_class_template
:
6338 return "DW_TAG_class_template";
6340 return "DW_TAG_<unknown>";
6344 /* Convert a DWARF attribute code into its string name. */
6347 dwarf_attr_name (unsigned attr
)
6352 return "DW_AT_sibling";
6353 case DW_AT_location
:
6354 return "DW_AT_location";
6356 return "DW_AT_name";
6357 case DW_AT_ordering
:
6358 return "DW_AT_ordering";
6359 case DW_AT_subscr_data
:
6360 return "DW_AT_subscr_data";
6361 case DW_AT_byte_size
:
6362 return "DW_AT_byte_size";
6363 case DW_AT_bit_offset
:
6364 return "DW_AT_bit_offset";
6365 case DW_AT_bit_size
:
6366 return "DW_AT_bit_size";
6367 case DW_AT_element_list
:
6368 return "DW_AT_element_list";
6369 case DW_AT_stmt_list
:
6370 return "DW_AT_stmt_list";
6372 return "DW_AT_low_pc";
6374 return "DW_AT_high_pc";
6375 case DW_AT_language
:
6376 return "DW_AT_language";
6378 return "DW_AT_member";
6380 return "DW_AT_discr";
6381 case DW_AT_discr_value
:
6382 return "DW_AT_discr_value";
6383 case DW_AT_visibility
:
6384 return "DW_AT_visibility";
6386 return "DW_AT_import";
6387 case DW_AT_string_length
:
6388 return "DW_AT_string_length";
6389 case DW_AT_common_reference
:
6390 return "DW_AT_common_reference";
6391 case DW_AT_comp_dir
:
6392 return "DW_AT_comp_dir";
6393 case DW_AT_const_value
:
6394 return "DW_AT_const_value";
6395 case DW_AT_containing_type
:
6396 return "DW_AT_containing_type";
6397 case DW_AT_default_value
:
6398 return "DW_AT_default_value";
6400 return "DW_AT_inline";
6401 case DW_AT_is_optional
:
6402 return "DW_AT_is_optional";
6403 case DW_AT_lower_bound
:
6404 return "DW_AT_lower_bound";
6405 case DW_AT_producer
:
6406 return "DW_AT_producer";
6407 case DW_AT_prototyped
:
6408 return "DW_AT_prototyped";
6409 case DW_AT_return_addr
:
6410 return "DW_AT_return_addr";
6411 case DW_AT_start_scope
:
6412 return "DW_AT_start_scope";
6413 case DW_AT_stride_size
:
6414 return "DW_AT_stride_size";
6415 case DW_AT_upper_bound
:
6416 return "DW_AT_upper_bound";
6417 case DW_AT_abstract_origin
:
6418 return "DW_AT_abstract_origin";
6419 case DW_AT_accessibility
:
6420 return "DW_AT_accessibility";
6421 case DW_AT_address_class
:
6422 return "DW_AT_address_class";
6423 case DW_AT_artificial
:
6424 return "DW_AT_artificial";
6425 case DW_AT_base_types
:
6426 return "DW_AT_base_types";
6427 case DW_AT_calling_convention
:
6428 return "DW_AT_calling_convention";
6430 return "DW_AT_count";
6431 case DW_AT_data_member_location
:
6432 return "DW_AT_data_member_location";
6433 case DW_AT_decl_column
:
6434 return "DW_AT_decl_column";
6435 case DW_AT_decl_file
:
6436 return "DW_AT_decl_file";
6437 case DW_AT_decl_line
:
6438 return "DW_AT_decl_line";
6439 case DW_AT_declaration
:
6440 return "DW_AT_declaration";
6441 case DW_AT_discr_list
:
6442 return "DW_AT_discr_list";
6443 case DW_AT_encoding
:
6444 return "DW_AT_encoding";
6445 case DW_AT_external
:
6446 return "DW_AT_external";
6447 case DW_AT_frame_base
:
6448 return "DW_AT_frame_base";
6450 return "DW_AT_friend";
6451 case DW_AT_identifier_case
:
6452 return "DW_AT_identifier_case";
6453 case DW_AT_macro_info
:
6454 return "DW_AT_macro_info";
6455 case DW_AT_namelist_items
:
6456 return "DW_AT_namelist_items";
6457 case DW_AT_priority
:
6458 return "DW_AT_priority";
6460 return "DW_AT_segment";
6461 case DW_AT_specification
:
6462 return "DW_AT_specification";
6463 case DW_AT_static_link
:
6464 return "DW_AT_static_link";
6466 return "DW_AT_type";
6467 case DW_AT_use_location
:
6468 return "DW_AT_use_location";
6469 case DW_AT_variable_parameter
:
6470 return "DW_AT_variable_parameter";
6471 case DW_AT_virtuality
:
6472 return "DW_AT_virtuality";
6473 case DW_AT_vtable_elem_location
:
6474 return "DW_AT_vtable_elem_location";
6475 case DW_AT_allocated
:
6476 return "DW_AT_allocated";
6477 case DW_AT_associated
:
6478 return "DW_AT_associated";
6479 case DW_AT_data_location
:
6480 return "DW_AT_data_location";
6482 return "DW_AT_stride";
6483 case DW_AT_entry_pc
:
6484 return "DW_AT_entry_pc";
6485 case DW_AT_use_UTF8
:
6486 return "DW_AT_use_UTF8";
6487 case DW_AT_extension
:
6488 return "DW_AT_extension";
6490 return "DW_AT_ranges";
6491 case DW_AT_trampoline
:
6492 return "DW_AT_trampoline";
6493 case DW_AT_call_column
:
6494 return "DW_AT_call_column";
6495 case DW_AT_call_file
:
6496 return "DW_AT_call_file";
6497 case DW_AT_call_line
:
6498 return "DW_AT_call_line";
6500 case DW_AT_MIPS_fde
:
6501 return "DW_AT_MIPS_fde";
6502 case DW_AT_MIPS_loop_begin
:
6503 return "DW_AT_MIPS_loop_begin";
6504 case DW_AT_MIPS_tail_loop_begin
:
6505 return "DW_AT_MIPS_tail_loop_begin";
6506 case DW_AT_MIPS_epilog_begin
:
6507 return "DW_AT_MIPS_epilog_begin";
6508 case DW_AT_MIPS_loop_unroll_factor
:
6509 return "DW_AT_MIPS_loop_unroll_factor";
6510 case DW_AT_MIPS_software_pipeline_depth
:
6511 return "DW_AT_MIPS_software_pipeline_depth";
6513 case DW_AT_MIPS_linkage_name
:
6514 return "DW_AT_MIPS_linkage_name";
6516 case DW_AT_sf_names
:
6517 return "DW_AT_sf_names";
6518 case DW_AT_src_info
:
6519 return "DW_AT_src_info";
6520 case DW_AT_mac_info
:
6521 return "DW_AT_mac_info";
6522 case DW_AT_src_coords
:
6523 return "DW_AT_src_coords";
6524 case DW_AT_body_begin
:
6525 return "DW_AT_body_begin";
6526 case DW_AT_body_end
:
6527 return "DW_AT_body_end";
6528 case DW_AT_GNU_vector
:
6529 return "DW_AT_GNU_vector";
6531 return "DW_AT_<unknown>";
6535 /* Convert a DWARF value form code into its string name. */
6538 dwarf_form_name (unsigned form
)
6543 return "DW_FORM_addr";
6544 case DW_FORM_block2
:
6545 return "DW_FORM_block2";
6546 case DW_FORM_block4
:
6547 return "DW_FORM_block4";
6549 return "DW_FORM_data2";
6551 return "DW_FORM_data4";
6553 return "DW_FORM_data8";
6554 case DW_FORM_string
:
6555 return "DW_FORM_string";
6557 return "DW_FORM_block";
6558 case DW_FORM_block1
:
6559 return "DW_FORM_block1";
6561 return "DW_FORM_data1";
6563 return "DW_FORM_flag";
6565 return "DW_FORM_sdata";
6567 return "DW_FORM_strp";
6569 return "DW_FORM_udata";
6570 case DW_FORM_ref_addr
:
6571 return "DW_FORM_ref_addr";
6573 return "DW_FORM_ref1";
6575 return "DW_FORM_ref2";
6577 return "DW_FORM_ref4";
6579 return "DW_FORM_ref8";
6580 case DW_FORM_ref_udata
:
6581 return "DW_FORM_ref_udata";
6582 case DW_FORM_indirect
:
6583 return "DW_FORM_indirect";
6585 return "DW_FORM_<unknown>";
6589 /* Convert a DWARF stack opcode into its string name. */
6592 dwarf_stack_op_name (unsigned op
)
6597 return "DW_OP_addr";
6599 return "DW_OP_deref";
6601 return "DW_OP_const1u";
6603 return "DW_OP_const1s";
6605 return "DW_OP_const2u";
6607 return "DW_OP_const2s";
6609 return "DW_OP_const4u";
6611 return "DW_OP_const4s";
6613 return "DW_OP_const8u";
6615 return "DW_OP_const8s";
6617 return "DW_OP_constu";
6619 return "DW_OP_consts";
6623 return "DW_OP_drop";
6625 return "DW_OP_over";
6627 return "DW_OP_pick";
6629 return "DW_OP_swap";
6633 return "DW_OP_xderef";
6641 return "DW_OP_minus";
6653 return "DW_OP_plus";
6654 case DW_OP_plus_uconst
:
6655 return "DW_OP_plus_uconst";
6661 return "DW_OP_shra";
6679 return "DW_OP_skip";
6681 return "DW_OP_lit0";
6683 return "DW_OP_lit1";
6685 return "DW_OP_lit2";
6687 return "DW_OP_lit3";
6689 return "DW_OP_lit4";
6691 return "DW_OP_lit5";
6693 return "DW_OP_lit6";
6695 return "DW_OP_lit7";
6697 return "DW_OP_lit8";
6699 return "DW_OP_lit9";
6701 return "DW_OP_lit10";
6703 return "DW_OP_lit11";
6705 return "DW_OP_lit12";
6707 return "DW_OP_lit13";
6709 return "DW_OP_lit14";
6711 return "DW_OP_lit15";
6713 return "DW_OP_lit16";
6715 return "DW_OP_lit17";
6717 return "DW_OP_lit18";
6719 return "DW_OP_lit19";
6721 return "DW_OP_lit20";
6723 return "DW_OP_lit21";
6725 return "DW_OP_lit22";
6727 return "DW_OP_lit23";
6729 return "DW_OP_lit24";
6731 return "DW_OP_lit25";
6733 return "DW_OP_lit26";
6735 return "DW_OP_lit27";
6737 return "DW_OP_lit28";
6739 return "DW_OP_lit29";
6741 return "DW_OP_lit30";
6743 return "DW_OP_lit31";
6745 return "DW_OP_reg0";
6747 return "DW_OP_reg1";
6749 return "DW_OP_reg2";
6751 return "DW_OP_reg3";
6753 return "DW_OP_reg4";
6755 return "DW_OP_reg5";
6757 return "DW_OP_reg6";
6759 return "DW_OP_reg7";
6761 return "DW_OP_reg8";
6763 return "DW_OP_reg9";
6765 return "DW_OP_reg10";
6767 return "DW_OP_reg11";
6769 return "DW_OP_reg12";
6771 return "DW_OP_reg13";
6773 return "DW_OP_reg14";
6775 return "DW_OP_reg15";
6777 return "DW_OP_reg16";
6779 return "DW_OP_reg17";
6781 return "DW_OP_reg18";
6783 return "DW_OP_reg19";
6785 return "DW_OP_reg20";
6787 return "DW_OP_reg21";
6789 return "DW_OP_reg22";
6791 return "DW_OP_reg23";
6793 return "DW_OP_reg24";
6795 return "DW_OP_reg25";
6797 return "DW_OP_reg26";
6799 return "DW_OP_reg27";
6801 return "DW_OP_reg28";
6803 return "DW_OP_reg29";
6805 return "DW_OP_reg30";
6807 return "DW_OP_reg31";
6809 return "DW_OP_breg0";
6811 return "DW_OP_breg1";
6813 return "DW_OP_breg2";
6815 return "DW_OP_breg3";
6817 return "DW_OP_breg4";
6819 return "DW_OP_breg5";
6821 return "DW_OP_breg6";
6823 return "DW_OP_breg7";
6825 return "DW_OP_breg8";
6827 return "DW_OP_breg9";
6829 return "DW_OP_breg10";
6831 return "DW_OP_breg11";
6833 return "DW_OP_breg12";
6835 return "DW_OP_breg13";
6837 return "DW_OP_breg14";
6839 return "DW_OP_breg15";
6841 return "DW_OP_breg16";
6843 return "DW_OP_breg17";
6845 return "DW_OP_breg18";
6847 return "DW_OP_breg19";
6849 return "DW_OP_breg20";
6851 return "DW_OP_breg21";
6853 return "DW_OP_breg22";
6855 return "DW_OP_breg23";
6857 return "DW_OP_breg24";
6859 return "DW_OP_breg25";
6861 return "DW_OP_breg26";
6863 return "DW_OP_breg27";
6865 return "DW_OP_breg28";
6867 return "DW_OP_breg29";
6869 return "DW_OP_breg30";
6871 return "DW_OP_breg31";
6873 return "DW_OP_regx";
6875 return "DW_OP_fbreg";
6877 return "DW_OP_bregx";
6879 return "DW_OP_piece";
6880 case DW_OP_deref_size
:
6881 return "DW_OP_deref_size";
6882 case DW_OP_xderef_size
:
6883 return "DW_OP_xderef_size";
6886 /* DWARF 3 extensions. */
6887 case DW_OP_push_object_address
:
6888 return "DW_OP_push_object_address";
6890 return "DW_OP_call2";
6892 return "DW_OP_call4";
6893 case DW_OP_call_ref
:
6894 return "DW_OP_call_ref";
6895 /* GNU extensions. */
6896 case DW_OP_GNU_push_tls_address
:
6897 return "DW_OP_GNU_push_tls_address";
6899 return "OP_<unknown>";
6904 dwarf_bool_name (unsigned mybool
)
6912 /* Convert a DWARF type code into its string name. */
6915 dwarf_type_encoding_name (unsigned enc
)
6919 case DW_ATE_address
:
6920 return "DW_ATE_address";
6921 case DW_ATE_boolean
:
6922 return "DW_ATE_boolean";
6923 case DW_ATE_complex_float
:
6924 return "DW_ATE_complex_float";
6926 return "DW_ATE_float";
6928 return "DW_ATE_signed";
6929 case DW_ATE_signed_char
:
6930 return "DW_ATE_signed_char";
6931 case DW_ATE_unsigned
:
6932 return "DW_ATE_unsigned";
6933 case DW_ATE_unsigned_char
:
6934 return "DW_ATE_unsigned_char";
6935 case DW_ATE_imaginary_float
:
6936 return "DW_ATE_imaginary_float";
6938 return "DW_ATE_<unknown>";
6942 /* Convert a DWARF call frame info operation to its string name. */
6946 dwarf_cfi_name (unsigned cfi_opc
)
6950 case DW_CFA_advance_loc
:
6951 return "DW_CFA_advance_loc";
6953 return "DW_CFA_offset";
6954 case DW_CFA_restore
:
6955 return "DW_CFA_restore";
6957 return "DW_CFA_nop";
6958 case DW_CFA_set_loc
:
6959 return "DW_CFA_set_loc";
6960 case DW_CFA_advance_loc1
:
6961 return "DW_CFA_advance_loc1";
6962 case DW_CFA_advance_loc2
:
6963 return "DW_CFA_advance_loc2";
6964 case DW_CFA_advance_loc4
:
6965 return "DW_CFA_advance_loc4";
6966 case DW_CFA_offset_extended
:
6967 return "DW_CFA_offset_extended";
6968 case DW_CFA_restore_extended
:
6969 return "DW_CFA_restore_extended";
6970 case DW_CFA_undefined
:
6971 return "DW_CFA_undefined";
6972 case DW_CFA_same_value
:
6973 return "DW_CFA_same_value";
6974 case DW_CFA_register
:
6975 return "DW_CFA_register";
6976 case DW_CFA_remember_state
:
6977 return "DW_CFA_remember_state";
6978 case DW_CFA_restore_state
:
6979 return "DW_CFA_restore_state";
6980 case DW_CFA_def_cfa
:
6981 return "DW_CFA_def_cfa";
6982 case DW_CFA_def_cfa_register
:
6983 return "DW_CFA_def_cfa_register";
6984 case DW_CFA_def_cfa_offset
:
6985 return "DW_CFA_def_cfa_offset";
6988 case DW_CFA_def_cfa_expression
:
6989 return "DW_CFA_def_cfa_expression";
6990 case DW_CFA_expression
:
6991 return "DW_CFA_expression";
6992 case DW_CFA_offset_extended_sf
:
6993 return "DW_CFA_offset_extended_sf";
6994 case DW_CFA_def_cfa_sf
:
6995 return "DW_CFA_def_cfa_sf";
6996 case DW_CFA_def_cfa_offset_sf
:
6997 return "DW_CFA_def_cfa_offset_sf";
6999 /* SGI/MIPS specific */
7000 case DW_CFA_MIPS_advance_loc8
:
7001 return "DW_CFA_MIPS_advance_loc8";
7003 /* GNU extensions */
7004 case DW_CFA_GNU_window_save
:
7005 return "DW_CFA_GNU_window_save";
7006 case DW_CFA_GNU_args_size
:
7007 return "DW_CFA_GNU_args_size";
7008 case DW_CFA_GNU_negative_offset_extended
:
7009 return "DW_CFA_GNU_negative_offset_extended";
7012 return "DW_CFA_<unknown>";
7018 dump_die (struct die_info
*die
)
7022 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
7023 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
7024 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
7025 dwarf_bool_name (die
->child
!= NULL
));
7027 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
7028 for (i
= 0; i
< die
->num_attrs
; ++i
)
7030 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
7031 dwarf_attr_name (die
->attrs
[i
].name
),
7032 dwarf_form_name (die
->attrs
[i
].form
));
7033 switch (die
->attrs
[i
].form
)
7035 case DW_FORM_ref_addr
:
7037 fprintf_unfiltered (gdb_stderr
, "address: ");
7038 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
7040 case DW_FORM_block2
:
7041 case DW_FORM_block4
:
7043 case DW_FORM_block1
:
7044 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
7055 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
7057 case DW_FORM_string
:
7059 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
7060 DW_STRING (&die
->attrs
[i
])
7061 ? DW_STRING (&die
->attrs
[i
]) : "");
7064 if (DW_UNSND (&die
->attrs
[i
]))
7065 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
7067 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
7069 case DW_FORM_indirect
:
7070 /* the reader will have reduced the indirect form to
7071 the "base form" so this form should not occur */
7072 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
7075 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
7076 die
->attrs
[i
].form
);
7078 fprintf_unfiltered (gdb_stderr
, "\n");
7083 dump_die_list (struct die_info
*die
)
7088 if (die
->child
!= NULL
)
7089 dump_die_list (die
->child
);
7090 if (die
->sibling
!= NULL
)
7091 dump_die_list (die
->sibling
);
7096 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
7099 struct die_info
*old
;
7101 h
= (offset
% REF_HASH_SIZE
);
7102 old
= die_ref_table
[h
];
7103 die
->next_ref
= old
;
7104 die_ref_table
[h
] = die
;
7109 dwarf2_empty_hash_tables (void)
7111 memset (die_ref_table
, 0, sizeof (die_ref_table
));
7115 dwarf2_get_ref_die_offset (struct attribute
*attr
)
7117 unsigned int result
= 0;
7121 case DW_FORM_ref_addr
:
7122 result
= DW_ADDR (attr
);
7128 case DW_FORM_ref_udata
:
7129 result
= cu_header_offset
+ DW_UNSND (attr
);
7132 complaint (&symfile_complaints
,
7133 "unsupported die ref attribute form: '%s'",
7134 dwarf_form_name (attr
->form
));
7139 static struct die_info
*
7140 follow_die_ref (unsigned int offset
)
7142 struct die_info
*die
;
7145 h
= (offset
% REF_HASH_SIZE
);
7146 die
= die_ref_table
[h
];
7149 if (die
->offset
== offset
)
7153 die
= die
->next_ref
;
7158 static struct type
*
7159 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
7161 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
7163 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
7164 typeid, objfile
->name
);
7167 /* Look for this particular type in the fundamental type vector. If
7168 one is not found, create and install one appropriate for the
7169 current language and the current target machine. */
7171 if (ftypes
[typeid] == NULL
)
7173 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
7176 return (ftypes
[typeid]);
7179 /* Decode simple location descriptions.
7180 Given a pointer to a dwarf block that defines a location, compute
7181 the location and return the value.
7183 NOTE drow/2003-11-18: This function is called in two situations
7184 now: for the address of static or global variables (partial symbols
7185 only) and for offsets into structures which are expected to be
7186 (more or less) constant. The partial symbol case should go away,
7187 and only the constant case should remain. That will let this
7188 function complain more accurately. A few special modes are allowed
7189 without complaint for global variables (for instance, global
7190 register values and thread-local values).
7192 A location description containing no operations indicates that the
7193 object is optimized out. The return value is 0 for that case.
7194 FIXME drow/2003-11-16: No callers check for this case any more; soon all
7195 callers will only want a very basic result and this can become a
7198 When the result is a register number, the global isreg flag is set,
7199 otherwise it is cleared.
7201 Note that stack[0] is unused except as a default error return.
7202 Note that stack overflow is not yet handled. */
7205 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
7207 struct objfile
*objfile
= cu
->objfile
;
7208 struct comp_unit_head
*cu_header
= &cu
->header
;
7210 int size
= blk
->size
;
7211 char *data
= blk
->data
;
7212 CORE_ADDR stack
[64];
7214 unsigned int bytes_read
, unsnd
;
7259 stack
[++stacki
] = op
- DW_OP_lit0
;
7295 stack
[++stacki
] = op
- DW_OP_reg0
;
7297 dwarf2_complex_location_expr_complaint ();
7302 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7304 stack
[++stacki
] = unsnd
;
7306 dwarf2_complex_location_expr_complaint ();
7310 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
7316 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
7321 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
7326 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
7331 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
7336 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
7341 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
7346 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
7352 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7357 stack
[stacki
+ 1] = stack
[stacki
];
7362 stack
[stacki
- 1] += stack
[stacki
];
7366 case DW_OP_plus_uconst
:
7367 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7372 stack
[stacki
- 1] -= stack
[stacki
];
7377 /* If we're not the last op, then we definitely can't encode
7378 this using GDB's address_class enum. This is valid for partial
7379 global symbols, although the variable's address will be bogus
7382 dwarf2_complex_location_expr_complaint ();
7385 case DW_OP_GNU_push_tls_address
:
7386 /* The top of the stack has the offset from the beginning
7387 of the thread control block at which the variable is located. */
7388 /* Nothing should follow this operator, so the top of stack would
7390 /* This is valid for partial global symbols, but the variable's
7391 address will be bogus in the psymtab. */
7393 dwarf2_complex_location_expr_complaint ();
7397 complaint (&symfile_complaints
, "unsupported stack op: '%s'",
7398 dwarf_stack_op_name (op
));
7399 return (stack
[stacki
]);
7402 return (stack
[stacki
]);
7405 /* memory allocation interface */
7408 dwarf2_free_tmp_obstack (void *ignore
)
7410 obstack_free (&dwarf2_tmp_obstack
, NULL
);
7413 static struct dwarf_block
*
7414 dwarf_alloc_block (void)
7416 struct dwarf_block
*blk
;
7418 blk
= (struct dwarf_block
*)
7419 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
7423 static struct abbrev_info
*
7424 dwarf_alloc_abbrev (void)
7426 struct abbrev_info
*abbrev
;
7428 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
7429 memset (abbrev
, 0, sizeof (struct abbrev_info
));
7433 static struct die_info
*
7434 dwarf_alloc_die (void)
7436 struct die_info
*die
;
7438 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7439 memset (die
, 0, sizeof (struct die_info
));
7444 /* Macro support. */
7447 /* Return the full name of file number I in *LH's file name table.
7448 Use COMP_DIR as the name of the current directory of the
7449 compilation. The result is allocated using xmalloc; the caller is
7450 responsible for freeing it. */
7452 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
7454 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
7456 if (IS_ABSOLUTE_PATH (fe
->name
))
7457 return xstrdup (fe
->name
);
7465 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7471 dir_len
= strlen (dir
);
7472 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
7473 strcpy (full_name
, dir
);
7474 full_name
[dir_len
] = '/';
7475 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
7479 return xstrdup (fe
->name
);
7484 static struct macro_source_file
*
7485 macro_start_file (int file
, int line
,
7486 struct macro_source_file
*current_file
,
7487 const char *comp_dir
,
7488 struct line_header
*lh
, struct objfile
*objfile
)
7490 /* The full name of this source file. */
7491 char *full_name
= file_full_name (file
, lh
, comp_dir
);
7493 /* We don't create a macro table for this compilation unit
7494 at all until we actually get a filename. */
7495 if (! pending_macros
)
7496 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
7497 objfile
->macro_cache
);
7500 /* If we have no current file, then this must be the start_file
7501 directive for the compilation unit's main source file. */
7502 current_file
= macro_set_main (pending_macros
, full_name
);
7504 current_file
= macro_include (current_file
, line
, full_name
);
7508 return current_file
;
7512 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7513 followed by a null byte. */
7515 copy_string (const char *buf
, int len
)
7517 char *s
= xmalloc (len
+ 1);
7518 memcpy (s
, buf
, len
);
7526 consume_improper_spaces (const char *p
, const char *body
)
7530 complaint (&symfile_complaints
,
7531 "macro definition contains spaces in formal argument list:\n`%s'",
7543 parse_macro_definition (struct macro_source_file
*file
, int line
,
7548 /* The body string takes one of two forms. For object-like macro
7549 definitions, it should be:
7551 <macro name> " " <definition>
7553 For function-like macro definitions, it should be:
7555 <macro name> "() " <definition>
7557 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7559 Spaces may appear only where explicitly indicated, and in the
7562 The Dwarf 2 spec says that an object-like macro's name is always
7563 followed by a space, but versions of GCC around March 2002 omit
7564 the space when the macro's definition is the empty string.
7566 The Dwarf 2 spec says that there should be no spaces between the
7567 formal arguments in a function-like macro's formal argument list,
7568 but versions of GCC around March 2002 include spaces after the
7572 /* Find the extent of the macro name. The macro name is terminated
7573 by either a space or null character (for an object-like macro) or
7574 an opening paren (for a function-like macro). */
7575 for (p
= body
; *p
; p
++)
7576 if (*p
== ' ' || *p
== '(')
7579 if (*p
== ' ' || *p
== '\0')
7581 /* It's an object-like macro. */
7582 int name_len
= p
- body
;
7583 char *name
= copy_string (body
, name_len
);
7584 const char *replacement
;
7587 replacement
= body
+ name_len
+ 1;
7590 dwarf2_macro_malformed_definition_complaint (body
);
7591 replacement
= body
+ name_len
;
7594 macro_define_object (file
, line
, name
, replacement
);
7600 /* It's a function-like macro. */
7601 char *name
= copy_string (body
, p
- body
);
7604 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
7608 p
= consume_improper_spaces (p
, body
);
7610 /* Parse the formal argument list. */
7611 while (*p
&& *p
!= ')')
7613 /* Find the extent of the current argument name. */
7614 const char *arg_start
= p
;
7616 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
7619 if (! *p
|| p
== arg_start
)
7620 dwarf2_macro_malformed_definition_complaint (body
);
7623 /* Make sure argv has room for the new argument. */
7624 if (argc
>= argv_size
)
7627 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
7630 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
7633 p
= consume_improper_spaces (p
, body
);
7635 /* Consume the comma, if present. */
7640 p
= consume_improper_spaces (p
, body
);
7649 /* Perfectly formed definition, no complaints. */
7650 macro_define_function (file
, line
, name
,
7651 argc
, (const char **) argv
,
7653 else if (*p
== '\0')
7655 /* Complain, but do define it. */
7656 dwarf2_macro_malformed_definition_complaint (body
);
7657 macro_define_function (file
, line
, name
,
7658 argc
, (const char **) argv
,
7662 /* Just complain. */
7663 dwarf2_macro_malformed_definition_complaint (body
);
7666 /* Just complain. */
7667 dwarf2_macro_malformed_definition_complaint (body
);
7673 for (i
= 0; i
< argc
; i
++)
7679 dwarf2_macro_malformed_definition_complaint (body
);
7684 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7685 char *comp_dir
, bfd
*abfd
,
7686 struct dwarf2_cu
*cu
)
7688 char *mac_ptr
, *mac_end
;
7689 struct macro_source_file
*current_file
= 0;
7691 if (dwarf_macinfo_buffer
== NULL
)
7693 complaint (&symfile_complaints
, "missing .debug_macinfo section");
7697 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7698 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7702 enum dwarf_macinfo_record_type macinfo_type
;
7704 /* Do we at least have room for a macinfo type byte? */
7705 if (mac_ptr
>= mac_end
)
7707 dwarf2_macros_too_long_complaint ();
7711 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7714 switch (macinfo_type
)
7716 /* A zero macinfo type indicates the end of the macro
7721 case DW_MACINFO_define
:
7722 case DW_MACINFO_undef
:
7728 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7729 mac_ptr
+= bytes_read
;
7730 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7731 mac_ptr
+= bytes_read
;
7734 complaint (&symfile_complaints
,
7735 "debug info gives macro %s outside of any file: %s",
7737 DW_MACINFO_define
? "definition" : macinfo_type
==
7738 DW_MACINFO_undef
? "undefinition" :
7739 "something-or-other", body
);
7742 if (macinfo_type
== DW_MACINFO_define
)
7743 parse_macro_definition (current_file
, line
, body
);
7744 else if (macinfo_type
== DW_MACINFO_undef
)
7745 macro_undef (current_file
, line
, body
);
7750 case DW_MACINFO_start_file
:
7755 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7756 mac_ptr
+= bytes_read
;
7757 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7758 mac_ptr
+= bytes_read
;
7760 current_file
= macro_start_file (file
, line
,
7761 current_file
, comp_dir
,
7766 case DW_MACINFO_end_file
:
7768 complaint (&symfile_complaints
,
7769 "macro debug info has an unmatched `close_file' directive");
7772 current_file
= current_file
->included_by
;
7775 enum dwarf_macinfo_record_type next_type
;
7777 /* GCC circa March 2002 doesn't produce the zero
7778 type byte marking the end of the compilation
7779 unit. Complain if it's not there, but exit no
7782 /* Do we at least have room for a macinfo type byte? */
7783 if (mac_ptr
>= mac_end
)
7785 dwarf2_macros_too_long_complaint ();
7789 /* We don't increment mac_ptr here, so this is just
7791 next_type
= read_1_byte (abfd
, mac_ptr
);
7793 complaint (&symfile_complaints
,
7794 "no terminating 0-type entry for macros in `.debug_macinfo' section");
7801 case DW_MACINFO_vendor_ext
:
7807 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7808 mac_ptr
+= bytes_read
;
7809 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7810 mac_ptr
+= bytes_read
;
7812 /* We don't recognize any vendor extensions. */
7819 /* Check if the attribute's form is a DW_FORM_block*
7820 if so return true else false. */
7822 attr_form_is_block (struct attribute
*attr
)
7824 return (attr
== NULL
? 0 :
7825 attr
->form
== DW_FORM_block1
7826 || attr
->form
== DW_FORM_block2
7827 || attr
->form
== DW_FORM_block4
7828 || attr
->form
== DW_FORM_block
);
7832 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
7833 struct dwarf2_cu
*cu
)
7835 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
7837 struct dwarf2_loclist_baton
*baton
;
7839 baton
= obstack_alloc (&cu
->objfile
->symbol_obstack
,
7840 sizeof (struct dwarf2_loclist_baton
));
7841 baton
->objfile
= cu
->objfile
;
7843 /* We don't know how long the location list is, but make sure we
7844 don't run off the edge of the section. */
7845 baton
->size
= dwarf_loc_size
- DW_UNSND (attr
);
7846 baton
->data
= dwarf_loc_buffer
+ DW_UNSND (attr
);
7847 baton
->base_address
= cu
->header
.base_address
;
7848 if (cu
->header
.base_known
== 0)
7849 complaint (&symfile_complaints
,
7850 "Location list used without specifying the CU base address.");
7852 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_loclist_funcs
;
7853 SYMBOL_LOCATION_BATON (sym
) = baton
;
7857 struct dwarf2_locexpr_baton
*baton
;
7859 baton
= obstack_alloc (&cu
->objfile
->symbol_obstack
,
7860 sizeof (struct dwarf2_locexpr_baton
));
7861 baton
->objfile
= cu
->objfile
;
7863 if (attr_form_is_block (attr
))
7865 /* Note that we're just copying the block's data pointer
7866 here, not the actual data. We're still pointing into the
7867 dwarf_info_buffer for SYM's objfile; right now we never
7868 release that buffer, but when we do clean up properly
7869 this may need to change. */
7870 baton
->size
= DW_BLOCK (attr
)->size
;
7871 baton
->data
= DW_BLOCK (attr
)->data
;
7875 dwarf2_invalid_attrib_class_complaint ("location description",
7876 SYMBOL_NATURAL_NAME (sym
));
7881 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_locexpr_funcs
;
7882 SYMBOL_LOCATION_BATON (sym
) = baton
;