1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
10 support in dwarfread.c
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or (at
17 your option) any later version.
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330,
27 Boston, MA 02111-1307, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
46 #include "gdb_string.h"
47 #include "gdb_assert.h"
48 #include <sys/types.h>
50 #ifndef DWARF2_REG_TO_REGNUM
51 #define DWARF2_REG_TO_REGNUM(REG) (REG)
55 /* .debug_info header for a compilation unit
56 Because of alignment constraints, this structure has padding and cannot
57 be mapped directly onto the beginning of the .debug_info section. */
58 typedef struct comp_unit_header
60 unsigned int length
; /* length of the .debug_info
62 unsigned short version
; /* version number -- 2 for DWARF
64 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
65 unsigned char addr_size
; /* byte size of an address -- 4 */
68 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
71 /* .debug_pubnames header
72 Because of alignment constraints, this structure has padding and cannot
73 be mapped directly onto the beginning of the .debug_info section. */
74 typedef struct pubnames_header
76 unsigned int length
; /* length of the .debug_pubnames
78 unsigned char version
; /* version number -- 2 for DWARF
80 unsigned int info_offset
; /* offset into .debug_info section */
81 unsigned int info_size
; /* byte size of .debug_info section
85 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
87 /* .debug_pubnames header
88 Because of alignment constraints, this structure has padding and cannot
89 be mapped directly onto the beginning of the .debug_info section. */
90 typedef struct aranges_header
92 unsigned int length
; /* byte len of the .debug_aranges
94 unsigned short version
; /* version number -- 2 for DWARF
96 unsigned int info_offset
; /* offset into .debug_info section */
97 unsigned char addr_size
; /* byte size of an address */
98 unsigned char seg_size
; /* byte size of segment descriptor */
101 #define _ACTUAL_ARANGES_HEADER_SIZE 12
103 /* .debug_line statement program prologue
104 Because of alignment constraints, this structure has padding and cannot
105 be mapped directly onto the beginning of the .debug_info section. */
106 typedef struct statement_prologue
108 unsigned int total_length
; /* byte length of the statement
110 unsigned short version
; /* version number -- 2 for DWARF
112 unsigned int prologue_length
; /* # bytes between prologue &
114 unsigned char minimum_instruction_length
; /* byte size of
116 unsigned char default_is_stmt
; /* initial value of is_stmt
119 unsigned char line_range
;
120 unsigned char opcode_base
; /* number assigned to first special
122 unsigned char *standard_opcode_lengths
;
126 /* offsets and sizes of debugging sections */
128 static file_ptr dwarf_info_offset
;
129 static file_ptr dwarf_abbrev_offset
;
130 static file_ptr dwarf_line_offset
;
131 static file_ptr dwarf_pubnames_offset
;
132 static file_ptr dwarf_aranges_offset
;
133 static file_ptr dwarf_loc_offset
;
134 static file_ptr dwarf_macinfo_offset
;
135 static file_ptr dwarf_str_offset
;
136 file_ptr dwarf_frame_offset
;
137 file_ptr dwarf_eh_frame_offset
;
139 static unsigned int dwarf_info_size
;
140 static unsigned int dwarf_abbrev_size
;
141 static unsigned int dwarf_line_size
;
142 static unsigned int dwarf_pubnames_size
;
143 static unsigned int dwarf_aranges_size
;
144 static unsigned int dwarf_loc_size
;
145 static unsigned int dwarf_macinfo_size
;
146 static unsigned int dwarf_str_size
;
147 unsigned int dwarf_frame_size
;
148 unsigned int dwarf_eh_frame_size
;
150 /* names of the debugging sections */
152 #define INFO_SECTION ".debug_info"
153 #define ABBREV_SECTION ".debug_abbrev"
154 #define LINE_SECTION ".debug_line"
155 #define PUBNAMES_SECTION ".debug_pubnames"
156 #define ARANGES_SECTION ".debug_aranges"
157 #define LOC_SECTION ".debug_loc"
158 #define MACINFO_SECTION ".debug_macinfo"
159 #define STR_SECTION ".debug_str"
160 #define FRAME_SECTION ".debug_frame"
161 #define EH_FRAME_SECTION ".eh_frame"
163 /* local data types */
165 /* We hold several abbreviation tables in memory at the same time. */
166 #ifndef ABBREV_HASH_SIZE
167 #define ABBREV_HASH_SIZE 121
170 /* The data in a compilation unit header, after target2host
171 translation, looks like this. */
172 struct comp_unit_head
174 unsigned long length
;
176 unsigned int abbrev_offset
;
177 unsigned char addr_size
;
178 unsigned char signed_addr_p
;
179 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
180 unsigned int initial_length_size
; /* size of the length field; either
183 /* Offset to the first byte of this compilation unit header in the
184 * .debug_info section, for resolving relative reference dies. */
188 /* Pointer to this compilation unit header in the .debug_info
193 /* Pointer to the first die of this compilatio unit. This will
194 * be the first byte following the compilation unit header. */
198 /* Pointer to the next compilation unit header in the program. */
200 struct comp_unit_head
*next
;
202 /* DWARF abbreviation table associated with this compilation unit */
204 struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
207 /* The line number information for a compilation unit (found in the
208 .debug_line section) begins with a "statement program header",
209 which contains the following information. */
212 unsigned int total_length
;
213 unsigned short version
;
214 unsigned int header_length
;
215 unsigned char minimum_instruction_length
;
216 unsigned char default_is_stmt
;
218 unsigned char line_range
;
219 unsigned char opcode_base
;
221 /* standard_opcode_lengths[i] is the number of operands for the
222 standard opcode whose value is i. This means that
223 standard_opcode_lengths[0] is unused, and the last meaningful
224 element is standard_opcode_lengths[opcode_base - 1]. */
225 unsigned char *standard_opcode_lengths
;
227 /* The include_directories table. NOTE! These strings are not
228 allocated with xmalloc; instead, they are pointers into
229 debug_line_buffer. If you try to free them, `free' will get
231 unsigned int num_include_dirs
, include_dirs_size
;
234 /* The file_names table. NOTE! These strings are not allocated
235 with xmalloc; instead, they are pointers into debug_line_buffer.
236 Don't try to free them directly. */
237 unsigned int num_file_names
, file_names_size
;
241 unsigned int dir_index
;
242 unsigned int mod_time
;
246 /* The start and end of the statement program following this
247 header. These point into dwarf_line_buffer. */
248 char *statement_program_start
, *statement_program_end
;
251 /* When we construct a partial symbol table entry we only
252 need this much information. */
253 struct partial_die_info
256 unsigned char has_children
;
257 unsigned char is_external
;
258 unsigned char is_declaration
;
259 unsigned char has_type
;
266 struct dwarf_block
*locdesc
;
267 unsigned int language
;
271 /* This data structure holds the information of an abbrev. */
274 unsigned int number
; /* number identifying abbrev */
275 enum dwarf_tag tag
; /* dwarf tag */
276 int has_children
; /* boolean */
277 unsigned int num_attrs
; /* number of attributes */
278 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
279 struct abbrev_info
*next
; /* next in chain */
284 enum dwarf_attribute name
;
285 enum dwarf_form form
;
288 /* This data structure holds a complete die structure. */
291 enum dwarf_tag tag
; /* Tag indicating type of die */
292 unsigned short has_children
; /* Does the die have children */
293 unsigned int abbrev
; /* Abbrev number */
294 unsigned int offset
; /* Offset in .debug_info section */
295 unsigned int num_attrs
; /* Number of attributes */
296 struct attribute
*attrs
; /* An array of attributes */
297 struct die_info
*next_ref
; /* Next die in ref hash table */
298 struct die_info
*next
; /* Next die in linked list */
299 struct type
*type
; /* Cached type information */
302 /* Attributes have a name and a value */
305 enum dwarf_attribute name
;
306 enum dwarf_form form
;
310 struct dwarf_block
*blk
;
318 struct function_range
321 CORE_ADDR lowpc
, highpc
;
323 struct function_range
*next
;
326 static struct function_range
*cu_first_fn
, *cu_last_fn
, *cu_cached_fn
;
328 /* Get at parts of an attribute structure */
330 #define DW_STRING(attr) ((attr)->u.str)
331 #define DW_UNSND(attr) ((attr)->u.unsnd)
332 #define DW_BLOCK(attr) ((attr)->u.blk)
333 #define DW_SND(attr) ((attr)->u.snd)
334 #define DW_ADDR(attr) ((attr)->u.addr)
336 /* Blocks are a bunch of untyped bytes. */
343 #ifndef ATTR_ALLOC_CHUNK
344 #define ATTR_ALLOC_CHUNK 4
347 /* A hash table of die offsets for following references. */
348 #ifndef REF_HASH_SIZE
349 #define REF_HASH_SIZE 1021
352 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
354 /* Obstack for allocating temporary storage used during symbol reading. */
355 static struct obstack dwarf2_tmp_obstack
;
357 /* Offset to the first byte of the current compilation unit header,
358 for resolving relative reference dies. */
359 static unsigned int cu_header_offset
;
361 /* Allocate fields for structs, unions and enums in this size. */
362 #ifndef DW_FIELD_ALLOC_CHUNK
363 #define DW_FIELD_ALLOC_CHUNK 4
366 /* The language we are debugging. */
367 static enum language cu_language
;
368 static const struct language_defn
*cu_language_defn
;
370 /* Actually data from the sections. */
371 static char *dwarf_info_buffer
;
372 static char *dwarf_abbrev_buffer
;
373 static char *dwarf_line_buffer
;
374 static char *dwarf_str_buffer
;
375 static char *dwarf_macinfo_buffer
;
377 /* A zeroed version of a partial die for initialization purposes. */
378 static struct partial_die_info zeroed_partial_die
;
380 /* The generic symbol table building routines have separate lists for
381 file scope symbols and all all other scopes (local scopes). So
382 we need to select the right one to pass to add_symbol_to_list().
383 We do it by keeping a pointer to the correct list in list_in_scope.
385 FIXME: The original dwarf code just treated the file scope as the first
386 local scope, and all other local scopes as nested local scopes, and worked
387 fine. Check to see if we really need to distinguish these
389 static struct pending
**list_in_scope
= &file_symbols
;
391 /* FIXME: decode_locdesc sets these variables to describe the location
392 to the caller. These ought to be a structure or something. If
393 none of the flags are set, the object lives at the address returned
394 by decode_locdesc. */
396 static int optimized_out
; /* No ops in location in expression,
397 so object was optimized out. */
398 static int isreg
; /* Object lives in register.
399 decode_locdesc's return value is
400 the register number. */
401 static int offreg
; /* Object's address is the sum of the
402 register specified by basereg, plus
403 the offset returned. */
404 static int basereg
; /* See `offreg'. */
405 static int isderef
; /* Value described by flags above is
406 the address of a pointer to the object. */
407 static int islocal
; /* Variable is at the returned offset
408 from the frame start, but there's
409 no identified frame pointer for
410 this function, so we can't say
411 which register it's relative to;
413 static int is_thread_local
; /* Variable is at a constant offset in the
414 thread-local storage block for the
415 current thread and the dynamic linker
416 module containing this expression.
417 decode_locdesc returns the offset from
420 /* DW_AT_frame_base values for the current function.
421 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
422 contains the register number for the frame register.
423 frame_base_offset is the offset from the frame register to the
424 virtual stack frame. */
425 static int frame_base_reg
;
426 static CORE_ADDR frame_base_offset
;
428 /* This value is added to each symbol value. FIXME: Generalize to
429 the section_offsets structure used by dbxread (once this is done,
430 pass the appropriate section number to end_symtab). */
431 static CORE_ADDR baseaddr
; /* Add to each symbol value */
433 /* We put a pointer to this structure in the read_symtab_private field
435 The complete dwarf information for an objfile is kept in the
436 psymbol_obstack, so that absolute die references can be handled.
437 Most of the information in this structure is related to an entire
438 object file and could be passed via the sym_private field of the objfile.
439 It is however conceivable that dwarf2 might not be the only type
440 of symbols read from an object file. */
444 /* Pointer to start of dwarf info buffer for the objfile. */
446 char *dwarf_info_buffer
;
448 /* Offset in dwarf_info_buffer for this compilation unit. */
450 unsigned long dwarf_info_offset
;
452 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
454 char *dwarf_abbrev_buffer
;
456 /* Size of dwarf abbreviation section for the objfile. */
458 unsigned int dwarf_abbrev_size
;
460 /* Pointer to start of dwarf line buffer for the objfile. */
462 char *dwarf_line_buffer
;
464 /* Size of dwarf_line_buffer, in bytes. */
466 unsigned int dwarf_line_size
;
468 /* Pointer to start of dwarf string buffer for the objfile. */
470 char *dwarf_str_buffer
;
472 /* Size of dwarf string section for the objfile. */
474 unsigned int dwarf_str_size
;
476 /* Pointer to start of dwarf macro buffer for the objfile. */
478 char *dwarf_macinfo_buffer
;
480 /* Size of dwarf macinfo section for the objfile. */
482 unsigned int dwarf_macinfo_size
;
486 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
487 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
488 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
489 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
490 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
491 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
492 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
493 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
494 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
495 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
496 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
498 /* Maintain an array of referenced fundamental types for the current
499 compilation unit being read. For DWARF version 1, we have to construct
500 the fundamental types on the fly, since no information about the
501 fundamental types is supplied. Each such fundamental type is created by
502 calling a language dependent routine to create the type, and then a
503 pointer to that type is then placed in the array at the index specified
504 by it's FT_<TYPENAME> value. The array has a fixed size set by the
505 FT_NUM_MEMBERS compile time constant, which is the number of predefined
506 fundamental types gdb knows how to construct. */
507 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
509 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
510 but this would require a corresponding change in unpack_field_as_long
512 static int bits_per_byte
= 8;
514 /* The routines that read and process dies for a C struct or C++ class
515 pass lists of data member fields and lists of member function fields
516 in an instance of a field_info structure, as defined below. */
519 /* List of data member and baseclasses fields. */
522 struct nextfield
*next
;
529 /* Number of fields. */
532 /* Number of baseclasses. */
535 /* Set if the accesibility of one of the fields is not public. */
536 int non_public_fields
;
538 /* Member function fields array, entries are allocated in the order they
539 are encountered in the object file. */
542 struct nextfnfield
*next
;
543 struct fn_field fnfield
;
547 /* Member function fieldlist array, contains name of possibly overloaded
548 member function, number of overloaded member functions and a pointer
549 to the head of the member function field chain. */
554 struct nextfnfield
*head
;
558 /* Number of entries in the fnfieldlists array. */
562 /* Various complaints about symbol reading that don't abort the process */
564 static struct deprecated_complaint dwarf2_const_ignored
=
566 "type qualifier 'const' ignored", 0, 0
568 static struct deprecated_complaint dwarf2_volatile_ignored
=
570 "type qualifier 'volatile' ignored", 0, 0
572 static struct deprecated_complaint dwarf2_non_const_array_bound_ignored
=
574 "non-constant array bounds form '%s' ignored", 0, 0
576 static struct deprecated_complaint dwarf2_missing_line_number_section
=
578 "missing .debug_line section", 0, 0
580 static struct deprecated_complaint dwarf2_statement_list_fits_in_line_number_section
=
582 "statement list doesn't fit in .debug_line section", 0, 0
584 static struct deprecated_complaint dwarf2_mangled_line_number_section
=
586 "mangled .debug_line section", 0, 0
588 static struct deprecated_complaint dwarf2_unsupported_die_ref_attr
=
590 "unsupported die ref attribute form: '%s'", 0, 0
592 static struct deprecated_complaint dwarf2_unsupported_stack_op
=
594 "unsupported stack op: '%s'", 0, 0
596 static struct deprecated_complaint dwarf2_complex_location_expr
=
598 "location expression too complex", 0, 0
600 static struct deprecated_complaint dwarf2_unsupported_tag
=
602 "unsupported tag: '%s'", 0, 0
604 static struct deprecated_complaint dwarf2_unsupported_at_encoding
=
606 "unsupported DW_AT_encoding: '%s'", 0, 0
608 static struct deprecated_complaint dwarf2_unsupported_at_frame_base
=
610 "unsupported DW_AT_frame_base for function '%s'", 0, 0
612 static struct deprecated_complaint dwarf2_unexpected_tag
=
614 "unexepected tag in read_type_die: '%s'", 0, 0
616 static struct deprecated_complaint dwarf2_missing_at_frame_base
=
618 "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
620 static struct deprecated_complaint dwarf2_bad_static_member_name
=
622 "unrecognized static data member name '%s'", 0, 0
624 static struct deprecated_complaint dwarf2_unsupported_accessibility
=
626 "unsupported accessibility %d", 0, 0
628 static struct deprecated_complaint dwarf2_bad_member_name_complaint
=
630 "cannot extract member name from '%s'", 0, 0
632 static struct deprecated_complaint dwarf2_missing_member_fn_type_complaint
=
634 "member function type missing for '%s'", 0, 0
636 static struct deprecated_complaint dwarf2_vtbl_not_found_complaint
=
638 "virtual function table pointer not found when defining class '%s'", 0, 0
640 static struct deprecated_complaint dwarf2_absolute_sibling_complaint
=
642 "ignoring absolute DW_AT_sibling", 0, 0
644 static struct deprecated_complaint dwarf2_const_value_length_mismatch
=
646 "const value length mismatch for '%s', got %d, expected %d", 0, 0
648 static struct deprecated_complaint dwarf2_unsupported_const_value_attr
=
650 "unsupported const value attribute form: '%s'", 0, 0
652 static struct deprecated_complaint dwarf2_misplaced_line_number
=
654 "misplaced first line number at 0x%lx for '%s'", 0, 0
656 static struct deprecated_complaint dwarf2_line_header_too_long
=
658 "line number info header doesn't fit in `.debug_line' section", 0, 0
660 static struct deprecated_complaint dwarf2_missing_macinfo_section
=
662 "missing .debug_macinfo section", 0, 0
664 static struct deprecated_complaint dwarf2_macros_too_long
=
666 "macro info runs off end of `.debug_macinfo' section", 0, 0
668 static struct deprecated_complaint dwarf2_macros_not_terminated
=
670 "no terminating 0-type entry for macros in `.debug_macinfo' section", 0, 0
672 static struct deprecated_complaint dwarf2_macro_outside_file
=
674 "debug info gives macro %s outside of any file: %s", 0, 0
676 static struct deprecated_complaint dwarf2_macro_unmatched_end_file
=
678 "macro debug info has an unmatched `close_file' directive", 0, 0
680 static struct deprecated_complaint dwarf2_macro_malformed_definition
=
682 "macro debug info contains a malformed macro definition:\n`%s'", 0, 0
684 static struct deprecated_complaint dwarf2_macro_spaces_in_definition
=
686 "macro definition contains spaces in formal argument list:\n`%s'", 0, 0
688 static struct deprecated_complaint dwarf2_invalid_attrib_class
=
690 "invalid attribute class or form for '%s' in '%s'", 0, 0
692 static struct deprecated_complaint dwarf2_invalid_pointer_size
=
694 "invalid pointer size %d", 0, 0
697 /* local function prototypes */
699 static void dwarf2_locate_sections (bfd
*, asection
*, PTR
);
702 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
705 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
707 static char *scan_partial_symbols (char *, struct objfile
*,
708 CORE_ADDR
*, CORE_ADDR
*,
709 const struct comp_unit_head
*);
711 static void add_partial_symbol (struct partial_die_info
*, struct objfile
*,
712 const struct comp_unit_head
*);
714 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
716 static void psymtab_to_symtab_1 (struct partial_symtab
*);
718 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int);
720 static void dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
);
722 static void dwarf2_empty_abbrev_table (PTR
);
724 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
725 const struct comp_unit_head
*cu_header
);
727 static char *read_partial_die (struct partial_die_info
*,
729 const struct comp_unit_head
*);
731 static char *read_full_die (struct die_info
**, bfd
*, char *,
732 const struct comp_unit_head
*);
734 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
735 bfd
*, char *, const struct comp_unit_head
*);
737 static char *read_attribute_value (struct attribute
*, unsigned,
738 bfd
*, char *, const struct comp_unit_head
*);
740 static unsigned int read_1_byte (bfd
*, char *);
742 static int read_1_signed_byte (bfd
*, char *);
744 static unsigned int read_2_bytes (bfd
*, char *);
746 static unsigned int read_4_bytes (bfd
*, char *);
748 static unsigned long read_8_bytes (bfd
*, char *);
750 static CORE_ADDR
read_address (bfd
*, char *ptr
, const struct comp_unit_head
*,
753 static LONGEST
read_initial_length (bfd
*, char *,
754 struct comp_unit_head
*, int *bytes_read
);
756 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
759 static char *read_n_bytes (bfd
*, char *, unsigned int);
761 static char *read_string (bfd
*, char *, unsigned int *);
763 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
766 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
768 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
770 static void set_cu_language (unsigned int);
772 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
774 static int die_is_declaration (struct die_info
*);
776 static void free_line_header (struct line_header
*lh
);
778 static struct line_header
*(dwarf_decode_line_header
779 (unsigned int offset
,
781 const struct comp_unit_head
*cu_header
));
783 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
784 const struct comp_unit_head
*);
786 static void dwarf2_start_subfile (char *, char *);
788 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
789 struct objfile
*, const struct comp_unit_head
*);
791 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
792 struct objfile
*, const struct comp_unit_head
*);
794 static void dwarf2_const_value_data (struct attribute
*attr
,
798 static struct type
*die_type (struct die_info
*, struct objfile
*,
799 const struct comp_unit_head
*);
801 static struct type
*die_containing_type (struct die_info
*, struct objfile
*,
802 const struct comp_unit_head
*);
805 static struct type
*type_at_offset (unsigned int, struct objfile
*);
808 static struct type
*tag_type_to_type (struct die_info
*, struct objfile
*,
809 const struct comp_unit_head
*);
811 static void read_type_die (struct die_info
*, struct objfile
*,
812 const struct comp_unit_head
*);
814 static void read_typedef (struct die_info
*, struct objfile
*,
815 const struct comp_unit_head
*);
817 static void read_base_type (struct die_info
*, struct objfile
*);
819 static void read_file_scope (struct die_info
*, struct objfile
*,
820 const struct comp_unit_head
*);
822 static void read_func_scope (struct die_info
*, struct objfile
*,
823 const struct comp_unit_head
*);
825 static void read_lexical_block_scope (struct die_info
*, struct objfile
*,
826 const struct comp_unit_head
*);
828 static int dwarf2_get_pc_bounds (struct die_info
*,
829 CORE_ADDR
*, CORE_ADDR
*, struct objfile
*);
831 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
832 struct objfile
*, const struct comp_unit_head
*);
834 static void dwarf2_attach_fields_to_type (struct field_info
*,
835 struct type
*, struct objfile
*);
837 static void dwarf2_add_member_fn (struct field_info
*,
838 struct die_info
*, struct type
*,
839 struct objfile
*objfile
,
840 const struct comp_unit_head
*);
842 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
843 struct type
*, struct objfile
*);
845 static void read_structure_scope (struct die_info
*, struct objfile
*,
846 const struct comp_unit_head
*);
848 static void read_common_block (struct die_info
*, struct objfile
*,
849 const struct comp_unit_head
*);
851 static void read_namespace (struct die_info
*die
, struct objfile
*objfile
,
852 const struct comp_unit_head
*cu_header
);
854 static void read_enumeration (struct die_info
*, struct objfile
*,
855 const struct comp_unit_head
*);
857 static struct type
*dwarf_base_type (int, int, struct objfile
*);
859 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct objfile
*,
860 const struct comp_unit_head
*);
862 static void read_array_type (struct die_info
*, struct objfile
*,
863 const struct comp_unit_head
*);
865 static void read_tag_pointer_type (struct die_info
*, struct objfile
*,
866 const struct comp_unit_head
*);
868 static void read_tag_ptr_to_member_type (struct die_info
*, struct objfile
*,
869 const struct comp_unit_head
*);
871 static void read_tag_reference_type (struct die_info
*, struct objfile
*,
872 const struct comp_unit_head
*);
874 static void read_tag_const_type (struct die_info
*, struct objfile
*,
875 const struct comp_unit_head
*);
877 static void read_tag_volatile_type (struct die_info
*, struct objfile
*,
878 const struct comp_unit_head
*);
880 static void read_tag_string_type (struct die_info
*, struct objfile
*);
882 static void read_subroutine_type (struct die_info
*, struct objfile
*,
883 const struct comp_unit_head
*);
885 static struct die_info
*read_comp_unit (char *, bfd
*,
886 const struct comp_unit_head
*);
888 static void free_die_list (struct die_info
*);
890 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
892 static void process_die (struct die_info
*, struct objfile
*,
893 const struct comp_unit_head
*);
895 static char *dwarf2_linkage_name (struct die_info
*);
897 static char *dwarf_tag_name (unsigned int);
899 static char *dwarf_attr_name (unsigned int);
901 static char *dwarf_form_name (unsigned int);
903 static char *dwarf_stack_op_name (unsigned int);
905 static char *dwarf_bool_name (unsigned int);
907 static char *dwarf_type_encoding_name (unsigned int);
910 static char *dwarf_cfi_name (unsigned int);
912 struct die_info
*copy_die (struct die_info
*);
915 static struct die_info
*sibling_die (struct die_info
*);
917 static void dump_die (struct die_info
*);
919 static void dump_die_list (struct die_info
*);
921 static void store_in_ref_table (unsigned int, struct die_info
*);
923 static void dwarf2_empty_hash_tables (void);
925 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
927 static struct die_info
*follow_die_ref (unsigned int);
929 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
931 /* memory allocation interface */
933 static void dwarf2_free_tmp_obstack (PTR
);
935 static struct dwarf_block
*dwarf_alloc_block (void);
937 static struct abbrev_info
*dwarf_alloc_abbrev (void);
939 static struct die_info
*dwarf_alloc_die (void);
941 static void initialize_cu_func_list (void);
943 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
945 static void dwarf_decode_macros (struct line_header
*, unsigned int,
946 char *, bfd
*, const struct comp_unit_head
*,
949 static int attr_form_is_block (struct attribute
*);
951 /* Try to locate the sections we need for DWARF 2 debugging
952 information and return true if we have enough to do something. */
955 dwarf2_has_info (bfd
*abfd
)
957 dwarf_info_offset
= 0;
958 dwarf_abbrev_offset
= 0;
959 dwarf_line_offset
= 0;
960 dwarf_str_offset
= 0;
961 dwarf_macinfo_offset
= 0;
962 dwarf_frame_offset
= 0;
963 dwarf_eh_frame_offset
= 0;
964 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
965 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
975 /* This function is mapped across the sections and remembers the
976 offset and size of each of the debugging sections we are interested
980 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, PTR ignore_ptr
)
982 if (STREQ (sectp
->name
, INFO_SECTION
))
984 dwarf_info_offset
= sectp
->filepos
;
985 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
987 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
989 dwarf_abbrev_offset
= sectp
->filepos
;
990 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
992 else if (STREQ (sectp
->name
, LINE_SECTION
))
994 dwarf_line_offset
= sectp
->filepos
;
995 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
997 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
999 dwarf_pubnames_offset
= sectp
->filepos
;
1000 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
1002 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
1004 dwarf_aranges_offset
= sectp
->filepos
;
1005 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
1007 else if (STREQ (sectp
->name
, LOC_SECTION
))
1009 dwarf_loc_offset
= sectp
->filepos
;
1010 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
1012 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
1014 dwarf_macinfo_offset
= sectp
->filepos
;
1015 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
1017 else if (STREQ (sectp
->name
, STR_SECTION
))
1019 dwarf_str_offset
= sectp
->filepos
;
1020 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
1022 else if (STREQ (sectp
->name
, FRAME_SECTION
))
1024 dwarf_frame_offset
= sectp
->filepos
;
1025 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1027 else if (STREQ (sectp
->name
, EH_FRAME_SECTION
))
1029 dwarf_eh_frame_offset
= sectp
->filepos
;
1030 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1034 /* Build a partial symbol table. */
1037 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1040 /* We definitely need the .debug_info and .debug_abbrev sections */
1042 dwarf_info_buffer
= dwarf2_read_section (objfile
,
1045 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
1046 dwarf_abbrev_offset
,
1049 if (dwarf_line_offset
)
1050 dwarf_line_buffer
= dwarf2_read_section (objfile
,
1054 dwarf_line_buffer
= NULL
;
1056 if (dwarf_str_offset
)
1057 dwarf_str_buffer
= dwarf2_read_section (objfile
,
1061 dwarf_str_buffer
= NULL
;
1063 if (dwarf_macinfo_offset
)
1064 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1065 dwarf_macinfo_offset
,
1066 dwarf_macinfo_size
);
1068 dwarf_macinfo_buffer
= NULL
;
1071 || (objfile
->global_psymbols
.size
== 0
1072 && objfile
->static_psymbols
.size
== 0))
1074 init_psymbol_list (objfile
, 1024);
1078 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1080 /* Things are significantly easier if we have .debug_aranges and
1081 .debug_pubnames sections */
1083 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1087 /* only test this case for now */
1089 /* In this case we have to work a bit harder */
1090 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1095 /* Build the partial symbol table from the information in the
1096 .debug_pubnames and .debug_aranges sections. */
1099 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1101 bfd
*abfd
= objfile
->obfd
;
1102 char *aranges_buffer
, *pubnames_buffer
;
1103 char *aranges_ptr
, *pubnames_ptr
;
1104 unsigned int entry_length
, version
, info_offset
, info_size
;
1106 pubnames_buffer
= dwarf2_read_section (objfile
,
1107 dwarf_pubnames_offset
,
1108 dwarf_pubnames_size
);
1109 pubnames_ptr
= pubnames_buffer
;
1110 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1112 struct comp_unit_head cu_header
;
1115 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1117 pubnames_ptr
+= bytes_read
;
1118 version
= read_1_byte (abfd
, pubnames_ptr
);
1120 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1122 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1126 aranges_buffer
= dwarf2_read_section (objfile
,
1127 dwarf_aranges_offset
,
1128 dwarf_aranges_size
);
1133 /* Read in the comp unit header information from the debug_info at
1137 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1138 char *info_ptr
, bfd
*abfd
)
1142 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1144 info_ptr
+= bytes_read
;
1145 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1147 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1149 info_ptr
+= bytes_read
;
1150 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1152 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1153 if (signed_addr
< 0)
1154 internal_error (__FILE__
, __LINE__
,
1155 "read_comp_unit_head: dwarf from non elf file");
1156 cu_header
->signed_addr_p
= signed_addr
;
1160 /* Build the partial symbol table by doing a quick pass through the
1161 .debug_info and .debug_abbrev sections. */
1164 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1166 /* Instead of reading this into a big buffer, we should probably use
1167 mmap() on architectures that support it. (FIXME) */
1168 bfd
*abfd
= objfile
->obfd
;
1169 char *info_ptr
, *abbrev_ptr
;
1170 char *beg_of_comp_unit
;
1171 struct partial_die_info comp_unit_die
;
1172 struct partial_symtab
*pst
;
1173 struct cleanup
*back_to
;
1174 CORE_ADDR lowpc
, highpc
;
1176 info_ptr
= dwarf_info_buffer
;
1177 abbrev_ptr
= dwarf_abbrev_buffer
;
1179 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1180 the partial symbol scan, like attribute values.
1182 We could reduce our peak memory consumption during partial symbol
1183 table construction by freeing stuff from this obstack more often
1184 --- say, after processing each compilation unit, or each die ---
1185 but it turns out that this saves almost nothing. For an
1186 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1187 on dwarf2_tmp_obstack. Some investigation showed:
1189 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1190 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1191 all fixed-length values not requiring dynamic allocation.
1193 2) 30% of the attributes used the form DW_FORM_string. For
1194 DW_FORM_string, read_attribute simply hands back a pointer to
1195 the null-terminated string in dwarf_info_buffer, so no dynamic
1196 allocation is needed there either.
1198 3) The remaining 1% of the attributes all used DW_FORM_block1.
1199 75% of those were DW_AT_frame_base location lists for
1200 functions; the rest were DW_AT_location attributes, probably
1201 for the global variables.
1203 Anyway, what this all means is that the memory the dwarf2
1204 reader uses as temporary space reading partial symbols is about
1205 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1207 obstack_init (&dwarf2_tmp_obstack
);
1208 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1210 /* Since the objects we're extracting from dwarf_info_buffer vary in
1211 length, only the individual functions to extract them (like
1212 read_comp_unit_head and read_partial_die) can really know whether
1213 the buffer is large enough to hold another complete object.
1215 At the moment, they don't actually check that. If
1216 dwarf_info_buffer holds just one extra byte after the last
1217 compilation unit's dies, then read_comp_unit_head will happily
1218 read off the end of the buffer. read_partial_die is similarly
1219 casual. Those functions should be fixed.
1221 For this loop condition, simply checking whether there's any data
1222 left at all should be sufficient. */
1223 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1225 struct comp_unit_head cu_header
;
1226 beg_of_comp_unit
= info_ptr
;
1227 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1229 if (cu_header
.version
!= 2)
1231 error ("Dwarf Error: wrong version in compilation unit header.");
1234 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
1236 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6).",
1237 (long) cu_header
.abbrev_offset
,
1238 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1241 if (beg_of_comp_unit
+ cu_header
.length
+ cu_header
.initial_length_size
1242 > dwarf_info_buffer
+ dwarf_info_size
)
1244 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0).",
1245 (long) cu_header
.length
,
1246 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1249 /* Complete the cu_header */
1250 cu_header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1251 cu_header
.first_die_ptr
= info_ptr
;
1252 cu_header
.cu_head_ptr
= beg_of_comp_unit
;
1254 /* Read the abbrevs for this compilation unit into a table */
1255 dwarf2_read_abbrevs (abfd
, &cu_header
);
1256 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1258 /* Read the compilation unit die */
1259 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1262 /* Set the language we're debugging */
1263 set_cu_language (comp_unit_die
.language
);
1265 /* Allocate a new partial symbol table structure */
1266 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1267 comp_unit_die
.name
? comp_unit_die
.name
: "",
1268 comp_unit_die
.lowpc
,
1269 objfile
->global_psymbols
.next
,
1270 objfile
->static_psymbols
.next
);
1272 pst
->read_symtab_private
= (char *)
1273 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1274 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1275 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1276 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1277 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1278 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1279 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1280 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1281 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1282 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1283 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1284 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1285 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1287 /* Store the function that reads in the rest of the symbol table */
1288 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1290 /* Check if comp unit has_children.
1291 If so, read the rest of the partial symbols from this comp unit.
1292 If not, there's no more debug_info for this comp unit. */
1293 if (comp_unit_die
.has_children
)
1295 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
,
1298 /* If the compilation unit didn't have an explicit address range,
1299 then use the information extracted from its child dies. */
1300 if (! comp_unit_die
.has_pc_info
)
1302 comp_unit_die
.lowpc
= lowpc
;
1303 comp_unit_die
.highpc
= highpc
;
1306 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1307 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1309 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1310 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1311 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1312 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1313 sort_pst_symbols (pst
);
1315 /* If there is already a psymtab or symtab for a file of this
1316 name, remove it. (If there is a symtab, more drastic things
1317 also happen.) This happens in VxWorks. */
1318 free_named_symtabs (pst
->filename
);
1320 info_ptr
= beg_of_comp_unit
+ cu_header
.length
1321 + cu_header
.initial_length_size
;
1323 do_cleanups (back_to
);
1326 /* Read in all interesting dies to the end of the compilation unit. */
1329 scan_partial_symbols (char *info_ptr
, struct objfile
*objfile
,
1330 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1331 const struct comp_unit_head
*cu_header
)
1333 bfd
*abfd
= objfile
->obfd
;
1334 struct partial_die_info pdi
;
1336 /* This function is called after we've read in the comp_unit_die in
1337 order to read its children. We start the nesting level at 1 since
1338 we have pushed 1 level down in order to read the comp unit's children.
1339 The comp unit itself is at level 0, so we stop reading when we pop
1340 back to that level. */
1342 int nesting_level
= 1;
1344 /* We only want to read in symbols corresponding to variables or
1345 other similar objects that are global or static. Normally, these
1346 are all children of the DW_TAG_compile_unit die, so are all at
1347 level 1. But C++ namespaces give ries to DW_TAG_namespace dies
1348 whose children are global objects. So we keep track of what
1349 level we currently think of as referring to file scope; this
1350 should always equal 1 plus the number of namespaces that we are
1351 currently nested within. */
1353 int file_scope_level
= 1;
1355 *lowpc
= ((CORE_ADDR
) -1);
1356 *highpc
= ((CORE_ADDR
) 0);
1358 while (nesting_level
)
1360 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
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_external
|| nesting_level
== file_scope_level
)
1378 && !pdi
.is_declaration
)
1380 add_partial_symbol (&pdi
, objfile
, cu_header
);
1384 case DW_TAG_variable
:
1385 case DW_TAG_typedef
:
1386 case DW_TAG_class_type
:
1387 case DW_TAG_structure_type
:
1388 case DW_TAG_union_type
:
1389 case DW_TAG_enumeration_type
:
1390 if ((pdi
.is_external
|| nesting_level
== file_scope_level
)
1391 && !pdi
.is_declaration
)
1393 add_partial_symbol (&pdi
, objfile
, cu_header
);
1396 case DW_TAG_enumerator
:
1397 /* File scope enumerators are added to the partial
1398 symbol table. They're children of the enumeration
1399 type die, so they occur at a level one higher than we
1400 normally look for. */
1401 if (nesting_level
== file_scope_level
+ 1)
1402 add_partial_symbol (&pdi
, objfile
, cu_header
);
1404 case DW_TAG_base_type
:
1405 /* File scope base type definitions are added to the partial
1407 if (nesting_level
== file_scope_level
)
1408 add_partial_symbol (&pdi
, objfile
, cu_header
);
1410 case DW_TAG_namespace
:
1411 /* FIXME: carlton/2002-10-16: we're not yet doing
1412 anything useful with this, but for now make sure that
1413 these tags at least don't cause us to miss any
1414 important symbols. */
1415 if (pdi
.has_children
)
1422 /* If the die has a sibling, skip to the sibling. Do not skip
1423 enumeration types, we want to record their enumerators. Do
1424 not skip namespaces, we want to record symbols inside
1427 && pdi
.tag
!= DW_TAG_enumeration_type
1428 && pdi
.tag
!= DW_TAG_namespace
)
1430 info_ptr
= pdi
.sibling
;
1432 else if (pdi
.has_children
)
1434 /* Die has children, but either the optional DW_AT_sibling
1435 attribute is missing or we want to look at them. */
1442 /* If this is the end of a DW_TAG_namespace entry, then
1443 decrease the file_scope_level, too. */
1444 if (nesting_level
< file_scope_level
)
1447 gdb_assert (nesting_level
== file_scope_level
);
1452 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1453 from `maint check'. */
1454 if (*lowpc
== ((CORE_ADDR
) -1))
1460 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1461 const struct comp_unit_head
*cu_header
)
1467 case DW_TAG_subprogram
:
1468 if (pdi
->is_external
)
1470 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1471 mst_text, objfile); */
1472 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1473 VAR_NAMESPACE
, LOC_BLOCK
,
1474 &objfile
->global_psymbols
,
1475 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1479 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1480 mst_file_text, objfile); */
1481 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1482 VAR_NAMESPACE
, LOC_BLOCK
,
1483 &objfile
->static_psymbols
,
1484 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1487 case DW_TAG_variable
:
1488 if (pdi
->is_external
)
1491 Don't enter into the minimal symbol tables as there is
1492 a minimal symbol table entry from the ELF symbols already.
1493 Enter into partial symbol table if it has a location
1494 descriptor or a type.
1495 If the location descriptor is missing, new_symbol will create
1496 a LOC_UNRESOLVED symbol, the address of the variable will then
1497 be determined from the minimal symbol table whenever the variable
1499 The address for the partial symbol table entry is not
1500 used by GDB, but it comes in handy for debugging partial symbol
1504 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1505 if (pdi
->locdesc
|| pdi
->has_type
)
1506 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1507 VAR_NAMESPACE
, LOC_STATIC
,
1508 &objfile
->global_psymbols
,
1509 0, addr
+ baseaddr
, cu_language
, objfile
);
1513 /* Static Variable. Skip symbols without location descriptors. */
1514 if (pdi
->locdesc
== NULL
)
1516 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1517 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1518 mst_file_data, objfile); */
1519 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1520 VAR_NAMESPACE
, LOC_STATIC
,
1521 &objfile
->static_psymbols
,
1522 0, addr
+ baseaddr
, cu_language
, objfile
);
1525 case DW_TAG_typedef
:
1526 case DW_TAG_base_type
:
1527 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1528 VAR_NAMESPACE
, LOC_TYPEDEF
,
1529 &objfile
->static_psymbols
,
1530 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1532 case DW_TAG_class_type
:
1533 case DW_TAG_structure_type
:
1534 case DW_TAG_union_type
:
1535 case DW_TAG_enumeration_type
:
1536 /* Skip aggregate types without children, these are external
1538 if (pdi
->has_children
== 0)
1540 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1541 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1542 &objfile
->static_psymbols
,
1543 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1545 if (cu_language
== language_cplus
)
1547 /* For C++, these implicitly act as typedefs as well. */
1548 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1549 VAR_NAMESPACE
, LOC_TYPEDEF
,
1550 &objfile
->static_psymbols
,
1551 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1554 case DW_TAG_enumerator
:
1555 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1556 VAR_NAMESPACE
, LOC_CONST
,
1557 &objfile
->static_psymbols
,
1558 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1565 /* Expand this partial symbol table into a full symbol table. */
1568 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1570 /* FIXME: This is barely more than a stub. */
1575 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1581 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1582 gdb_flush (gdb_stdout
);
1585 psymtab_to_symtab_1 (pst
);
1587 /* Finish up the debug error message. */
1589 printf_filtered ("done.\n");
1595 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1597 struct objfile
*objfile
= pst
->objfile
;
1598 bfd
*abfd
= objfile
->obfd
;
1599 struct comp_unit_head cu_header
;
1600 struct die_info
*dies
;
1601 unsigned long offset
;
1602 CORE_ADDR lowpc
, highpc
;
1603 struct die_info
*child_die
;
1605 struct symtab
*symtab
;
1606 struct cleanup
*back_to
;
1608 /* Set local variables from the partial symbol table info. */
1609 offset
= DWARF_INFO_OFFSET (pst
);
1610 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1611 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1612 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1613 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1614 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1615 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1616 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1617 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1618 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1619 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1620 cu_header_offset
= offset
;
1621 info_ptr
= dwarf_info_buffer
+ offset
;
1623 obstack_init (&dwarf2_tmp_obstack
);
1624 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1627 make_cleanup (really_free_pendings
, NULL
);
1629 /* read in the comp_unit header */
1630 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1632 /* Read the abbrevs for this compilation unit */
1633 dwarf2_read_abbrevs (abfd
, &cu_header
);
1634 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1636 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
1638 make_cleanup_free_die_list (dies
);
1640 /* Do line number decoding in read_file_scope () */
1641 process_die (dies
, objfile
, &cu_header
);
1643 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1645 /* Some compilers don't define a DW_AT_high_pc attribute for
1646 the compilation unit. If the DW_AT_high_pc is missing,
1647 synthesize it, by scanning the DIE's below the compilation unit. */
1649 if (dies
->has_children
)
1651 child_die
= dies
->next
;
1652 while (child_die
&& child_die
->tag
)
1654 if (child_die
->tag
== DW_TAG_subprogram
)
1656 CORE_ADDR low
, high
;
1658 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1660 highpc
= max (highpc
, high
);
1663 child_die
= sibling_die (child_die
);
1667 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1669 /* Set symtab language to language from DW_AT_language.
1670 If the compilation is from a C file generated by language preprocessors,
1671 do not set the language if it was already deduced by start_subfile. */
1673 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1675 symtab
->language
= cu_language
;
1677 pst
->symtab
= symtab
;
1679 sort_symtab_syms (pst
->symtab
);
1681 do_cleanups (back_to
);
1684 /* Process a die and its children. */
1687 process_die (struct die_info
*die
, struct objfile
*objfile
,
1688 const struct comp_unit_head
*cu_header
)
1692 case DW_TAG_padding
:
1694 case DW_TAG_compile_unit
:
1695 read_file_scope (die
, objfile
, cu_header
);
1697 case DW_TAG_subprogram
:
1698 read_subroutine_type (die
, objfile
, cu_header
);
1699 read_func_scope (die
, objfile
, cu_header
);
1701 case DW_TAG_inlined_subroutine
:
1702 /* FIXME: These are ignored for now.
1703 They could be used to set breakpoints on all inlined instances
1704 of a function and make GDB `next' properly over inlined functions. */
1706 case DW_TAG_lexical_block
:
1707 read_lexical_block_scope (die
, objfile
, cu_header
);
1709 case DW_TAG_class_type
:
1710 case DW_TAG_structure_type
:
1711 case DW_TAG_union_type
:
1712 read_structure_scope (die
, objfile
, cu_header
);
1714 case DW_TAG_enumeration_type
:
1715 read_enumeration (die
, objfile
, cu_header
);
1717 case DW_TAG_subroutine_type
:
1718 read_subroutine_type (die
, objfile
, cu_header
);
1720 case DW_TAG_array_type
:
1721 read_array_type (die
, objfile
, cu_header
);
1723 case DW_TAG_pointer_type
:
1724 read_tag_pointer_type (die
, objfile
, cu_header
);
1726 case DW_TAG_ptr_to_member_type
:
1727 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1729 case DW_TAG_reference_type
:
1730 read_tag_reference_type (die
, objfile
, cu_header
);
1732 case DW_TAG_string_type
:
1733 read_tag_string_type (die
, objfile
);
1735 case DW_TAG_base_type
:
1736 read_base_type (die
, objfile
);
1737 if (dwarf_attr (die
, DW_AT_name
))
1739 /* Add a typedef symbol for the base type definition. */
1740 new_symbol (die
, die
->type
, objfile
, cu_header
);
1743 case DW_TAG_common_block
:
1744 read_common_block (die
, objfile
, cu_header
);
1746 case DW_TAG_common_inclusion
:
1748 case DW_TAG_namespace
:
1749 read_namespace (die
, objfile
, cu_header
);
1751 case DW_TAG_imported_declaration
:
1752 case DW_TAG_imported_module
:
1753 /* FIXME: carlton/2002-10-16: Eventually, we should use the
1754 information contained in these. DW_TAG_imported_declaration
1755 dies shouldn't have children; DW_TAG_imported_module dies
1756 shouldn't in the C++ case, but conceivably could in the
1757 Fortran case, so we'll have to replace this gdb_assert if
1758 Fortran compilers start generating that info. */
1759 gdb_assert (!die
->has_children
);
1762 new_symbol (die
, NULL
, objfile
, cu_header
);
1768 initialize_cu_func_list (void)
1770 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1774 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1775 const struct comp_unit_head
*cu_header
)
1777 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1778 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1779 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1780 struct attribute
*attr
;
1781 char *name
= "<unknown>";
1782 char *comp_dir
= NULL
;
1783 struct die_info
*child_die
;
1784 bfd
*abfd
= objfile
->obfd
;
1785 struct line_header
*line_header
= 0;
1787 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1789 if (die
->has_children
)
1791 child_die
= die
->next
;
1792 while (child_die
&& child_die
->tag
)
1794 if (child_die
->tag
== DW_TAG_subprogram
)
1796 CORE_ADDR low
, high
;
1798 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1800 lowpc
= min (lowpc
, low
);
1801 highpc
= max (highpc
, high
);
1804 child_die
= sibling_die (child_die
);
1809 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1810 from finish_block. */
1811 if (lowpc
== ((CORE_ADDR
) -1))
1816 attr
= dwarf_attr (die
, DW_AT_name
);
1819 name
= DW_STRING (attr
);
1821 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1824 comp_dir
= DW_STRING (attr
);
1827 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1828 directory, get rid of it. */
1829 char *cp
= strchr (comp_dir
, ':');
1831 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1836 if (objfile
->ei
.entry_point
>= lowpc
&&
1837 objfile
->ei
.entry_point
< highpc
)
1839 objfile
->ei
.entry_file_lowpc
= lowpc
;
1840 objfile
->ei
.entry_file_highpc
= highpc
;
1843 attr
= dwarf_attr (die
, DW_AT_language
);
1846 set_cu_language (DW_UNSND (attr
));
1849 /* We assume that we're processing GCC output. */
1850 processing_gcc_compilation
= 2;
1852 /* FIXME:Do something here. */
1853 if (dip
->at_producer
!= NULL
)
1855 handle_producer (dip
->at_producer
);
1859 /* The compilation unit may be in a different language or objfile,
1860 zero out all remembered fundamental types. */
1861 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1863 start_symtab (name
, comp_dir
, lowpc
);
1864 record_debugformat ("DWARF 2");
1866 initialize_cu_func_list ();
1868 /* Process all dies in compilation unit. */
1869 if (die
->has_children
)
1871 child_die
= die
->next
;
1872 while (child_die
&& child_die
->tag
)
1874 process_die (child_die
, objfile
, cu_header
);
1875 child_die
= sibling_die (child_die
);
1879 /* Decode line number information if present. */
1880 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1883 unsigned int line_offset
= DW_UNSND (attr
);
1884 line_header
= dwarf_decode_line_header (line_offset
,
1888 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
1889 (void *) line_header
);
1890 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu_header
);
1894 /* Decode macro information, if present. Dwarf 2 macro information
1895 refers to information in the line number info statement program
1896 header, so we can only read it if we've read the header
1898 attr
= dwarf_attr (die
, DW_AT_macro_info
);
1899 if (attr
&& line_header
)
1901 unsigned int macro_offset
= DW_UNSND (attr
);
1902 dwarf_decode_macros (line_header
, macro_offset
,
1903 comp_dir
, abfd
, cu_header
, objfile
);
1905 do_cleanups (back_to
);
1909 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
1911 struct function_range
*thisfn
;
1913 thisfn
= (struct function_range
*)
1914 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
1915 thisfn
->name
= name
;
1916 thisfn
->lowpc
= lowpc
;
1917 thisfn
->highpc
= highpc
;
1918 thisfn
->seen_line
= 0;
1919 thisfn
->next
= NULL
;
1921 if (cu_last_fn
== NULL
)
1922 cu_first_fn
= thisfn
;
1924 cu_last_fn
->next
= thisfn
;
1926 cu_last_fn
= thisfn
;
1930 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
1931 const struct comp_unit_head
*cu_header
)
1933 register struct context_stack
*new;
1936 struct die_info
*child_die
;
1937 struct attribute
*attr
;
1940 name
= dwarf2_linkage_name (die
);
1942 /* Ignore functions with missing or empty names and functions with
1943 missing or invalid low and high pc attributes. */
1944 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1950 /* Record the function range for dwarf_decode_lines. */
1951 add_to_cu_func_list (name
, lowpc
, highpc
);
1953 if (objfile
->ei
.entry_point
>= lowpc
&&
1954 objfile
->ei
.entry_point
< highpc
)
1956 objfile
->ei
.entry_func_lowpc
= lowpc
;
1957 objfile
->ei
.entry_func_highpc
= highpc
;
1960 /* Decode DW_AT_frame_base location descriptor if present, keep result
1961 for DW_OP_fbreg operands in decode_locdesc. */
1962 frame_base_reg
= -1;
1963 frame_base_offset
= 0;
1964 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1969 /* Support the .debug_loc offsets */
1970 if (attr_form_is_block (attr
))
1972 addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
1974 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
1976 complain (&dwarf2_complex_location_expr
);
1981 complain (&dwarf2_invalid_attrib_class
, "DW_AT_frame_base", name
);
1986 complain (&dwarf2_unsupported_at_frame_base
, name
);
1988 frame_base_reg
= addr
;
1991 frame_base_reg
= basereg
;
1992 frame_base_offset
= addr
;
1995 complain (&dwarf2_unsupported_at_frame_base
, name
);
1998 new = push_context (0, lowpc
);
1999 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
2000 list_in_scope
= &local_symbols
;
2002 if (die
->has_children
)
2004 child_die
= die
->next
;
2005 while (child_die
&& child_die
->tag
)
2007 process_die (child_die
, objfile
, cu_header
);
2008 child_die
= sibling_die (child_die
);
2012 new = pop_context ();
2013 /* Make a block for the local symbols within. */
2014 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2015 lowpc
, highpc
, objfile
);
2017 /* In C++, we can have functions nested inside functions (e.g., when
2018 a function declares a class that has methods). This means that
2019 when we finish processing a function scope, we may need to go
2020 back to building a containing block's symbol lists. */
2021 local_symbols
= new->locals
;
2022 param_symbols
= new->params
;
2024 list_in_scope
= &file_symbols
;
2027 /* Process all the DIES contained within a lexical block scope. Start
2028 a new scope, process the dies, and then close the scope. */
2031 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
2032 const struct comp_unit_head
*cu_header
)
2034 register struct context_stack
*new;
2035 CORE_ADDR lowpc
, highpc
;
2036 struct die_info
*child_die
;
2038 /* Ignore blocks with missing or invalid low and high pc attributes. */
2039 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
2044 push_context (0, lowpc
);
2045 if (die
->has_children
)
2047 child_die
= die
->next
;
2048 while (child_die
&& child_die
->tag
)
2050 process_die (child_die
, objfile
, cu_header
);
2051 child_die
= sibling_die (child_die
);
2054 new = pop_context ();
2056 if (local_symbols
!= NULL
)
2058 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2061 local_symbols
= new->locals
;
2064 /* Get low and high pc attributes from a die.
2065 Return 1 if the attributes are present and valid, otherwise, return 0. */
2068 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2069 struct objfile
*objfile
)
2071 struct attribute
*attr
;
2075 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2077 low
= DW_ADDR (attr
);
2080 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2082 high
= DW_ADDR (attr
);
2089 /* When using the GNU linker, .gnu.linkonce. sections are used to
2090 eliminate duplicate copies of functions and vtables and such.
2091 The linker will arbitrarily choose one and discard the others.
2092 The AT_*_pc values for such functions refer to local labels in
2093 these sections. If the section from that file was discarded, the
2094 labels are not in the output, so the relocs get a value of 0.
2095 If this is a discarded function, mark the pc bounds as invalid,
2096 so that GDB will ignore it. */
2097 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
2105 /* Add an aggregate field to the field list. */
2108 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2109 struct objfile
*objfile
,
2110 const struct comp_unit_head
*cu_header
)
2112 struct nextfield
*new_field
;
2113 struct attribute
*attr
;
2115 char *fieldname
= "";
2117 /* Allocate a new field list entry and link it in. */
2118 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2119 make_cleanup (xfree
, new_field
);
2120 memset (new_field
, 0, sizeof (struct nextfield
));
2121 new_field
->next
= fip
->fields
;
2122 fip
->fields
= new_field
;
2125 /* Handle accessibility and virtuality of field.
2126 The default accessibility for members is public, the default
2127 accessibility for inheritance is private. */
2128 if (die
->tag
!= DW_TAG_inheritance
)
2129 new_field
->accessibility
= DW_ACCESS_public
;
2131 new_field
->accessibility
= DW_ACCESS_private
;
2132 new_field
->virtuality
= DW_VIRTUALITY_none
;
2134 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2136 new_field
->accessibility
= DW_UNSND (attr
);
2137 if (new_field
->accessibility
!= DW_ACCESS_public
)
2138 fip
->non_public_fields
= 1;
2139 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2141 new_field
->virtuality
= DW_UNSND (attr
);
2143 fp
= &new_field
->field
;
2144 if (die
->tag
== DW_TAG_member
)
2146 /* Get type of field. */
2147 fp
->type
= die_type (die
, objfile
, cu_header
);
2149 /* Get bit size of field (zero if none). */
2150 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2153 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2157 FIELD_BITSIZE (*fp
) = 0;
2160 /* Get bit offset of field. */
2161 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2164 FIELD_BITPOS (*fp
) =
2165 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
2168 FIELD_BITPOS (*fp
) = 0;
2169 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2172 if (BITS_BIG_ENDIAN
)
2174 /* For big endian bits, the DW_AT_bit_offset gives the
2175 additional bit offset from the MSB of the containing
2176 anonymous object to the MSB of the field. We don't
2177 have to do anything special since we don't need to
2178 know the size of the anonymous object. */
2179 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2183 /* For little endian bits, compute the bit offset to the
2184 MSB of the anonymous object, subtract off the number of
2185 bits from the MSB of the field to the MSB of the
2186 object, and then subtract off the number of bits of
2187 the field itself. The result is the bit offset of
2188 the LSB of the field. */
2190 int bit_offset
= DW_UNSND (attr
);
2192 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2195 /* The size of the anonymous object containing
2196 the bit field is explicit, so use the
2197 indicated size (in bytes). */
2198 anonymous_size
= DW_UNSND (attr
);
2202 /* The size of the anonymous object containing
2203 the bit field must be inferred from the type
2204 attribute of the data member containing the
2206 anonymous_size
= TYPE_LENGTH (fp
->type
);
2208 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2209 - bit_offset
- FIELD_BITSIZE (*fp
);
2213 /* Get name of field. */
2214 attr
= dwarf_attr (die
, DW_AT_name
);
2215 if (attr
&& DW_STRING (attr
))
2216 fieldname
= DW_STRING (attr
);
2217 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2218 &objfile
->type_obstack
);
2220 /* Change accessibility for artificial fields (e.g. virtual table
2221 pointer or virtual base class pointer) to private. */
2222 if (dwarf_attr (die
, DW_AT_artificial
))
2224 new_field
->accessibility
= DW_ACCESS_private
;
2225 fip
->non_public_fields
= 1;
2228 else if (die
->tag
== DW_TAG_variable
)
2232 /* C++ static member.
2233 Get name of field. */
2234 attr
= dwarf_attr (die
, DW_AT_name
);
2235 if (attr
&& DW_STRING (attr
))
2236 fieldname
= DW_STRING (attr
);
2240 /* Get physical name. */
2241 physname
= dwarf2_linkage_name (die
);
2243 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2244 &objfile
->type_obstack
));
2245 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2246 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2247 &objfile
->type_obstack
);
2249 else if (die
->tag
== DW_TAG_inheritance
)
2251 /* C++ base class field. */
2252 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2254 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
2256 FIELD_BITSIZE (*fp
) = 0;
2257 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2258 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2259 fip
->nbaseclasses
++;
2263 /* Create the vector of fields, and attach it to the type. */
2266 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2267 struct objfile
*objfile
)
2269 int nfields
= fip
->nfields
;
2271 /* Record the field count, allocate space for the array of fields,
2272 and create blank accessibility bitfields if necessary. */
2273 TYPE_NFIELDS (type
) = nfields
;
2274 TYPE_FIELDS (type
) = (struct field
*)
2275 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2276 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2278 if (fip
->non_public_fields
)
2280 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2282 TYPE_FIELD_PRIVATE_BITS (type
) =
2283 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2284 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2286 TYPE_FIELD_PROTECTED_BITS (type
) =
2287 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2288 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2290 TYPE_FIELD_IGNORE_BITS (type
) =
2291 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2292 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2295 /* If the type has baseclasses, allocate and clear a bit vector for
2296 TYPE_FIELD_VIRTUAL_BITS. */
2297 if (fip
->nbaseclasses
)
2299 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2302 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2303 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2304 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2305 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2306 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2309 /* Copy the saved-up fields into the field vector. Start from the head
2310 of the list, adding to the tail of the field array, so that they end
2311 up in the same order in the array in which they were added to the list. */
2312 while (nfields
-- > 0)
2314 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2315 switch (fip
->fields
->accessibility
)
2317 case DW_ACCESS_private
:
2318 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2321 case DW_ACCESS_protected
:
2322 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2325 case DW_ACCESS_public
:
2329 /* Unknown accessibility. Complain and treat it as public. */
2331 complain (&dwarf2_unsupported_accessibility
,
2332 fip
->fields
->accessibility
);
2336 if (nfields
< fip
->nbaseclasses
)
2338 switch (fip
->fields
->virtuality
)
2340 case DW_VIRTUALITY_virtual
:
2341 case DW_VIRTUALITY_pure_virtual
:
2342 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2346 fip
->fields
= fip
->fields
->next
;
2350 /* Add a member function to the proper fieldlist. */
2353 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2354 struct type
*type
, struct objfile
*objfile
,
2355 const struct comp_unit_head
*cu_header
)
2357 struct attribute
*attr
;
2358 struct fnfieldlist
*flp
;
2360 struct fn_field
*fnp
;
2363 struct nextfnfield
*new_fnfield
;
2365 /* Get name of member function. */
2366 attr
= dwarf_attr (die
, DW_AT_name
);
2367 if (attr
&& DW_STRING (attr
))
2368 fieldname
= DW_STRING (attr
);
2372 /* Get the mangled name. */
2373 physname
= dwarf2_linkage_name (die
);
2375 /* Look up member function name in fieldlist. */
2376 for (i
= 0; i
< fip
->nfnfields
; i
++)
2378 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2382 /* Create new list element if necessary. */
2383 if (i
< fip
->nfnfields
)
2384 flp
= &fip
->fnfieldlists
[i
];
2387 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2389 fip
->fnfieldlists
= (struct fnfieldlist
*)
2390 xrealloc (fip
->fnfieldlists
,
2391 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2392 * sizeof (struct fnfieldlist
));
2393 if (fip
->nfnfields
== 0)
2394 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2396 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2397 flp
->name
= fieldname
;
2403 /* Create a new member function field and chain it to the field list
2405 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2406 make_cleanup (xfree
, new_fnfield
);
2407 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2408 new_fnfield
->next
= flp
->head
;
2409 flp
->head
= new_fnfield
;
2412 /* Fill in the member function field info. */
2413 fnp
= &new_fnfield
->fnfield
;
2414 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2415 &objfile
->type_obstack
);
2416 fnp
->type
= alloc_type (objfile
);
2417 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2419 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2420 int nparams
= TYPE_NFIELDS (die
->type
);
2422 /* TYPE is the domain of this method, and DIE->TYPE is the type
2423 of the method itself (TYPE_CODE_METHOD). */
2424 smash_to_method_type (fnp
->type
, type
,
2425 TYPE_TARGET_TYPE (die
->type
),
2426 TYPE_FIELDS (die
->type
),
2427 TYPE_NFIELDS (die
->type
),
2428 TYPE_VARARGS (die
->type
));
2430 /* Handle static member functions.
2431 Dwarf2 has no clean way to discern C++ static and non-static
2432 member functions. G++ helps GDB by marking the first
2433 parameter for non-static member functions (which is the
2434 this pointer) as artificial. We obtain this information
2435 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2436 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2437 fnp
->voffset
= VOFFSET_STATIC
;
2440 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2442 /* Get fcontext from DW_AT_containing_type if present. */
2443 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2444 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2446 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2447 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2449 /* Get accessibility. */
2450 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2453 switch (DW_UNSND (attr
))
2455 case DW_ACCESS_private
:
2456 fnp
->is_private
= 1;
2458 case DW_ACCESS_protected
:
2459 fnp
->is_protected
= 1;
2464 /* Check for artificial methods. */
2465 attr
= dwarf_attr (die
, DW_AT_artificial
);
2466 if (attr
&& DW_UNSND (attr
) != 0)
2467 fnp
->is_artificial
= 1;
2469 /* Get index in virtual function table if it is a virtual member function. */
2470 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2473 /* Support the .debug_loc offsets */
2474 if (attr_form_is_block (attr
))
2476 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2478 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2480 complain (&dwarf2_complex_location_expr
);
2484 complain (&dwarf2_invalid_attrib_class
, "DW_AT_vtable_elem_location",
2490 /* Create the vector of member function fields, and attach it to the type. */
2493 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2494 struct objfile
*objfile
)
2496 struct fnfieldlist
*flp
;
2497 int total_length
= 0;
2500 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2501 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2502 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2504 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2506 struct nextfnfield
*nfp
= flp
->head
;
2507 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2510 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2511 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2512 fn_flp
->fn_fields
= (struct fn_field
*)
2513 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2514 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2515 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2517 total_length
+= flp
->length
;
2520 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2521 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2524 /* Called when we find the DIE that starts a structure or union scope
2525 (definition) to process all dies that define the members of the
2528 NOTE: we need to call struct_type regardless of whether or not the
2529 DIE has an at_name attribute, since it might be an anonymous
2530 structure or union. This gets the type entered into our set of
2533 However, if the structure is incomplete (an opaque struct/union)
2534 then suppress creating a symbol table entry for it since gdb only
2535 wants to find the one with the complete definition. Note that if
2536 it is complete, we just call new_symbol, which does it's own
2537 checking about whether the struct/union is anonymous or not (and
2538 suppresses creating a symbol table entry itself). */
2541 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2542 const struct comp_unit_head
*cu_header
)
2545 struct attribute
*attr
;
2547 type
= alloc_type (objfile
);
2549 INIT_CPLUS_SPECIFIC (type
);
2550 attr
= dwarf_attr (die
, DW_AT_name
);
2551 if (attr
&& DW_STRING (attr
))
2553 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2554 strlen (DW_STRING (attr
)),
2555 &objfile
->type_obstack
);
2558 if (die
->tag
== DW_TAG_structure_type
)
2560 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2562 else if (die
->tag
== DW_TAG_union_type
)
2564 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2568 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2570 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2573 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2576 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2580 TYPE_LENGTH (type
) = 0;
2583 /* We need to add the type field to the die immediately so we don't
2584 infinitely recurse when dealing with pointers to the structure
2585 type within the structure itself. */
2588 if (die
->has_children
&& ! die_is_declaration (die
))
2590 struct field_info fi
;
2591 struct die_info
*child_die
;
2592 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2594 memset (&fi
, 0, sizeof (struct field_info
));
2596 child_die
= die
->next
;
2598 while (child_die
&& child_die
->tag
)
2600 if (child_die
->tag
== DW_TAG_member
)
2602 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2604 else if (child_die
->tag
== DW_TAG_variable
)
2606 /* C++ static member. */
2607 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2609 else if (child_die
->tag
== DW_TAG_subprogram
)
2611 /* C++ member function. */
2612 process_die (child_die
, objfile
, cu_header
);
2613 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2615 else if (child_die
->tag
== DW_TAG_inheritance
)
2617 /* C++ base class field. */
2618 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2622 process_die (child_die
, objfile
, cu_header
);
2624 child_die
= sibling_die (child_die
);
2627 /* Attach fields and member functions to the type. */
2629 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2632 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2634 /* Get the type which refers to the base class (possibly this
2635 class itself) which contains the vtable pointer for the current
2636 class from the DW_AT_containing_type attribute. */
2638 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2640 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2642 TYPE_VPTR_BASETYPE (type
) = t
;
2645 static const char vptr_name
[] =
2646 {'_', 'v', 'p', 't', 'r', '\0'};
2649 /* Our own class provides vtbl ptr. */
2650 for (i
= TYPE_NFIELDS (t
) - 1;
2651 i
>= TYPE_N_BASECLASSES (t
);
2654 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2656 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2657 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2659 TYPE_VPTR_FIELDNO (type
) = i
;
2664 /* Complain if virtual function table field not found. */
2665 if (i
< TYPE_N_BASECLASSES (t
))
2666 complain (&dwarf2_vtbl_not_found_complaint
,
2667 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2671 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2676 new_symbol (die
, type
, objfile
, cu_header
);
2678 do_cleanups (back_to
);
2682 /* No children, must be stub. */
2683 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2687 /* Given a pointer to a die which begins an enumeration, process all
2688 the dies that define the members of the enumeration.
2690 This will be much nicer in draft 6 of the DWARF spec when our
2691 members will be dies instead squished into the DW_AT_element_list
2694 NOTE: We reverse the order of the element list. */
2697 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2698 const struct comp_unit_head
*cu_header
)
2700 struct die_info
*child_die
;
2702 struct field
*fields
;
2703 struct attribute
*attr
;
2706 int unsigned_enum
= 1;
2708 type
= alloc_type (objfile
);
2710 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2711 attr
= dwarf_attr (die
, DW_AT_name
);
2712 if (attr
&& DW_STRING (attr
))
2714 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2715 strlen (DW_STRING (attr
)),
2716 &objfile
->type_obstack
);
2719 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2722 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2726 TYPE_LENGTH (type
) = 0;
2731 if (die
->has_children
)
2733 child_die
= die
->next
;
2734 while (child_die
&& child_die
->tag
)
2736 if (child_die
->tag
!= DW_TAG_enumerator
)
2738 process_die (child_die
, objfile
, cu_header
);
2742 attr
= dwarf_attr (child_die
, DW_AT_name
);
2745 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2746 if (SYMBOL_VALUE (sym
) < 0)
2749 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2751 fields
= (struct field
*)
2753 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2754 * sizeof (struct field
));
2757 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2758 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2759 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2760 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2766 child_die
= sibling_die (child_die
);
2771 TYPE_NFIELDS (type
) = num_fields
;
2772 TYPE_FIELDS (type
) = (struct field
*)
2773 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2774 memcpy (TYPE_FIELDS (type
), fields
,
2775 sizeof (struct field
) * num_fields
);
2779 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2782 new_symbol (die
, type
, objfile
, cu_header
);
2785 /* Extract all information from a DW_TAG_array_type DIE and put it in
2786 the DIE's type field. For now, this only handles one dimensional
2790 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2791 const struct comp_unit_head
*cu_header
)
2793 struct die_info
*child_die
;
2794 struct type
*type
= NULL
;
2795 struct type
*element_type
, *range_type
, *index_type
;
2796 struct type
**range_types
= NULL
;
2797 struct attribute
*attr
;
2799 struct cleanup
*back_to
;
2801 /* Return if we've already decoded this type. */
2807 element_type
= die_type (die
, objfile
, cu_header
);
2809 /* Irix 6.2 native cc creates array types without children for
2810 arrays with unspecified length. */
2811 if (die
->has_children
== 0)
2813 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2814 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2815 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2819 back_to
= make_cleanup (null_cleanup
, NULL
);
2820 child_die
= die
->next
;
2821 while (child_die
&& child_die
->tag
)
2823 if (child_die
->tag
== DW_TAG_subrange_type
)
2825 unsigned int low
, high
;
2827 /* Default bounds to an array with unspecified length. */
2830 if (cu_language
== language_fortran
)
2832 /* FORTRAN implies a lower bound of 1, if not given. */
2836 index_type
= die_type (child_die
, objfile
, cu_header
);
2837 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2840 if (attr
->form
== DW_FORM_sdata
)
2842 low
= DW_SND (attr
);
2844 else if (attr
->form
== DW_FORM_udata
2845 || attr
->form
== DW_FORM_data1
2846 || attr
->form
== DW_FORM_data2
2847 || attr
->form
== DW_FORM_data4
2848 || attr
->form
== DW_FORM_data8
)
2850 low
= DW_UNSND (attr
);
2854 complain (&dwarf2_non_const_array_bound_ignored
,
2855 dwarf_form_name (attr
->form
));
2857 die
->type
= lookup_pointer_type (element_type
);
2864 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2867 if (attr
->form
== DW_FORM_sdata
)
2869 high
= DW_SND (attr
);
2871 else if (attr
->form
== DW_FORM_udata
2872 || attr
->form
== DW_FORM_data1
2873 || attr
->form
== DW_FORM_data2
2874 || attr
->form
== DW_FORM_data4
2875 || attr
->form
== DW_FORM_data8
)
2877 high
= DW_UNSND (attr
);
2879 else if (attr
->form
== DW_FORM_block1
)
2881 /* GCC encodes arrays with unspecified or dynamic length
2882 with a DW_FORM_block1 attribute.
2883 FIXME: GDB does not yet know how to handle dynamic
2884 arrays properly, treat them as arrays with unspecified
2890 complain (&dwarf2_non_const_array_bound_ignored
,
2891 dwarf_form_name (attr
->form
));
2893 die
->type
= lookup_pointer_type (element_type
);
2901 /* Create a range type and save it for array type creation. */
2902 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2904 range_types
= (struct type
**)
2905 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2906 * sizeof (struct type
*));
2908 make_cleanup (free_current_contents
, &range_types
);
2910 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2912 child_die
= sibling_die (child_die
);
2915 /* Dwarf2 dimensions are output from left to right, create the
2916 necessary array types in backwards order. */
2917 type
= element_type
;
2919 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2921 /* Understand Dwarf2 support for vector types (like they occur on
2922 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
2923 array type. This is not part of the Dwarf2/3 standard yet, but a
2924 custom vendor extension. The main difference between a regular
2925 array and the vector variant is that vectors are passed by value
2927 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
2929 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
2931 do_cleanups (back_to
);
2933 /* Install the type in the die. */
2937 /* First cut: install each common block member as a global variable. */
2940 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
2941 const struct comp_unit_head
*cu_header
)
2943 struct die_info
*child_die
;
2944 struct attribute
*attr
;
2946 CORE_ADDR base
= (CORE_ADDR
) 0;
2948 attr
= dwarf_attr (die
, DW_AT_location
);
2951 /* Support the .debug_loc offsets */
2952 if (attr_form_is_block (attr
))
2954 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2956 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2958 complain (&dwarf2_complex_location_expr
);
2962 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
2963 "common block member");
2966 if (die
->has_children
)
2968 child_die
= die
->next
;
2969 while (child_die
&& child_die
->tag
)
2971 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
2972 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2975 SYMBOL_VALUE_ADDRESS (sym
) =
2976 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2977 add_symbol_to_list (sym
, &global_symbols
);
2979 child_die
= sibling_die (child_die
);
2984 /* Read a C++ namespace. */
2986 /* FIXME: carlton/2002-10-16: For now, we don't actually do anything
2987 useful with the namespace data: we just process its children. */
2990 read_namespace (struct die_info
*die
, struct objfile
*objfile
,
2991 const struct comp_unit_head
*cu_header
)
2993 if (die
->has_children
)
2995 struct die_info
*child_die
= die
->next
;
2997 while (child_die
&& child_die
->tag
)
2999 process_die (child_die
, objfile
, cu_header
);
3000 child_die
= sibling_die (child_die
);
3005 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3006 the user defined type vector. */
3009 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
3010 const struct comp_unit_head
*cu_header
)
3013 struct attribute
*attr_byte_size
;
3014 struct attribute
*attr_address_class
;
3015 int byte_size
, addr_class
;
3022 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
3024 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
3026 byte_size
= DW_UNSND (attr_byte_size
);
3028 byte_size
= cu_header
->addr_size
;
3030 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
3031 if (attr_address_class
)
3032 addr_class
= DW_UNSND (attr_address_class
);
3034 addr_class
= DW_ADDR_none
;
3036 /* If the pointer size or address class is different than the
3037 default, create a type variant marked as such and set the
3038 length accordingly. */
3039 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3041 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3045 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3046 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3047 type
= make_type_with_address_space (type
, type_flags
);
3049 else if (TYPE_LENGTH (type
) != byte_size
)
3051 complain (&dwarf2_invalid_pointer_size
, byte_size
);
3054 /* Should we also complain about unhandled address classes? */
3058 TYPE_LENGTH (type
) = byte_size
;
3062 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3063 the user defined type vector. */
3066 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
3067 const struct comp_unit_head
*cu_header
)
3070 struct type
*to_type
;
3071 struct type
*domain
;
3078 type
= alloc_type (objfile
);
3079 to_type
= die_type (die
, objfile
, cu_header
);
3080 domain
= die_containing_type (die
, objfile
, cu_header
);
3081 smash_to_member_type (type
, domain
, to_type
);
3086 /* Extract all information from a DW_TAG_reference_type DIE and add to
3087 the user defined type vector. */
3090 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
3091 const struct comp_unit_head
*cu_header
)
3094 struct attribute
*attr
;
3101 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
3102 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3105 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3109 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3115 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
3116 const struct comp_unit_head
*cu_header
)
3118 struct type
*base_type
;
3125 base_type
= die_type (die
, objfile
, cu_header
);
3126 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3130 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
3131 const struct comp_unit_head
*cu_header
)
3133 struct type
*base_type
;
3140 base_type
= die_type (die
, objfile
, cu_header
);
3141 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3144 /* Extract all information from a DW_TAG_string_type DIE and add to
3145 the user defined type vector. It isn't really a user defined type,
3146 but it behaves like one, with other DIE's using an AT_user_def_type
3147 attribute to reference it. */
3150 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
3152 struct type
*type
, *range_type
, *index_type
, *char_type
;
3153 struct attribute
*attr
;
3154 unsigned int length
;
3161 attr
= dwarf_attr (die
, DW_AT_string_length
);
3164 length
= DW_UNSND (attr
);
3168 /* check for the DW_AT_byte_size attribute */
3169 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3172 length
= DW_UNSND (attr
);
3179 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3180 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3181 if (cu_language
== language_fortran
)
3183 /* Need to create a unique string type for bounds
3185 type
= create_string_type (0, range_type
);
3189 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3190 type
= create_string_type (char_type
, range_type
);
3195 /* Handle DIES due to C code like:
3199 int (*funcp)(int a, long l);
3203 ('funcp' generates a DW_TAG_subroutine_type DIE)
3207 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
3208 const struct comp_unit_head
*cu_header
)
3210 struct type
*type
; /* Type that this function returns */
3211 struct type
*ftype
; /* Function that returns above type */
3212 struct attribute
*attr
;
3214 /* Decode the type that this subroutine returns */
3219 type
= die_type (die
, objfile
, cu_header
);
3220 ftype
= lookup_function_type (type
);
3222 /* All functions in C++ have prototypes. */
3223 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3224 if ((attr
&& (DW_UNSND (attr
) != 0))
3225 || cu_language
== language_cplus
)
3226 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3228 if (die
->has_children
)
3230 struct die_info
*child_die
;
3234 /* Count the number of parameters.
3235 FIXME: GDB currently ignores vararg functions, but knows about
3236 vararg member functions. */
3237 child_die
= die
->next
;
3238 while (child_die
&& child_die
->tag
)
3240 if (child_die
->tag
== DW_TAG_formal_parameter
)
3242 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3243 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3244 child_die
= sibling_die (child_die
);
3247 /* Allocate storage for parameters and fill them in. */
3248 TYPE_NFIELDS (ftype
) = nparams
;
3249 TYPE_FIELDS (ftype
) = (struct field
*)
3250 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3252 child_die
= die
->next
;
3253 while (child_die
&& child_die
->tag
)
3255 if (child_die
->tag
== DW_TAG_formal_parameter
)
3257 /* Dwarf2 has no clean way to discern C++ static and non-static
3258 member functions. G++ helps GDB by marking the first
3259 parameter for non-static member functions (which is the
3260 this pointer) as artificial. We pass this information
3261 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3262 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3264 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3266 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3267 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
3271 child_die
= sibling_die (child_die
);
3279 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
3280 const struct comp_unit_head
*cu_header
)
3282 struct attribute
*attr
;
3287 attr
= dwarf_attr (die
, DW_AT_name
);
3288 if (attr
&& DW_STRING (attr
))
3290 name
= DW_STRING (attr
);
3292 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3293 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
3297 /* Find a representation of a given base type and install
3298 it in the TYPE field of the die. */
3301 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
3304 struct attribute
*attr
;
3305 int encoding
= 0, size
= 0;
3307 /* If we've already decoded this die, this is a no-op. */
3313 attr
= dwarf_attr (die
, DW_AT_encoding
);
3316 encoding
= DW_UNSND (attr
);
3318 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3321 size
= DW_UNSND (attr
);
3323 attr
= dwarf_attr (die
, DW_AT_name
);
3324 if (attr
&& DW_STRING (attr
))
3326 enum type_code code
= TYPE_CODE_INT
;
3331 case DW_ATE_address
:
3332 /* Turn DW_ATE_address into a void * pointer. */
3333 code
= TYPE_CODE_PTR
;
3334 type_flags
|= TYPE_FLAG_UNSIGNED
;
3336 case DW_ATE_boolean
:
3337 code
= TYPE_CODE_BOOL
;
3338 type_flags
|= TYPE_FLAG_UNSIGNED
;
3340 case DW_ATE_complex_float
:
3341 code
= TYPE_CODE_COMPLEX
;
3344 code
= TYPE_CODE_FLT
;
3347 case DW_ATE_signed_char
:
3349 case DW_ATE_unsigned
:
3350 case DW_ATE_unsigned_char
:
3351 type_flags
|= TYPE_FLAG_UNSIGNED
;
3354 complain (&dwarf2_unsupported_at_encoding
,
3355 dwarf_type_encoding_name (encoding
));
3358 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3359 if (encoding
== DW_ATE_address
)
3360 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3361 else if (encoding
== DW_ATE_complex_float
)
3364 TYPE_TARGET_TYPE (type
)
3365 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3366 else if (size
== 16)
3367 TYPE_TARGET_TYPE (type
)
3368 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3370 TYPE_TARGET_TYPE (type
)
3371 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3376 type
= dwarf_base_type (encoding
, size
, objfile
);
3381 /* Read a whole compilation unit into a linked list of dies. */
3383 static struct die_info
*
3384 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3385 const struct comp_unit_head
*cu_header
)
3387 struct die_info
*first_die
, *last_die
, *die
;
3391 /* Reset die reference table; we are
3392 building new ones now. */
3393 dwarf2_empty_hash_tables ();
3397 first_die
= last_die
= NULL
;
3400 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3401 if (die
->has_children
)
3412 /* Enter die in reference hash table */
3413 store_in_ref_table (die
->offset
, die
);
3417 first_die
= last_die
= die
;
3421 last_die
->next
= die
;
3425 while (nesting_level
> 0);
3429 /* Free a linked list of dies. */
3432 free_die_list (struct die_info
*dies
)
3434 struct die_info
*die
, *next
;
3447 do_free_die_list_cleanup (void *dies
)
3449 free_die_list (dies
);
3452 static struct cleanup
*
3453 make_cleanup_free_die_list (struct die_info
*dies
)
3455 return make_cleanup (do_free_die_list_cleanup
, dies
);
3459 /* Read the contents of the section at OFFSET and of size SIZE from the
3460 object file specified by OBJFILE into the psymbol_obstack and return it. */
3463 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3466 bfd
*abfd
= objfile
->obfd
;
3472 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3473 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3474 (bfd_bread (buf
, size
, abfd
) != size
))
3477 error ("Dwarf Error: Can't read DWARF data from '%s'",
3478 bfd_get_filename (abfd
));
3483 /* In DWARF version 2, the description of the debugging information is
3484 stored in a separate .debug_abbrev section. Before we read any
3485 dies from a section we read in all abbreviations and install them
3489 dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
)
3492 struct abbrev_info
*cur_abbrev
;
3493 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3494 unsigned int abbrev_form
, hash_number
;
3496 /* Initialize dwarf2 abbrevs */
3497 memset (cu_header
->dwarf2_abbrevs
, 0,
3498 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
3500 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
3501 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3502 abbrev_ptr
+= bytes_read
;
3504 /* loop until we reach an abbrev number of 0 */
3505 while (abbrev_number
)
3507 cur_abbrev
= dwarf_alloc_abbrev ();
3509 /* read in abbrev header */
3510 cur_abbrev
->number
= abbrev_number
;
3511 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3512 abbrev_ptr
+= bytes_read
;
3513 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3516 /* now read in declarations */
3517 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3518 abbrev_ptr
+= bytes_read
;
3519 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3520 abbrev_ptr
+= bytes_read
;
3523 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3525 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3526 xrealloc (cur_abbrev
->attrs
,
3527 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3528 * sizeof (struct attr_abbrev
));
3530 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3531 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3532 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3533 abbrev_ptr
+= bytes_read
;
3534 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3535 abbrev_ptr
+= bytes_read
;
3538 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3539 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
3540 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3542 /* Get next abbreviation.
3543 Under Irix6 the abbreviations for a compilation unit are not
3544 always properly terminated with an abbrev number of 0.
3545 Exit loop if we encounter an abbreviation which we have
3546 already read (which means we are about to read the abbreviations
3547 for the next compile unit) or if the end of the abbreviation
3548 table is reached. */
3549 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3550 >= dwarf_abbrev_size
)
3552 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3553 abbrev_ptr
+= bytes_read
;
3554 if (dwarf2_lookup_abbrev (abbrev_number
, cu_header
) != NULL
)
3559 /* Empty the abbrev table for a new compilation unit. */
3563 dwarf2_empty_abbrev_table (PTR ptr_to_abbrevs_table
)
3566 struct abbrev_info
*abbrev
, *next
;
3567 struct abbrev_info
**abbrevs
;
3569 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
3571 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3574 abbrev
= abbrevs
[i
];
3577 next
= abbrev
->next
;
3578 xfree (abbrev
->attrs
);
3586 /* Lookup an abbrev_info structure in the abbrev hash table. */
3588 static struct abbrev_info
*
3589 dwarf2_lookup_abbrev (unsigned int number
, const struct comp_unit_head
*cu_header
)
3591 unsigned int hash_number
;
3592 struct abbrev_info
*abbrev
;
3594 hash_number
= number
% ABBREV_HASH_SIZE
;
3595 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
3599 if (abbrev
->number
== number
)
3602 abbrev
= abbrev
->next
;
3607 /* Read a minimal amount of information into the minimal die structure. */
3610 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3611 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3613 unsigned int abbrev_number
, bytes_read
, i
;
3614 struct abbrev_info
*abbrev
;
3615 struct attribute attr
;
3616 struct attribute spec_attr
;
3617 int found_spec_attr
= 0;
3618 int has_low_pc_attr
= 0;
3619 int has_high_pc_attr
= 0;
3621 *part_die
= zeroed_partial_die
;
3622 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3623 info_ptr
+= bytes_read
;
3627 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3630 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3632 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3633 part_die
->tag
= abbrev
->tag
;
3634 part_die
->has_children
= abbrev
->has_children
;
3635 part_die
->abbrev
= abbrev_number
;
3637 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3639 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3640 info_ptr
, cu_header
);
3642 /* Store the data if it is of an attribute we want to keep in a
3643 partial symbol table. */
3648 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3649 if (part_die
->name
== NULL
)
3650 part_die
->name
= DW_STRING (&attr
);
3652 case DW_AT_MIPS_linkage_name
:
3653 part_die
->name
= DW_STRING (&attr
);
3656 has_low_pc_attr
= 1;
3657 part_die
->lowpc
= DW_ADDR (&attr
);
3660 has_high_pc_attr
= 1;
3661 part_die
->highpc
= DW_ADDR (&attr
);
3663 case DW_AT_location
:
3664 /* Support the .debug_loc offsets */
3665 if (attr_form_is_block (&attr
))
3667 part_die
->locdesc
= DW_BLOCK (&attr
);
3669 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
3671 complain (&dwarf2_complex_location_expr
);
3675 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
3676 "partial symbol information");
3679 case DW_AT_language
:
3680 part_die
->language
= DW_UNSND (&attr
);
3682 case DW_AT_external
:
3683 part_die
->is_external
= DW_UNSND (&attr
);
3685 case DW_AT_declaration
:
3686 part_die
->is_declaration
= DW_UNSND (&attr
);
3689 part_die
->has_type
= 1;
3691 case DW_AT_abstract_origin
:
3692 case DW_AT_specification
:
3693 found_spec_attr
= 1;
3697 /* Ignore absolute siblings, they might point outside of
3698 the current compile unit. */
3699 if (attr
.form
== DW_FORM_ref_addr
)
3700 complain (&dwarf2_absolute_sibling_complaint
);
3703 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3710 /* If we found a reference attribute and the die has no name, try
3711 to find a name in the referred to die. */
3713 if (found_spec_attr
&& part_die
->name
== NULL
)
3715 struct partial_die_info spec_die
;
3719 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3720 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3723 part_die
->name
= spec_die
.name
;
3725 /* Copy DW_AT_external attribute if it is set. */
3726 if (spec_die
.is_external
)
3727 part_die
->is_external
= spec_die
.is_external
;
3731 /* When using the GNU linker, .gnu.linkonce. sections are used to
3732 eliminate duplicate copies of functions and vtables and such.
3733 The linker will arbitrarily choose one and discard the others.
3734 The AT_*_pc values for such functions refer to local labels in
3735 these sections. If the section from that file was discarded, the
3736 labels are not in the output, so the relocs get a value of 0.
3737 If this is a discarded function, mark the pc bounds as invalid,
3738 so that GDB will ignore it. */
3739 if (has_low_pc_attr
&& has_high_pc_attr
3740 && part_die
->lowpc
< part_die
->highpc
3741 && (part_die
->lowpc
!= 0
3742 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3743 part_die
->has_pc_info
= 1;
3747 /* Read the die from the .debug_info section buffer. And set diep to
3748 point to a newly allocated die with its information. */
3751 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3752 const struct comp_unit_head
*cu_header
)
3754 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3755 struct abbrev_info
*abbrev
;
3756 struct die_info
*die
;
3758 offset
= info_ptr
- dwarf_info_buffer
;
3759 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3760 info_ptr
+= bytes_read
;
3763 die
= dwarf_alloc_die ();
3765 die
->abbrev
= abbrev_number
;
3771 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3774 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3776 die
= dwarf_alloc_die ();
3777 die
->offset
= offset
;
3778 die
->tag
= abbrev
->tag
;
3779 die
->has_children
= abbrev
->has_children
;
3780 die
->abbrev
= abbrev_number
;
3783 die
->num_attrs
= abbrev
->num_attrs
;
3784 die
->attrs
= (struct attribute
*)
3785 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3787 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3789 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3790 abfd
, info_ptr
, cu_header
);
3797 /* Read an attribute value described by an attribute form. */
3800 read_attribute_value (struct attribute
*attr
, unsigned form
,
3801 bfd
*abfd
, char *info_ptr
,
3802 const struct comp_unit_head
*cu_header
)
3804 unsigned int bytes_read
;
3805 struct dwarf_block
*blk
;
3811 case DW_FORM_ref_addr
:
3812 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3813 info_ptr
+= bytes_read
;
3815 case DW_FORM_block2
:
3816 blk
= dwarf_alloc_block ();
3817 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3819 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3820 info_ptr
+= blk
->size
;
3821 DW_BLOCK (attr
) = blk
;
3823 case DW_FORM_block4
:
3824 blk
= dwarf_alloc_block ();
3825 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3827 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3828 info_ptr
+= blk
->size
;
3829 DW_BLOCK (attr
) = blk
;
3832 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3836 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3840 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3843 case DW_FORM_string
:
3844 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3845 info_ptr
+= bytes_read
;
3848 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
3850 info_ptr
+= bytes_read
;
3853 blk
= dwarf_alloc_block ();
3854 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3855 info_ptr
+= bytes_read
;
3856 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3857 info_ptr
+= blk
->size
;
3858 DW_BLOCK (attr
) = blk
;
3860 case DW_FORM_block1
:
3861 blk
= dwarf_alloc_block ();
3862 blk
->size
= read_1_byte (abfd
, info_ptr
);
3864 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3865 info_ptr
+= blk
->size
;
3866 DW_BLOCK (attr
) = blk
;
3869 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3873 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3877 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3878 info_ptr
+= bytes_read
;
3881 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3882 info_ptr
+= bytes_read
;
3885 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3889 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3893 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3897 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3900 case DW_FORM_ref_udata
:
3901 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3902 info_ptr
+= bytes_read
;
3904 case DW_FORM_indirect
:
3905 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3906 info_ptr
+= bytes_read
;
3907 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
3910 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3911 dwarf_form_name (form
));
3916 /* Read an attribute described by an abbreviated attribute. */
3919 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
3920 bfd
*abfd
, char *info_ptr
,
3921 const struct comp_unit_head
*cu_header
)
3923 attr
->name
= abbrev
->name
;
3924 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
3927 /* read dwarf information from a buffer */
3930 read_1_byte (bfd
*abfd
, char *buf
)
3932 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3936 read_1_signed_byte (bfd
*abfd
, char *buf
)
3938 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3942 read_2_bytes (bfd
*abfd
, char *buf
)
3944 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3948 read_2_signed_bytes (bfd
*abfd
, char *buf
)
3950 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3954 read_4_bytes (bfd
*abfd
, char *buf
)
3956 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3960 read_4_signed_bytes (bfd
*abfd
, char *buf
)
3962 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3965 static unsigned long
3966 read_8_bytes (bfd
*abfd
, char *buf
)
3968 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3972 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3975 CORE_ADDR retval
= 0;
3977 if (cu_header
->signed_addr_p
)
3979 switch (cu_header
->addr_size
)
3982 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3985 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3988 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
3991 internal_error (__FILE__
, __LINE__
,
3992 "read_address: bad switch, signed");
3997 switch (cu_header
->addr_size
)
4000 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4003 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4006 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4009 internal_error (__FILE__
, __LINE__
,
4010 "read_address: bad switch, unsigned");
4014 *bytes_read
= cu_header
->addr_size
;
4018 /* Read the initial length from a section. The (draft) DWARF 3
4019 specification allows the initial length to take up either 4 bytes
4020 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4021 bytes describe the length and all offsets will be 8 bytes in length
4024 An older, non-standard 64-bit format is also handled by this
4025 function. The older format in question stores the initial length
4026 as an 8-byte quantity without an escape value. Lengths greater
4027 than 2^32 aren't very common which means that the initial 4 bytes
4028 is almost always zero. Since a length value of zero doesn't make
4029 sense for the 32-bit format, this initial zero can be considered to
4030 be an escape value which indicates the presence of the older 64-bit
4031 format. As written, the code can't detect (old format) lengths
4032 greater than 4GB. If it becomes necessary to handle lengths somewhat
4033 larger than 4GB, we could allow other small values (such as the
4034 non-sensical values of 1, 2, and 3) to also be used as escape values
4035 indicating the presence of the old format.
4037 The value returned via bytes_read should be used to increment
4038 the relevant pointer after calling read_initial_length().
4040 As a side effect, this function sets the fields initial_length_size
4041 and offset_size in cu_header to the values appropriate for the
4042 length field. (The format of the initial length field determines
4043 the width of file offsets to be fetched later with fetch_offset().)
4045 [ Note: read_initial_length() and read_offset() are based on the
4046 document entitled "DWARF Debugging Information Format", revision
4047 3, draft 8, dated November 19, 2001. This document was obtained
4050 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4052 This document is only a draft and is subject to change. (So beware.)
4054 Details regarding the older, non-standard 64-bit format were
4055 determined empirically by examining 64-bit ELF files produced
4056 by the SGI toolchain on an IRIX 6.5 machine.
4058 - Kevin, July 16, 2002
4062 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4067 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4069 if (retval
== 0xffffffff)
4071 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4073 if (cu_header
!= NULL
)
4075 cu_header
->initial_length_size
= 12;
4076 cu_header
->offset_size
= 8;
4079 else if (retval
== 0)
4081 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4083 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4085 if (cu_header
!= NULL
)
4087 cu_header
->initial_length_size
= 8;
4088 cu_header
->offset_size
= 8;
4094 if (cu_header
!= NULL
)
4096 cu_header
->initial_length_size
= 4;
4097 cu_header
->offset_size
= 4;
4104 /* Read an offset from the data stream. The size of the offset is
4105 given by cu_header->offset_size. */
4108 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4113 switch (cu_header
->offset_size
)
4116 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4120 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4124 internal_error (__FILE__
, __LINE__
,
4125 "read_offset: bad switch");
4132 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4134 /* If the size of a host char is 8 bits, we can return a pointer
4135 to the buffer, otherwise we have to copy the data to a buffer
4136 allocated on the temporary obstack. */
4137 gdb_assert (HOST_CHAR_BIT
== 8);
4142 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4144 /* If the size of a host char is 8 bits, we can return a pointer
4145 to the string, otherwise we have to copy the string to a buffer
4146 allocated on the temporary obstack. */
4147 gdb_assert (HOST_CHAR_BIT
== 8);
4150 *bytes_read_ptr
= 1;
4153 *bytes_read_ptr
= strlen (buf
) + 1;
4158 read_indirect_string (bfd
*abfd
, char *buf
,
4159 const struct comp_unit_head
*cu_header
,
4160 unsigned int *bytes_read_ptr
)
4162 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4163 (int *) bytes_read_ptr
);
4165 if (dwarf_str_buffer
== NULL
)
4167 error ("DW_FORM_strp used without .debug_str section");
4170 if (str_offset
>= dwarf_str_size
)
4172 error ("DW_FORM_strp pointing outside of .debug_str section");
4175 gdb_assert (HOST_CHAR_BIT
== 8);
4176 if (dwarf_str_buffer
[str_offset
] == '\0')
4178 return dwarf_str_buffer
+ str_offset
;
4181 static unsigned long
4182 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4184 unsigned long result
;
4185 unsigned int num_read
;
4195 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4198 result
|= ((unsigned long)(byte
& 127) << shift
);
4199 if ((byte
& 128) == 0)
4205 *bytes_read_ptr
= num_read
;
4210 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4213 int i
, shift
, size
, num_read
;
4223 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4226 result
|= ((long)(byte
& 127) << shift
);
4228 if ((byte
& 128) == 0)
4233 if ((shift
< size
) && (byte
& 0x40))
4235 result
|= -(1 << shift
);
4237 *bytes_read_ptr
= num_read
;
4242 set_cu_language (unsigned int lang
)
4248 cu_language
= language_c
;
4250 case DW_LANG_C_plus_plus
:
4251 cu_language
= language_cplus
;
4253 case DW_LANG_Fortran77
:
4254 case DW_LANG_Fortran90
:
4255 case DW_LANG_Fortran95
:
4256 cu_language
= language_fortran
;
4258 case DW_LANG_Mips_Assembler
:
4259 cu_language
= language_asm
;
4262 cu_language
= language_java
;
4266 case DW_LANG_Cobol74
:
4267 case DW_LANG_Cobol85
:
4268 case DW_LANG_Pascal83
:
4269 case DW_LANG_Modula2
:
4271 cu_language
= language_unknown
;
4274 cu_language_defn
= language_def (cu_language
);
4277 /* Return the named attribute or NULL if not there. */
4279 static struct attribute
*
4280 dwarf_attr (struct die_info
*die
, unsigned int name
)
4283 struct attribute
*spec
= NULL
;
4285 for (i
= 0; i
< die
->num_attrs
; ++i
)
4287 if (die
->attrs
[i
].name
== name
)
4289 return &die
->attrs
[i
];
4291 if (die
->attrs
[i
].name
== DW_AT_specification
4292 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4293 spec
= &die
->attrs
[i
];
4297 struct die_info
*ref_die
=
4298 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4301 return dwarf_attr (ref_die
, name
);
4308 die_is_declaration (struct die_info
*die
)
4310 return (dwarf_attr (die
, DW_AT_declaration
)
4311 && ! dwarf_attr (die
, DW_AT_specification
));
4315 /* Free the line_header structure *LH, and any arrays and strings it
4318 free_line_header (struct line_header
*lh
)
4320 if (lh
->standard_opcode_lengths
)
4321 xfree (lh
->standard_opcode_lengths
);
4323 /* Remember that all the lh->file_names[i].name pointers are
4324 pointers into debug_line_buffer, and don't need to be freed. */
4326 xfree (lh
->file_names
);
4328 /* Similarly for the include directory names. */
4329 if (lh
->include_dirs
)
4330 xfree (lh
->include_dirs
);
4336 /* Add an entry to LH's include directory table. */
4338 add_include_dir (struct line_header
*lh
, char *include_dir
)
4340 /* Grow the array if necessary. */
4341 if (lh
->include_dirs_size
== 0)
4343 lh
->include_dirs_size
= 1; /* for testing */
4344 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4345 * sizeof (*lh
->include_dirs
));
4347 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4349 lh
->include_dirs_size
*= 2;
4350 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4351 (lh
->include_dirs_size
4352 * sizeof (*lh
->include_dirs
)));
4355 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4359 /* Add an entry to LH's file name table. */
4361 add_file_name (struct line_header
*lh
,
4363 unsigned int dir_index
,
4364 unsigned int mod_time
,
4365 unsigned int length
)
4367 struct file_entry
*fe
;
4369 /* Grow the array if necessary. */
4370 if (lh
->file_names_size
== 0)
4372 lh
->file_names_size
= 1; /* for testing */
4373 lh
->file_names
= xmalloc (lh
->file_names_size
4374 * sizeof (*lh
->file_names
));
4376 else if (lh
->num_file_names
>= lh
->file_names_size
)
4378 lh
->file_names_size
*= 2;
4379 lh
->file_names
= xrealloc (lh
->file_names
,
4380 (lh
->file_names_size
4381 * sizeof (*lh
->file_names
)));
4384 fe
= &lh
->file_names
[lh
->num_file_names
++];
4386 fe
->dir_index
= dir_index
;
4387 fe
->mod_time
= mod_time
;
4388 fe
->length
= length
;
4392 /* Read the statement program header starting at OFFSET in
4393 dwarf_line_buffer, according to the endianness of ABFD. Return a
4394 pointer to a struct line_header, allocated using xmalloc.
4396 NOTE: the strings in the include directory and file name tables of
4397 the returned object point into debug_line_buffer, and must not be
4399 static struct line_header
*
4400 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4401 const struct comp_unit_head
*cu_header
)
4403 struct cleanup
*back_to
;
4404 struct line_header
*lh
;
4408 char *cur_dir
, *cur_file
;
4410 if (dwarf_line_buffer
== NULL
)
4412 complain (&dwarf2_missing_line_number_section
);
4416 /* Make sure that at least there's room for the total_length field. That
4417 could be 12 bytes long, but we're just going to fudge that. */
4418 if (offset
+ 4 >= dwarf_line_size
)
4420 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4424 lh
= xmalloc (sizeof (*lh
));
4425 memset (lh
, 0, sizeof (*lh
));
4426 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4429 line_ptr
= dwarf_line_buffer
+ offset
;
4431 /* read in the header */
4432 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4433 line_ptr
+= bytes_read
;
4434 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4436 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4439 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4440 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4442 lh
->header_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
4443 line_ptr
+= bytes_read
;
4444 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4446 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4448 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4450 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4452 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4454 lh
->standard_opcode_lengths
4455 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4457 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4458 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4460 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4464 /* Read directory table */
4465 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4467 line_ptr
+= bytes_read
;
4468 add_include_dir (lh
, cur_dir
);
4470 line_ptr
+= bytes_read
;
4472 /* Read file name table */
4473 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4475 unsigned int dir_index
, mod_time
, length
;
4477 line_ptr
+= bytes_read
;
4478 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4479 line_ptr
+= bytes_read
;
4480 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4481 line_ptr
+= bytes_read
;
4482 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4483 line_ptr
+= bytes_read
;
4485 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4487 line_ptr
+= bytes_read
;
4488 lh
->statement_program_start
= line_ptr
;
4490 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4491 complain (&dwarf2_line_header_too_long
);
4493 discard_cleanups (back_to
);
4497 /* This function exists to work around a bug in certain compilers
4498 (particularly GCC 2.95), in which the first line number marker of a
4499 function does not show up until after the prologue, right before
4500 the second line number marker. This function shifts ADDRESS down
4501 to the beginning of the function if necessary, and is called on
4502 addresses passed to record_line. */
4505 check_cu_functions (CORE_ADDR address
)
4507 struct function_range
*fn
;
4509 /* Find the function_range containing address. */
4514 cu_cached_fn
= cu_first_fn
;
4518 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4524 while (fn
&& fn
!= cu_cached_fn
)
4525 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4535 if (address
!= fn
->lowpc
)
4536 complain (&dwarf2_misplaced_line_number
,
4537 (unsigned long) address
, fn
->name
);
4542 /* Decode the line number information for the compilation unit whose
4543 line number info is at OFFSET in the .debug_line section.
4544 The compilation directory of the file is passed in COMP_DIR. */
4547 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
4548 const struct comp_unit_head
*cu_header
)
4552 unsigned int i
, bytes_read
;
4554 unsigned char op_code
, extended_op
, adj_opcode
;
4556 line_ptr
= lh
->statement_program_start
;
4557 line_end
= lh
->statement_program_end
;
4559 /* Read the statement sequences until there's nothing left. */
4560 while (line_ptr
< line_end
)
4562 /* state machine registers */
4563 CORE_ADDR address
= 0;
4564 unsigned int file
= 1;
4565 unsigned int line
= 1;
4566 unsigned int column
= 0;
4567 int is_stmt
= lh
->default_is_stmt
;
4568 int basic_block
= 0;
4569 int end_sequence
= 0;
4571 /* Start a subfile for the current file of the state machine. */
4572 if (lh
->num_file_names
>= file
)
4574 /* lh->include_dirs and lh->file_names are 0-based, but the
4575 directory and file name numbers in the statement program
4577 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
4580 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4583 dwarf2_start_subfile (fe
->name
, dir
);
4586 /* Decode the table. */
4587 while (!end_sequence
)
4589 op_code
= read_1_byte (abfd
, line_ptr
);
4592 if (op_code
>= lh
->opcode_base
)
4593 { /* Special operand. */
4594 adj_opcode
= op_code
- lh
->opcode_base
;
4595 address
+= (adj_opcode
/ lh
->line_range
)
4596 * lh
->minimum_instruction_length
;
4597 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
4598 /* append row to matrix using current values */
4599 address
= check_cu_functions (address
);
4600 record_line (current_subfile
, line
, address
);
4603 else switch (op_code
)
4605 case DW_LNS_extended_op
:
4606 line_ptr
+= 1; /* ignore length */
4607 extended_op
= read_1_byte (abfd
, line_ptr
);
4609 switch (extended_op
)
4611 case DW_LNE_end_sequence
:
4613 record_line (current_subfile
, 0, address
);
4615 case DW_LNE_set_address
:
4616 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4617 line_ptr
+= bytes_read
;
4618 address
+= baseaddr
;
4620 case DW_LNE_define_file
:
4623 unsigned int dir_index
, mod_time
, length
;
4625 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
4626 line_ptr
+= bytes_read
;
4628 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4629 line_ptr
+= bytes_read
;
4631 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4632 line_ptr
+= bytes_read
;
4634 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4635 line_ptr
+= bytes_read
;
4636 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4640 complain (&dwarf2_mangled_line_number_section
);
4645 address
= check_cu_functions (address
);
4646 record_line (current_subfile
, line
, address
);
4649 case DW_LNS_advance_pc
:
4650 address
+= lh
->minimum_instruction_length
4651 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4652 line_ptr
+= bytes_read
;
4654 case DW_LNS_advance_line
:
4655 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4656 line_ptr
+= bytes_read
;
4658 case DW_LNS_set_file
:
4660 /* lh->include_dirs and lh->file_names are 0-based,
4661 but the directory and file name numbers in the
4662 statement program are 1-based. */
4663 struct file_entry
*fe
;
4665 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4666 line_ptr
+= bytes_read
;
4667 fe
= &lh
->file_names
[file
- 1];
4669 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4672 dwarf2_start_subfile (fe
->name
, dir
);
4675 case DW_LNS_set_column
:
4676 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4677 line_ptr
+= bytes_read
;
4679 case DW_LNS_negate_stmt
:
4680 is_stmt
= (!is_stmt
);
4682 case DW_LNS_set_basic_block
:
4685 /* Add to the address register of the state machine the
4686 address increment value corresponding to special opcode
4687 255. Ie, this value is scaled by the minimum instruction
4688 length since special opcode 255 would have scaled the
4690 case DW_LNS_const_add_pc
:
4691 address
+= (lh
->minimum_instruction_length
4692 * ((255 - lh
->opcode_base
) / lh
->line_range
));
4694 case DW_LNS_fixed_advance_pc
:
4695 address
+= read_2_bytes (abfd
, line_ptr
);
4699 { /* Unknown standard opcode, ignore it. */
4701 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
4703 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4704 line_ptr
+= bytes_read
;
4712 /* Start a subfile for DWARF. FILENAME is the name of the file and
4713 DIRNAME the name of the source directory which contains FILENAME
4714 or NULL if not known.
4715 This routine tries to keep line numbers from identical absolute and
4716 relative file names in a common subfile.
4718 Using the `list' example from the GDB testsuite, which resides in
4719 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4720 of /srcdir/list0.c yields the following debugging information for list0.c:
4722 DW_AT_name: /srcdir/list0.c
4723 DW_AT_comp_dir: /compdir
4724 files.files[0].name: list0.h
4725 files.files[0].dir: /srcdir
4726 files.files[1].name: list0.c
4727 files.files[1].dir: /srcdir
4729 The line number information for list0.c has to end up in a single
4730 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4733 dwarf2_start_subfile (char *filename
, char *dirname
)
4735 /* If the filename isn't absolute, try to match an existing subfile
4736 with the full pathname. */
4738 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4740 struct subfile
*subfile
;
4741 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4743 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4745 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4747 current_subfile
= subfile
;
4754 start_subfile (filename
, dirname
);
4757 /* Given a pointer to a DWARF information entry, figure out if we need
4758 to make a symbol table entry for it, and if so, create a new entry
4759 and return a pointer to it.
4760 If TYPE is NULL, determine symbol type from the die, otherwise
4761 used the passed type. */
4763 static struct symbol
*
4764 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4765 const struct comp_unit_head
*cu_header
)
4767 struct symbol
*sym
= NULL
;
4769 struct attribute
*attr
= NULL
;
4770 struct attribute
*attr2
= NULL
;
4773 name
= dwarf2_linkage_name (die
);
4776 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4777 sizeof (struct symbol
));
4778 OBJSTAT (objfile
, n_syms
++);
4779 memset (sym
, 0, sizeof (struct symbol
));
4780 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4781 &objfile
->symbol_obstack
);
4783 /* Default assumptions.
4784 Use the passed type or decode it from the die. */
4785 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4786 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4788 SYMBOL_TYPE (sym
) = type
;
4790 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4791 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4794 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4797 /* If this symbol is from a C++ compilation, then attempt to
4798 cache the demangled form for future reference. This is a
4799 typical time versus space tradeoff, that was decided in favor
4800 of time because it sped up C++ symbol lookups by a factor of
4803 SYMBOL_LANGUAGE (sym
) = cu_language
;
4804 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4808 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4811 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4813 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4815 case DW_TAG_subprogram
:
4816 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4818 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4819 attr2
= dwarf_attr (die
, DW_AT_external
);
4820 if (attr2
&& (DW_UNSND (attr2
) != 0))
4822 add_symbol_to_list (sym
, &global_symbols
);
4826 add_symbol_to_list (sym
, list_in_scope
);
4829 case DW_TAG_variable
:
4830 /* Compilation with minimal debug info may result in variables
4831 with missing type entries. Change the misleading `void' type
4832 to something sensible. */
4833 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4834 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4835 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4836 "<variable, no debug info>",
4838 attr
= dwarf_attr (die
, DW_AT_const_value
);
4841 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4842 attr2
= dwarf_attr (die
, DW_AT_external
);
4843 if (attr2
&& (DW_UNSND (attr2
) != 0))
4844 add_symbol_to_list (sym
, &global_symbols
);
4846 add_symbol_to_list (sym
, list_in_scope
);
4849 attr
= dwarf_attr (die
, DW_AT_location
);
4852 attr2
= dwarf_attr (die
, DW_AT_external
);
4853 if (attr2
&& (DW_UNSND (attr2
) != 0))
4855 /* Support the .debug_loc offsets */
4856 if (attr_form_is_block (attr
))
4858 SYMBOL_VALUE_ADDRESS (sym
) =
4859 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4861 else if (attr
->form
== DW_FORM_data4
4862 || attr
->form
== DW_FORM_data8
)
4864 complain (&dwarf2_complex_location_expr
);
4868 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4869 "external variable");
4871 add_symbol_to_list (sym
, &global_symbols
);
4872 if (is_thread_local
)
4874 /* SYMBOL_VALUE_ADDRESS contains at this point the
4875 offset of the variable within the thread local
4877 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
4878 SYMBOL_OBJFILE (sym
) = objfile
;
4881 /* In shared libraries the address of the variable
4882 in the location descriptor might still be relocatable,
4883 so its value could be zero.
4884 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4885 value is zero, the address of the variable will then
4886 be determined from the minimal symbol table whenever
4887 the variable is referenced. */
4888 else if (SYMBOL_VALUE_ADDRESS (sym
))
4890 fixup_symbol_section (sym
, objfile
);
4891 SYMBOL_VALUE_ADDRESS (sym
) +=
4892 ANOFFSET (objfile
->section_offsets
,
4893 SYMBOL_SECTION (sym
));
4894 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4897 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4901 /* Support the .debug_loc offsets */
4902 if (attr_form_is_block (attr
))
4904 SYMBOL_VALUE (sym
) = addr
=
4905 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4907 else if (attr
->form
== DW_FORM_data4
4908 || attr
->form
== DW_FORM_data8
)
4910 complain (&dwarf2_complex_location_expr
);
4914 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4915 "external variable");
4918 add_symbol_to_list (sym
, list_in_scope
);
4921 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4925 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4926 SYMBOL_VALUE (sym
) =
4927 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4931 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4932 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4936 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4938 else if (is_thread_local
)
4940 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
4941 SYMBOL_OBJFILE (sym
) = objfile
;
4945 fixup_symbol_section (sym
, objfile
);
4946 SYMBOL_VALUE_ADDRESS (sym
) =
4947 addr
+ ANOFFSET (objfile
->section_offsets
,
4948 SYMBOL_SECTION (sym
));
4949 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4955 /* We do not know the address of this symbol.
4956 If it is an external symbol and we have type information
4957 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4958 The address of the variable will then be determined from
4959 the minimal symbol table whenever the variable is
4961 attr2
= dwarf_attr (die
, DW_AT_external
);
4962 if (attr2
&& (DW_UNSND (attr2
) != 0)
4963 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4965 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4966 add_symbol_to_list (sym
, &global_symbols
);
4970 case DW_TAG_formal_parameter
:
4971 attr
= dwarf_attr (die
, DW_AT_location
);
4974 SYMBOL_VALUE (sym
) =
4975 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4978 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4979 SYMBOL_VALUE (sym
) =
4980 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4986 if (basereg
!= frame_base_reg
)
4987 complain (&dwarf2_complex_location_expr
);
4988 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
4992 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4993 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4998 SYMBOL_CLASS (sym
) = LOC_ARG
;
5001 attr
= dwarf_attr (die
, DW_AT_const_value
);
5004 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5006 add_symbol_to_list (sym
, list_in_scope
);
5008 case DW_TAG_unspecified_parameters
:
5009 /* From varargs functions; gdb doesn't seem to have any
5010 interest in this information, so just ignore it for now.
5013 case DW_TAG_class_type
:
5014 case DW_TAG_structure_type
:
5015 case DW_TAG_union_type
:
5016 case DW_TAG_enumeration_type
:
5017 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5018 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
5019 add_symbol_to_list (sym
, list_in_scope
);
5021 /* The semantics of C++ state that "struct foo { ... }" also
5022 defines a typedef for "foo". Synthesize a typedef symbol so
5023 that "ptype foo" works as expected. */
5024 if (cu_language
== language_cplus
)
5026 struct symbol
*typedef_sym
= (struct symbol
*)
5027 obstack_alloc (&objfile
->symbol_obstack
,
5028 sizeof (struct symbol
));
5029 *typedef_sym
= *sym
;
5030 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
5031 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5032 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5033 obsavestring (SYMBOL_NAME (sym
),
5034 strlen (SYMBOL_NAME (sym
)),
5035 &objfile
->type_obstack
);
5036 add_symbol_to_list (typedef_sym
, list_in_scope
);
5039 case DW_TAG_typedef
:
5040 case DW_TAG_base_type
:
5041 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5042 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
5043 add_symbol_to_list (sym
, list_in_scope
);
5045 case DW_TAG_enumerator
:
5046 attr
= dwarf_attr (die
, DW_AT_const_value
);
5049 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5051 add_symbol_to_list (sym
, list_in_scope
);
5054 /* Not a tag we recognize. Hopefully we aren't processing
5055 trash data, but since we must specifically ignore things
5056 we don't recognize, there is nothing else we should do at
5058 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
5065 /* Copy constant value from an attribute to a symbol. */
5068 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5069 struct objfile
*objfile
,
5070 const struct comp_unit_head
*cu_header
)
5072 struct dwarf_block
*blk
;
5077 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5078 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
5079 cu_header
->addr_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
5080 SYMBOL_VALUE_BYTES (sym
) = (char *)
5081 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5082 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5084 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5086 case DW_FORM_block1
:
5087 case DW_FORM_block2
:
5088 case DW_FORM_block4
:
5090 blk
= DW_BLOCK (attr
);
5091 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5092 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
5093 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
5094 SYMBOL_VALUE_BYTES (sym
) = (char *)
5095 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5096 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5097 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5100 /* The DW_AT_const_value attributes are supposed to carry the
5101 symbol's value "represented as it would be on the target
5102 architecture." By the time we get here, it's already been
5103 converted to host endianness, so we just need to sign- or
5104 zero-extend it as appropriate. */
5106 dwarf2_const_value_data (attr
, sym
, 8);
5109 dwarf2_const_value_data (attr
, sym
, 16);
5112 dwarf2_const_value_data (attr
, sym
, 32);
5115 dwarf2_const_value_data (attr
, sym
, 64);
5119 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5120 SYMBOL_CLASS (sym
) = LOC_CONST
;
5124 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5125 SYMBOL_CLASS (sym
) = LOC_CONST
;
5129 complain (&dwarf2_unsupported_const_value_attr
,
5130 dwarf_form_name (attr
->form
));
5131 SYMBOL_VALUE (sym
) = 0;
5132 SYMBOL_CLASS (sym
) = LOC_CONST
;
5138 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5139 or zero-extend it as appropriate for the symbol's type. */
5141 dwarf2_const_value_data (struct attribute
*attr
,
5145 LONGEST l
= DW_UNSND (attr
);
5147 if (bits
< sizeof (l
) * 8)
5149 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5150 l
&= ((LONGEST
) 1 << bits
) - 1;
5152 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5155 SYMBOL_VALUE (sym
) = l
;
5156 SYMBOL_CLASS (sym
) = LOC_CONST
;
5160 /* Return the type of the die in question using its DW_AT_type attribute. */
5162 static struct type
*
5163 die_type (struct die_info
*die
, struct objfile
*objfile
,
5164 const struct comp_unit_head
*cu_header
)
5167 struct attribute
*type_attr
;
5168 struct die_info
*type_die
;
5171 type_attr
= dwarf_attr (die
, DW_AT_type
);
5174 /* A missing DW_AT_type represents a void type. */
5175 return dwarf2_fundamental_type (objfile
, FT_VOID
);
5179 ref
= dwarf2_get_ref_die_offset (type_attr
);
5180 type_die
= follow_die_ref (ref
);
5183 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5187 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5190 dump_die (type_die
);
5191 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
5196 /* Return the containing type of the die in question using its
5197 DW_AT_containing_type attribute. */
5199 static struct type
*
5200 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
5201 const struct comp_unit_head
*cu_header
)
5203 struct type
*type
= NULL
;
5204 struct attribute
*type_attr
;
5205 struct die_info
*type_die
= NULL
;
5208 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5211 ref
= dwarf2_get_ref_die_offset (type_attr
);
5212 type_die
= follow_die_ref (ref
);
5215 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5218 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5223 dump_die (type_die
);
5224 error ("Dwarf Error: Problem turning containing type into gdb type.");
5230 static struct type
*
5231 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
5233 struct die_info
*die
;
5236 die
= follow_die_ref (offset
);
5239 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5242 type
= tag_type_to_type (die
, objfile
);
5247 static struct type
*
5248 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
5249 const struct comp_unit_head
*cu_header
)
5257 read_type_die (die
, objfile
, cu_header
);
5261 error ("Dwarf Error: Cannot find type of die.");
5268 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
5269 const struct comp_unit_head
*cu_header
)
5273 case DW_TAG_class_type
:
5274 case DW_TAG_structure_type
:
5275 case DW_TAG_union_type
:
5276 read_structure_scope (die
, objfile
, cu_header
);
5278 case DW_TAG_enumeration_type
:
5279 read_enumeration (die
, objfile
, cu_header
);
5281 case DW_TAG_subprogram
:
5282 case DW_TAG_subroutine_type
:
5283 read_subroutine_type (die
, objfile
, cu_header
);
5285 case DW_TAG_array_type
:
5286 read_array_type (die
, objfile
, cu_header
);
5288 case DW_TAG_pointer_type
:
5289 read_tag_pointer_type (die
, objfile
, cu_header
);
5291 case DW_TAG_ptr_to_member_type
:
5292 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
5294 case DW_TAG_reference_type
:
5295 read_tag_reference_type (die
, objfile
, cu_header
);
5297 case DW_TAG_const_type
:
5298 read_tag_const_type (die
, objfile
, cu_header
);
5300 case DW_TAG_volatile_type
:
5301 read_tag_volatile_type (die
, objfile
, cu_header
);
5303 case DW_TAG_string_type
:
5304 read_tag_string_type (die
, objfile
);
5306 case DW_TAG_typedef
:
5307 read_typedef (die
, objfile
, cu_header
);
5309 case DW_TAG_base_type
:
5310 read_base_type (die
, objfile
);
5313 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
5318 static struct type
*
5319 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
5321 /* FIXME - this should not produce a new (struct type *)
5322 every time. It should cache base types. */
5326 case DW_ATE_address
:
5327 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5329 case DW_ATE_boolean
:
5330 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5332 case DW_ATE_complex_float
:
5335 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5339 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5345 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5349 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5356 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5359 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5363 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5367 case DW_ATE_signed_char
:
5368 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5370 case DW_ATE_unsigned
:
5374 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5377 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5381 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5385 case DW_ATE_unsigned_char
:
5386 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5389 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5396 copy_die (struct die_info
*old_die
)
5398 struct die_info
*new_die
;
5401 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5402 memset (new_die
, 0, sizeof (struct die_info
));
5404 new_die
->tag
= old_die
->tag
;
5405 new_die
->has_children
= old_die
->has_children
;
5406 new_die
->abbrev
= old_die
->abbrev
;
5407 new_die
->offset
= old_die
->offset
;
5408 new_die
->type
= NULL
;
5410 num_attrs
= old_die
->num_attrs
;
5411 new_die
->num_attrs
= num_attrs
;
5412 new_die
->attrs
= (struct attribute
*)
5413 xmalloc (num_attrs
* sizeof (struct attribute
));
5415 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5417 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5418 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5419 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5422 new_die
->next
= NULL
;
5427 /* Return sibling of die, NULL if no sibling. */
5429 static struct die_info
*
5430 sibling_die (struct die_info
*die
)
5432 int nesting_level
= 0;
5434 if (!die
->has_children
)
5436 if (die
->next
&& (die
->next
->tag
== 0))
5449 if (die
->has_children
)
5459 while (nesting_level
);
5460 if (die
&& (die
->tag
== 0))
5471 /* Get linkage name of a die, return NULL if not found. */
5474 dwarf2_linkage_name (struct die_info
*die
)
5476 struct attribute
*attr
;
5478 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5479 if (attr
&& DW_STRING (attr
))
5480 return DW_STRING (attr
);
5481 attr
= dwarf_attr (die
, DW_AT_name
);
5482 if (attr
&& DW_STRING (attr
))
5483 return DW_STRING (attr
);
5487 /* Convert a DIE tag into its string name. */
5490 dwarf_tag_name (register unsigned tag
)
5494 case DW_TAG_padding
:
5495 return "DW_TAG_padding";
5496 case DW_TAG_array_type
:
5497 return "DW_TAG_array_type";
5498 case DW_TAG_class_type
:
5499 return "DW_TAG_class_type";
5500 case DW_TAG_entry_point
:
5501 return "DW_TAG_entry_point";
5502 case DW_TAG_enumeration_type
:
5503 return "DW_TAG_enumeration_type";
5504 case DW_TAG_formal_parameter
:
5505 return "DW_TAG_formal_parameter";
5506 case DW_TAG_imported_declaration
:
5507 return "DW_TAG_imported_declaration";
5509 return "DW_TAG_label";
5510 case DW_TAG_lexical_block
:
5511 return "DW_TAG_lexical_block";
5513 return "DW_TAG_member";
5514 case DW_TAG_pointer_type
:
5515 return "DW_TAG_pointer_type";
5516 case DW_TAG_reference_type
:
5517 return "DW_TAG_reference_type";
5518 case DW_TAG_compile_unit
:
5519 return "DW_TAG_compile_unit";
5520 case DW_TAG_string_type
:
5521 return "DW_TAG_string_type";
5522 case DW_TAG_structure_type
:
5523 return "DW_TAG_structure_type";
5524 case DW_TAG_subroutine_type
:
5525 return "DW_TAG_subroutine_type";
5526 case DW_TAG_typedef
:
5527 return "DW_TAG_typedef";
5528 case DW_TAG_union_type
:
5529 return "DW_TAG_union_type";
5530 case DW_TAG_unspecified_parameters
:
5531 return "DW_TAG_unspecified_parameters";
5532 case DW_TAG_variant
:
5533 return "DW_TAG_variant";
5534 case DW_TAG_common_block
:
5535 return "DW_TAG_common_block";
5536 case DW_TAG_common_inclusion
:
5537 return "DW_TAG_common_inclusion";
5538 case DW_TAG_inheritance
:
5539 return "DW_TAG_inheritance";
5540 case DW_TAG_inlined_subroutine
:
5541 return "DW_TAG_inlined_subroutine";
5543 return "DW_TAG_module";
5544 case DW_TAG_ptr_to_member_type
:
5545 return "DW_TAG_ptr_to_member_type";
5546 case DW_TAG_set_type
:
5547 return "DW_TAG_set_type";
5548 case DW_TAG_subrange_type
:
5549 return "DW_TAG_subrange_type";
5550 case DW_TAG_with_stmt
:
5551 return "DW_TAG_with_stmt";
5552 case DW_TAG_access_declaration
:
5553 return "DW_TAG_access_declaration";
5554 case DW_TAG_base_type
:
5555 return "DW_TAG_base_type";
5556 case DW_TAG_catch_block
:
5557 return "DW_TAG_catch_block";
5558 case DW_TAG_const_type
:
5559 return "DW_TAG_const_type";
5560 case DW_TAG_constant
:
5561 return "DW_TAG_constant";
5562 case DW_TAG_enumerator
:
5563 return "DW_TAG_enumerator";
5564 case DW_TAG_file_type
:
5565 return "DW_TAG_file_type";
5567 return "DW_TAG_friend";
5568 case DW_TAG_namelist
:
5569 return "DW_TAG_namelist";
5570 case DW_TAG_namelist_item
:
5571 return "DW_TAG_namelist_item";
5572 case DW_TAG_packed_type
:
5573 return "DW_TAG_packed_type";
5574 case DW_TAG_subprogram
:
5575 return "DW_TAG_subprogram";
5576 case DW_TAG_template_type_param
:
5577 return "DW_TAG_template_type_param";
5578 case DW_TAG_template_value_param
:
5579 return "DW_TAG_template_value_param";
5580 case DW_TAG_thrown_type
:
5581 return "DW_TAG_thrown_type";
5582 case DW_TAG_try_block
:
5583 return "DW_TAG_try_block";
5584 case DW_TAG_variant_part
:
5585 return "DW_TAG_variant_part";
5586 case DW_TAG_variable
:
5587 return "DW_TAG_variable";
5588 case DW_TAG_volatile_type
:
5589 return "DW_TAG_volatile_type";
5590 case DW_TAG_dwarf_procedure
:
5591 return "DW_TAG_dwarf_procedure";
5592 case DW_TAG_restrict_type
:
5593 return "DW_TAG_restrict_type";
5594 case DW_TAG_interface_type
:
5595 return "DW_TAG_interface_type";
5596 case DW_TAG_namespace
:
5597 return "DW_TAG_namespace";
5598 case DW_TAG_imported_module
:
5599 return "DW_TAG_imported_module";
5600 case DW_TAG_unspecified_type
:
5601 return "DW_TAG_unspecified_type";
5602 case DW_TAG_partial_unit
:
5603 return "DW_TAG_partial_unit";
5604 case DW_TAG_imported_unit
:
5605 return "DW_TAG_imported_unit";
5606 case DW_TAG_MIPS_loop
:
5607 return "DW_TAG_MIPS_loop";
5608 case DW_TAG_format_label
:
5609 return "DW_TAG_format_label";
5610 case DW_TAG_function_template
:
5611 return "DW_TAG_function_template";
5612 case DW_TAG_class_template
:
5613 return "DW_TAG_class_template";
5615 return "DW_TAG_<unknown>";
5619 /* Convert a DWARF attribute code into its string name. */
5622 dwarf_attr_name (register unsigned attr
)
5627 return "DW_AT_sibling";
5628 case DW_AT_location
:
5629 return "DW_AT_location";
5631 return "DW_AT_name";
5632 case DW_AT_ordering
:
5633 return "DW_AT_ordering";
5634 case DW_AT_subscr_data
:
5635 return "DW_AT_subscr_data";
5636 case DW_AT_byte_size
:
5637 return "DW_AT_byte_size";
5638 case DW_AT_bit_offset
:
5639 return "DW_AT_bit_offset";
5640 case DW_AT_bit_size
:
5641 return "DW_AT_bit_size";
5642 case DW_AT_element_list
:
5643 return "DW_AT_element_list";
5644 case DW_AT_stmt_list
:
5645 return "DW_AT_stmt_list";
5647 return "DW_AT_low_pc";
5649 return "DW_AT_high_pc";
5650 case DW_AT_language
:
5651 return "DW_AT_language";
5653 return "DW_AT_member";
5655 return "DW_AT_discr";
5656 case DW_AT_discr_value
:
5657 return "DW_AT_discr_value";
5658 case DW_AT_visibility
:
5659 return "DW_AT_visibility";
5661 return "DW_AT_import";
5662 case DW_AT_string_length
:
5663 return "DW_AT_string_length";
5664 case DW_AT_common_reference
:
5665 return "DW_AT_common_reference";
5666 case DW_AT_comp_dir
:
5667 return "DW_AT_comp_dir";
5668 case DW_AT_const_value
:
5669 return "DW_AT_const_value";
5670 case DW_AT_containing_type
:
5671 return "DW_AT_containing_type";
5672 case DW_AT_default_value
:
5673 return "DW_AT_default_value";
5675 return "DW_AT_inline";
5676 case DW_AT_is_optional
:
5677 return "DW_AT_is_optional";
5678 case DW_AT_lower_bound
:
5679 return "DW_AT_lower_bound";
5680 case DW_AT_producer
:
5681 return "DW_AT_producer";
5682 case DW_AT_prototyped
:
5683 return "DW_AT_prototyped";
5684 case DW_AT_return_addr
:
5685 return "DW_AT_return_addr";
5686 case DW_AT_start_scope
:
5687 return "DW_AT_start_scope";
5688 case DW_AT_stride_size
:
5689 return "DW_AT_stride_size";
5690 case DW_AT_upper_bound
:
5691 return "DW_AT_upper_bound";
5692 case DW_AT_abstract_origin
:
5693 return "DW_AT_abstract_origin";
5694 case DW_AT_accessibility
:
5695 return "DW_AT_accessibility";
5696 case DW_AT_address_class
:
5697 return "DW_AT_address_class";
5698 case DW_AT_artificial
:
5699 return "DW_AT_artificial";
5700 case DW_AT_base_types
:
5701 return "DW_AT_base_types";
5702 case DW_AT_calling_convention
:
5703 return "DW_AT_calling_convention";
5705 return "DW_AT_count";
5706 case DW_AT_data_member_location
:
5707 return "DW_AT_data_member_location";
5708 case DW_AT_decl_column
:
5709 return "DW_AT_decl_column";
5710 case DW_AT_decl_file
:
5711 return "DW_AT_decl_file";
5712 case DW_AT_decl_line
:
5713 return "DW_AT_decl_line";
5714 case DW_AT_declaration
:
5715 return "DW_AT_declaration";
5716 case DW_AT_discr_list
:
5717 return "DW_AT_discr_list";
5718 case DW_AT_encoding
:
5719 return "DW_AT_encoding";
5720 case DW_AT_external
:
5721 return "DW_AT_external";
5722 case DW_AT_frame_base
:
5723 return "DW_AT_frame_base";
5725 return "DW_AT_friend";
5726 case DW_AT_identifier_case
:
5727 return "DW_AT_identifier_case";
5728 case DW_AT_macro_info
:
5729 return "DW_AT_macro_info";
5730 case DW_AT_namelist_items
:
5731 return "DW_AT_namelist_items";
5732 case DW_AT_priority
:
5733 return "DW_AT_priority";
5735 return "DW_AT_segment";
5736 case DW_AT_specification
:
5737 return "DW_AT_specification";
5738 case DW_AT_static_link
:
5739 return "DW_AT_static_link";
5741 return "DW_AT_type";
5742 case DW_AT_use_location
:
5743 return "DW_AT_use_location";
5744 case DW_AT_variable_parameter
:
5745 return "DW_AT_variable_parameter";
5746 case DW_AT_virtuality
:
5747 return "DW_AT_virtuality";
5748 case DW_AT_vtable_elem_location
:
5749 return "DW_AT_vtable_elem_location";
5750 case DW_AT_allocated
:
5751 return "DW_AT_allocated";
5752 case DW_AT_associated
:
5753 return "DW_AT_associated";
5754 case DW_AT_data_location
:
5755 return "DW_AT_data_location";
5757 return "DW_AT_stride";
5758 case DW_AT_entry_pc
:
5759 return "DW_AT_entry_pc";
5760 case DW_AT_use_UTF8
:
5761 return "DW_AT_use_UTF8";
5762 case DW_AT_extension
:
5763 return "DW_AT_extension";
5765 return "DW_AT_ranges";
5766 case DW_AT_trampoline
:
5767 return "DW_AT_trampoline";
5768 case DW_AT_call_column
:
5769 return "DW_AT_call_column";
5770 case DW_AT_call_file
:
5771 return "DW_AT_call_file";
5772 case DW_AT_call_line
:
5773 return "DW_AT_call_line";
5775 case DW_AT_MIPS_fde
:
5776 return "DW_AT_MIPS_fde";
5777 case DW_AT_MIPS_loop_begin
:
5778 return "DW_AT_MIPS_loop_begin";
5779 case DW_AT_MIPS_tail_loop_begin
:
5780 return "DW_AT_MIPS_tail_loop_begin";
5781 case DW_AT_MIPS_epilog_begin
:
5782 return "DW_AT_MIPS_epilog_begin";
5783 case DW_AT_MIPS_loop_unroll_factor
:
5784 return "DW_AT_MIPS_loop_unroll_factor";
5785 case DW_AT_MIPS_software_pipeline_depth
:
5786 return "DW_AT_MIPS_software_pipeline_depth";
5787 case DW_AT_MIPS_linkage_name
:
5788 return "DW_AT_MIPS_linkage_name";
5791 case DW_AT_sf_names
:
5792 return "DW_AT_sf_names";
5793 case DW_AT_src_info
:
5794 return "DW_AT_src_info";
5795 case DW_AT_mac_info
:
5796 return "DW_AT_mac_info";
5797 case DW_AT_src_coords
:
5798 return "DW_AT_src_coords";
5799 case DW_AT_body_begin
:
5800 return "DW_AT_body_begin";
5801 case DW_AT_body_end
:
5802 return "DW_AT_body_end";
5803 case DW_AT_GNU_vector
:
5804 return "DW_AT_GNU_vector";
5806 return "DW_AT_<unknown>";
5810 /* Convert a DWARF value form code into its string name. */
5813 dwarf_form_name (register unsigned form
)
5818 return "DW_FORM_addr";
5819 case DW_FORM_block2
:
5820 return "DW_FORM_block2";
5821 case DW_FORM_block4
:
5822 return "DW_FORM_block4";
5824 return "DW_FORM_data2";
5826 return "DW_FORM_data4";
5828 return "DW_FORM_data8";
5829 case DW_FORM_string
:
5830 return "DW_FORM_string";
5832 return "DW_FORM_block";
5833 case DW_FORM_block1
:
5834 return "DW_FORM_block1";
5836 return "DW_FORM_data1";
5838 return "DW_FORM_flag";
5840 return "DW_FORM_sdata";
5842 return "DW_FORM_strp";
5844 return "DW_FORM_udata";
5845 case DW_FORM_ref_addr
:
5846 return "DW_FORM_ref_addr";
5848 return "DW_FORM_ref1";
5850 return "DW_FORM_ref2";
5852 return "DW_FORM_ref4";
5854 return "DW_FORM_ref8";
5855 case DW_FORM_ref_udata
:
5856 return "DW_FORM_ref_udata";
5857 case DW_FORM_indirect
:
5858 return "DW_FORM_indirect";
5860 return "DW_FORM_<unknown>";
5864 /* Convert a DWARF stack opcode into its string name. */
5867 dwarf_stack_op_name (register unsigned op
)
5872 return "DW_OP_addr";
5874 return "DW_OP_deref";
5876 return "DW_OP_const1u";
5878 return "DW_OP_const1s";
5880 return "DW_OP_const2u";
5882 return "DW_OP_const2s";
5884 return "DW_OP_const4u";
5886 return "DW_OP_const4s";
5888 return "DW_OP_const8u";
5890 return "DW_OP_const8s";
5892 return "DW_OP_constu";
5894 return "DW_OP_consts";
5898 return "DW_OP_drop";
5900 return "DW_OP_over";
5902 return "DW_OP_pick";
5904 return "DW_OP_swap";
5908 return "DW_OP_xderef";
5916 return "DW_OP_minus";
5928 return "DW_OP_plus";
5929 case DW_OP_plus_uconst
:
5930 return "DW_OP_plus_uconst";
5936 return "DW_OP_shra";
5954 return "DW_OP_skip";
5956 return "DW_OP_lit0";
5958 return "DW_OP_lit1";
5960 return "DW_OP_lit2";
5962 return "DW_OP_lit3";
5964 return "DW_OP_lit4";
5966 return "DW_OP_lit5";
5968 return "DW_OP_lit6";
5970 return "DW_OP_lit7";
5972 return "DW_OP_lit8";
5974 return "DW_OP_lit9";
5976 return "DW_OP_lit10";
5978 return "DW_OP_lit11";
5980 return "DW_OP_lit12";
5982 return "DW_OP_lit13";
5984 return "DW_OP_lit14";
5986 return "DW_OP_lit15";
5988 return "DW_OP_lit16";
5990 return "DW_OP_lit17";
5992 return "DW_OP_lit18";
5994 return "DW_OP_lit19";
5996 return "DW_OP_lit20";
5998 return "DW_OP_lit21";
6000 return "DW_OP_lit22";
6002 return "DW_OP_lit23";
6004 return "DW_OP_lit24";
6006 return "DW_OP_lit25";
6008 return "DW_OP_lit26";
6010 return "DW_OP_lit27";
6012 return "DW_OP_lit28";
6014 return "DW_OP_lit29";
6016 return "DW_OP_lit30";
6018 return "DW_OP_lit31";
6020 return "DW_OP_reg0";
6022 return "DW_OP_reg1";
6024 return "DW_OP_reg2";
6026 return "DW_OP_reg3";
6028 return "DW_OP_reg4";
6030 return "DW_OP_reg5";
6032 return "DW_OP_reg6";
6034 return "DW_OP_reg7";
6036 return "DW_OP_reg8";
6038 return "DW_OP_reg9";
6040 return "DW_OP_reg10";
6042 return "DW_OP_reg11";
6044 return "DW_OP_reg12";
6046 return "DW_OP_reg13";
6048 return "DW_OP_reg14";
6050 return "DW_OP_reg15";
6052 return "DW_OP_reg16";
6054 return "DW_OP_reg17";
6056 return "DW_OP_reg18";
6058 return "DW_OP_reg19";
6060 return "DW_OP_reg20";
6062 return "DW_OP_reg21";
6064 return "DW_OP_reg22";
6066 return "DW_OP_reg23";
6068 return "DW_OP_reg24";
6070 return "DW_OP_reg25";
6072 return "DW_OP_reg26";
6074 return "DW_OP_reg27";
6076 return "DW_OP_reg28";
6078 return "DW_OP_reg29";
6080 return "DW_OP_reg30";
6082 return "DW_OP_reg31";
6084 return "DW_OP_breg0";
6086 return "DW_OP_breg1";
6088 return "DW_OP_breg2";
6090 return "DW_OP_breg3";
6092 return "DW_OP_breg4";
6094 return "DW_OP_breg5";
6096 return "DW_OP_breg6";
6098 return "DW_OP_breg7";
6100 return "DW_OP_breg8";
6102 return "DW_OP_breg9";
6104 return "DW_OP_breg10";
6106 return "DW_OP_breg11";
6108 return "DW_OP_breg12";
6110 return "DW_OP_breg13";
6112 return "DW_OP_breg14";
6114 return "DW_OP_breg15";
6116 return "DW_OP_breg16";
6118 return "DW_OP_breg17";
6120 return "DW_OP_breg18";
6122 return "DW_OP_breg19";
6124 return "DW_OP_breg20";
6126 return "DW_OP_breg21";
6128 return "DW_OP_breg22";
6130 return "DW_OP_breg23";
6132 return "DW_OP_breg24";
6134 return "DW_OP_breg25";
6136 return "DW_OP_breg26";
6138 return "DW_OP_breg27";
6140 return "DW_OP_breg28";
6142 return "DW_OP_breg29";
6144 return "DW_OP_breg30";
6146 return "DW_OP_breg31";
6148 return "DW_OP_regx";
6150 return "DW_OP_fbreg";
6152 return "DW_OP_bregx";
6154 return "DW_OP_piece";
6155 case DW_OP_deref_size
:
6156 return "DW_OP_deref_size";
6157 case DW_OP_xderef_size
:
6158 return "DW_OP_xderef_size";
6161 /* DWARF 3 extensions. */
6162 case DW_OP_push_object_address
:
6163 return "DW_OP_push_object_address";
6165 return "DW_OP_call2";
6167 return "DW_OP_call4";
6168 case DW_OP_call_ref
:
6169 return "DW_OP_call_ref";
6170 /* GNU extensions. */
6171 case DW_OP_GNU_push_tls_address
:
6172 return "DW_OP_GNU_push_tls_address";
6174 return "OP_<unknown>";
6179 dwarf_bool_name (unsigned mybool
)
6187 /* Convert a DWARF type code into its string name. */
6190 dwarf_type_encoding_name (register unsigned enc
)
6194 case DW_ATE_address
:
6195 return "DW_ATE_address";
6196 case DW_ATE_boolean
:
6197 return "DW_ATE_boolean";
6198 case DW_ATE_complex_float
:
6199 return "DW_ATE_complex_float";
6201 return "DW_ATE_float";
6203 return "DW_ATE_signed";
6204 case DW_ATE_signed_char
:
6205 return "DW_ATE_signed_char";
6206 case DW_ATE_unsigned
:
6207 return "DW_ATE_unsigned";
6208 case DW_ATE_unsigned_char
:
6209 return "DW_ATE_unsigned_char";
6210 case DW_ATE_imaginary_float
:
6211 return "DW_ATE_imaginary_float";
6213 return "DW_ATE_<unknown>";
6217 /* Convert a DWARF call frame info operation to its string name. */
6221 dwarf_cfi_name (register unsigned cfi_opc
)
6225 case DW_CFA_advance_loc
:
6226 return "DW_CFA_advance_loc";
6228 return "DW_CFA_offset";
6229 case DW_CFA_restore
:
6230 return "DW_CFA_restore";
6232 return "DW_CFA_nop";
6233 case DW_CFA_set_loc
:
6234 return "DW_CFA_set_loc";
6235 case DW_CFA_advance_loc1
:
6236 return "DW_CFA_advance_loc1";
6237 case DW_CFA_advance_loc2
:
6238 return "DW_CFA_advance_loc2";
6239 case DW_CFA_advance_loc4
:
6240 return "DW_CFA_advance_loc4";
6241 case DW_CFA_offset_extended
:
6242 return "DW_CFA_offset_extended";
6243 case DW_CFA_restore_extended
:
6244 return "DW_CFA_restore_extended";
6245 case DW_CFA_undefined
:
6246 return "DW_CFA_undefined";
6247 case DW_CFA_same_value
:
6248 return "DW_CFA_same_value";
6249 case DW_CFA_register
:
6250 return "DW_CFA_register";
6251 case DW_CFA_remember_state
:
6252 return "DW_CFA_remember_state";
6253 case DW_CFA_restore_state
:
6254 return "DW_CFA_restore_state";
6255 case DW_CFA_def_cfa
:
6256 return "DW_CFA_def_cfa";
6257 case DW_CFA_def_cfa_register
:
6258 return "DW_CFA_def_cfa_register";
6259 case DW_CFA_def_cfa_offset
:
6260 return "DW_CFA_def_cfa_offset";
6263 case DW_CFA_def_cfa_expression
:
6264 return "DW_CFA_def_cfa_expression";
6265 case DW_CFA_expression
:
6266 return "DW_CFA_expression";
6267 case DW_CFA_offset_extended_sf
:
6268 return "DW_CFA_offset_extended_sf";
6269 case DW_CFA_def_cfa_sf
:
6270 return "DW_CFA_def_cfa_sf";
6271 case DW_CFA_def_cfa_offset_sf
:
6272 return "DW_CFA_def_cfa_offset_sf";
6274 /* SGI/MIPS specific */
6275 case DW_CFA_MIPS_advance_loc8
:
6276 return "DW_CFA_MIPS_advance_loc8";
6278 /* GNU extensions */
6279 case DW_CFA_GNU_window_save
:
6280 return "DW_CFA_GNU_window_save";
6281 case DW_CFA_GNU_args_size
:
6282 return "DW_CFA_GNU_args_size";
6283 case DW_CFA_GNU_negative_offset_extended
:
6284 return "DW_CFA_GNU_negative_offset_extended";
6287 return "DW_CFA_<unknown>";
6293 dump_die (struct die_info
*die
)
6297 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6298 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6299 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6300 dwarf_bool_name (die
->has_children
));
6302 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6303 for (i
= 0; i
< die
->num_attrs
; ++i
)
6305 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6306 dwarf_attr_name (die
->attrs
[i
].name
),
6307 dwarf_form_name (die
->attrs
[i
].form
));
6308 switch (die
->attrs
[i
].form
)
6310 case DW_FORM_ref_addr
:
6312 fprintf_unfiltered (gdb_stderr
, "address: ");
6313 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6315 case DW_FORM_block2
:
6316 case DW_FORM_block4
:
6318 case DW_FORM_block1
:
6319 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6330 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6332 case DW_FORM_string
:
6334 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6335 DW_STRING (&die
->attrs
[i
])
6336 ? DW_STRING (&die
->attrs
[i
]) : "");
6339 if (DW_UNSND (&die
->attrs
[i
]))
6340 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6342 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6344 case DW_FORM_indirect
:
6345 /* the reader will have reduced the indirect form to
6346 the "base form" so this form should not occur */
6347 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6350 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6351 die
->attrs
[i
].form
);
6353 fprintf_unfiltered (gdb_stderr
, "\n");
6358 dump_die_list (struct die_info
*die
)
6368 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6371 struct die_info
*old
;
6373 h
= (offset
% REF_HASH_SIZE
);
6374 old
= die_ref_table
[h
];
6375 die
->next_ref
= old
;
6376 die_ref_table
[h
] = die
;
6381 dwarf2_empty_hash_tables (void)
6383 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6387 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6389 unsigned int result
= 0;
6393 case DW_FORM_ref_addr
:
6394 result
= DW_ADDR (attr
);
6400 case DW_FORM_ref_udata
:
6401 result
= cu_header_offset
+ DW_UNSND (attr
);
6404 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
6409 static struct die_info
*
6410 follow_die_ref (unsigned int offset
)
6412 struct die_info
*die
;
6415 h
= (offset
% REF_HASH_SIZE
);
6416 die
= die_ref_table
[h
];
6419 if (die
->offset
== offset
)
6423 die
= die
->next_ref
;
6428 static struct type
*
6429 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6431 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6433 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
6437 /* Look for this particular type in the fundamental type vector. If
6438 one is not found, create and install one appropriate for the
6439 current language and the current target machine. */
6441 if (ftypes
[typeid] == NULL
)
6443 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6446 return (ftypes
[typeid]);
6449 /* Decode simple location descriptions.
6450 Given a pointer to a dwarf block that defines a location, compute
6451 the location and return the value.
6453 FIXME: This is a kludge until we figure out a better
6454 way to handle the location descriptions.
6455 Gdb's design does not mesh well with the DWARF2 notion of a location
6456 computing interpreter, which is a shame because the flexibility goes unused.
6457 FIXME: Implement more operations as necessary.
6459 A location description containing no operations indicates that the
6460 object is optimized out. The global optimized_out flag is set for
6461 those, the return value is meaningless.
6463 When the result is a register number, the global isreg flag is set,
6464 otherwise it is cleared.
6466 When the result is a base register offset, the global offreg flag is set
6467 and the register number is returned in basereg, otherwise it is cleared.
6469 When the DW_OP_fbreg operation is encountered without a corresponding
6470 DW_AT_frame_base attribute, the global islocal flag is set.
6471 Hopefully the machine dependent code knows how to set up a virtual
6472 frame pointer for the local references.
6474 Note that stack[0] is unused except as a default error return.
6475 Note that stack overflow is not yet handled. */
6478 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
6479 const struct comp_unit_head
*cu_header
)
6482 int size
= blk
->size
;
6483 char *data
= blk
->data
;
6484 CORE_ADDR stack
[64];
6486 unsigned int bytes_read
, unsnd
;
6496 is_thread_local
= 0;
6537 stack
[++stacki
] = op
- DW_OP_lit0
;
6573 stack
[++stacki
] = op
- DW_OP_reg0
;
6578 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6580 stack
[++stacki
] = unsnd
;
6616 basereg
= op
- DW_OP_breg0
;
6617 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6623 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6625 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6630 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6632 if (frame_base_reg
>= 0)
6635 basereg
= frame_base_reg
;
6636 stack
[stacki
] += frame_base_offset
;
6640 complain (&dwarf2_missing_at_frame_base
);
6646 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
6647 cu_header
, &bytes_read
);
6652 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
6657 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
6662 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
6667 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
6672 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
6677 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
6682 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
6688 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6693 stack
[stacki
+ 1] = stack
[stacki
];
6698 stack
[stacki
- 1] += stack
[stacki
];
6702 case DW_OP_plus_uconst
:
6703 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6708 stack
[stacki
- 1] -= stack
[stacki
];
6714 /* If we're not the last op, then we definitely can't encode
6715 this using GDB's address_class enum. */
6717 complain (&dwarf2_complex_location_expr
);
6720 case DW_OP_GNU_push_tls_address
:
6721 is_thread_local
= 1;
6722 /* The top of the stack has the offset from the beginning
6723 of the thread control block at which the variable is located. */
6724 /* Nothing should follow this operator, so the top of stack would
6727 complain (&dwarf2_complex_location_expr
);
6731 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name (op
));
6732 return (stack
[stacki
]);
6735 return (stack
[stacki
]);
6738 /* memory allocation interface */
6742 dwarf2_free_tmp_obstack (PTR ignore
)
6744 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6747 static struct dwarf_block
*
6748 dwarf_alloc_block (void)
6750 struct dwarf_block
*blk
;
6752 blk
= (struct dwarf_block
*)
6753 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6757 static struct abbrev_info
*
6758 dwarf_alloc_abbrev (void)
6760 struct abbrev_info
*abbrev
;
6762 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6763 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6767 static struct die_info
*
6768 dwarf_alloc_die (void)
6770 struct die_info
*die
;
6772 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6773 memset (die
, 0, sizeof (struct die_info
));
6778 /* Macro support. */
6781 /* Return the full name of file number I in *LH's file name table.
6782 Use COMP_DIR as the name of the current directory of the
6783 compilation. The result is allocated using xmalloc; the caller is
6784 responsible for freeing it. */
6786 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
6788 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6790 if (IS_ABSOLUTE_PATH (fe
->name
))
6791 return xstrdup (fe
->name
);
6799 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6805 dir_len
= strlen (dir
);
6806 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
6807 strcpy (full_name
, dir
);
6808 full_name
[dir_len
] = '/';
6809 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
6813 return xstrdup (fe
->name
);
6818 static struct macro_source_file
*
6819 macro_start_file (int file
, int line
,
6820 struct macro_source_file
*current_file
,
6821 const char *comp_dir
,
6822 struct line_header
*lh
, struct objfile
*objfile
)
6824 /* The full name of this source file. */
6825 char *full_name
= file_full_name (file
, lh
, comp_dir
);
6827 /* We don't create a macro table for this compilation unit
6828 at all until we actually get a filename. */
6829 if (! pending_macros
)
6830 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
6831 objfile
->macro_cache
);
6834 /* If we have no current file, then this must be the start_file
6835 directive for the compilation unit's main source file. */
6836 current_file
= macro_set_main (pending_macros
, full_name
);
6838 current_file
= macro_include (current_file
, line
, full_name
);
6842 return current_file
;
6846 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
6847 followed by a null byte. */
6849 copy_string (const char *buf
, int len
)
6851 char *s
= xmalloc (len
+ 1);
6852 memcpy (s
, buf
, len
);
6860 consume_improper_spaces (const char *p
, const char *body
)
6864 complain (&dwarf2_macro_spaces_in_definition
, body
);
6875 parse_macro_definition (struct macro_source_file
*file
, int line
,
6880 /* The body string takes one of two forms. For object-like macro
6881 definitions, it should be:
6883 <macro name> " " <definition>
6885 For function-like macro definitions, it should be:
6887 <macro name> "() " <definition>
6889 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
6891 Spaces may appear only where explicitly indicated, and in the
6894 The Dwarf 2 spec says that an object-like macro's name is always
6895 followed by a space, but versions of GCC around March 2002 omit
6896 the space when the macro's definition is the empty string.
6898 The Dwarf 2 spec says that there should be no spaces between the
6899 formal arguments in a function-like macro's formal argument list,
6900 but versions of GCC around March 2002 include spaces after the
6904 /* Find the extent of the macro name. The macro name is terminated
6905 by either a space or null character (for an object-like macro) or
6906 an opening paren (for a function-like macro). */
6907 for (p
= body
; *p
; p
++)
6908 if (*p
== ' ' || *p
== '(')
6911 if (*p
== ' ' || *p
== '\0')
6913 /* It's an object-like macro. */
6914 int name_len
= p
- body
;
6915 char *name
= copy_string (body
, name_len
);
6916 const char *replacement
;
6919 replacement
= body
+ name_len
+ 1;
6922 complain (&dwarf2_macro_malformed_definition
, body
);
6923 replacement
= body
+ name_len
;
6926 macro_define_object (file
, line
, name
, replacement
);
6932 /* It's a function-like macro. */
6933 char *name
= copy_string (body
, p
- body
);
6936 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
6940 p
= consume_improper_spaces (p
, body
);
6942 /* Parse the formal argument list. */
6943 while (*p
&& *p
!= ')')
6945 /* Find the extent of the current argument name. */
6946 const char *arg_start
= p
;
6948 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
6951 if (! *p
|| p
== arg_start
)
6952 complain (&dwarf2_macro_malformed_definition
,
6956 /* Make sure argv has room for the new argument. */
6957 if (argc
>= argv_size
)
6960 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
6963 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
6966 p
= consume_improper_spaces (p
, body
);
6968 /* Consume the comma, if present. */
6973 p
= consume_improper_spaces (p
, body
);
6982 /* Perfectly formed definition, no complaints. */
6983 macro_define_function (file
, line
, name
,
6984 argc
, (const char **) argv
,
6986 else if (*p
== '\0')
6988 /* Complain, but do define it. */
6989 complain (&dwarf2_macro_malformed_definition
, body
);
6990 macro_define_function (file
, line
, name
,
6991 argc
, (const char **) argv
,
6995 /* Just complain. */
6996 complain (&dwarf2_macro_malformed_definition
, body
);
6999 /* Just complain. */
7000 complain (&dwarf2_macro_malformed_definition
, body
);
7006 for (i
= 0; i
< argc
; i
++)
7012 complain (&dwarf2_macro_malformed_definition
, body
);
7017 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7018 char *comp_dir
, bfd
*abfd
,
7019 const struct comp_unit_head
*cu_header
,
7020 struct objfile
*objfile
)
7022 char *mac_ptr
, *mac_end
;
7023 struct macro_source_file
*current_file
= 0;
7025 if (dwarf_macinfo_buffer
== NULL
)
7027 complain (&dwarf2_missing_macinfo_section
);
7031 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7032 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7036 enum dwarf_macinfo_record_type macinfo_type
;
7038 /* Do we at least have room for a macinfo type byte? */
7039 if (mac_ptr
>= mac_end
)
7041 complain (&dwarf2_macros_too_long
);
7045 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7048 switch (macinfo_type
)
7050 /* A zero macinfo type indicates the end of the macro
7055 case DW_MACINFO_define
:
7056 case DW_MACINFO_undef
:
7062 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7063 mac_ptr
+= bytes_read
;
7064 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7065 mac_ptr
+= bytes_read
;
7068 complain (&dwarf2_macro_outside_file
,
7069 macinfo_type
== DW_MACINFO_define
? "definition" :
7070 macinfo_type
== DW_MACINFO_undef
? "undefinition" :
7071 "something-or-other",
7075 if (macinfo_type
== DW_MACINFO_define
)
7076 parse_macro_definition (current_file
, line
, body
);
7077 else if (macinfo_type
== DW_MACINFO_undef
)
7078 macro_undef (current_file
, line
, body
);
7083 case DW_MACINFO_start_file
:
7088 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7089 mac_ptr
+= bytes_read
;
7090 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7091 mac_ptr
+= bytes_read
;
7093 current_file
= macro_start_file (file
, line
,
7094 current_file
, comp_dir
,
7099 case DW_MACINFO_end_file
:
7101 complain (&dwarf2_macro_unmatched_end_file
);
7104 current_file
= current_file
->included_by
;
7107 enum dwarf_macinfo_record_type next_type
;
7109 /* GCC circa March 2002 doesn't produce the zero
7110 type byte marking the end of the compilation
7111 unit. Complain if it's not there, but exit no
7114 /* Do we at least have room for a macinfo type byte? */
7115 if (mac_ptr
>= mac_end
)
7117 complain (&dwarf2_macros_too_long
);
7121 /* We don't increment mac_ptr here, so this is just
7123 next_type
= read_1_byte (abfd
, mac_ptr
);
7125 complain (&dwarf2_macros_not_terminated
);
7132 case DW_MACINFO_vendor_ext
:
7138 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7139 mac_ptr
+= bytes_read
;
7140 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7141 mac_ptr
+= bytes_read
;
7143 /* We don't recognize any vendor extensions. */
7150 /* Check if the attribute's form is a DW_FORM_block*
7151 if so return true else false. */
7153 attr_form_is_block (struct attribute
*attr
)
7155 return (attr
== NULL
? 0 :
7156 attr
->form
== DW_FORM_block1
7157 || attr
->form
== DW_FORM_block2
7158 || attr
->form
== DW_FORM_block4
7159 || attr
->form
== DW_FORM_block
);