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 /* If we've finished processing a top-level function, subsequent
2025 symbols go in the file symbol list. */
2026 if (outermost_context_p ())
2027 list_in_scope
= &file_symbols
;
2030 /* Process all the DIES contained within a lexical block scope. Start
2031 a new scope, process the dies, and then close the scope. */
2034 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
2035 const struct comp_unit_head
*cu_header
)
2037 register struct context_stack
*new;
2038 CORE_ADDR lowpc
, highpc
;
2039 struct die_info
*child_die
;
2041 /* Ignore blocks with missing or invalid low and high pc attributes. */
2042 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
2047 push_context (0, lowpc
);
2048 if (die
->has_children
)
2050 child_die
= die
->next
;
2051 while (child_die
&& child_die
->tag
)
2053 process_die (child_die
, objfile
, cu_header
);
2054 child_die
= sibling_die (child_die
);
2057 new = pop_context ();
2059 if (local_symbols
!= NULL
)
2061 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2064 local_symbols
= new->locals
;
2067 /* Get low and high pc attributes from a die.
2068 Return 1 if the attributes are present and valid, otherwise, return 0. */
2071 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2072 struct objfile
*objfile
)
2074 struct attribute
*attr
;
2078 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2080 low
= DW_ADDR (attr
);
2083 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2085 high
= DW_ADDR (attr
);
2092 /* When using the GNU linker, .gnu.linkonce. sections are used to
2093 eliminate duplicate copies of functions and vtables and such.
2094 The linker will arbitrarily choose one and discard the others.
2095 The AT_*_pc values for such functions refer to local labels in
2096 these sections. If the section from that file was discarded, the
2097 labels are not in the output, so the relocs get a value of 0.
2098 If this is a discarded function, mark the pc bounds as invalid,
2099 so that GDB will ignore it. */
2100 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
2108 /* Add an aggregate field to the field list. */
2111 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2112 struct objfile
*objfile
,
2113 const struct comp_unit_head
*cu_header
)
2115 struct nextfield
*new_field
;
2116 struct attribute
*attr
;
2118 char *fieldname
= "";
2120 /* Allocate a new field list entry and link it in. */
2121 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2122 make_cleanup (xfree
, new_field
);
2123 memset (new_field
, 0, sizeof (struct nextfield
));
2124 new_field
->next
= fip
->fields
;
2125 fip
->fields
= new_field
;
2128 /* Handle accessibility and virtuality of field.
2129 The default accessibility for members is public, the default
2130 accessibility for inheritance is private. */
2131 if (die
->tag
!= DW_TAG_inheritance
)
2132 new_field
->accessibility
= DW_ACCESS_public
;
2134 new_field
->accessibility
= DW_ACCESS_private
;
2135 new_field
->virtuality
= DW_VIRTUALITY_none
;
2137 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2139 new_field
->accessibility
= DW_UNSND (attr
);
2140 if (new_field
->accessibility
!= DW_ACCESS_public
)
2141 fip
->non_public_fields
= 1;
2142 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2144 new_field
->virtuality
= DW_UNSND (attr
);
2146 fp
= &new_field
->field
;
2147 if (die
->tag
== DW_TAG_member
)
2149 /* Get type of field. */
2150 fp
->type
= die_type (die
, objfile
, cu_header
);
2152 /* Get bit size of field (zero if none). */
2153 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2156 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2160 FIELD_BITSIZE (*fp
) = 0;
2163 /* Get bit offset of field. */
2164 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2167 FIELD_BITPOS (*fp
) =
2168 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
2171 FIELD_BITPOS (*fp
) = 0;
2172 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2175 if (BITS_BIG_ENDIAN
)
2177 /* For big endian bits, the DW_AT_bit_offset gives the
2178 additional bit offset from the MSB of the containing
2179 anonymous object to the MSB of the field. We don't
2180 have to do anything special since we don't need to
2181 know the size of the anonymous object. */
2182 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2186 /* For little endian bits, compute the bit offset to the
2187 MSB of the anonymous object, subtract off the number of
2188 bits from the MSB of the field to the MSB of the
2189 object, and then subtract off the number of bits of
2190 the field itself. The result is the bit offset of
2191 the LSB of the field. */
2193 int bit_offset
= DW_UNSND (attr
);
2195 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2198 /* The size of the anonymous object containing
2199 the bit field is explicit, so use the
2200 indicated size (in bytes). */
2201 anonymous_size
= DW_UNSND (attr
);
2205 /* The size of the anonymous object containing
2206 the bit field must be inferred from the type
2207 attribute of the data member containing the
2209 anonymous_size
= TYPE_LENGTH (fp
->type
);
2211 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2212 - bit_offset
- FIELD_BITSIZE (*fp
);
2216 /* Get name of field. */
2217 attr
= dwarf_attr (die
, DW_AT_name
);
2218 if (attr
&& DW_STRING (attr
))
2219 fieldname
= DW_STRING (attr
);
2220 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2221 &objfile
->type_obstack
);
2223 /* Change accessibility for artificial fields (e.g. virtual table
2224 pointer or virtual base class pointer) to private. */
2225 if (dwarf_attr (die
, DW_AT_artificial
))
2227 new_field
->accessibility
= DW_ACCESS_private
;
2228 fip
->non_public_fields
= 1;
2231 else if (die
->tag
== DW_TAG_variable
)
2235 /* C++ static member.
2236 Get name of field. */
2237 attr
= dwarf_attr (die
, DW_AT_name
);
2238 if (attr
&& DW_STRING (attr
))
2239 fieldname
= DW_STRING (attr
);
2243 /* Get physical name. */
2244 physname
= dwarf2_linkage_name (die
);
2246 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2247 &objfile
->type_obstack
));
2248 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2249 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2250 &objfile
->type_obstack
);
2252 else if (die
->tag
== DW_TAG_inheritance
)
2254 /* C++ base class field. */
2255 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2257 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
2259 FIELD_BITSIZE (*fp
) = 0;
2260 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2261 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2262 fip
->nbaseclasses
++;
2266 /* Create the vector of fields, and attach it to the type. */
2269 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2270 struct objfile
*objfile
)
2272 int nfields
= fip
->nfields
;
2274 /* Record the field count, allocate space for the array of fields,
2275 and create blank accessibility bitfields if necessary. */
2276 TYPE_NFIELDS (type
) = nfields
;
2277 TYPE_FIELDS (type
) = (struct field
*)
2278 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2279 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2281 if (fip
->non_public_fields
)
2283 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2285 TYPE_FIELD_PRIVATE_BITS (type
) =
2286 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2287 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2289 TYPE_FIELD_PROTECTED_BITS (type
) =
2290 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2291 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2293 TYPE_FIELD_IGNORE_BITS (type
) =
2294 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2295 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2298 /* If the type has baseclasses, allocate and clear a bit vector for
2299 TYPE_FIELD_VIRTUAL_BITS. */
2300 if (fip
->nbaseclasses
)
2302 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2305 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2306 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2307 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2308 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2309 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2312 /* Copy the saved-up fields into the field vector. Start from the head
2313 of the list, adding to the tail of the field array, so that they end
2314 up in the same order in the array in which they were added to the list. */
2315 while (nfields
-- > 0)
2317 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2318 switch (fip
->fields
->accessibility
)
2320 case DW_ACCESS_private
:
2321 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2324 case DW_ACCESS_protected
:
2325 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2328 case DW_ACCESS_public
:
2332 /* Unknown accessibility. Complain and treat it as public. */
2334 complain (&dwarf2_unsupported_accessibility
,
2335 fip
->fields
->accessibility
);
2339 if (nfields
< fip
->nbaseclasses
)
2341 switch (fip
->fields
->virtuality
)
2343 case DW_VIRTUALITY_virtual
:
2344 case DW_VIRTUALITY_pure_virtual
:
2345 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2349 fip
->fields
= fip
->fields
->next
;
2353 /* Add a member function to the proper fieldlist. */
2356 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2357 struct type
*type
, struct objfile
*objfile
,
2358 const struct comp_unit_head
*cu_header
)
2360 struct attribute
*attr
;
2361 struct fnfieldlist
*flp
;
2363 struct fn_field
*fnp
;
2366 struct nextfnfield
*new_fnfield
;
2368 /* Get name of member function. */
2369 attr
= dwarf_attr (die
, DW_AT_name
);
2370 if (attr
&& DW_STRING (attr
))
2371 fieldname
= DW_STRING (attr
);
2375 /* Get the mangled name. */
2376 physname
= dwarf2_linkage_name (die
);
2378 /* Look up member function name in fieldlist. */
2379 for (i
= 0; i
< fip
->nfnfields
; i
++)
2381 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2385 /* Create new list element if necessary. */
2386 if (i
< fip
->nfnfields
)
2387 flp
= &fip
->fnfieldlists
[i
];
2390 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2392 fip
->fnfieldlists
= (struct fnfieldlist
*)
2393 xrealloc (fip
->fnfieldlists
,
2394 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2395 * sizeof (struct fnfieldlist
));
2396 if (fip
->nfnfields
== 0)
2397 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2399 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2400 flp
->name
= fieldname
;
2406 /* Create a new member function field and chain it to the field list
2408 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2409 make_cleanup (xfree
, new_fnfield
);
2410 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2411 new_fnfield
->next
= flp
->head
;
2412 flp
->head
= new_fnfield
;
2415 /* Fill in the member function field info. */
2416 fnp
= &new_fnfield
->fnfield
;
2417 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2418 &objfile
->type_obstack
);
2419 fnp
->type
= alloc_type (objfile
);
2420 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2422 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2423 int nparams
= TYPE_NFIELDS (die
->type
);
2425 /* TYPE is the domain of this method, and DIE->TYPE is the type
2426 of the method itself (TYPE_CODE_METHOD). */
2427 smash_to_method_type (fnp
->type
, type
,
2428 TYPE_TARGET_TYPE (die
->type
),
2429 TYPE_FIELDS (die
->type
),
2430 TYPE_NFIELDS (die
->type
),
2431 TYPE_VARARGS (die
->type
));
2433 /* Handle static member functions.
2434 Dwarf2 has no clean way to discern C++ static and non-static
2435 member functions. G++ helps GDB by marking the first
2436 parameter for non-static member functions (which is the
2437 this pointer) as artificial. We obtain this information
2438 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2439 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2440 fnp
->voffset
= VOFFSET_STATIC
;
2443 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2445 /* Get fcontext from DW_AT_containing_type if present. */
2446 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2447 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2449 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2450 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2452 /* Get accessibility. */
2453 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2456 switch (DW_UNSND (attr
))
2458 case DW_ACCESS_private
:
2459 fnp
->is_private
= 1;
2461 case DW_ACCESS_protected
:
2462 fnp
->is_protected
= 1;
2467 /* Check for artificial methods. */
2468 attr
= dwarf_attr (die
, DW_AT_artificial
);
2469 if (attr
&& DW_UNSND (attr
) != 0)
2470 fnp
->is_artificial
= 1;
2472 /* Get index in virtual function table if it is a virtual member function. */
2473 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2476 /* Support the .debug_loc offsets */
2477 if (attr_form_is_block (attr
))
2479 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2481 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2483 complain (&dwarf2_complex_location_expr
);
2487 complain (&dwarf2_invalid_attrib_class
, "DW_AT_vtable_elem_location",
2493 /* Create the vector of member function fields, and attach it to the type. */
2496 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2497 struct objfile
*objfile
)
2499 struct fnfieldlist
*flp
;
2500 int total_length
= 0;
2503 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2504 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2505 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2507 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2509 struct nextfnfield
*nfp
= flp
->head
;
2510 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2513 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2514 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2515 fn_flp
->fn_fields
= (struct fn_field
*)
2516 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2517 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2518 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2520 total_length
+= flp
->length
;
2523 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2524 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2527 /* Called when we find the DIE that starts a structure or union scope
2528 (definition) to process all dies that define the members of the
2531 NOTE: we need to call struct_type regardless of whether or not the
2532 DIE has an at_name attribute, since it might be an anonymous
2533 structure or union. This gets the type entered into our set of
2536 However, if the structure is incomplete (an opaque struct/union)
2537 then suppress creating a symbol table entry for it since gdb only
2538 wants to find the one with the complete definition. Note that if
2539 it is complete, we just call new_symbol, which does it's own
2540 checking about whether the struct/union is anonymous or not (and
2541 suppresses creating a symbol table entry itself). */
2544 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2545 const struct comp_unit_head
*cu_header
)
2548 struct attribute
*attr
;
2550 type
= alloc_type (objfile
);
2552 INIT_CPLUS_SPECIFIC (type
);
2553 attr
= dwarf_attr (die
, DW_AT_name
);
2554 if (attr
&& DW_STRING (attr
))
2556 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2557 strlen (DW_STRING (attr
)),
2558 &objfile
->type_obstack
);
2561 if (die
->tag
== DW_TAG_structure_type
)
2563 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2565 else if (die
->tag
== DW_TAG_union_type
)
2567 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2571 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2573 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2576 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2579 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2583 TYPE_LENGTH (type
) = 0;
2586 /* We need to add the type field to the die immediately so we don't
2587 infinitely recurse when dealing with pointers to the structure
2588 type within the structure itself. */
2591 if (die
->has_children
&& ! die_is_declaration (die
))
2593 struct field_info fi
;
2594 struct die_info
*child_die
;
2595 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2597 memset (&fi
, 0, sizeof (struct field_info
));
2599 child_die
= die
->next
;
2601 while (child_die
&& child_die
->tag
)
2603 if (child_die
->tag
== DW_TAG_member
)
2605 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2607 else if (child_die
->tag
== DW_TAG_variable
)
2609 /* C++ static member. */
2610 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2612 else if (child_die
->tag
== DW_TAG_subprogram
)
2614 /* C++ member function. */
2615 process_die (child_die
, objfile
, cu_header
);
2616 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2618 else if (child_die
->tag
== DW_TAG_inheritance
)
2620 /* C++ base class field. */
2621 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2625 process_die (child_die
, objfile
, cu_header
);
2627 child_die
= sibling_die (child_die
);
2630 /* Attach fields and member functions to the type. */
2632 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2635 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2637 /* Get the type which refers to the base class (possibly this
2638 class itself) which contains the vtable pointer for the current
2639 class from the DW_AT_containing_type attribute. */
2641 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2643 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2645 TYPE_VPTR_BASETYPE (type
) = t
;
2648 static const char vptr_name
[] =
2649 {'_', 'v', 'p', 't', 'r', '\0'};
2652 /* Our own class provides vtbl ptr. */
2653 for (i
= TYPE_NFIELDS (t
) - 1;
2654 i
>= TYPE_N_BASECLASSES (t
);
2657 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2659 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2660 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2662 TYPE_VPTR_FIELDNO (type
) = i
;
2667 /* Complain if virtual function table field not found. */
2668 if (i
< TYPE_N_BASECLASSES (t
))
2669 complain (&dwarf2_vtbl_not_found_complaint
,
2670 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2674 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2679 new_symbol (die
, type
, objfile
, cu_header
);
2681 do_cleanups (back_to
);
2685 /* No children, must be stub. */
2686 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2690 /* Given a pointer to a die which begins an enumeration, process all
2691 the dies that define the members of the enumeration.
2693 This will be much nicer in draft 6 of the DWARF spec when our
2694 members will be dies instead squished into the DW_AT_element_list
2697 NOTE: We reverse the order of the element list. */
2700 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2701 const struct comp_unit_head
*cu_header
)
2703 struct die_info
*child_die
;
2705 struct field
*fields
;
2706 struct attribute
*attr
;
2709 int unsigned_enum
= 1;
2711 type
= alloc_type (objfile
);
2713 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2714 attr
= dwarf_attr (die
, DW_AT_name
);
2715 if (attr
&& DW_STRING (attr
))
2717 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2718 strlen (DW_STRING (attr
)),
2719 &objfile
->type_obstack
);
2722 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2725 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2729 TYPE_LENGTH (type
) = 0;
2734 if (die
->has_children
)
2736 child_die
= die
->next
;
2737 while (child_die
&& child_die
->tag
)
2739 if (child_die
->tag
!= DW_TAG_enumerator
)
2741 process_die (child_die
, objfile
, cu_header
);
2745 attr
= dwarf_attr (child_die
, DW_AT_name
);
2748 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2749 if (SYMBOL_VALUE (sym
) < 0)
2752 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2754 fields
= (struct field
*)
2756 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2757 * sizeof (struct field
));
2760 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2761 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2762 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2763 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2769 child_die
= sibling_die (child_die
);
2774 TYPE_NFIELDS (type
) = num_fields
;
2775 TYPE_FIELDS (type
) = (struct field
*)
2776 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2777 memcpy (TYPE_FIELDS (type
), fields
,
2778 sizeof (struct field
) * num_fields
);
2782 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2785 new_symbol (die
, type
, objfile
, cu_header
);
2788 /* Extract all information from a DW_TAG_array_type DIE and put it in
2789 the DIE's type field. For now, this only handles one dimensional
2793 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2794 const struct comp_unit_head
*cu_header
)
2796 struct die_info
*child_die
;
2797 struct type
*type
= NULL
;
2798 struct type
*element_type
, *range_type
, *index_type
;
2799 struct type
**range_types
= NULL
;
2800 struct attribute
*attr
;
2802 struct cleanup
*back_to
;
2804 /* Return if we've already decoded this type. */
2810 element_type
= die_type (die
, objfile
, cu_header
);
2812 /* Irix 6.2 native cc creates array types without children for
2813 arrays with unspecified length. */
2814 if (die
->has_children
== 0)
2816 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2817 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2818 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2822 back_to
= make_cleanup (null_cleanup
, NULL
);
2823 child_die
= die
->next
;
2824 while (child_die
&& child_die
->tag
)
2826 if (child_die
->tag
== DW_TAG_subrange_type
)
2828 unsigned int low
, high
;
2830 /* Default bounds to an array with unspecified length. */
2833 if (cu_language
== language_fortran
)
2835 /* FORTRAN implies a lower bound of 1, if not given. */
2839 index_type
= die_type (child_die
, objfile
, cu_header
);
2840 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2843 if (attr
->form
== DW_FORM_sdata
)
2845 low
= DW_SND (attr
);
2847 else if (attr
->form
== DW_FORM_udata
2848 || attr
->form
== DW_FORM_data1
2849 || attr
->form
== DW_FORM_data2
2850 || attr
->form
== DW_FORM_data4
2851 || attr
->form
== DW_FORM_data8
)
2853 low
= DW_UNSND (attr
);
2857 complain (&dwarf2_non_const_array_bound_ignored
,
2858 dwarf_form_name (attr
->form
));
2860 die
->type
= lookup_pointer_type (element_type
);
2867 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2870 if (attr
->form
== DW_FORM_sdata
)
2872 high
= DW_SND (attr
);
2874 else if (attr
->form
== DW_FORM_udata
2875 || attr
->form
== DW_FORM_data1
2876 || attr
->form
== DW_FORM_data2
2877 || attr
->form
== DW_FORM_data4
2878 || attr
->form
== DW_FORM_data8
)
2880 high
= DW_UNSND (attr
);
2882 else if (attr
->form
== DW_FORM_block1
)
2884 /* GCC encodes arrays with unspecified or dynamic length
2885 with a DW_FORM_block1 attribute.
2886 FIXME: GDB does not yet know how to handle dynamic
2887 arrays properly, treat them as arrays with unspecified
2893 complain (&dwarf2_non_const_array_bound_ignored
,
2894 dwarf_form_name (attr
->form
));
2896 die
->type
= lookup_pointer_type (element_type
);
2904 /* Create a range type and save it for array type creation. */
2905 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2907 range_types
= (struct type
**)
2908 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2909 * sizeof (struct type
*));
2911 make_cleanup (free_current_contents
, &range_types
);
2913 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2915 child_die
= sibling_die (child_die
);
2918 /* Dwarf2 dimensions are output from left to right, create the
2919 necessary array types in backwards order. */
2920 type
= element_type
;
2922 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2924 /* Understand Dwarf2 support for vector types (like they occur on
2925 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
2926 array type. This is not part of the Dwarf2/3 standard yet, but a
2927 custom vendor extension. The main difference between a regular
2928 array and the vector variant is that vectors are passed by value
2930 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
2932 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
2934 do_cleanups (back_to
);
2936 /* Install the type in the die. */
2940 /* First cut: install each common block member as a global variable. */
2943 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
2944 const struct comp_unit_head
*cu_header
)
2946 struct die_info
*child_die
;
2947 struct attribute
*attr
;
2949 CORE_ADDR base
= (CORE_ADDR
) 0;
2951 attr
= dwarf_attr (die
, DW_AT_location
);
2954 /* Support the .debug_loc offsets */
2955 if (attr_form_is_block (attr
))
2957 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2959 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2961 complain (&dwarf2_complex_location_expr
);
2965 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
2966 "common block member");
2969 if (die
->has_children
)
2971 child_die
= die
->next
;
2972 while (child_die
&& child_die
->tag
)
2974 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
2975 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2978 SYMBOL_VALUE_ADDRESS (sym
) =
2979 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2980 add_symbol_to_list (sym
, &global_symbols
);
2982 child_die
= sibling_die (child_die
);
2987 /* Read a C++ namespace. */
2989 /* FIXME: carlton/2002-10-16: For now, we don't actually do anything
2990 useful with the namespace data: we just process its children. */
2993 read_namespace (struct die_info
*die
, struct objfile
*objfile
,
2994 const struct comp_unit_head
*cu_header
)
2996 if (die
->has_children
)
2998 struct die_info
*child_die
= die
->next
;
3000 while (child_die
&& child_die
->tag
)
3002 process_die (child_die
, objfile
, cu_header
);
3003 child_die
= sibling_die (child_die
);
3008 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3009 the user defined type vector. */
3012 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
3013 const struct comp_unit_head
*cu_header
)
3016 struct attribute
*attr_byte_size
;
3017 struct attribute
*attr_address_class
;
3018 int byte_size
, addr_class
;
3025 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
3027 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
3029 byte_size
= DW_UNSND (attr_byte_size
);
3031 byte_size
= cu_header
->addr_size
;
3033 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
3034 if (attr_address_class
)
3035 addr_class
= DW_UNSND (attr_address_class
);
3037 addr_class
= DW_ADDR_none
;
3039 /* If the pointer size or address class is different than the
3040 default, create a type variant marked as such and set the
3041 length accordingly. */
3042 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3044 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3048 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3049 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3050 type
= make_type_with_address_space (type
, type_flags
);
3052 else if (TYPE_LENGTH (type
) != byte_size
)
3054 complain (&dwarf2_invalid_pointer_size
, byte_size
);
3057 /* Should we also complain about unhandled address classes? */
3061 TYPE_LENGTH (type
) = byte_size
;
3065 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3066 the user defined type vector. */
3069 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
3070 const struct comp_unit_head
*cu_header
)
3073 struct type
*to_type
;
3074 struct type
*domain
;
3081 type
= alloc_type (objfile
);
3082 to_type
= die_type (die
, objfile
, cu_header
);
3083 domain
= die_containing_type (die
, objfile
, cu_header
);
3084 smash_to_member_type (type
, domain
, to_type
);
3089 /* Extract all information from a DW_TAG_reference_type DIE and add to
3090 the user defined type vector. */
3093 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
3094 const struct comp_unit_head
*cu_header
)
3097 struct attribute
*attr
;
3104 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
3105 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3108 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3112 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3118 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
3119 const struct comp_unit_head
*cu_header
)
3121 struct type
*base_type
;
3128 base_type
= die_type (die
, objfile
, cu_header
);
3129 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3133 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
3134 const struct comp_unit_head
*cu_header
)
3136 struct type
*base_type
;
3143 base_type
= die_type (die
, objfile
, cu_header
);
3144 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3147 /* Extract all information from a DW_TAG_string_type DIE and add to
3148 the user defined type vector. It isn't really a user defined type,
3149 but it behaves like one, with other DIE's using an AT_user_def_type
3150 attribute to reference it. */
3153 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
3155 struct type
*type
, *range_type
, *index_type
, *char_type
;
3156 struct attribute
*attr
;
3157 unsigned int length
;
3164 attr
= dwarf_attr (die
, DW_AT_string_length
);
3167 length
= DW_UNSND (attr
);
3171 /* check for the DW_AT_byte_size attribute */
3172 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3175 length
= DW_UNSND (attr
);
3182 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3183 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3184 if (cu_language
== language_fortran
)
3186 /* Need to create a unique string type for bounds
3188 type
= create_string_type (0, range_type
);
3192 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3193 type
= create_string_type (char_type
, range_type
);
3198 /* Handle DIES due to C code like:
3202 int (*funcp)(int a, long l);
3206 ('funcp' generates a DW_TAG_subroutine_type DIE)
3210 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
3211 const struct comp_unit_head
*cu_header
)
3213 struct type
*type
; /* Type that this function returns */
3214 struct type
*ftype
; /* Function that returns above type */
3215 struct attribute
*attr
;
3217 /* Decode the type that this subroutine returns */
3222 type
= die_type (die
, objfile
, cu_header
);
3223 ftype
= lookup_function_type (type
);
3225 /* All functions in C++ have prototypes. */
3226 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3227 if ((attr
&& (DW_UNSND (attr
) != 0))
3228 || cu_language
== language_cplus
)
3229 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3231 if (die
->has_children
)
3233 struct die_info
*child_die
;
3237 /* Count the number of parameters.
3238 FIXME: GDB currently ignores vararg functions, but knows about
3239 vararg member functions. */
3240 child_die
= die
->next
;
3241 while (child_die
&& child_die
->tag
)
3243 if (child_die
->tag
== DW_TAG_formal_parameter
)
3245 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3246 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3247 child_die
= sibling_die (child_die
);
3250 /* Allocate storage for parameters and fill them in. */
3251 TYPE_NFIELDS (ftype
) = nparams
;
3252 TYPE_FIELDS (ftype
) = (struct field
*)
3253 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3255 child_die
= die
->next
;
3256 while (child_die
&& child_die
->tag
)
3258 if (child_die
->tag
== DW_TAG_formal_parameter
)
3260 /* Dwarf2 has no clean way to discern C++ static and non-static
3261 member functions. G++ helps GDB by marking the first
3262 parameter for non-static member functions (which is the
3263 this pointer) as artificial. We pass this information
3264 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3265 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3267 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3269 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3270 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
3274 child_die
= sibling_die (child_die
);
3282 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
3283 const struct comp_unit_head
*cu_header
)
3285 struct attribute
*attr
;
3290 attr
= dwarf_attr (die
, DW_AT_name
);
3291 if (attr
&& DW_STRING (attr
))
3293 name
= DW_STRING (attr
);
3295 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3296 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
3300 /* Find a representation of a given base type and install
3301 it in the TYPE field of the die. */
3304 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
3307 struct attribute
*attr
;
3308 int encoding
= 0, size
= 0;
3310 /* If we've already decoded this die, this is a no-op. */
3316 attr
= dwarf_attr (die
, DW_AT_encoding
);
3319 encoding
= DW_UNSND (attr
);
3321 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3324 size
= DW_UNSND (attr
);
3326 attr
= dwarf_attr (die
, DW_AT_name
);
3327 if (attr
&& DW_STRING (attr
))
3329 enum type_code code
= TYPE_CODE_INT
;
3334 case DW_ATE_address
:
3335 /* Turn DW_ATE_address into a void * pointer. */
3336 code
= TYPE_CODE_PTR
;
3337 type_flags
|= TYPE_FLAG_UNSIGNED
;
3339 case DW_ATE_boolean
:
3340 code
= TYPE_CODE_BOOL
;
3341 type_flags
|= TYPE_FLAG_UNSIGNED
;
3343 case DW_ATE_complex_float
:
3344 code
= TYPE_CODE_COMPLEX
;
3347 code
= TYPE_CODE_FLT
;
3350 case DW_ATE_signed_char
:
3352 case DW_ATE_unsigned
:
3353 case DW_ATE_unsigned_char
:
3354 type_flags
|= TYPE_FLAG_UNSIGNED
;
3357 complain (&dwarf2_unsupported_at_encoding
,
3358 dwarf_type_encoding_name (encoding
));
3361 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3362 if (encoding
== DW_ATE_address
)
3363 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3364 else if (encoding
== DW_ATE_complex_float
)
3367 TYPE_TARGET_TYPE (type
)
3368 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3369 else if (size
== 16)
3370 TYPE_TARGET_TYPE (type
)
3371 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3373 TYPE_TARGET_TYPE (type
)
3374 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3379 type
= dwarf_base_type (encoding
, size
, objfile
);
3384 /* Read a whole compilation unit into a linked list of dies. */
3386 static struct die_info
*
3387 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3388 const struct comp_unit_head
*cu_header
)
3390 struct die_info
*first_die
, *last_die
, *die
;
3394 /* Reset die reference table; we are
3395 building new ones now. */
3396 dwarf2_empty_hash_tables ();
3400 first_die
= last_die
= NULL
;
3403 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3404 if (die
->has_children
)
3415 /* Enter die in reference hash table */
3416 store_in_ref_table (die
->offset
, die
);
3420 first_die
= last_die
= die
;
3424 last_die
->next
= die
;
3428 while (nesting_level
> 0);
3432 /* Free a linked list of dies. */
3435 free_die_list (struct die_info
*dies
)
3437 struct die_info
*die
, *next
;
3450 do_free_die_list_cleanup (void *dies
)
3452 free_die_list (dies
);
3455 static struct cleanup
*
3456 make_cleanup_free_die_list (struct die_info
*dies
)
3458 return make_cleanup (do_free_die_list_cleanup
, dies
);
3462 /* Read the contents of the section at OFFSET and of size SIZE from the
3463 object file specified by OBJFILE into the psymbol_obstack and return it. */
3466 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3469 bfd
*abfd
= objfile
->obfd
;
3475 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3476 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3477 (bfd_bread (buf
, size
, abfd
) != size
))
3480 error ("Dwarf Error: Can't read DWARF data from '%s'",
3481 bfd_get_filename (abfd
));
3486 /* In DWARF version 2, the description of the debugging information is
3487 stored in a separate .debug_abbrev section. Before we read any
3488 dies from a section we read in all abbreviations and install them
3492 dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
)
3495 struct abbrev_info
*cur_abbrev
;
3496 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3497 unsigned int abbrev_form
, hash_number
;
3499 /* Initialize dwarf2 abbrevs */
3500 memset (cu_header
->dwarf2_abbrevs
, 0,
3501 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
3503 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
3504 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3505 abbrev_ptr
+= bytes_read
;
3507 /* loop until we reach an abbrev number of 0 */
3508 while (abbrev_number
)
3510 cur_abbrev
= dwarf_alloc_abbrev ();
3512 /* read in abbrev header */
3513 cur_abbrev
->number
= abbrev_number
;
3514 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3515 abbrev_ptr
+= bytes_read
;
3516 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3519 /* now read in declarations */
3520 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3521 abbrev_ptr
+= bytes_read
;
3522 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3523 abbrev_ptr
+= bytes_read
;
3526 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3528 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3529 xrealloc (cur_abbrev
->attrs
,
3530 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3531 * sizeof (struct attr_abbrev
));
3533 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3534 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3535 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3536 abbrev_ptr
+= bytes_read
;
3537 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3538 abbrev_ptr
+= bytes_read
;
3541 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3542 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
3543 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3545 /* Get next abbreviation.
3546 Under Irix6 the abbreviations for a compilation unit are not
3547 always properly terminated with an abbrev number of 0.
3548 Exit loop if we encounter an abbreviation which we have
3549 already read (which means we are about to read the abbreviations
3550 for the next compile unit) or if the end of the abbreviation
3551 table is reached. */
3552 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3553 >= dwarf_abbrev_size
)
3555 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3556 abbrev_ptr
+= bytes_read
;
3557 if (dwarf2_lookup_abbrev (abbrev_number
, cu_header
) != NULL
)
3562 /* Empty the abbrev table for a new compilation unit. */
3566 dwarf2_empty_abbrev_table (PTR ptr_to_abbrevs_table
)
3569 struct abbrev_info
*abbrev
, *next
;
3570 struct abbrev_info
**abbrevs
;
3572 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
3574 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3577 abbrev
= abbrevs
[i
];
3580 next
= abbrev
->next
;
3581 xfree (abbrev
->attrs
);
3589 /* Lookup an abbrev_info structure in the abbrev hash table. */
3591 static struct abbrev_info
*
3592 dwarf2_lookup_abbrev (unsigned int number
, const struct comp_unit_head
*cu_header
)
3594 unsigned int hash_number
;
3595 struct abbrev_info
*abbrev
;
3597 hash_number
= number
% ABBREV_HASH_SIZE
;
3598 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
3602 if (abbrev
->number
== number
)
3605 abbrev
= abbrev
->next
;
3610 /* Read a minimal amount of information into the minimal die structure. */
3613 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3614 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3616 unsigned int abbrev_number
, bytes_read
, i
;
3617 struct abbrev_info
*abbrev
;
3618 struct attribute attr
;
3619 struct attribute spec_attr
;
3620 int found_spec_attr
= 0;
3621 int has_low_pc_attr
= 0;
3622 int has_high_pc_attr
= 0;
3624 *part_die
= zeroed_partial_die
;
3625 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3626 info_ptr
+= bytes_read
;
3630 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3633 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3635 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3636 part_die
->tag
= abbrev
->tag
;
3637 part_die
->has_children
= abbrev
->has_children
;
3638 part_die
->abbrev
= abbrev_number
;
3640 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3642 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3643 info_ptr
, cu_header
);
3645 /* Store the data if it is of an attribute we want to keep in a
3646 partial symbol table. */
3651 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3652 if (part_die
->name
== NULL
)
3653 part_die
->name
= DW_STRING (&attr
);
3655 case DW_AT_MIPS_linkage_name
:
3656 part_die
->name
= DW_STRING (&attr
);
3659 has_low_pc_attr
= 1;
3660 part_die
->lowpc
= DW_ADDR (&attr
);
3663 has_high_pc_attr
= 1;
3664 part_die
->highpc
= DW_ADDR (&attr
);
3666 case DW_AT_location
:
3667 /* Support the .debug_loc offsets */
3668 if (attr_form_is_block (&attr
))
3670 part_die
->locdesc
= DW_BLOCK (&attr
);
3672 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
3674 complain (&dwarf2_complex_location_expr
);
3678 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
3679 "partial symbol information");
3682 case DW_AT_language
:
3683 part_die
->language
= DW_UNSND (&attr
);
3685 case DW_AT_external
:
3686 part_die
->is_external
= DW_UNSND (&attr
);
3688 case DW_AT_declaration
:
3689 part_die
->is_declaration
= DW_UNSND (&attr
);
3692 part_die
->has_type
= 1;
3694 case DW_AT_abstract_origin
:
3695 case DW_AT_specification
:
3696 found_spec_attr
= 1;
3700 /* Ignore absolute siblings, they might point outside of
3701 the current compile unit. */
3702 if (attr
.form
== DW_FORM_ref_addr
)
3703 complain (&dwarf2_absolute_sibling_complaint
);
3706 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3713 /* If we found a reference attribute and the die has no name, try
3714 to find a name in the referred to die. */
3716 if (found_spec_attr
&& part_die
->name
== NULL
)
3718 struct partial_die_info spec_die
;
3722 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3723 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3726 part_die
->name
= spec_die
.name
;
3728 /* Copy DW_AT_external attribute if it is set. */
3729 if (spec_die
.is_external
)
3730 part_die
->is_external
= spec_die
.is_external
;
3734 /* When using the GNU linker, .gnu.linkonce. sections are used to
3735 eliminate duplicate copies of functions and vtables and such.
3736 The linker will arbitrarily choose one and discard the others.
3737 The AT_*_pc values for such functions refer to local labels in
3738 these sections. If the section from that file was discarded, the
3739 labels are not in the output, so the relocs get a value of 0.
3740 If this is a discarded function, mark the pc bounds as invalid,
3741 so that GDB will ignore it. */
3742 if (has_low_pc_attr
&& has_high_pc_attr
3743 && part_die
->lowpc
< part_die
->highpc
3744 && (part_die
->lowpc
!= 0
3745 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3746 part_die
->has_pc_info
= 1;
3750 /* Read the die from the .debug_info section buffer. And set diep to
3751 point to a newly allocated die with its information. */
3754 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3755 const struct comp_unit_head
*cu_header
)
3757 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3758 struct abbrev_info
*abbrev
;
3759 struct die_info
*die
;
3761 offset
= info_ptr
- dwarf_info_buffer
;
3762 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3763 info_ptr
+= bytes_read
;
3766 die
= dwarf_alloc_die ();
3768 die
->abbrev
= abbrev_number
;
3774 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3777 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3779 die
= dwarf_alloc_die ();
3780 die
->offset
= offset
;
3781 die
->tag
= abbrev
->tag
;
3782 die
->has_children
= abbrev
->has_children
;
3783 die
->abbrev
= abbrev_number
;
3786 die
->num_attrs
= abbrev
->num_attrs
;
3787 die
->attrs
= (struct attribute
*)
3788 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3790 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3792 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3793 abfd
, info_ptr
, cu_header
);
3800 /* Read an attribute value described by an attribute form. */
3803 read_attribute_value (struct attribute
*attr
, unsigned form
,
3804 bfd
*abfd
, char *info_ptr
,
3805 const struct comp_unit_head
*cu_header
)
3807 unsigned int bytes_read
;
3808 struct dwarf_block
*blk
;
3814 case DW_FORM_ref_addr
:
3815 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3816 info_ptr
+= bytes_read
;
3818 case DW_FORM_block2
:
3819 blk
= dwarf_alloc_block ();
3820 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3822 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3823 info_ptr
+= blk
->size
;
3824 DW_BLOCK (attr
) = blk
;
3826 case DW_FORM_block4
:
3827 blk
= dwarf_alloc_block ();
3828 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3830 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3831 info_ptr
+= blk
->size
;
3832 DW_BLOCK (attr
) = blk
;
3835 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3839 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3843 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3846 case DW_FORM_string
:
3847 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3848 info_ptr
+= bytes_read
;
3851 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
3853 info_ptr
+= bytes_read
;
3856 blk
= dwarf_alloc_block ();
3857 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3858 info_ptr
+= bytes_read
;
3859 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3860 info_ptr
+= blk
->size
;
3861 DW_BLOCK (attr
) = blk
;
3863 case DW_FORM_block1
:
3864 blk
= dwarf_alloc_block ();
3865 blk
->size
= read_1_byte (abfd
, info_ptr
);
3867 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3868 info_ptr
+= blk
->size
;
3869 DW_BLOCK (attr
) = blk
;
3872 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3876 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3880 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3881 info_ptr
+= bytes_read
;
3884 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3885 info_ptr
+= bytes_read
;
3888 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3892 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3896 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3900 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3903 case DW_FORM_ref_udata
:
3904 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3905 info_ptr
+= bytes_read
;
3907 case DW_FORM_indirect
:
3908 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3909 info_ptr
+= bytes_read
;
3910 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
3913 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3914 dwarf_form_name (form
));
3919 /* Read an attribute described by an abbreviated attribute. */
3922 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
3923 bfd
*abfd
, char *info_ptr
,
3924 const struct comp_unit_head
*cu_header
)
3926 attr
->name
= abbrev
->name
;
3927 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
3930 /* read dwarf information from a buffer */
3933 read_1_byte (bfd
*abfd
, char *buf
)
3935 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3939 read_1_signed_byte (bfd
*abfd
, char *buf
)
3941 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3945 read_2_bytes (bfd
*abfd
, char *buf
)
3947 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3951 read_2_signed_bytes (bfd
*abfd
, char *buf
)
3953 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3957 read_4_bytes (bfd
*abfd
, char *buf
)
3959 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3963 read_4_signed_bytes (bfd
*abfd
, char *buf
)
3965 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3968 static unsigned long
3969 read_8_bytes (bfd
*abfd
, char *buf
)
3971 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3975 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3978 CORE_ADDR retval
= 0;
3980 if (cu_header
->signed_addr_p
)
3982 switch (cu_header
->addr_size
)
3985 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3988 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3991 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
3994 internal_error (__FILE__
, __LINE__
,
3995 "read_address: bad switch, signed");
4000 switch (cu_header
->addr_size
)
4003 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4006 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4009 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4012 internal_error (__FILE__
, __LINE__
,
4013 "read_address: bad switch, unsigned");
4017 *bytes_read
= cu_header
->addr_size
;
4021 /* Read the initial length from a section. The (draft) DWARF 3
4022 specification allows the initial length to take up either 4 bytes
4023 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4024 bytes describe the length and all offsets will be 8 bytes in length
4027 An older, non-standard 64-bit format is also handled by this
4028 function. The older format in question stores the initial length
4029 as an 8-byte quantity without an escape value. Lengths greater
4030 than 2^32 aren't very common which means that the initial 4 bytes
4031 is almost always zero. Since a length value of zero doesn't make
4032 sense for the 32-bit format, this initial zero can be considered to
4033 be an escape value which indicates the presence of the older 64-bit
4034 format. As written, the code can't detect (old format) lengths
4035 greater than 4GB. If it becomes necessary to handle lengths somewhat
4036 larger than 4GB, we could allow other small values (such as the
4037 non-sensical values of 1, 2, and 3) to also be used as escape values
4038 indicating the presence of the old format.
4040 The value returned via bytes_read should be used to increment
4041 the relevant pointer after calling read_initial_length().
4043 As a side effect, this function sets the fields initial_length_size
4044 and offset_size in cu_header to the values appropriate for the
4045 length field. (The format of the initial length field determines
4046 the width of file offsets to be fetched later with fetch_offset().)
4048 [ Note: read_initial_length() and read_offset() are based on the
4049 document entitled "DWARF Debugging Information Format", revision
4050 3, draft 8, dated November 19, 2001. This document was obtained
4053 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4055 This document is only a draft and is subject to change. (So beware.)
4057 Details regarding the older, non-standard 64-bit format were
4058 determined empirically by examining 64-bit ELF files produced
4059 by the SGI toolchain on an IRIX 6.5 machine.
4061 - Kevin, July 16, 2002
4065 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4070 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4072 if (retval
== 0xffffffff)
4074 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4076 if (cu_header
!= NULL
)
4078 cu_header
->initial_length_size
= 12;
4079 cu_header
->offset_size
= 8;
4082 else if (retval
== 0)
4084 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4086 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4088 if (cu_header
!= NULL
)
4090 cu_header
->initial_length_size
= 8;
4091 cu_header
->offset_size
= 8;
4097 if (cu_header
!= NULL
)
4099 cu_header
->initial_length_size
= 4;
4100 cu_header
->offset_size
= 4;
4107 /* Read an offset from the data stream. The size of the offset is
4108 given by cu_header->offset_size. */
4111 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4116 switch (cu_header
->offset_size
)
4119 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4123 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4127 internal_error (__FILE__
, __LINE__
,
4128 "read_offset: bad switch");
4135 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4137 /* If the size of a host char is 8 bits, we can return a pointer
4138 to the buffer, otherwise we have to copy the data to a buffer
4139 allocated on the temporary obstack. */
4140 gdb_assert (HOST_CHAR_BIT
== 8);
4145 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4147 /* If the size of a host char is 8 bits, we can return a pointer
4148 to the string, otherwise we have to copy the string to a buffer
4149 allocated on the temporary obstack. */
4150 gdb_assert (HOST_CHAR_BIT
== 8);
4153 *bytes_read_ptr
= 1;
4156 *bytes_read_ptr
= strlen (buf
) + 1;
4161 read_indirect_string (bfd
*abfd
, char *buf
,
4162 const struct comp_unit_head
*cu_header
,
4163 unsigned int *bytes_read_ptr
)
4165 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4166 (int *) bytes_read_ptr
);
4168 if (dwarf_str_buffer
== NULL
)
4170 error ("DW_FORM_strp used without .debug_str section");
4173 if (str_offset
>= dwarf_str_size
)
4175 error ("DW_FORM_strp pointing outside of .debug_str section");
4178 gdb_assert (HOST_CHAR_BIT
== 8);
4179 if (dwarf_str_buffer
[str_offset
] == '\0')
4181 return dwarf_str_buffer
+ str_offset
;
4184 static unsigned long
4185 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4187 unsigned long result
;
4188 unsigned int num_read
;
4198 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4201 result
|= ((unsigned long)(byte
& 127) << shift
);
4202 if ((byte
& 128) == 0)
4208 *bytes_read_ptr
= num_read
;
4213 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4216 int i
, shift
, size
, num_read
;
4226 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4229 result
|= ((long)(byte
& 127) << shift
);
4231 if ((byte
& 128) == 0)
4236 if ((shift
< size
) && (byte
& 0x40))
4238 result
|= -(1 << shift
);
4240 *bytes_read_ptr
= num_read
;
4245 set_cu_language (unsigned int lang
)
4251 cu_language
= language_c
;
4253 case DW_LANG_C_plus_plus
:
4254 cu_language
= language_cplus
;
4256 case DW_LANG_Fortran77
:
4257 case DW_LANG_Fortran90
:
4258 case DW_LANG_Fortran95
:
4259 cu_language
= language_fortran
;
4261 case DW_LANG_Mips_Assembler
:
4262 cu_language
= language_asm
;
4265 cu_language
= language_java
;
4269 case DW_LANG_Cobol74
:
4270 case DW_LANG_Cobol85
:
4271 case DW_LANG_Pascal83
:
4272 case DW_LANG_Modula2
:
4274 cu_language
= language_unknown
;
4277 cu_language_defn
= language_def (cu_language
);
4280 /* Return the named attribute or NULL if not there. */
4282 static struct attribute
*
4283 dwarf_attr (struct die_info
*die
, unsigned int name
)
4286 struct attribute
*spec
= NULL
;
4288 for (i
= 0; i
< die
->num_attrs
; ++i
)
4290 if (die
->attrs
[i
].name
== name
)
4292 return &die
->attrs
[i
];
4294 if (die
->attrs
[i
].name
== DW_AT_specification
4295 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4296 spec
= &die
->attrs
[i
];
4300 struct die_info
*ref_die
=
4301 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4304 return dwarf_attr (ref_die
, name
);
4311 die_is_declaration (struct die_info
*die
)
4313 return (dwarf_attr (die
, DW_AT_declaration
)
4314 && ! dwarf_attr (die
, DW_AT_specification
));
4318 /* Free the line_header structure *LH, and any arrays and strings it
4321 free_line_header (struct line_header
*lh
)
4323 if (lh
->standard_opcode_lengths
)
4324 xfree (lh
->standard_opcode_lengths
);
4326 /* Remember that all the lh->file_names[i].name pointers are
4327 pointers into debug_line_buffer, and don't need to be freed. */
4329 xfree (lh
->file_names
);
4331 /* Similarly for the include directory names. */
4332 if (lh
->include_dirs
)
4333 xfree (lh
->include_dirs
);
4339 /* Add an entry to LH's include directory table. */
4341 add_include_dir (struct line_header
*lh
, char *include_dir
)
4343 /* Grow the array if necessary. */
4344 if (lh
->include_dirs_size
== 0)
4346 lh
->include_dirs_size
= 1; /* for testing */
4347 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4348 * sizeof (*lh
->include_dirs
));
4350 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4352 lh
->include_dirs_size
*= 2;
4353 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4354 (lh
->include_dirs_size
4355 * sizeof (*lh
->include_dirs
)));
4358 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4362 /* Add an entry to LH's file name table. */
4364 add_file_name (struct line_header
*lh
,
4366 unsigned int dir_index
,
4367 unsigned int mod_time
,
4368 unsigned int length
)
4370 struct file_entry
*fe
;
4372 /* Grow the array if necessary. */
4373 if (lh
->file_names_size
== 0)
4375 lh
->file_names_size
= 1; /* for testing */
4376 lh
->file_names
= xmalloc (lh
->file_names_size
4377 * sizeof (*lh
->file_names
));
4379 else if (lh
->num_file_names
>= lh
->file_names_size
)
4381 lh
->file_names_size
*= 2;
4382 lh
->file_names
= xrealloc (lh
->file_names
,
4383 (lh
->file_names_size
4384 * sizeof (*lh
->file_names
)));
4387 fe
= &lh
->file_names
[lh
->num_file_names
++];
4389 fe
->dir_index
= dir_index
;
4390 fe
->mod_time
= mod_time
;
4391 fe
->length
= length
;
4395 /* Read the statement program header starting at OFFSET in
4396 dwarf_line_buffer, according to the endianness of ABFD. Return a
4397 pointer to a struct line_header, allocated using xmalloc.
4399 NOTE: the strings in the include directory and file name tables of
4400 the returned object point into debug_line_buffer, and must not be
4402 static struct line_header
*
4403 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4404 const struct comp_unit_head
*cu_header
)
4406 struct cleanup
*back_to
;
4407 struct line_header
*lh
;
4411 char *cur_dir
, *cur_file
;
4413 if (dwarf_line_buffer
== NULL
)
4415 complain (&dwarf2_missing_line_number_section
);
4419 /* Make sure that at least there's room for the total_length field. That
4420 could be 12 bytes long, but we're just going to fudge that. */
4421 if (offset
+ 4 >= dwarf_line_size
)
4423 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4427 lh
= xmalloc (sizeof (*lh
));
4428 memset (lh
, 0, sizeof (*lh
));
4429 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4432 line_ptr
= dwarf_line_buffer
+ offset
;
4434 /* read in the header */
4435 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4436 line_ptr
+= bytes_read
;
4437 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4439 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4442 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4443 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4445 lh
->header_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
4446 line_ptr
+= bytes_read
;
4447 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4449 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4451 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4453 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4455 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4457 lh
->standard_opcode_lengths
4458 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4460 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4461 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4463 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4467 /* Read directory table */
4468 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4470 line_ptr
+= bytes_read
;
4471 add_include_dir (lh
, cur_dir
);
4473 line_ptr
+= bytes_read
;
4475 /* Read file name table */
4476 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4478 unsigned int dir_index
, mod_time
, length
;
4480 line_ptr
+= bytes_read
;
4481 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4482 line_ptr
+= bytes_read
;
4483 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4484 line_ptr
+= bytes_read
;
4485 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4486 line_ptr
+= bytes_read
;
4488 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4490 line_ptr
+= bytes_read
;
4491 lh
->statement_program_start
= line_ptr
;
4493 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4494 complain (&dwarf2_line_header_too_long
);
4496 discard_cleanups (back_to
);
4500 /* This function exists to work around a bug in certain compilers
4501 (particularly GCC 2.95), in which the first line number marker of a
4502 function does not show up until after the prologue, right before
4503 the second line number marker. This function shifts ADDRESS down
4504 to the beginning of the function if necessary, and is called on
4505 addresses passed to record_line. */
4508 check_cu_functions (CORE_ADDR address
)
4510 struct function_range
*fn
;
4512 /* Find the function_range containing address. */
4517 cu_cached_fn
= cu_first_fn
;
4521 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4527 while (fn
&& fn
!= cu_cached_fn
)
4528 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4538 if (address
!= fn
->lowpc
)
4539 complain (&dwarf2_misplaced_line_number
,
4540 (unsigned long) address
, fn
->name
);
4545 /* Decode the line number information for the compilation unit whose
4546 line number info is at OFFSET in the .debug_line section.
4547 The compilation directory of the file is passed in COMP_DIR. */
4550 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
4551 const struct comp_unit_head
*cu_header
)
4555 unsigned int i
, bytes_read
;
4557 unsigned char op_code
, extended_op
, adj_opcode
;
4559 line_ptr
= lh
->statement_program_start
;
4560 line_end
= lh
->statement_program_end
;
4562 /* Read the statement sequences until there's nothing left. */
4563 while (line_ptr
< line_end
)
4565 /* state machine registers */
4566 CORE_ADDR address
= 0;
4567 unsigned int file
= 1;
4568 unsigned int line
= 1;
4569 unsigned int column
= 0;
4570 int is_stmt
= lh
->default_is_stmt
;
4571 int basic_block
= 0;
4572 int end_sequence
= 0;
4574 /* Start a subfile for the current file of the state machine. */
4575 if (lh
->num_file_names
>= file
)
4577 /* lh->include_dirs and lh->file_names are 0-based, but the
4578 directory and file name numbers in the statement program
4580 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
4583 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4586 dwarf2_start_subfile (fe
->name
, dir
);
4589 /* Decode the table. */
4590 while (!end_sequence
)
4592 op_code
= read_1_byte (abfd
, line_ptr
);
4595 if (op_code
>= lh
->opcode_base
)
4596 { /* Special operand. */
4597 adj_opcode
= op_code
- lh
->opcode_base
;
4598 address
+= (adj_opcode
/ lh
->line_range
)
4599 * lh
->minimum_instruction_length
;
4600 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
4601 /* append row to matrix using current values */
4602 address
= check_cu_functions (address
);
4603 record_line (current_subfile
, line
, address
);
4606 else switch (op_code
)
4608 case DW_LNS_extended_op
:
4609 line_ptr
+= 1; /* ignore length */
4610 extended_op
= read_1_byte (abfd
, line_ptr
);
4612 switch (extended_op
)
4614 case DW_LNE_end_sequence
:
4616 record_line (current_subfile
, 0, address
);
4618 case DW_LNE_set_address
:
4619 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4620 line_ptr
+= bytes_read
;
4621 address
+= baseaddr
;
4623 case DW_LNE_define_file
:
4626 unsigned int dir_index
, mod_time
, length
;
4628 cur_file
= read_string (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
;
4637 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4638 line_ptr
+= bytes_read
;
4639 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4643 complain (&dwarf2_mangled_line_number_section
);
4648 address
= check_cu_functions (address
);
4649 record_line (current_subfile
, line
, address
);
4652 case DW_LNS_advance_pc
:
4653 address
+= lh
->minimum_instruction_length
4654 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4655 line_ptr
+= bytes_read
;
4657 case DW_LNS_advance_line
:
4658 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4659 line_ptr
+= bytes_read
;
4661 case DW_LNS_set_file
:
4663 /* lh->include_dirs and lh->file_names are 0-based,
4664 but the directory and file name numbers in the
4665 statement program are 1-based. */
4666 struct file_entry
*fe
;
4668 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4669 line_ptr
+= bytes_read
;
4670 fe
= &lh
->file_names
[file
- 1];
4672 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4675 dwarf2_start_subfile (fe
->name
, dir
);
4678 case DW_LNS_set_column
:
4679 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4680 line_ptr
+= bytes_read
;
4682 case DW_LNS_negate_stmt
:
4683 is_stmt
= (!is_stmt
);
4685 case DW_LNS_set_basic_block
:
4688 /* Add to the address register of the state machine the
4689 address increment value corresponding to special opcode
4690 255. Ie, this value is scaled by the minimum instruction
4691 length since special opcode 255 would have scaled the
4693 case DW_LNS_const_add_pc
:
4694 address
+= (lh
->minimum_instruction_length
4695 * ((255 - lh
->opcode_base
) / lh
->line_range
));
4697 case DW_LNS_fixed_advance_pc
:
4698 address
+= read_2_bytes (abfd
, line_ptr
);
4702 { /* Unknown standard opcode, ignore it. */
4704 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
4706 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4707 line_ptr
+= bytes_read
;
4715 /* Start a subfile for DWARF. FILENAME is the name of the file and
4716 DIRNAME the name of the source directory which contains FILENAME
4717 or NULL if not known.
4718 This routine tries to keep line numbers from identical absolute and
4719 relative file names in a common subfile.
4721 Using the `list' example from the GDB testsuite, which resides in
4722 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4723 of /srcdir/list0.c yields the following debugging information for list0.c:
4725 DW_AT_name: /srcdir/list0.c
4726 DW_AT_comp_dir: /compdir
4727 files.files[0].name: list0.h
4728 files.files[0].dir: /srcdir
4729 files.files[1].name: list0.c
4730 files.files[1].dir: /srcdir
4732 The line number information for list0.c has to end up in a single
4733 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4736 dwarf2_start_subfile (char *filename
, char *dirname
)
4738 /* If the filename isn't absolute, try to match an existing subfile
4739 with the full pathname. */
4741 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4743 struct subfile
*subfile
;
4744 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4746 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4748 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4750 current_subfile
= subfile
;
4757 start_subfile (filename
, dirname
);
4760 /* Given a pointer to a DWARF information entry, figure out if we need
4761 to make a symbol table entry for it, and if so, create a new entry
4762 and return a pointer to it.
4763 If TYPE is NULL, determine symbol type from the die, otherwise
4764 used the passed type. */
4766 static struct symbol
*
4767 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4768 const struct comp_unit_head
*cu_header
)
4770 struct symbol
*sym
= NULL
;
4772 struct attribute
*attr
= NULL
;
4773 struct attribute
*attr2
= NULL
;
4776 name
= dwarf2_linkage_name (die
);
4779 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4780 sizeof (struct symbol
));
4781 OBJSTAT (objfile
, n_syms
++);
4782 memset (sym
, 0, sizeof (struct symbol
));
4783 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4784 &objfile
->symbol_obstack
);
4786 /* Default assumptions.
4787 Use the passed type or decode it from the die. */
4788 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4789 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4791 SYMBOL_TYPE (sym
) = type
;
4793 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4794 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4797 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4800 /* If this symbol is from a C++ compilation, then attempt to
4801 cache the demangled form for future reference. This is a
4802 typical time versus space tradeoff, that was decided in favor
4803 of time because it sped up C++ symbol lookups by a factor of
4806 SYMBOL_LANGUAGE (sym
) = cu_language
;
4807 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4811 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4814 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4816 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4818 case DW_TAG_subprogram
:
4819 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4821 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4822 attr2
= dwarf_attr (die
, DW_AT_external
);
4823 if (attr2
&& (DW_UNSND (attr2
) != 0))
4825 add_symbol_to_list (sym
, &global_symbols
);
4829 add_symbol_to_list (sym
, list_in_scope
);
4832 case DW_TAG_variable
:
4833 /* Compilation with minimal debug info may result in variables
4834 with missing type entries. Change the misleading `void' type
4835 to something sensible. */
4836 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4837 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4838 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4839 "<variable, no debug info>",
4841 attr
= dwarf_attr (die
, DW_AT_const_value
);
4844 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4845 attr2
= dwarf_attr (die
, DW_AT_external
);
4846 if (attr2
&& (DW_UNSND (attr2
) != 0))
4847 add_symbol_to_list (sym
, &global_symbols
);
4849 add_symbol_to_list (sym
, list_in_scope
);
4852 attr
= dwarf_attr (die
, DW_AT_location
);
4855 attr2
= dwarf_attr (die
, DW_AT_external
);
4856 if (attr2
&& (DW_UNSND (attr2
) != 0))
4858 /* Support the .debug_loc offsets */
4859 if (attr_form_is_block (attr
))
4861 SYMBOL_VALUE_ADDRESS (sym
) =
4862 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4864 else if (attr
->form
== DW_FORM_data4
4865 || attr
->form
== DW_FORM_data8
)
4867 complain (&dwarf2_complex_location_expr
);
4871 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4872 "external variable");
4874 add_symbol_to_list (sym
, &global_symbols
);
4875 if (is_thread_local
)
4877 /* SYMBOL_VALUE_ADDRESS contains at this point the
4878 offset of the variable within the thread local
4880 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
4881 SYMBOL_OBJFILE (sym
) = objfile
;
4884 /* In shared libraries the address of the variable
4885 in the location descriptor might still be relocatable,
4886 so its value could be zero.
4887 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4888 value is zero, the address of the variable will then
4889 be determined from the minimal symbol table whenever
4890 the variable is referenced. */
4891 else if (SYMBOL_VALUE_ADDRESS (sym
))
4893 fixup_symbol_section (sym
, objfile
);
4894 SYMBOL_VALUE_ADDRESS (sym
) +=
4895 ANOFFSET (objfile
->section_offsets
,
4896 SYMBOL_SECTION (sym
));
4897 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4900 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4904 /* Support the .debug_loc offsets */
4905 if (attr_form_is_block (attr
))
4907 SYMBOL_VALUE (sym
) = addr
=
4908 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4910 else if (attr
->form
== DW_FORM_data4
4911 || attr
->form
== DW_FORM_data8
)
4913 complain (&dwarf2_complex_location_expr
);
4917 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4918 "external variable");
4921 add_symbol_to_list (sym
, list_in_scope
);
4924 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4928 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4929 SYMBOL_VALUE (sym
) =
4930 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4934 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4935 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4939 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4941 else if (is_thread_local
)
4943 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
4944 SYMBOL_OBJFILE (sym
) = objfile
;
4948 fixup_symbol_section (sym
, objfile
);
4949 SYMBOL_VALUE_ADDRESS (sym
) =
4950 addr
+ ANOFFSET (objfile
->section_offsets
,
4951 SYMBOL_SECTION (sym
));
4952 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4958 /* We do not know the address of this symbol.
4959 If it is an external symbol and we have type information
4960 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4961 The address of the variable will then be determined from
4962 the minimal symbol table whenever the variable is
4964 attr2
= dwarf_attr (die
, DW_AT_external
);
4965 if (attr2
&& (DW_UNSND (attr2
) != 0)
4966 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4968 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4969 add_symbol_to_list (sym
, &global_symbols
);
4973 case DW_TAG_formal_parameter
:
4974 attr
= dwarf_attr (die
, DW_AT_location
);
4977 SYMBOL_VALUE (sym
) =
4978 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4981 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4982 SYMBOL_VALUE (sym
) =
4983 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4989 if (basereg
!= frame_base_reg
)
4990 complain (&dwarf2_complex_location_expr
);
4991 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
4995 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4996 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
5001 SYMBOL_CLASS (sym
) = LOC_ARG
;
5004 attr
= dwarf_attr (die
, DW_AT_const_value
);
5007 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5009 add_symbol_to_list (sym
, list_in_scope
);
5011 case DW_TAG_unspecified_parameters
:
5012 /* From varargs functions; gdb doesn't seem to have any
5013 interest in this information, so just ignore it for now.
5016 case DW_TAG_class_type
:
5017 case DW_TAG_structure_type
:
5018 case DW_TAG_union_type
:
5019 case DW_TAG_enumeration_type
:
5020 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5021 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
5022 add_symbol_to_list (sym
, list_in_scope
);
5024 /* The semantics of C++ state that "struct foo { ... }" also
5025 defines a typedef for "foo". Synthesize a typedef symbol so
5026 that "ptype foo" works as expected. */
5027 if (cu_language
== language_cplus
)
5029 struct symbol
*typedef_sym
= (struct symbol
*)
5030 obstack_alloc (&objfile
->symbol_obstack
,
5031 sizeof (struct symbol
));
5032 *typedef_sym
= *sym
;
5033 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
5034 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5035 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5036 obsavestring (SYMBOL_NAME (sym
),
5037 strlen (SYMBOL_NAME (sym
)),
5038 &objfile
->type_obstack
);
5039 add_symbol_to_list (typedef_sym
, list_in_scope
);
5042 case DW_TAG_typedef
:
5043 case DW_TAG_base_type
:
5044 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5045 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
5046 add_symbol_to_list (sym
, list_in_scope
);
5048 case DW_TAG_enumerator
:
5049 attr
= dwarf_attr (die
, DW_AT_const_value
);
5052 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5054 add_symbol_to_list (sym
, list_in_scope
);
5057 /* Not a tag we recognize. Hopefully we aren't processing
5058 trash data, but since we must specifically ignore things
5059 we don't recognize, there is nothing else we should do at
5061 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
5068 /* Copy constant value from an attribute to a symbol. */
5071 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5072 struct objfile
*objfile
,
5073 const struct comp_unit_head
*cu_header
)
5075 struct dwarf_block
*blk
;
5080 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5081 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
5082 cu_header
->addr_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
5083 SYMBOL_VALUE_BYTES (sym
) = (char *)
5084 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5085 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5087 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5089 case DW_FORM_block1
:
5090 case DW_FORM_block2
:
5091 case DW_FORM_block4
:
5093 blk
= DW_BLOCK (attr
);
5094 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5095 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
5096 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
5097 SYMBOL_VALUE_BYTES (sym
) = (char *)
5098 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5099 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5100 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5103 /* The DW_AT_const_value attributes are supposed to carry the
5104 symbol's value "represented as it would be on the target
5105 architecture." By the time we get here, it's already been
5106 converted to host endianness, so we just need to sign- or
5107 zero-extend it as appropriate. */
5109 dwarf2_const_value_data (attr
, sym
, 8);
5112 dwarf2_const_value_data (attr
, sym
, 16);
5115 dwarf2_const_value_data (attr
, sym
, 32);
5118 dwarf2_const_value_data (attr
, sym
, 64);
5122 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5123 SYMBOL_CLASS (sym
) = LOC_CONST
;
5127 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5128 SYMBOL_CLASS (sym
) = LOC_CONST
;
5132 complain (&dwarf2_unsupported_const_value_attr
,
5133 dwarf_form_name (attr
->form
));
5134 SYMBOL_VALUE (sym
) = 0;
5135 SYMBOL_CLASS (sym
) = LOC_CONST
;
5141 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5142 or zero-extend it as appropriate for the symbol's type. */
5144 dwarf2_const_value_data (struct attribute
*attr
,
5148 LONGEST l
= DW_UNSND (attr
);
5150 if (bits
< sizeof (l
) * 8)
5152 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5153 l
&= ((LONGEST
) 1 << bits
) - 1;
5155 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5158 SYMBOL_VALUE (sym
) = l
;
5159 SYMBOL_CLASS (sym
) = LOC_CONST
;
5163 /* Return the type of the die in question using its DW_AT_type attribute. */
5165 static struct type
*
5166 die_type (struct die_info
*die
, struct objfile
*objfile
,
5167 const struct comp_unit_head
*cu_header
)
5170 struct attribute
*type_attr
;
5171 struct die_info
*type_die
;
5174 type_attr
= dwarf_attr (die
, DW_AT_type
);
5177 /* A missing DW_AT_type represents a void type. */
5178 return dwarf2_fundamental_type (objfile
, FT_VOID
);
5182 ref
= dwarf2_get_ref_die_offset (type_attr
);
5183 type_die
= follow_die_ref (ref
);
5186 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5190 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5193 dump_die (type_die
);
5194 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
5199 /* Return the containing type of the die in question using its
5200 DW_AT_containing_type attribute. */
5202 static struct type
*
5203 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
5204 const struct comp_unit_head
*cu_header
)
5206 struct type
*type
= NULL
;
5207 struct attribute
*type_attr
;
5208 struct die_info
*type_die
= NULL
;
5211 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5214 ref
= dwarf2_get_ref_die_offset (type_attr
);
5215 type_die
= follow_die_ref (ref
);
5218 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5221 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5226 dump_die (type_die
);
5227 error ("Dwarf Error: Problem turning containing type into gdb type.");
5233 static struct type
*
5234 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
5236 struct die_info
*die
;
5239 die
= follow_die_ref (offset
);
5242 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5245 type
= tag_type_to_type (die
, objfile
);
5250 static struct type
*
5251 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
5252 const struct comp_unit_head
*cu_header
)
5260 read_type_die (die
, objfile
, cu_header
);
5264 error ("Dwarf Error: Cannot find type of die.");
5271 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
5272 const struct comp_unit_head
*cu_header
)
5276 case DW_TAG_class_type
:
5277 case DW_TAG_structure_type
:
5278 case DW_TAG_union_type
:
5279 read_structure_scope (die
, objfile
, cu_header
);
5281 case DW_TAG_enumeration_type
:
5282 read_enumeration (die
, objfile
, cu_header
);
5284 case DW_TAG_subprogram
:
5285 case DW_TAG_subroutine_type
:
5286 read_subroutine_type (die
, objfile
, cu_header
);
5288 case DW_TAG_array_type
:
5289 read_array_type (die
, objfile
, cu_header
);
5291 case DW_TAG_pointer_type
:
5292 read_tag_pointer_type (die
, objfile
, cu_header
);
5294 case DW_TAG_ptr_to_member_type
:
5295 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
5297 case DW_TAG_reference_type
:
5298 read_tag_reference_type (die
, objfile
, cu_header
);
5300 case DW_TAG_const_type
:
5301 read_tag_const_type (die
, objfile
, cu_header
);
5303 case DW_TAG_volatile_type
:
5304 read_tag_volatile_type (die
, objfile
, cu_header
);
5306 case DW_TAG_string_type
:
5307 read_tag_string_type (die
, objfile
);
5309 case DW_TAG_typedef
:
5310 read_typedef (die
, objfile
, cu_header
);
5312 case DW_TAG_base_type
:
5313 read_base_type (die
, objfile
);
5316 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
5321 static struct type
*
5322 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
5324 /* FIXME - this should not produce a new (struct type *)
5325 every time. It should cache base types. */
5329 case DW_ATE_address
:
5330 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5332 case DW_ATE_boolean
:
5333 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5335 case DW_ATE_complex_float
:
5338 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5342 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5348 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5352 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5359 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5362 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5366 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5370 case DW_ATE_signed_char
:
5371 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5373 case DW_ATE_unsigned
:
5377 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5380 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5384 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5388 case DW_ATE_unsigned_char
:
5389 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5392 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5399 copy_die (struct die_info
*old_die
)
5401 struct die_info
*new_die
;
5404 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5405 memset (new_die
, 0, sizeof (struct die_info
));
5407 new_die
->tag
= old_die
->tag
;
5408 new_die
->has_children
= old_die
->has_children
;
5409 new_die
->abbrev
= old_die
->abbrev
;
5410 new_die
->offset
= old_die
->offset
;
5411 new_die
->type
= NULL
;
5413 num_attrs
= old_die
->num_attrs
;
5414 new_die
->num_attrs
= num_attrs
;
5415 new_die
->attrs
= (struct attribute
*)
5416 xmalloc (num_attrs
* sizeof (struct attribute
));
5418 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5420 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5421 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5422 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5425 new_die
->next
= NULL
;
5430 /* Return sibling of die, NULL if no sibling. */
5432 static struct die_info
*
5433 sibling_die (struct die_info
*die
)
5435 int nesting_level
= 0;
5437 if (!die
->has_children
)
5439 if (die
->next
&& (die
->next
->tag
== 0))
5452 if (die
->has_children
)
5462 while (nesting_level
);
5463 if (die
&& (die
->tag
== 0))
5474 /* Get linkage name of a die, return NULL if not found. */
5477 dwarf2_linkage_name (struct die_info
*die
)
5479 struct attribute
*attr
;
5481 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5482 if (attr
&& DW_STRING (attr
))
5483 return DW_STRING (attr
);
5484 attr
= dwarf_attr (die
, DW_AT_name
);
5485 if (attr
&& DW_STRING (attr
))
5486 return DW_STRING (attr
);
5490 /* Convert a DIE tag into its string name. */
5493 dwarf_tag_name (register unsigned tag
)
5497 case DW_TAG_padding
:
5498 return "DW_TAG_padding";
5499 case DW_TAG_array_type
:
5500 return "DW_TAG_array_type";
5501 case DW_TAG_class_type
:
5502 return "DW_TAG_class_type";
5503 case DW_TAG_entry_point
:
5504 return "DW_TAG_entry_point";
5505 case DW_TAG_enumeration_type
:
5506 return "DW_TAG_enumeration_type";
5507 case DW_TAG_formal_parameter
:
5508 return "DW_TAG_formal_parameter";
5509 case DW_TAG_imported_declaration
:
5510 return "DW_TAG_imported_declaration";
5512 return "DW_TAG_label";
5513 case DW_TAG_lexical_block
:
5514 return "DW_TAG_lexical_block";
5516 return "DW_TAG_member";
5517 case DW_TAG_pointer_type
:
5518 return "DW_TAG_pointer_type";
5519 case DW_TAG_reference_type
:
5520 return "DW_TAG_reference_type";
5521 case DW_TAG_compile_unit
:
5522 return "DW_TAG_compile_unit";
5523 case DW_TAG_string_type
:
5524 return "DW_TAG_string_type";
5525 case DW_TAG_structure_type
:
5526 return "DW_TAG_structure_type";
5527 case DW_TAG_subroutine_type
:
5528 return "DW_TAG_subroutine_type";
5529 case DW_TAG_typedef
:
5530 return "DW_TAG_typedef";
5531 case DW_TAG_union_type
:
5532 return "DW_TAG_union_type";
5533 case DW_TAG_unspecified_parameters
:
5534 return "DW_TAG_unspecified_parameters";
5535 case DW_TAG_variant
:
5536 return "DW_TAG_variant";
5537 case DW_TAG_common_block
:
5538 return "DW_TAG_common_block";
5539 case DW_TAG_common_inclusion
:
5540 return "DW_TAG_common_inclusion";
5541 case DW_TAG_inheritance
:
5542 return "DW_TAG_inheritance";
5543 case DW_TAG_inlined_subroutine
:
5544 return "DW_TAG_inlined_subroutine";
5546 return "DW_TAG_module";
5547 case DW_TAG_ptr_to_member_type
:
5548 return "DW_TAG_ptr_to_member_type";
5549 case DW_TAG_set_type
:
5550 return "DW_TAG_set_type";
5551 case DW_TAG_subrange_type
:
5552 return "DW_TAG_subrange_type";
5553 case DW_TAG_with_stmt
:
5554 return "DW_TAG_with_stmt";
5555 case DW_TAG_access_declaration
:
5556 return "DW_TAG_access_declaration";
5557 case DW_TAG_base_type
:
5558 return "DW_TAG_base_type";
5559 case DW_TAG_catch_block
:
5560 return "DW_TAG_catch_block";
5561 case DW_TAG_const_type
:
5562 return "DW_TAG_const_type";
5563 case DW_TAG_constant
:
5564 return "DW_TAG_constant";
5565 case DW_TAG_enumerator
:
5566 return "DW_TAG_enumerator";
5567 case DW_TAG_file_type
:
5568 return "DW_TAG_file_type";
5570 return "DW_TAG_friend";
5571 case DW_TAG_namelist
:
5572 return "DW_TAG_namelist";
5573 case DW_TAG_namelist_item
:
5574 return "DW_TAG_namelist_item";
5575 case DW_TAG_packed_type
:
5576 return "DW_TAG_packed_type";
5577 case DW_TAG_subprogram
:
5578 return "DW_TAG_subprogram";
5579 case DW_TAG_template_type_param
:
5580 return "DW_TAG_template_type_param";
5581 case DW_TAG_template_value_param
:
5582 return "DW_TAG_template_value_param";
5583 case DW_TAG_thrown_type
:
5584 return "DW_TAG_thrown_type";
5585 case DW_TAG_try_block
:
5586 return "DW_TAG_try_block";
5587 case DW_TAG_variant_part
:
5588 return "DW_TAG_variant_part";
5589 case DW_TAG_variable
:
5590 return "DW_TAG_variable";
5591 case DW_TAG_volatile_type
:
5592 return "DW_TAG_volatile_type";
5593 case DW_TAG_dwarf_procedure
:
5594 return "DW_TAG_dwarf_procedure";
5595 case DW_TAG_restrict_type
:
5596 return "DW_TAG_restrict_type";
5597 case DW_TAG_interface_type
:
5598 return "DW_TAG_interface_type";
5599 case DW_TAG_namespace
:
5600 return "DW_TAG_namespace";
5601 case DW_TAG_imported_module
:
5602 return "DW_TAG_imported_module";
5603 case DW_TAG_unspecified_type
:
5604 return "DW_TAG_unspecified_type";
5605 case DW_TAG_partial_unit
:
5606 return "DW_TAG_partial_unit";
5607 case DW_TAG_imported_unit
:
5608 return "DW_TAG_imported_unit";
5609 case DW_TAG_MIPS_loop
:
5610 return "DW_TAG_MIPS_loop";
5611 case DW_TAG_format_label
:
5612 return "DW_TAG_format_label";
5613 case DW_TAG_function_template
:
5614 return "DW_TAG_function_template";
5615 case DW_TAG_class_template
:
5616 return "DW_TAG_class_template";
5618 return "DW_TAG_<unknown>";
5622 /* Convert a DWARF attribute code into its string name. */
5625 dwarf_attr_name (register unsigned attr
)
5630 return "DW_AT_sibling";
5631 case DW_AT_location
:
5632 return "DW_AT_location";
5634 return "DW_AT_name";
5635 case DW_AT_ordering
:
5636 return "DW_AT_ordering";
5637 case DW_AT_subscr_data
:
5638 return "DW_AT_subscr_data";
5639 case DW_AT_byte_size
:
5640 return "DW_AT_byte_size";
5641 case DW_AT_bit_offset
:
5642 return "DW_AT_bit_offset";
5643 case DW_AT_bit_size
:
5644 return "DW_AT_bit_size";
5645 case DW_AT_element_list
:
5646 return "DW_AT_element_list";
5647 case DW_AT_stmt_list
:
5648 return "DW_AT_stmt_list";
5650 return "DW_AT_low_pc";
5652 return "DW_AT_high_pc";
5653 case DW_AT_language
:
5654 return "DW_AT_language";
5656 return "DW_AT_member";
5658 return "DW_AT_discr";
5659 case DW_AT_discr_value
:
5660 return "DW_AT_discr_value";
5661 case DW_AT_visibility
:
5662 return "DW_AT_visibility";
5664 return "DW_AT_import";
5665 case DW_AT_string_length
:
5666 return "DW_AT_string_length";
5667 case DW_AT_common_reference
:
5668 return "DW_AT_common_reference";
5669 case DW_AT_comp_dir
:
5670 return "DW_AT_comp_dir";
5671 case DW_AT_const_value
:
5672 return "DW_AT_const_value";
5673 case DW_AT_containing_type
:
5674 return "DW_AT_containing_type";
5675 case DW_AT_default_value
:
5676 return "DW_AT_default_value";
5678 return "DW_AT_inline";
5679 case DW_AT_is_optional
:
5680 return "DW_AT_is_optional";
5681 case DW_AT_lower_bound
:
5682 return "DW_AT_lower_bound";
5683 case DW_AT_producer
:
5684 return "DW_AT_producer";
5685 case DW_AT_prototyped
:
5686 return "DW_AT_prototyped";
5687 case DW_AT_return_addr
:
5688 return "DW_AT_return_addr";
5689 case DW_AT_start_scope
:
5690 return "DW_AT_start_scope";
5691 case DW_AT_stride_size
:
5692 return "DW_AT_stride_size";
5693 case DW_AT_upper_bound
:
5694 return "DW_AT_upper_bound";
5695 case DW_AT_abstract_origin
:
5696 return "DW_AT_abstract_origin";
5697 case DW_AT_accessibility
:
5698 return "DW_AT_accessibility";
5699 case DW_AT_address_class
:
5700 return "DW_AT_address_class";
5701 case DW_AT_artificial
:
5702 return "DW_AT_artificial";
5703 case DW_AT_base_types
:
5704 return "DW_AT_base_types";
5705 case DW_AT_calling_convention
:
5706 return "DW_AT_calling_convention";
5708 return "DW_AT_count";
5709 case DW_AT_data_member_location
:
5710 return "DW_AT_data_member_location";
5711 case DW_AT_decl_column
:
5712 return "DW_AT_decl_column";
5713 case DW_AT_decl_file
:
5714 return "DW_AT_decl_file";
5715 case DW_AT_decl_line
:
5716 return "DW_AT_decl_line";
5717 case DW_AT_declaration
:
5718 return "DW_AT_declaration";
5719 case DW_AT_discr_list
:
5720 return "DW_AT_discr_list";
5721 case DW_AT_encoding
:
5722 return "DW_AT_encoding";
5723 case DW_AT_external
:
5724 return "DW_AT_external";
5725 case DW_AT_frame_base
:
5726 return "DW_AT_frame_base";
5728 return "DW_AT_friend";
5729 case DW_AT_identifier_case
:
5730 return "DW_AT_identifier_case";
5731 case DW_AT_macro_info
:
5732 return "DW_AT_macro_info";
5733 case DW_AT_namelist_items
:
5734 return "DW_AT_namelist_items";
5735 case DW_AT_priority
:
5736 return "DW_AT_priority";
5738 return "DW_AT_segment";
5739 case DW_AT_specification
:
5740 return "DW_AT_specification";
5741 case DW_AT_static_link
:
5742 return "DW_AT_static_link";
5744 return "DW_AT_type";
5745 case DW_AT_use_location
:
5746 return "DW_AT_use_location";
5747 case DW_AT_variable_parameter
:
5748 return "DW_AT_variable_parameter";
5749 case DW_AT_virtuality
:
5750 return "DW_AT_virtuality";
5751 case DW_AT_vtable_elem_location
:
5752 return "DW_AT_vtable_elem_location";
5753 case DW_AT_allocated
:
5754 return "DW_AT_allocated";
5755 case DW_AT_associated
:
5756 return "DW_AT_associated";
5757 case DW_AT_data_location
:
5758 return "DW_AT_data_location";
5760 return "DW_AT_stride";
5761 case DW_AT_entry_pc
:
5762 return "DW_AT_entry_pc";
5763 case DW_AT_use_UTF8
:
5764 return "DW_AT_use_UTF8";
5765 case DW_AT_extension
:
5766 return "DW_AT_extension";
5768 return "DW_AT_ranges";
5769 case DW_AT_trampoline
:
5770 return "DW_AT_trampoline";
5771 case DW_AT_call_column
:
5772 return "DW_AT_call_column";
5773 case DW_AT_call_file
:
5774 return "DW_AT_call_file";
5775 case DW_AT_call_line
:
5776 return "DW_AT_call_line";
5778 case DW_AT_MIPS_fde
:
5779 return "DW_AT_MIPS_fde";
5780 case DW_AT_MIPS_loop_begin
:
5781 return "DW_AT_MIPS_loop_begin";
5782 case DW_AT_MIPS_tail_loop_begin
:
5783 return "DW_AT_MIPS_tail_loop_begin";
5784 case DW_AT_MIPS_epilog_begin
:
5785 return "DW_AT_MIPS_epilog_begin";
5786 case DW_AT_MIPS_loop_unroll_factor
:
5787 return "DW_AT_MIPS_loop_unroll_factor";
5788 case DW_AT_MIPS_software_pipeline_depth
:
5789 return "DW_AT_MIPS_software_pipeline_depth";
5790 case DW_AT_MIPS_linkage_name
:
5791 return "DW_AT_MIPS_linkage_name";
5794 case DW_AT_sf_names
:
5795 return "DW_AT_sf_names";
5796 case DW_AT_src_info
:
5797 return "DW_AT_src_info";
5798 case DW_AT_mac_info
:
5799 return "DW_AT_mac_info";
5800 case DW_AT_src_coords
:
5801 return "DW_AT_src_coords";
5802 case DW_AT_body_begin
:
5803 return "DW_AT_body_begin";
5804 case DW_AT_body_end
:
5805 return "DW_AT_body_end";
5806 case DW_AT_GNU_vector
:
5807 return "DW_AT_GNU_vector";
5809 return "DW_AT_<unknown>";
5813 /* Convert a DWARF value form code into its string name. */
5816 dwarf_form_name (register unsigned form
)
5821 return "DW_FORM_addr";
5822 case DW_FORM_block2
:
5823 return "DW_FORM_block2";
5824 case DW_FORM_block4
:
5825 return "DW_FORM_block4";
5827 return "DW_FORM_data2";
5829 return "DW_FORM_data4";
5831 return "DW_FORM_data8";
5832 case DW_FORM_string
:
5833 return "DW_FORM_string";
5835 return "DW_FORM_block";
5836 case DW_FORM_block1
:
5837 return "DW_FORM_block1";
5839 return "DW_FORM_data1";
5841 return "DW_FORM_flag";
5843 return "DW_FORM_sdata";
5845 return "DW_FORM_strp";
5847 return "DW_FORM_udata";
5848 case DW_FORM_ref_addr
:
5849 return "DW_FORM_ref_addr";
5851 return "DW_FORM_ref1";
5853 return "DW_FORM_ref2";
5855 return "DW_FORM_ref4";
5857 return "DW_FORM_ref8";
5858 case DW_FORM_ref_udata
:
5859 return "DW_FORM_ref_udata";
5860 case DW_FORM_indirect
:
5861 return "DW_FORM_indirect";
5863 return "DW_FORM_<unknown>";
5867 /* Convert a DWARF stack opcode into its string name. */
5870 dwarf_stack_op_name (register unsigned op
)
5875 return "DW_OP_addr";
5877 return "DW_OP_deref";
5879 return "DW_OP_const1u";
5881 return "DW_OP_const1s";
5883 return "DW_OP_const2u";
5885 return "DW_OP_const2s";
5887 return "DW_OP_const4u";
5889 return "DW_OP_const4s";
5891 return "DW_OP_const8u";
5893 return "DW_OP_const8s";
5895 return "DW_OP_constu";
5897 return "DW_OP_consts";
5901 return "DW_OP_drop";
5903 return "DW_OP_over";
5905 return "DW_OP_pick";
5907 return "DW_OP_swap";
5911 return "DW_OP_xderef";
5919 return "DW_OP_minus";
5931 return "DW_OP_plus";
5932 case DW_OP_plus_uconst
:
5933 return "DW_OP_plus_uconst";
5939 return "DW_OP_shra";
5957 return "DW_OP_skip";
5959 return "DW_OP_lit0";
5961 return "DW_OP_lit1";
5963 return "DW_OP_lit2";
5965 return "DW_OP_lit3";
5967 return "DW_OP_lit4";
5969 return "DW_OP_lit5";
5971 return "DW_OP_lit6";
5973 return "DW_OP_lit7";
5975 return "DW_OP_lit8";
5977 return "DW_OP_lit9";
5979 return "DW_OP_lit10";
5981 return "DW_OP_lit11";
5983 return "DW_OP_lit12";
5985 return "DW_OP_lit13";
5987 return "DW_OP_lit14";
5989 return "DW_OP_lit15";
5991 return "DW_OP_lit16";
5993 return "DW_OP_lit17";
5995 return "DW_OP_lit18";
5997 return "DW_OP_lit19";
5999 return "DW_OP_lit20";
6001 return "DW_OP_lit21";
6003 return "DW_OP_lit22";
6005 return "DW_OP_lit23";
6007 return "DW_OP_lit24";
6009 return "DW_OP_lit25";
6011 return "DW_OP_lit26";
6013 return "DW_OP_lit27";
6015 return "DW_OP_lit28";
6017 return "DW_OP_lit29";
6019 return "DW_OP_lit30";
6021 return "DW_OP_lit31";
6023 return "DW_OP_reg0";
6025 return "DW_OP_reg1";
6027 return "DW_OP_reg2";
6029 return "DW_OP_reg3";
6031 return "DW_OP_reg4";
6033 return "DW_OP_reg5";
6035 return "DW_OP_reg6";
6037 return "DW_OP_reg7";
6039 return "DW_OP_reg8";
6041 return "DW_OP_reg9";
6043 return "DW_OP_reg10";
6045 return "DW_OP_reg11";
6047 return "DW_OP_reg12";
6049 return "DW_OP_reg13";
6051 return "DW_OP_reg14";
6053 return "DW_OP_reg15";
6055 return "DW_OP_reg16";
6057 return "DW_OP_reg17";
6059 return "DW_OP_reg18";
6061 return "DW_OP_reg19";
6063 return "DW_OP_reg20";
6065 return "DW_OP_reg21";
6067 return "DW_OP_reg22";
6069 return "DW_OP_reg23";
6071 return "DW_OP_reg24";
6073 return "DW_OP_reg25";
6075 return "DW_OP_reg26";
6077 return "DW_OP_reg27";
6079 return "DW_OP_reg28";
6081 return "DW_OP_reg29";
6083 return "DW_OP_reg30";
6085 return "DW_OP_reg31";
6087 return "DW_OP_breg0";
6089 return "DW_OP_breg1";
6091 return "DW_OP_breg2";
6093 return "DW_OP_breg3";
6095 return "DW_OP_breg4";
6097 return "DW_OP_breg5";
6099 return "DW_OP_breg6";
6101 return "DW_OP_breg7";
6103 return "DW_OP_breg8";
6105 return "DW_OP_breg9";
6107 return "DW_OP_breg10";
6109 return "DW_OP_breg11";
6111 return "DW_OP_breg12";
6113 return "DW_OP_breg13";
6115 return "DW_OP_breg14";
6117 return "DW_OP_breg15";
6119 return "DW_OP_breg16";
6121 return "DW_OP_breg17";
6123 return "DW_OP_breg18";
6125 return "DW_OP_breg19";
6127 return "DW_OP_breg20";
6129 return "DW_OP_breg21";
6131 return "DW_OP_breg22";
6133 return "DW_OP_breg23";
6135 return "DW_OP_breg24";
6137 return "DW_OP_breg25";
6139 return "DW_OP_breg26";
6141 return "DW_OP_breg27";
6143 return "DW_OP_breg28";
6145 return "DW_OP_breg29";
6147 return "DW_OP_breg30";
6149 return "DW_OP_breg31";
6151 return "DW_OP_regx";
6153 return "DW_OP_fbreg";
6155 return "DW_OP_bregx";
6157 return "DW_OP_piece";
6158 case DW_OP_deref_size
:
6159 return "DW_OP_deref_size";
6160 case DW_OP_xderef_size
:
6161 return "DW_OP_xderef_size";
6164 /* DWARF 3 extensions. */
6165 case DW_OP_push_object_address
:
6166 return "DW_OP_push_object_address";
6168 return "DW_OP_call2";
6170 return "DW_OP_call4";
6171 case DW_OP_call_ref
:
6172 return "DW_OP_call_ref";
6173 /* GNU extensions. */
6174 case DW_OP_GNU_push_tls_address
:
6175 return "DW_OP_GNU_push_tls_address";
6177 return "OP_<unknown>";
6182 dwarf_bool_name (unsigned mybool
)
6190 /* Convert a DWARF type code into its string name. */
6193 dwarf_type_encoding_name (register unsigned enc
)
6197 case DW_ATE_address
:
6198 return "DW_ATE_address";
6199 case DW_ATE_boolean
:
6200 return "DW_ATE_boolean";
6201 case DW_ATE_complex_float
:
6202 return "DW_ATE_complex_float";
6204 return "DW_ATE_float";
6206 return "DW_ATE_signed";
6207 case DW_ATE_signed_char
:
6208 return "DW_ATE_signed_char";
6209 case DW_ATE_unsigned
:
6210 return "DW_ATE_unsigned";
6211 case DW_ATE_unsigned_char
:
6212 return "DW_ATE_unsigned_char";
6213 case DW_ATE_imaginary_float
:
6214 return "DW_ATE_imaginary_float";
6216 return "DW_ATE_<unknown>";
6220 /* Convert a DWARF call frame info operation to its string name. */
6224 dwarf_cfi_name (register unsigned cfi_opc
)
6228 case DW_CFA_advance_loc
:
6229 return "DW_CFA_advance_loc";
6231 return "DW_CFA_offset";
6232 case DW_CFA_restore
:
6233 return "DW_CFA_restore";
6235 return "DW_CFA_nop";
6236 case DW_CFA_set_loc
:
6237 return "DW_CFA_set_loc";
6238 case DW_CFA_advance_loc1
:
6239 return "DW_CFA_advance_loc1";
6240 case DW_CFA_advance_loc2
:
6241 return "DW_CFA_advance_loc2";
6242 case DW_CFA_advance_loc4
:
6243 return "DW_CFA_advance_loc4";
6244 case DW_CFA_offset_extended
:
6245 return "DW_CFA_offset_extended";
6246 case DW_CFA_restore_extended
:
6247 return "DW_CFA_restore_extended";
6248 case DW_CFA_undefined
:
6249 return "DW_CFA_undefined";
6250 case DW_CFA_same_value
:
6251 return "DW_CFA_same_value";
6252 case DW_CFA_register
:
6253 return "DW_CFA_register";
6254 case DW_CFA_remember_state
:
6255 return "DW_CFA_remember_state";
6256 case DW_CFA_restore_state
:
6257 return "DW_CFA_restore_state";
6258 case DW_CFA_def_cfa
:
6259 return "DW_CFA_def_cfa";
6260 case DW_CFA_def_cfa_register
:
6261 return "DW_CFA_def_cfa_register";
6262 case DW_CFA_def_cfa_offset
:
6263 return "DW_CFA_def_cfa_offset";
6266 case DW_CFA_def_cfa_expression
:
6267 return "DW_CFA_def_cfa_expression";
6268 case DW_CFA_expression
:
6269 return "DW_CFA_expression";
6270 case DW_CFA_offset_extended_sf
:
6271 return "DW_CFA_offset_extended_sf";
6272 case DW_CFA_def_cfa_sf
:
6273 return "DW_CFA_def_cfa_sf";
6274 case DW_CFA_def_cfa_offset_sf
:
6275 return "DW_CFA_def_cfa_offset_sf";
6277 /* SGI/MIPS specific */
6278 case DW_CFA_MIPS_advance_loc8
:
6279 return "DW_CFA_MIPS_advance_loc8";
6281 /* GNU extensions */
6282 case DW_CFA_GNU_window_save
:
6283 return "DW_CFA_GNU_window_save";
6284 case DW_CFA_GNU_args_size
:
6285 return "DW_CFA_GNU_args_size";
6286 case DW_CFA_GNU_negative_offset_extended
:
6287 return "DW_CFA_GNU_negative_offset_extended";
6290 return "DW_CFA_<unknown>";
6296 dump_die (struct die_info
*die
)
6300 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6301 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6302 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6303 dwarf_bool_name (die
->has_children
));
6305 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6306 for (i
= 0; i
< die
->num_attrs
; ++i
)
6308 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6309 dwarf_attr_name (die
->attrs
[i
].name
),
6310 dwarf_form_name (die
->attrs
[i
].form
));
6311 switch (die
->attrs
[i
].form
)
6313 case DW_FORM_ref_addr
:
6315 fprintf_unfiltered (gdb_stderr
, "address: ");
6316 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6318 case DW_FORM_block2
:
6319 case DW_FORM_block4
:
6321 case DW_FORM_block1
:
6322 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6333 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6335 case DW_FORM_string
:
6337 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6338 DW_STRING (&die
->attrs
[i
])
6339 ? DW_STRING (&die
->attrs
[i
]) : "");
6342 if (DW_UNSND (&die
->attrs
[i
]))
6343 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6345 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6347 case DW_FORM_indirect
:
6348 /* the reader will have reduced the indirect form to
6349 the "base form" so this form should not occur */
6350 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6353 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6354 die
->attrs
[i
].form
);
6356 fprintf_unfiltered (gdb_stderr
, "\n");
6361 dump_die_list (struct die_info
*die
)
6371 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6374 struct die_info
*old
;
6376 h
= (offset
% REF_HASH_SIZE
);
6377 old
= die_ref_table
[h
];
6378 die
->next_ref
= old
;
6379 die_ref_table
[h
] = die
;
6384 dwarf2_empty_hash_tables (void)
6386 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6390 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6392 unsigned int result
= 0;
6396 case DW_FORM_ref_addr
:
6397 result
= DW_ADDR (attr
);
6403 case DW_FORM_ref_udata
:
6404 result
= cu_header_offset
+ DW_UNSND (attr
);
6407 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
6412 static struct die_info
*
6413 follow_die_ref (unsigned int offset
)
6415 struct die_info
*die
;
6418 h
= (offset
% REF_HASH_SIZE
);
6419 die
= die_ref_table
[h
];
6422 if (die
->offset
== offset
)
6426 die
= die
->next_ref
;
6431 static struct type
*
6432 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6434 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6436 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
6440 /* Look for this particular type in the fundamental type vector. If
6441 one is not found, create and install one appropriate for the
6442 current language and the current target machine. */
6444 if (ftypes
[typeid] == NULL
)
6446 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6449 return (ftypes
[typeid]);
6452 /* Decode simple location descriptions.
6453 Given a pointer to a dwarf block that defines a location, compute
6454 the location and return the value.
6456 FIXME: This is a kludge until we figure out a better
6457 way to handle the location descriptions.
6458 Gdb's design does not mesh well with the DWARF2 notion of a location
6459 computing interpreter, which is a shame because the flexibility goes unused.
6460 FIXME: Implement more operations as necessary.
6462 A location description containing no operations indicates that the
6463 object is optimized out. The global optimized_out flag is set for
6464 those, the return value is meaningless.
6466 When the result is a register number, the global isreg flag is set,
6467 otherwise it is cleared.
6469 When the result is a base register offset, the global offreg flag is set
6470 and the register number is returned in basereg, otherwise it is cleared.
6472 When the DW_OP_fbreg operation is encountered without a corresponding
6473 DW_AT_frame_base attribute, the global islocal flag is set.
6474 Hopefully the machine dependent code knows how to set up a virtual
6475 frame pointer for the local references.
6477 Note that stack[0] is unused except as a default error return.
6478 Note that stack overflow is not yet handled. */
6481 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
6482 const struct comp_unit_head
*cu_header
)
6485 int size
= blk
->size
;
6486 char *data
= blk
->data
;
6487 CORE_ADDR stack
[64];
6489 unsigned int bytes_read
, unsnd
;
6499 is_thread_local
= 0;
6540 stack
[++stacki
] = op
- DW_OP_lit0
;
6576 stack
[++stacki
] = op
- DW_OP_reg0
;
6581 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6583 stack
[++stacki
] = unsnd
;
6619 basereg
= op
- DW_OP_breg0
;
6620 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6626 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6628 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6633 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6635 if (frame_base_reg
>= 0)
6638 basereg
= frame_base_reg
;
6639 stack
[stacki
] += frame_base_offset
;
6643 complain (&dwarf2_missing_at_frame_base
);
6649 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
6650 cu_header
, &bytes_read
);
6655 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
6660 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
6665 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
6670 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
6675 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
6680 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
6685 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
6691 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6696 stack
[stacki
+ 1] = stack
[stacki
];
6701 stack
[stacki
- 1] += stack
[stacki
];
6705 case DW_OP_plus_uconst
:
6706 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6711 stack
[stacki
- 1] -= stack
[stacki
];
6717 /* If we're not the last op, then we definitely can't encode
6718 this using GDB's address_class enum. */
6720 complain (&dwarf2_complex_location_expr
);
6723 case DW_OP_GNU_push_tls_address
:
6724 is_thread_local
= 1;
6725 /* The top of the stack has the offset from the beginning
6726 of the thread control block at which the variable is located. */
6727 /* Nothing should follow this operator, so the top of stack would
6730 complain (&dwarf2_complex_location_expr
);
6734 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name (op
));
6735 return (stack
[stacki
]);
6738 return (stack
[stacki
]);
6741 /* memory allocation interface */
6745 dwarf2_free_tmp_obstack (PTR ignore
)
6747 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6750 static struct dwarf_block
*
6751 dwarf_alloc_block (void)
6753 struct dwarf_block
*blk
;
6755 blk
= (struct dwarf_block
*)
6756 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6760 static struct abbrev_info
*
6761 dwarf_alloc_abbrev (void)
6763 struct abbrev_info
*abbrev
;
6765 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6766 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6770 static struct die_info
*
6771 dwarf_alloc_die (void)
6773 struct die_info
*die
;
6775 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6776 memset (die
, 0, sizeof (struct die_info
));
6781 /* Macro support. */
6784 /* Return the full name of file number I in *LH's file name table.
6785 Use COMP_DIR as the name of the current directory of the
6786 compilation. The result is allocated using xmalloc; the caller is
6787 responsible for freeing it. */
6789 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
6791 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6793 if (IS_ABSOLUTE_PATH (fe
->name
))
6794 return xstrdup (fe
->name
);
6802 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6808 dir_len
= strlen (dir
);
6809 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
6810 strcpy (full_name
, dir
);
6811 full_name
[dir_len
] = '/';
6812 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
6816 return xstrdup (fe
->name
);
6821 static struct macro_source_file
*
6822 macro_start_file (int file
, int line
,
6823 struct macro_source_file
*current_file
,
6824 const char *comp_dir
,
6825 struct line_header
*lh
, struct objfile
*objfile
)
6827 /* The full name of this source file. */
6828 char *full_name
= file_full_name (file
, lh
, comp_dir
);
6830 /* We don't create a macro table for this compilation unit
6831 at all until we actually get a filename. */
6832 if (! pending_macros
)
6833 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
6834 objfile
->macro_cache
);
6837 /* If we have no current file, then this must be the start_file
6838 directive for the compilation unit's main source file. */
6839 current_file
= macro_set_main (pending_macros
, full_name
);
6841 current_file
= macro_include (current_file
, line
, full_name
);
6845 return current_file
;
6849 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
6850 followed by a null byte. */
6852 copy_string (const char *buf
, int len
)
6854 char *s
= xmalloc (len
+ 1);
6855 memcpy (s
, buf
, len
);
6863 consume_improper_spaces (const char *p
, const char *body
)
6867 complain (&dwarf2_macro_spaces_in_definition
, body
);
6878 parse_macro_definition (struct macro_source_file
*file
, int line
,
6883 /* The body string takes one of two forms. For object-like macro
6884 definitions, it should be:
6886 <macro name> " " <definition>
6888 For function-like macro definitions, it should be:
6890 <macro name> "() " <definition>
6892 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
6894 Spaces may appear only where explicitly indicated, and in the
6897 The Dwarf 2 spec says that an object-like macro's name is always
6898 followed by a space, but versions of GCC around March 2002 omit
6899 the space when the macro's definition is the empty string.
6901 The Dwarf 2 spec says that there should be no spaces between the
6902 formal arguments in a function-like macro's formal argument list,
6903 but versions of GCC around March 2002 include spaces after the
6907 /* Find the extent of the macro name. The macro name is terminated
6908 by either a space or null character (for an object-like macro) or
6909 an opening paren (for a function-like macro). */
6910 for (p
= body
; *p
; p
++)
6911 if (*p
== ' ' || *p
== '(')
6914 if (*p
== ' ' || *p
== '\0')
6916 /* It's an object-like macro. */
6917 int name_len
= p
- body
;
6918 char *name
= copy_string (body
, name_len
);
6919 const char *replacement
;
6922 replacement
= body
+ name_len
+ 1;
6925 complain (&dwarf2_macro_malformed_definition
, body
);
6926 replacement
= body
+ name_len
;
6929 macro_define_object (file
, line
, name
, replacement
);
6935 /* It's a function-like macro. */
6936 char *name
= copy_string (body
, p
- body
);
6939 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
6943 p
= consume_improper_spaces (p
, body
);
6945 /* Parse the formal argument list. */
6946 while (*p
&& *p
!= ')')
6948 /* Find the extent of the current argument name. */
6949 const char *arg_start
= p
;
6951 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
6954 if (! *p
|| p
== arg_start
)
6955 complain (&dwarf2_macro_malformed_definition
,
6959 /* Make sure argv has room for the new argument. */
6960 if (argc
>= argv_size
)
6963 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
6966 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
6969 p
= consume_improper_spaces (p
, body
);
6971 /* Consume the comma, if present. */
6976 p
= consume_improper_spaces (p
, body
);
6985 /* Perfectly formed definition, no complaints. */
6986 macro_define_function (file
, line
, name
,
6987 argc
, (const char **) argv
,
6989 else if (*p
== '\0')
6991 /* Complain, but do define it. */
6992 complain (&dwarf2_macro_malformed_definition
, body
);
6993 macro_define_function (file
, line
, name
,
6994 argc
, (const char **) argv
,
6998 /* Just complain. */
6999 complain (&dwarf2_macro_malformed_definition
, body
);
7002 /* Just complain. */
7003 complain (&dwarf2_macro_malformed_definition
, body
);
7009 for (i
= 0; i
< argc
; i
++)
7015 complain (&dwarf2_macro_malformed_definition
, body
);
7020 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7021 char *comp_dir
, bfd
*abfd
,
7022 const struct comp_unit_head
*cu_header
,
7023 struct objfile
*objfile
)
7025 char *mac_ptr
, *mac_end
;
7026 struct macro_source_file
*current_file
= 0;
7028 if (dwarf_macinfo_buffer
== NULL
)
7030 complain (&dwarf2_missing_macinfo_section
);
7034 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7035 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7039 enum dwarf_macinfo_record_type macinfo_type
;
7041 /* Do we at least have room for a macinfo type byte? */
7042 if (mac_ptr
>= mac_end
)
7044 complain (&dwarf2_macros_too_long
);
7048 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7051 switch (macinfo_type
)
7053 /* A zero macinfo type indicates the end of the macro
7058 case DW_MACINFO_define
:
7059 case DW_MACINFO_undef
:
7065 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7066 mac_ptr
+= bytes_read
;
7067 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7068 mac_ptr
+= bytes_read
;
7071 complain (&dwarf2_macro_outside_file
,
7072 macinfo_type
== DW_MACINFO_define
? "definition" :
7073 macinfo_type
== DW_MACINFO_undef
? "undefinition" :
7074 "something-or-other",
7078 if (macinfo_type
== DW_MACINFO_define
)
7079 parse_macro_definition (current_file
, line
, body
);
7080 else if (macinfo_type
== DW_MACINFO_undef
)
7081 macro_undef (current_file
, line
, body
);
7086 case DW_MACINFO_start_file
:
7091 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7092 mac_ptr
+= bytes_read
;
7093 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7094 mac_ptr
+= bytes_read
;
7096 current_file
= macro_start_file (file
, line
,
7097 current_file
, comp_dir
,
7102 case DW_MACINFO_end_file
:
7104 complain (&dwarf2_macro_unmatched_end_file
);
7107 current_file
= current_file
->included_by
;
7110 enum dwarf_macinfo_record_type next_type
;
7112 /* GCC circa March 2002 doesn't produce the zero
7113 type byte marking the end of the compilation
7114 unit. Complain if it's not there, but exit no
7117 /* Do we at least have room for a macinfo type byte? */
7118 if (mac_ptr
>= mac_end
)
7120 complain (&dwarf2_macros_too_long
);
7124 /* We don't increment mac_ptr here, so this is just
7126 next_type
= read_1_byte (abfd
, mac_ptr
);
7128 complain (&dwarf2_macros_not_terminated
);
7135 case DW_MACINFO_vendor_ext
:
7141 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7142 mac_ptr
+= bytes_read
;
7143 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7144 mac_ptr
+= bytes_read
;
7146 /* We don't recognize any vendor extensions. */
7153 /* Check if the attribute's form is a DW_FORM_block*
7154 if so return true else false. */
7156 attr_form_is_block (struct attribute
*attr
)
7158 return (attr
== NULL
? 0 :
7159 attr
->form
== DW_FORM_block1
7160 || attr
->form
== DW_FORM_block2
7161 || attr
->form
== DW_FORM_block4
7162 || attr
->form
== DW_FORM_block
);