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
);
1362 /* Anonymous namespaces have no name but are interesting. */
1364 if (pdi
.name
!= NULL
|| pdi
.tag
== DW_TAG_namespace
)
1368 case DW_TAG_subprogram
:
1369 if (pdi
.has_pc_info
)
1371 if (pdi
.lowpc
< *lowpc
)
1375 if (pdi
.highpc
> *highpc
)
1377 *highpc
= pdi
.highpc
;
1379 if ((pdi
.is_external
|| nesting_level
== file_scope_level
)
1380 && !pdi
.is_declaration
)
1382 add_partial_symbol (&pdi
, objfile
, cu_header
);
1386 case DW_TAG_variable
:
1387 case DW_TAG_typedef
:
1388 case DW_TAG_class_type
:
1389 case DW_TAG_structure_type
:
1390 case DW_TAG_union_type
:
1391 case DW_TAG_enumeration_type
:
1392 if ((pdi
.is_external
|| nesting_level
== file_scope_level
)
1393 && !pdi
.is_declaration
)
1395 add_partial_symbol (&pdi
, objfile
, cu_header
);
1398 case DW_TAG_enumerator
:
1399 /* File scope enumerators are added to the partial
1400 symbol table. They're children of the enumeration
1401 type die, so they occur at a level one higher than we
1402 normally look for. */
1403 if (nesting_level
== file_scope_level
+ 1)
1404 add_partial_symbol (&pdi
, objfile
, cu_header
);
1406 case DW_TAG_base_type
:
1407 /* File scope base type definitions are added to the partial
1409 if (nesting_level
== file_scope_level
)
1410 add_partial_symbol (&pdi
, objfile
, cu_header
);
1412 case DW_TAG_namespace
:
1413 /* FIXME: carlton/2002-10-16: we're not yet doing
1414 anything useful with this, but for now make sure that
1415 these tags at least don't cause us to miss any
1416 important symbols. */
1417 if (pdi
.has_children
)
1424 /* If the die has a sibling, skip to the sibling. Do not skip
1425 enumeration types, we want to record their enumerators. Do
1426 not skip namespaces, we want to record symbols inside
1429 && pdi
.tag
!= DW_TAG_enumeration_type
1430 && pdi
.tag
!= DW_TAG_namespace
)
1432 info_ptr
= pdi
.sibling
;
1434 else if (pdi
.has_children
)
1436 /* Die has children, but either the optional DW_AT_sibling
1437 attribute is missing or we want to look at them. */
1444 /* If this is the end of a DW_TAG_namespace entry, then
1445 decrease the file_scope_level, too. */
1446 if (nesting_level
< file_scope_level
)
1449 gdb_assert (nesting_level
== file_scope_level
);
1454 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1455 from `maint check'. */
1456 if (*lowpc
== ((CORE_ADDR
) -1))
1462 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1463 const struct comp_unit_head
*cu_header
)
1469 case DW_TAG_subprogram
:
1470 if (pdi
->is_external
)
1472 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1473 mst_text, objfile); */
1474 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1475 VAR_NAMESPACE
, LOC_BLOCK
,
1476 &objfile
->global_psymbols
,
1477 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1481 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1482 mst_file_text, objfile); */
1483 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1484 VAR_NAMESPACE
, LOC_BLOCK
,
1485 &objfile
->static_psymbols
,
1486 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1489 case DW_TAG_variable
:
1490 if (pdi
->is_external
)
1493 Don't enter into the minimal symbol tables as there is
1494 a minimal symbol table entry from the ELF symbols already.
1495 Enter into partial symbol table if it has a location
1496 descriptor or a type.
1497 If the location descriptor is missing, new_symbol will create
1498 a LOC_UNRESOLVED symbol, the address of the variable will then
1499 be determined from the minimal symbol table whenever the variable
1501 The address for the partial symbol table entry is not
1502 used by GDB, but it comes in handy for debugging partial symbol
1506 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1507 if (pdi
->locdesc
|| pdi
->has_type
)
1508 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1509 VAR_NAMESPACE
, LOC_STATIC
,
1510 &objfile
->global_psymbols
,
1511 0, addr
+ baseaddr
, cu_language
, objfile
);
1515 /* Static Variable. Skip symbols without location descriptors. */
1516 if (pdi
->locdesc
== NULL
)
1518 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1519 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1520 mst_file_data, objfile); */
1521 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1522 VAR_NAMESPACE
, LOC_STATIC
,
1523 &objfile
->static_psymbols
,
1524 0, addr
+ baseaddr
, cu_language
, objfile
);
1527 case DW_TAG_typedef
:
1528 case DW_TAG_base_type
:
1529 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1530 VAR_NAMESPACE
, LOC_TYPEDEF
,
1531 &objfile
->static_psymbols
,
1532 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1534 case DW_TAG_class_type
:
1535 case DW_TAG_structure_type
:
1536 case DW_TAG_union_type
:
1537 case DW_TAG_enumeration_type
:
1538 /* Skip aggregate types without children, these are external
1540 if (pdi
->has_children
== 0)
1542 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1543 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1544 &objfile
->static_psymbols
,
1545 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1547 if (cu_language
== language_cplus
)
1549 /* For C++, these implicitly act as typedefs as well. */
1550 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1551 VAR_NAMESPACE
, LOC_TYPEDEF
,
1552 &objfile
->static_psymbols
,
1553 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1556 case DW_TAG_enumerator
:
1557 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1558 VAR_NAMESPACE
, LOC_CONST
,
1559 &objfile
->static_psymbols
,
1560 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1567 /* Expand this partial symbol table into a full symbol table. */
1570 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1572 /* FIXME: This is barely more than a stub. */
1577 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1583 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1584 gdb_flush (gdb_stdout
);
1587 psymtab_to_symtab_1 (pst
);
1589 /* Finish up the debug error message. */
1591 printf_filtered ("done.\n");
1597 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1599 struct objfile
*objfile
= pst
->objfile
;
1600 bfd
*abfd
= objfile
->obfd
;
1601 struct comp_unit_head cu_header
;
1602 struct die_info
*dies
;
1603 unsigned long offset
;
1604 CORE_ADDR lowpc
, highpc
;
1605 struct die_info
*child_die
;
1607 struct symtab
*symtab
;
1608 struct cleanup
*back_to
;
1610 /* Set local variables from the partial symbol table info. */
1611 offset
= DWARF_INFO_OFFSET (pst
);
1612 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1613 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1614 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1615 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1616 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1617 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1618 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1619 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1620 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1621 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1622 cu_header_offset
= offset
;
1623 info_ptr
= dwarf_info_buffer
+ offset
;
1625 obstack_init (&dwarf2_tmp_obstack
);
1626 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1629 make_cleanup (really_free_pendings
, NULL
);
1631 /* read in the comp_unit header */
1632 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1634 /* Read the abbrevs for this compilation unit */
1635 dwarf2_read_abbrevs (abfd
, &cu_header
);
1636 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1638 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
1640 make_cleanup_free_die_list (dies
);
1642 /* Do line number decoding in read_file_scope () */
1643 process_die (dies
, objfile
, &cu_header
);
1645 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1647 /* Some compilers don't define a DW_AT_high_pc attribute for
1648 the compilation unit. If the DW_AT_high_pc is missing,
1649 synthesize it, by scanning the DIE's below the compilation unit. */
1651 if (dies
->has_children
)
1653 child_die
= dies
->next
;
1654 while (child_die
&& child_die
->tag
)
1656 if (child_die
->tag
== DW_TAG_subprogram
)
1658 CORE_ADDR low
, high
;
1660 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1662 highpc
= max (highpc
, high
);
1665 child_die
= sibling_die (child_die
);
1669 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1671 /* Set symtab language to language from DW_AT_language.
1672 If the compilation is from a C file generated by language preprocessors,
1673 do not set the language if it was already deduced by start_subfile. */
1675 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1677 symtab
->language
= cu_language
;
1679 pst
->symtab
= symtab
;
1681 sort_symtab_syms (pst
->symtab
);
1683 do_cleanups (back_to
);
1686 /* Process a die and its children. */
1689 process_die (struct die_info
*die
, struct objfile
*objfile
,
1690 const struct comp_unit_head
*cu_header
)
1694 case DW_TAG_padding
:
1696 case DW_TAG_compile_unit
:
1697 read_file_scope (die
, objfile
, cu_header
);
1699 case DW_TAG_subprogram
:
1700 read_subroutine_type (die
, objfile
, cu_header
);
1701 read_func_scope (die
, objfile
, cu_header
);
1703 case DW_TAG_inlined_subroutine
:
1704 /* FIXME: These are ignored for now.
1705 They could be used to set breakpoints on all inlined instances
1706 of a function and make GDB `next' properly over inlined functions. */
1708 case DW_TAG_lexical_block
:
1709 read_lexical_block_scope (die
, objfile
, cu_header
);
1711 case DW_TAG_class_type
:
1712 case DW_TAG_structure_type
:
1713 case DW_TAG_union_type
:
1714 read_structure_scope (die
, objfile
, cu_header
);
1716 case DW_TAG_enumeration_type
:
1717 read_enumeration (die
, objfile
, cu_header
);
1719 case DW_TAG_subroutine_type
:
1720 read_subroutine_type (die
, objfile
, cu_header
);
1722 case DW_TAG_array_type
:
1723 read_array_type (die
, objfile
, cu_header
);
1725 case DW_TAG_pointer_type
:
1726 read_tag_pointer_type (die
, objfile
, cu_header
);
1728 case DW_TAG_ptr_to_member_type
:
1729 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1731 case DW_TAG_reference_type
:
1732 read_tag_reference_type (die
, objfile
, cu_header
);
1734 case DW_TAG_string_type
:
1735 read_tag_string_type (die
, objfile
);
1737 case DW_TAG_base_type
:
1738 read_base_type (die
, objfile
);
1739 if (dwarf_attr (die
, DW_AT_name
))
1741 /* Add a typedef symbol for the base type definition. */
1742 new_symbol (die
, die
->type
, objfile
, cu_header
);
1745 case DW_TAG_common_block
:
1746 read_common_block (die
, objfile
, cu_header
);
1748 case DW_TAG_common_inclusion
:
1750 case DW_TAG_namespace
:
1751 read_namespace (die
, objfile
, cu_header
);
1753 case DW_TAG_imported_declaration
:
1754 case DW_TAG_imported_module
:
1755 /* FIXME: carlton/2002-10-16: Eventually, we should use the
1756 information contained in these. DW_TAG_imported_declaration
1757 dies shouldn't have children; DW_TAG_imported_module dies
1758 shouldn't in the C++ case, but conceivably could in the
1759 Fortran case, so we'll have to replace this gdb_assert if
1760 Fortran compilers start generating that info. */
1761 gdb_assert (!die
->has_children
);
1764 new_symbol (die
, NULL
, objfile
, cu_header
);
1770 initialize_cu_func_list (void)
1772 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1776 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1777 const struct comp_unit_head
*cu_header
)
1779 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1780 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1781 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1782 struct attribute
*attr
;
1783 char *name
= "<unknown>";
1784 char *comp_dir
= NULL
;
1785 struct die_info
*child_die
;
1786 bfd
*abfd
= objfile
->obfd
;
1787 struct line_header
*line_header
= 0;
1789 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1791 if (die
->has_children
)
1793 child_die
= die
->next
;
1794 while (child_die
&& child_die
->tag
)
1796 if (child_die
->tag
== DW_TAG_subprogram
)
1798 CORE_ADDR low
, high
;
1800 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1802 lowpc
= min (lowpc
, low
);
1803 highpc
= max (highpc
, high
);
1806 child_die
= sibling_die (child_die
);
1811 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1812 from finish_block. */
1813 if (lowpc
== ((CORE_ADDR
) -1))
1818 attr
= dwarf_attr (die
, DW_AT_name
);
1821 name
= DW_STRING (attr
);
1823 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1826 comp_dir
= DW_STRING (attr
);
1829 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1830 directory, get rid of it. */
1831 char *cp
= strchr (comp_dir
, ':');
1833 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1838 if (objfile
->ei
.entry_point
>= lowpc
&&
1839 objfile
->ei
.entry_point
< highpc
)
1841 objfile
->ei
.entry_file_lowpc
= lowpc
;
1842 objfile
->ei
.entry_file_highpc
= highpc
;
1845 attr
= dwarf_attr (die
, DW_AT_language
);
1848 set_cu_language (DW_UNSND (attr
));
1851 /* We assume that we're processing GCC output. */
1852 processing_gcc_compilation
= 2;
1854 /* FIXME:Do something here. */
1855 if (dip
->at_producer
!= NULL
)
1857 handle_producer (dip
->at_producer
);
1861 /* The compilation unit may be in a different language or objfile,
1862 zero out all remembered fundamental types. */
1863 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1865 start_symtab (name
, comp_dir
, lowpc
);
1866 record_debugformat ("DWARF 2");
1868 initialize_cu_func_list ();
1870 /* Process all dies in compilation unit. */
1871 if (die
->has_children
)
1873 child_die
= die
->next
;
1874 while (child_die
&& child_die
->tag
)
1876 process_die (child_die
, objfile
, cu_header
);
1877 child_die
= sibling_die (child_die
);
1881 /* Decode line number information if present. */
1882 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1885 unsigned int line_offset
= DW_UNSND (attr
);
1886 line_header
= dwarf_decode_line_header (line_offset
,
1890 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
1891 (void *) line_header
);
1892 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu_header
);
1896 /* Decode macro information, if present. Dwarf 2 macro information
1897 refers to information in the line number info statement program
1898 header, so we can only read it if we've read the header
1900 attr
= dwarf_attr (die
, DW_AT_macro_info
);
1901 if (attr
&& line_header
)
1903 unsigned int macro_offset
= DW_UNSND (attr
);
1904 dwarf_decode_macros (line_header
, macro_offset
,
1905 comp_dir
, abfd
, cu_header
, objfile
);
1907 do_cleanups (back_to
);
1911 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
1913 struct function_range
*thisfn
;
1915 thisfn
= (struct function_range
*)
1916 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
1917 thisfn
->name
= name
;
1918 thisfn
->lowpc
= lowpc
;
1919 thisfn
->highpc
= highpc
;
1920 thisfn
->seen_line
= 0;
1921 thisfn
->next
= NULL
;
1923 if (cu_last_fn
== NULL
)
1924 cu_first_fn
= thisfn
;
1926 cu_last_fn
->next
= thisfn
;
1928 cu_last_fn
= thisfn
;
1932 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
1933 const struct comp_unit_head
*cu_header
)
1935 register struct context_stack
*new;
1938 struct die_info
*child_die
;
1939 struct attribute
*attr
;
1942 name
= dwarf2_linkage_name (die
);
1944 /* Ignore functions with missing or empty names and functions with
1945 missing or invalid low and high pc attributes. */
1946 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1952 /* Record the function range for dwarf_decode_lines. */
1953 add_to_cu_func_list (name
, lowpc
, highpc
);
1955 if (objfile
->ei
.entry_point
>= lowpc
&&
1956 objfile
->ei
.entry_point
< highpc
)
1958 objfile
->ei
.entry_func_lowpc
= lowpc
;
1959 objfile
->ei
.entry_func_highpc
= highpc
;
1962 /* Decode DW_AT_frame_base location descriptor if present, keep result
1963 for DW_OP_fbreg operands in decode_locdesc. */
1964 frame_base_reg
= -1;
1965 frame_base_offset
= 0;
1966 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1971 /* Support the .debug_loc offsets */
1972 if (attr_form_is_block (attr
))
1974 addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
1976 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
1978 complain (&dwarf2_complex_location_expr
);
1983 complain (&dwarf2_invalid_attrib_class
, "DW_AT_frame_base", name
);
1988 complain (&dwarf2_unsupported_at_frame_base
, name
);
1990 frame_base_reg
= addr
;
1993 frame_base_reg
= basereg
;
1994 frame_base_offset
= addr
;
1997 complain (&dwarf2_unsupported_at_frame_base
, name
);
2000 new = push_context (0, lowpc
);
2001 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
2002 list_in_scope
= &local_symbols
;
2004 if (die
->has_children
)
2006 child_die
= die
->next
;
2007 while (child_die
&& child_die
->tag
)
2009 process_die (child_die
, objfile
, cu_header
);
2010 child_die
= sibling_die (child_die
);
2014 new = pop_context ();
2015 /* Make a block for the local symbols within. */
2016 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2017 lowpc
, highpc
, objfile
);
2019 /* In C++, we can have functions nested inside functions (e.g., when
2020 a function declares a class that has methods). This means that
2021 when we finish processing a function scope, we may need to go
2022 back to building a containing block's symbol lists. */
2023 local_symbols
= new->locals
;
2024 param_symbols
= new->params
;
2026 /* If we've finished processing a top-level function, subsequent
2027 symbols go in the file symbol list. */
2028 if (outermost_context_p ())
2029 list_in_scope
= &file_symbols
;
2032 /* Process all the DIES contained within a lexical block scope. Start
2033 a new scope, process the dies, and then close the scope. */
2036 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
2037 const struct comp_unit_head
*cu_header
)
2039 register struct context_stack
*new;
2040 CORE_ADDR lowpc
, highpc
;
2041 struct die_info
*child_die
;
2043 /* Ignore blocks with missing or invalid low and high pc attributes. */
2044 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
2049 push_context (0, lowpc
);
2050 if (die
->has_children
)
2052 child_die
= die
->next
;
2053 while (child_die
&& child_die
->tag
)
2055 process_die (child_die
, objfile
, cu_header
);
2056 child_die
= sibling_die (child_die
);
2059 new = pop_context ();
2061 if (local_symbols
!= NULL
)
2063 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2066 local_symbols
= new->locals
;
2069 /* Get low and high pc attributes from a die.
2070 Return 1 if the attributes are present and valid, otherwise, return 0. */
2073 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2074 struct objfile
*objfile
)
2076 struct attribute
*attr
;
2080 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2082 low
= DW_ADDR (attr
);
2085 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2087 high
= DW_ADDR (attr
);
2094 /* When using the GNU linker, .gnu.linkonce. sections are used to
2095 eliminate duplicate copies of functions and vtables and such.
2096 The linker will arbitrarily choose one and discard the others.
2097 The AT_*_pc values for such functions refer to local labels in
2098 these sections. If the section from that file was discarded, the
2099 labels are not in the output, so the relocs get a value of 0.
2100 If this is a discarded function, mark the pc bounds as invalid,
2101 so that GDB will ignore it. */
2102 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
2110 /* Add an aggregate field to the field list. */
2113 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2114 struct objfile
*objfile
,
2115 const struct comp_unit_head
*cu_header
)
2117 struct nextfield
*new_field
;
2118 struct attribute
*attr
;
2120 char *fieldname
= "";
2122 /* Allocate a new field list entry and link it in. */
2123 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2124 make_cleanup (xfree
, new_field
);
2125 memset (new_field
, 0, sizeof (struct nextfield
));
2126 new_field
->next
= fip
->fields
;
2127 fip
->fields
= new_field
;
2130 /* Handle accessibility and virtuality of field.
2131 The default accessibility for members is public, the default
2132 accessibility for inheritance is private. */
2133 if (die
->tag
!= DW_TAG_inheritance
)
2134 new_field
->accessibility
= DW_ACCESS_public
;
2136 new_field
->accessibility
= DW_ACCESS_private
;
2137 new_field
->virtuality
= DW_VIRTUALITY_none
;
2139 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2141 new_field
->accessibility
= DW_UNSND (attr
);
2142 if (new_field
->accessibility
!= DW_ACCESS_public
)
2143 fip
->non_public_fields
= 1;
2144 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2146 new_field
->virtuality
= DW_UNSND (attr
);
2148 fp
= &new_field
->field
;
2150 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
))
2152 /* Data member other than a C++ static data member. */
2154 /* Get type of field. */
2155 fp
->type
= die_type (die
, objfile
, cu_header
);
2157 FIELD_STATIC_KIND (*fp
) = 0;
2159 /* Get bit size of field (zero if none). */
2160 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2163 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2167 FIELD_BITSIZE (*fp
) = 0;
2170 /* Get bit offset of field. */
2171 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2174 FIELD_BITPOS (*fp
) =
2175 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
2178 FIELD_BITPOS (*fp
) = 0;
2179 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2182 if (BITS_BIG_ENDIAN
)
2184 /* For big endian bits, the DW_AT_bit_offset gives the
2185 additional bit offset from the MSB of the containing
2186 anonymous object to the MSB of the field. We don't
2187 have to do anything special since we don't need to
2188 know the size of the anonymous object. */
2189 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2193 /* For little endian bits, compute the bit offset to the
2194 MSB of the anonymous object, subtract off the number of
2195 bits from the MSB of the field to the MSB of the
2196 object, and then subtract off the number of bits of
2197 the field itself. The result is the bit offset of
2198 the LSB of the field. */
2200 int bit_offset
= DW_UNSND (attr
);
2202 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2205 /* The size of the anonymous object containing
2206 the bit field is explicit, so use the
2207 indicated size (in bytes). */
2208 anonymous_size
= DW_UNSND (attr
);
2212 /* The size of the anonymous object containing
2213 the bit field must be inferred from the type
2214 attribute of the data member containing the
2216 anonymous_size
= TYPE_LENGTH (fp
->type
);
2218 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2219 - bit_offset
- FIELD_BITSIZE (*fp
);
2223 /* Get name of field. */
2224 attr
= dwarf_attr (die
, DW_AT_name
);
2225 if (attr
&& DW_STRING (attr
))
2226 fieldname
= DW_STRING (attr
);
2227 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2228 &objfile
->type_obstack
);
2230 /* Change accessibility for artificial fields (e.g. virtual table
2231 pointer or virtual base class pointer) to private. */
2232 if (dwarf_attr (die
, DW_AT_artificial
))
2234 new_field
->accessibility
= DW_ACCESS_private
;
2235 fip
->non_public_fields
= 1;
2238 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
2240 /* C++ static member. */
2242 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2243 is a declaration, but all versions of G++ as of this writing
2244 (so through at least 3.2.1) incorrectly generate
2245 DW_TAG_variable tags. */
2249 /* Get name of field. */
2250 attr
= dwarf_attr (die
, DW_AT_name
);
2251 if (attr
&& DW_STRING (attr
))
2252 fieldname
= DW_STRING (attr
);
2256 /* Get physical name. */
2257 physname
= dwarf2_linkage_name (die
);
2259 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2260 &objfile
->type_obstack
));
2261 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2262 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2263 &objfile
->type_obstack
);
2265 else if (die
->tag
== DW_TAG_inheritance
)
2267 /* C++ base class field. */
2268 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2270 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
2272 FIELD_BITSIZE (*fp
) = 0;
2273 FIELD_STATIC_KIND (*fp
) = 0;
2274 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2275 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2276 fip
->nbaseclasses
++;
2280 /* Create the vector of fields, and attach it to the type. */
2283 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2284 struct objfile
*objfile
)
2286 int nfields
= fip
->nfields
;
2288 /* Record the field count, allocate space for the array of fields,
2289 and create blank accessibility bitfields if necessary. */
2290 TYPE_NFIELDS (type
) = nfields
;
2291 TYPE_FIELDS (type
) = (struct field
*)
2292 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2293 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2295 if (fip
->non_public_fields
)
2297 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2299 TYPE_FIELD_PRIVATE_BITS (type
) =
2300 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2301 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2303 TYPE_FIELD_PROTECTED_BITS (type
) =
2304 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2305 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2307 TYPE_FIELD_IGNORE_BITS (type
) =
2308 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2309 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2312 /* If the type has baseclasses, allocate and clear a bit vector for
2313 TYPE_FIELD_VIRTUAL_BITS. */
2314 if (fip
->nbaseclasses
)
2316 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2319 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2320 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2321 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2322 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2323 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2326 /* Copy the saved-up fields into the field vector. Start from the head
2327 of the list, adding to the tail of the field array, so that they end
2328 up in the same order in the array in which they were added to the list. */
2329 while (nfields
-- > 0)
2331 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2332 switch (fip
->fields
->accessibility
)
2334 case DW_ACCESS_private
:
2335 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2338 case DW_ACCESS_protected
:
2339 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2342 case DW_ACCESS_public
:
2346 /* Unknown accessibility. Complain and treat it as public. */
2348 complain (&dwarf2_unsupported_accessibility
,
2349 fip
->fields
->accessibility
);
2353 if (nfields
< fip
->nbaseclasses
)
2355 switch (fip
->fields
->virtuality
)
2357 case DW_VIRTUALITY_virtual
:
2358 case DW_VIRTUALITY_pure_virtual
:
2359 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2363 fip
->fields
= fip
->fields
->next
;
2367 /* Add a member function to the proper fieldlist. */
2370 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2371 struct type
*type
, struct objfile
*objfile
,
2372 const struct comp_unit_head
*cu_header
)
2374 struct attribute
*attr
;
2375 struct fnfieldlist
*flp
;
2377 struct fn_field
*fnp
;
2380 struct nextfnfield
*new_fnfield
;
2382 /* Get name of member function. */
2383 attr
= dwarf_attr (die
, DW_AT_name
);
2384 if (attr
&& DW_STRING (attr
))
2385 fieldname
= DW_STRING (attr
);
2389 /* Get the mangled name. */
2390 physname
= dwarf2_linkage_name (die
);
2392 /* Look up member function name in fieldlist. */
2393 for (i
= 0; i
< fip
->nfnfields
; i
++)
2395 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2399 /* Create new list element if necessary. */
2400 if (i
< fip
->nfnfields
)
2401 flp
= &fip
->fnfieldlists
[i
];
2404 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2406 fip
->fnfieldlists
= (struct fnfieldlist
*)
2407 xrealloc (fip
->fnfieldlists
,
2408 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2409 * sizeof (struct fnfieldlist
));
2410 if (fip
->nfnfields
== 0)
2411 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2413 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2414 flp
->name
= fieldname
;
2420 /* Create a new member function field and chain it to the field list
2422 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2423 make_cleanup (xfree
, new_fnfield
);
2424 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2425 new_fnfield
->next
= flp
->head
;
2426 flp
->head
= new_fnfield
;
2429 /* Fill in the member function field info. */
2430 fnp
= &new_fnfield
->fnfield
;
2431 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2432 &objfile
->type_obstack
);
2433 fnp
->type
= alloc_type (objfile
);
2434 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2436 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2437 int nparams
= TYPE_NFIELDS (die
->type
);
2439 /* TYPE is the domain of this method, and DIE->TYPE is the type
2440 of the method itself (TYPE_CODE_METHOD). */
2441 smash_to_method_type (fnp
->type
, type
,
2442 TYPE_TARGET_TYPE (die
->type
),
2443 TYPE_FIELDS (die
->type
),
2444 TYPE_NFIELDS (die
->type
),
2445 TYPE_VARARGS (die
->type
));
2447 /* Handle static member functions.
2448 Dwarf2 has no clean way to discern C++ static and non-static
2449 member functions. G++ helps GDB by marking the first
2450 parameter for non-static member functions (which is the
2451 this pointer) as artificial. We obtain this information
2452 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2453 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2454 fnp
->voffset
= VOFFSET_STATIC
;
2457 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2459 /* Get fcontext from DW_AT_containing_type if present. */
2460 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2461 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2463 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2464 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2466 /* Get accessibility. */
2467 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2470 switch (DW_UNSND (attr
))
2472 case DW_ACCESS_private
:
2473 fnp
->is_private
= 1;
2475 case DW_ACCESS_protected
:
2476 fnp
->is_protected
= 1;
2481 /* Check for artificial methods. */
2482 attr
= dwarf_attr (die
, DW_AT_artificial
);
2483 if (attr
&& DW_UNSND (attr
) != 0)
2484 fnp
->is_artificial
= 1;
2486 /* Get index in virtual function table if it is a virtual member function. */
2487 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2490 /* Support the .debug_loc offsets */
2491 if (attr_form_is_block (attr
))
2493 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2495 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2497 complain (&dwarf2_complex_location_expr
);
2501 complain (&dwarf2_invalid_attrib_class
, "DW_AT_vtable_elem_location",
2507 /* Create the vector of member function fields, and attach it to the type. */
2510 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2511 struct objfile
*objfile
)
2513 struct fnfieldlist
*flp
;
2514 int total_length
= 0;
2517 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2518 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2519 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2521 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2523 struct nextfnfield
*nfp
= flp
->head
;
2524 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2527 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2528 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2529 fn_flp
->fn_fields
= (struct fn_field
*)
2530 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2531 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2532 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2534 total_length
+= flp
->length
;
2537 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2538 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2541 /* Called when we find the DIE that starts a structure or union scope
2542 (definition) to process all dies that define the members of the
2545 NOTE: we need to call struct_type regardless of whether or not the
2546 DIE has an at_name attribute, since it might be an anonymous
2547 structure or union. This gets the type entered into our set of
2550 However, if the structure is incomplete (an opaque struct/union)
2551 then suppress creating a symbol table entry for it since gdb only
2552 wants to find the one with the complete definition. Note that if
2553 it is complete, we just call new_symbol, which does it's own
2554 checking about whether the struct/union is anonymous or not (and
2555 suppresses creating a symbol table entry itself). */
2558 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2559 const struct comp_unit_head
*cu_header
)
2562 struct attribute
*attr
;
2564 type
= alloc_type (objfile
);
2566 INIT_CPLUS_SPECIFIC (type
);
2567 attr
= dwarf_attr (die
, DW_AT_name
);
2568 if (attr
&& DW_STRING (attr
))
2570 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2571 strlen (DW_STRING (attr
)),
2572 &objfile
->type_obstack
);
2575 if (die
->tag
== DW_TAG_structure_type
)
2577 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2579 else if (die
->tag
== DW_TAG_union_type
)
2581 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2585 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2587 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2590 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2593 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2597 TYPE_LENGTH (type
) = 0;
2600 /* We need to add the type field to the die immediately so we don't
2601 infinitely recurse when dealing with pointers to the structure
2602 type within the structure itself. */
2605 if (die
->has_children
&& ! die_is_declaration (die
))
2607 struct field_info fi
;
2608 struct die_info
*child_die
;
2609 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2611 memset (&fi
, 0, sizeof (struct field_info
));
2613 child_die
= die
->next
;
2615 while (child_die
&& child_die
->tag
)
2617 if (child_die
->tag
== DW_TAG_member
2618 || child_die
->tag
== DW_TAG_variable
)
2620 /* NOTE: carlton/2002-11-05: A C++ static data member
2621 should be a DW_TAG_member that is a declaration, but
2622 all versions of G++ as of this writing (so through at
2623 least 3.2.1) incorrectly generate DW_TAG_variable
2624 tags for them instead. */
2625 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2627 else if (child_die
->tag
== DW_TAG_subprogram
)
2629 /* C++ member function. */
2630 process_die (child_die
, objfile
, cu_header
);
2631 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2633 else if (child_die
->tag
== DW_TAG_inheritance
)
2635 /* C++ base class field. */
2636 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2640 process_die (child_die
, objfile
, cu_header
);
2642 child_die
= sibling_die (child_die
);
2645 /* Attach fields and member functions to the type. */
2647 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2650 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2652 /* Get the type which refers to the base class (possibly this
2653 class itself) which contains the vtable pointer for the current
2654 class from the DW_AT_containing_type attribute. */
2656 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2658 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2660 TYPE_VPTR_BASETYPE (type
) = t
;
2663 static const char vptr_name
[] =
2664 {'_', 'v', 'p', 't', 'r', '\0'};
2667 /* Our own class provides vtbl ptr. */
2668 for (i
= TYPE_NFIELDS (t
) - 1;
2669 i
>= TYPE_N_BASECLASSES (t
);
2672 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2674 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2675 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2677 TYPE_VPTR_FIELDNO (type
) = i
;
2682 /* Complain if virtual function table field not found. */
2683 if (i
< TYPE_N_BASECLASSES (t
))
2684 complain (&dwarf2_vtbl_not_found_complaint
,
2685 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2689 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2694 new_symbol (die
, type
, objfile
, cu_header
);
2696 do_cleanups (back_to
);
2700 /* No children, must be stub. */
2701 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2705 /* Given a pointer to a die which begins an enumeration, process all
2706 the dies that define the members of the enumeration.
2708 This will be much nicer in draft 6 of the DWARF spec when our
2709 members will be dies instead squished into the DW_AT_element_list
2712 NOTE: We reverse the order of the element list. */
2715 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2716 const struct comp_unit_head
*cu_header
)
2718 struct die_info
*child_die
;
2720 struct field
*fields
;
2721 struct attribute
*attr
;
2724 int unsigned_enum
= 1;
2726 type
= alloc_type (objfile
);
2728 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2729 attr
= dwarf_attr (die
, DW_AT_name
);
2730 if (attr
&& DW_STRING (attr
))
2732 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2733 strlen (DW_STRING (attr
)),
2734 &objfile
->type_obstack
);
2737 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2740 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2744 TYPE_LENGTH (type
) = 0;
2749 if (die
->has_children
)
2751 child_die
= die
->next
;
2752 while (child_die
&& child_die
->tag
)
2754 if (child_die
->tag
!= DW_TAG_enumerator
)
2756 process_die (child_die
, objfile
, cu_header
);
2760 attr
= dwarf_attr (child_die
, DW_AT_name
);
2763 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2764 if (SYMBOL_VALUE (sym
) < 0)
2767 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2769 fields
= (struct field
*)
2771 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2772 * sizeof (struct field
));
2775 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2776 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2777 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2778 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2779 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
2785 child_die
= sibling_die (child_die
);
2790 TYPE_NFIELDS (type
) = num_fields
;
2791 TYPE_FIELDS (type
) = (struct field
*)
2792 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2793 memcpy (TYPE_FIELDS (type
), fields
,
2794 sizeof (struct field
) * num_fields
);
2798 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2801 new_symbol (die
, type
, objfile
, cu_header
);
2804 /* Extract all information from a DW_TAG_array_type DIE and put it in
2805 the DIE's type field. For now, this only handles one dimensional
2809 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2810 const struct comp_unit_head
*cu_header
)
2812 struct die_info
*child_die
;
2813 struct type
*type
= NULL
;
2814 struct type
*element_type
, *range_type
, *index_type
;
2815 struct type
**range_types
= NULL
;
2816 struct attribute
*attr
;
2818 struct cleanup
*back_to
;
2820 /* Return if we've already decoded this type. */
2826 element_type
= die_type (die
, objfile
, cu_header
);
2828 /* Irix 6.2 native cc creates array types without children for
2829 arrays with unspecified length. */
2830 if (die
->has_children
== 0)
2832 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2833 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2834 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2838 back_to
= make_cleanup (null_cleanup
, NULL
);
2839 child_die
= die
->next
;
2840 while (child_die
&& child_die
->tag
)
2842 if (child_die
->tag
== DW_TAG_subrange_type
)
2844 unsigned int low
, high
;
2846 /* Default bounds to an array with unspecified length. */
2849 if (cu_language
== language_fortran
)
2851 /* FORTRAN implies a lower bound of 1, if not given. */
2855 index_type
= die_type (child_die
, objfile
, cu_header
);
2856 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2859 if (attr
->form
== DW_FORM_sdata
)
2861 low
= DW_SND (attr
);
2863 else if (attr
->form
== DW_FORM_udata
2864 || attr
->form
== DW_FORM_data1
2865 || attr
->form
== DW_FORM_data2
2866 || attr
->form
== DW_FORM_data4
2867 || attr
->form
== DW_FORM_data8
)
2869 low
= DW_UNSND (attr
);
2873 complain (&dwarf2_non_const_array_bound_ignored
,
2874 dwarf_form_name (attr
->form
));
2876 die
->type
= lookup_pointer_type (element_type
);
2883 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2886 if (attr
->form
== DW_FORM_sdata
)
2888 high
= DW_SND (attr
);
2890 else if (attr
->form
== DW_FORM_udata
2891 || attr
->form
== DW_FORM_data1
2892 || attr
->form
== DW_FORM_data2
2893 || attr
->form
== DW_FORM_data4
2894 || attr
->form
== DW_FORM_data8
)
2896 high
= DW_UNSND (attr
);
2898 else if (attr
->form
== DW_FORM_block1
)
2900 /* GCC encodes arrays with unspecified or dynamic length
2901 with a DW_FORM_block1 attribute.
2902 FIXME: GDB does not yet know how to handle dynamic
2903 arrays properly, treat them as arrays with unspecified
2909 complain (&dwarf2_non_const_array_bound_ignored
,
2910 dwarf_form_name (attr
->form
));
2912 die
->type
= lookup_pointer_type (element_type
);
2920 /* Create a range type and save it for array type creation. */
2921 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2923 range_types
= (struct type
**)
2924 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2925 * sizeof (struct type
*));
2927 make_cleanup (free_current_contents
, &range_types
);
2929 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2931 child_die
= sibling_die (child_die
);
2934 /* Dwarf2 dimensions are output from left to right, create the
2935 necessary array types in backwards order. */
2936 type
= element_type
;
2938 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2940 /* Understand Dwarf2 support for vector types (like they occur on
2941 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
2942 array type. This is not part of the Dwarf2/3 standard yet, but a
2943 custom vendor extension. The main difference between a regular
2944 array and the vector variant is that vectors are passed by value
2946 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
2948 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
2950 do_cleanups (back_to
);
2952 /* Install the type in the die. */
2956 /* First cut: install each common block member as a global variable. */
2959 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
2960 const struct comp_unit_head
*cu_header
)
2962 struct die_info
*child_die
;
2963 struct attribute
*attr
;
2965 CORE_ADDR base
= (CORE_ADDR
) 0;
2967 attr
= dwarf_attr (die
, DW_AT_location
);
2970 /* Support the .debug_loc offsets */
2971 if (attr_form_is_block (attr
))
2973 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2975 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2977 complain (&dwarf2_complex_location_expr
);
2981 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
2982 "common block member");
2985 if (die
->has_children
)
2987 child_die
= die
->next
;
2988 while (child_die
&& child_die
->tag
)
2990 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
2991 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2994 SYMBOL_VALUE_ADDRESS (sym
) =
2995 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2996 add_symbol_to_list (sym
, &global_symbols
);
2998 child_die
= sibling_die (child_die
);
3003 /* Read a C++ namespace. */
3005 /* FIXME: carlton/2002-10-16: For now, we don't actually do anything
3006 useful with the namespace data: we just process its children. */
3009 read_namespace (struct die_info
*die
, struct objfile
*objfile
,
3010 const struct comp_unit_head
*cu_header
)
3012 if (die
->has_children
)
3014 struct die_info
*child_die
= die
->next
;
3016 while (child_die
&& child_die
->tag
)
3018 process_die (child_die
, objfile
, cu_header
);
3019 child_die
= sibling_die (child_die
);
3024 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3025 the user defined type vector. */
3028 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
3029 const struct comp_unit_head
*cu_header
)
3032 struct attribute
*attr_byte_size
;
3033 struct attribute
*attr_address_class
;
3034 int byte_size
, addr_class
;
3041 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
3043 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
3045 byte_size
= DW_UNSND (attr_byte_size
);
3047 byte_size
= cu_header
->addr_size
;
3049 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
3050 if (attr_address_class
)
3051 addr_class
= DW_UNSND (attr_address_class
);
3053 addr_class
= DW_ADDR_none
;
3055 /* If the pointer size or address class is different than the
3056 default, create a type variant marked as such and set the
3057 length accordingly. */
3058 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3060 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3064 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3065 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3066 type
= make_type_with_address_space (type
, type_flags
);
3068 else if (TYPE_LENGTH (type
) != byte_size
)
3070 complain (&dwarf2_invalid_pointer_size
, byte_size
);
3073 /* Should we also complain about unhandled address classes? */
3077 TYPE_LENGTH (type
) = byte_size
;
3081 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3082 the user defined type vector. */
3085 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
3086 const struct comp_unit_head
*cu_header
)
3089 struct type
*to_type
;
3090 struct type
*domain
;
3097 type
= alloc_type (objfile
);
3098 to_type
= die_type (die
, objfile
, cu_header
);
3099 domain
= die_containing_type (die
, objfile
, cu_header
);
3100 smash_to_member_type (type
, domain
, to_type
);
3105 /* Extract all information from a DW_TAG_reference_type DIE and add to
3106 the user defined type vector. */
3109 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
3110 const struct comp_unit_head
*cu_header
)
3113 struct attribute
*attr
;
3120 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
3121 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3124 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3128 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3134 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
3135 const struct comp_unit_head
*cu_header
)
3137 struct type
*base_type
;
3144 base_type
= die_type (die
, objfile
, cu_header
);
3145 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3149 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
3150 const struct comp_unit_head
*cu_header
)
3152 struct type
*base_type
;
3159 base_type
= die_type (die
, objfile
, cu_header
);
3160 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3163 /* Extract all information from a DW_TAG_string_type DIE and add to
3164 the user defined type vector. It isn't really a user defined type,
3165 but it behaves like one, with other DIE's using an AT_user_def_type
3166 attribute to reference it. */
3169 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
3171 struct type
*type
, *range_type
, *index_type
, *char_type
;
3172 struct attribute
*attr
;
3173 unsigned int length
;
3180 attr
= dwarf_attr (die
, DW_AT_string_length
);
3183 length
= DW_UNSND (attr
);
3187 /* check for the DW_AT_byte_size attribute */
3188 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3191 length
= DW_UNSND (attr
);
3198 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3199 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3200 if (cu_language
== language_fortran
)
3202 /* Need to create a unique string type for bounds
3204 type
= create_string_type (0, range_type
);
3208 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3209 type
= create_string_type (char_type
, range_type
);
3214 /* Handle DIES due to C code like:
3218 int (*funcp)(int a, long l);
3222 ('funcp' generates a DW_TAG_subroutine_type DIE)
3226 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
3227 const struct comp_unit_head
*cu_header
)
3229 struct type
*type
; /* Type that this function returns */
3230 struct type
*ftype
; /* Function that returns above type */
3231 struct attribute
*attr
;
3233 /* Decode the type that this subroutine returns */
3238 type
= die_type (die
, objfile
, cu_header
);
3239 ftype
= lookup_function_type (type
);
3241 /* All functions in C++ have prototypes. */
3242 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3243 if ((attr
&& (DW_UNSND (attr
) != 0))
3244 || cu_language
== language_cplus
)
3245 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3247 if (die
->has_children
)
3249 struct die_info
*child_die
;
3253 /* Count the number of parameters.
3254 FIXME: GDB currently ignores vararg functions, but knows about
3255 vararg member functions. */
3256 child_die
= die
->next
;
3257 while (child_die
&& child_die
->tag
)
3259 if (child_die
->tag
== DW_TAG_formal_parameter
)
3261 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3262 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3263 child_die
= sibling_die (child_die
);
3266 /* Allocate storage for parameters and fill them in. */
3267 TYPE_NFIELDS (ftype
) = nparams
;
3268 TYPE_FIELDS (ftype
) = (struct field
*)
3269 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3271 child_die
= die
->next
;
3272 while (child_die
&& child_die
->tag
)
3274 if (child_die
->tag
== DW_TAG_formal_parameter
)
3276 /* Dwarf2 has no clean way to discern C++ static and non-static
3277 member functions. G++ helps GDB by marking the first
3278 parameter for non-static member functions (which is the
3279 this pointer) as artificial. We pass this information
3280 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3281 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3283 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3285 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3286 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
3290 child_die
= sibling_die (child_die
);
3298 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
3299 const struct comp_unit_head
*cu_header
)
3301 struct attribute
*attr
;
3306 attr
= dwarf_attr (die
, DW_AT_name
);
3307 if (attr
&& DW_STRING (attr
))
3309 name
= DW_STRING (attr
);
3311 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3312 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
3316 /* Find a representation of a given base type and install
3317 it in the TYPE field of the die. */
3320 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
3323 struct attribute
*attr
;
3324 int encoding
= 0, size
= 0;
3326 /* If we've already decoded this die, this is a no-op. */
3332 attr
= dwarf_attr (die
, DW_AT_encoding
);
3335 encoding
= DW_UNSND (attr
);
3337 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3340 size
= DW_UNSND (attr
);
3342 attr
= dwarf_attr (die
, DW_AT_name
);
3343 if (attr
&& DW_STRING (attr
))
3345 enum type_code code
= TYPE_CODE_INT
;
3350 case DW_ATE_address
:
3351 /* Turn DW_ATE_address into a void * pointer. */
3352 code
= TYPE_CODE_PTR
;
3353 type_flags
|= TYPE_FLAG_UNSIGNED
;
3355 case DW_ATE_boolean
:
3356 code
= TYPE_CODE_BOOL
;
3357 type_flags
|= TYPE_FLAG_UNSIGNED
;
3359 case DW_ATE_complex_float
:
3360 code
= TYPE_CODE_COMPLEX
;
3363 code
= TYPE_CODE_FLT
;
3366 case DW_ATE_signed_char
:
3368 case DW_ATE_unsigned
:
3369 case DW_ATE_unsigned_char
:
3370 type_flags
|= TYPE_FLAG_UNSIGNED
;
3373 complain (&dwarf2_unsupported_at_encoding
,
3374 dwarf_type_encoding_name (encoding
));
3377 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3378 if (encoding
== DW_ATE_address
)
3379 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3380 else if (encoding
== DW_ATE_complex_float
)
3383 TYPE_TARGET_TYPE (type
)
3384 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3385 else if (size
== 16)
3386 TYPE_TARGET_TYPE (type
)
3387 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3389 TYPE_TARGET_TYPE (type
)
3390 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3395 type
= dwarf_base_type (encoding
, size
, objfile
);
3400 /* Read a whole compilation unit into a linked list of dies. */
3402 static struct die_info
*
3403 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3404 const struct comp_unit_head
*cu_header
)
3406 struct die_info
*first_die
, *last_die
, *die
;
3410 /* Reset die reference table; we are
3411 building new ones now. */
3412 dwarf2_empty_hash_tables ();
3416 first_die
= last_die
= NULL
;
3419 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3420 if (die
->has_children
)
3431 /* Enter die in reference hash table */
3432 store_in_ref_table (die
->offset
, die
);
3436 first_die
= last_die
= die
;
3440 last_die
->next
= die
;
3444 while (nesting_level
> 0);
3448 /* Free a linked list of dies. */
3451 free_die_list (struct die_info
*dies
)
3453 struct die_info
*die
, *next
;
3466 do_free_die_list_cleanup (void *dies
)
3468 free_die_list (dies
);
3471 static struct cleanup
*
3472 make_cleanup_free_die_list (struct die_info
*dies
)
3474 return make_cleanup (do_free_die_list_cleanup
, dies
);
3478 /* Read the contents of the section at OFFSET and of size SIZE from the
3479 object file specified by OBJFILE into the psymbol_obstack and return it. */
3482 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3485 bfd
*abfd
= objfile
->obfd
;
3491 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3492 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3493 (bfd_bread (buf
, size
, abfd
) != size
))
3496 error ("Dwarf Error: Can't read DWARF data from '%s'",
3497 bfd_get_filename (abfd
));
3502 /* In DWARF version 2, the description of the debugging information is
3503 stored in a separate .debug_abbrev section. Before we read any
3504 dies from a section we read in all abbreviations and install them
3508 dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
)
3511 struct abbrev_info
*cur_abbrev
;
3512 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3513 unsigned int abbrev_form
, hash_number
;
3515 /* Initialize dwarf2 abbrevs */
3516 memset (cu_header
->dwarf2_abbrevs
, 0,
3517 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
3519 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
3520 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3521 abbrev_ptr
+= bytes_read
;
3523 /* loop until we reach an abbrev number of 0 */
3524 while (abbrev_number
)
3526 cur_abbrev
= dwarf_alloc_abbrev ();
3528 /* read in abbrev header */
3529 cur_abbrev
->number
= abbrev_number
;
3530 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3531 abbrev_ptr
+= bytes_read
;
3532 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3535 /* now read in declarations */
3536 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3537 abbrev_ptr
+= bytes_read
;
3538 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3539 abbrev_ptr
+= bytes_read
;
3542 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3544 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3545 xrealloc (cur_abbrev
->attrs
,
3546 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3547 * sizeof (struct attr_abbrev
));
3549 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3550 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3551 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3552 abbrev_ptr
+= bytes_read
;
3553 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3554 abbrev_ptr
+= bytes_read
;
3557 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3558 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
3559 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3561 /* Get next abbreviation.
3562 Under Irix6 the abbreviations for a compilation unit are not
3563 always properly terminated with an abbrev number of 0.
3564 Exit loop if we encounter an abbreviation which we have
3565 already read (which means we are about to read the abbreviations
3566 for the next compile unit) or if the end of the abbreviation
3567 table is reached. */
3568 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3569 >= dwarf_abbrev_size
)
3571 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3572 abbrev_ptr
+= bytes_read
;
3573 if (dwarf2_lookup_abbrev (abbrev_number
, cu_header
) != NULL
)
3578 /* Empty the abbrev table for a new compilation unit. */
3582 dwarf2_empty_abbrev_table (PTR ptr_to_abbrevs_table
)
3585 struct abbrev_info
*abbrev
, *next
;
3586 struct abbrev_info
**abbrevs
;
3588 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
3590 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3593 abbrev
= abbrevs
[i
];
3596 next
= abbrev
->next
;
3597 xfree (abbrev
->attrs
);
3605 /* Lookup an abbrev_info structure in the abbrev hash table. */
3607 static struct abbrev_info
*
3608 dwarf2_lookup_abbrev (unsigned int number
, const struct comp_unit_head
*cu_header
)
3610 unsigned int hash_number
;
3611 struct abbrev_info
*abbrev
;
3613 hash_number
= number
% ABBREV_HASH_SIZE
;
3614 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
3618 if (abbrev
->number
== number
)
3621 abbrev
= abbrev
->next
;
3626 /* Read a minimal amount of information into the minimal die structure. */
3629 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3630 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3632 unsigned int abbrev_number
, bytes_read
, i
;
3633 struct abbrev_info
*abbrev
;
3634 struct attribute attr
;
3635 struct attribute spec_attr
;
3636 int found_spec_attr
= 0;
3637 int has_low_pc_attr
= 0;
3638 int has_high_pc_attr
= 0;
3640 *part_die
= zeroed_partial_die
;
3641 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3642 info_ptr
+= bytes_read
;
3646 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3649 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3651 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3652 part_die
->tag
= abbrev
->tag
;
3653 part_die
->has_children
= abbrev
->has_children
;
3654 part_die
->abbrev
= abbrev_number
;
3656 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3658 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3659 info_ptr
, cu_header
);
3661 /* Store the data if it is of an attribute we want to keep in a
3662 partial symbol table. */
3667 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3668 if (part_die
->name
== NULL
)
3669 part_die
->name
= DW_STRING (&attr
);
3671 case DW_AT_MIPS_linkage_name
:
3672 part_die
->name
= DW_STRING (&attr
);
3675 has_low_pc_attr
= 1;
3676 part_die
->lowpc
= DW_ADDR (&attr
);
3679 has_high_pc_attr
= 1;
3680 part_die
->highpc
= DW_ADDR (&attr
);
3682 case DW_AT_location
:
3683 /* Support the .debug_loc offsets */
3684 if (attr_form_is_block (&attr
))
3686 part_die
->locdesc
= DW_BLOCK (&attr
);
3688 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
3690 complain (&dwarf2_complex_location_expr
);
3694 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
3695 "partial symbol information");
3698 case DW_AT_language
:
3699 part_die
->language
= DW_UNSND (&attr
);
3701 case DW_AT_external
:
3702 part_die
->is_external
= DW_UNSND (&attr
);
3704 case DW_AT_declaration
:
3705 part_die
->is_declaration
= DW_UNSND (&attr
);
3708 part_die
->has_type
= 1;
3710 case DW_AT_abstract_origin
:
3711 case DW_AT_specification
:
3712 found_spec_attr
= 1;
3716 /* Ignore absolute siblings, they might point outside of
3717 the current compile unit. */
3718 if (attr
.form
== DW_FORM_ref_addr
)
3719 complain (&dwarf2_absolute_sibling_complaint
);
3722 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3729 /* If we found a reference attribute and the die has no name, try
3730 to find a name in the referred to die. */
3732 if (found_spec_attr
&& part_die
->name
== NULL
)
3734 struct partial_die_info spec_die
;
3738 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3739 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3742 part_die
->name
= spec_die
.name
;
3744 /* Copy DW_AT_external attribute if it is set. */
3745 if (spec_die
.is_external
)
3746 part_die
->is_external
= spec_die
.is_external
;
3750 /* When using the GNU linker, .gnu.linkonce. sections are used to
3751 eliminate duplicate copies of functions and vtables and such.
3752 The linker will arbitrarily choose one and discard the others.
3753 The AT_*_pc values for such functions refer to local labels in
3754 these sections. If the section from that file was discarded, the
3755 labels are not in the output, so the relocs get a value of 0.
3756 If this is a discarded function, mark the pc bounds as invalid,
3757 so that GDB will ignore it. */
3758 if (has_low_pc_attr
&& has_high_pc_attr
3759 && part_die
->lowpc
< part_die
->highpc
3760 && (part_die
->lowpc
!= 0
3761 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3762 part_die
->has_pc_info
= 1;
3766 /* Read the die from the .debug_info section buffer. And set diep to
3767 point to a newly allocated die with its information. */
3770 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3771 const struct comp_unit_head
*cu_header
)
3773 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3774 struct abbrev_info
*abbrev
;
3775 struct die_info
*die
;
3777 offset
= info_ptr
- dwarf_info_buffer
;
3778 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3779 info_ptr
+= bytes_read
;
3782 die
= dwarf_alloc_die ();
3784 die
->abbrev
= abbrev_number
;
3790 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3793 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3795 die
= dwarf_alloc_die ();
3796 die
->offset
= offset
;
3797 die
->tag
= abbrev
->tag
;
3798 die
->has_children
= abbrev
->has_children
;
3799 die
->abbrev
= abbrev_number
;
3802 die
->num_attrs
= abbrev
->num_attrs
;
3803 die
->attrs
= (struct attribute
*)
3804 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3806 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3808 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3809 abfd
, info_ptr
, cu_header
);
3816 /* Read an attribute value described by an attribute form. */
3819 read_attribute_value (struct attribute
*attr
, unsigned form
,
3820 bfd
*abfd
, char *info_ptr
,
3821 const struct comp_unit_head
*cu_header
)
3823 unsigned int bytes_read
;
3824 struct dwarf_block
*blk
;
3830 case DW_FORM_ref_addr
:
3831 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3832 info_ptr
+= bytes_read
;
3834 case DW_FORM_block2
:
3835 blk
= dwarf_alloc_block ();
3836 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3838 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3839 info_ptr
+= blk
->size
;
3840 DW_BLOCK (attr
) = blk
;
3842 case DW_FORM_block4
:
3843 blk
= dwarf_alloc_block ();
3844 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3846 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3847 info_ptr
+= blk
->size
;
3848 DW_BLOCK (attr
) = blk
;
3851 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3855 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3859 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3862 case DW_FORM_string
:
3863 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3864 info_ptr
+= bytes_read
;
3867 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
3869 info_ptr
+= bytes_read
;
3872 blk
= dwarf_alloc_block ();
3873 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3874 info_ptr
+= bytes_read
;
3875 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3876 info_ptr
+= blk
->size
;
3877 DW_BLOCK (attr
) = blk
;
3879 case DW_FORM_block1
:
3880 blk
= dwarf_alloc_block ();
3881 blk
->size
= read_1_byte (abfd
, info_ptr
);
3883 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3884 info_ptr
+= blk
->size
;
3885 DW_BLOCK (attr
) = blk
;
3888 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3892 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3896 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3897 info_ptr
+= bytes_read
;
3900 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3901 info_ptr
+= bytes_read
;
3904 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3908 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3912 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3916 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3919 case DW_FORM_ref_udata
:
3920 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3921 info_ptr
+= bytes_read
;
3923 case DW_FORM_indirect
:
3924 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3925 info_ptr
+= bytes_read
;
3926 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
3929 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3930 dwarf_form_name (form
));
3935 /* Read an attribute described by an abbreviated attribute. */
3938 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
3939 bfd
*abfd
, char *info_ptr
,
3940 const struct comp_unit_head
*cu_header
)
3942 attr
->name
= abbrev
->name
;
3943 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
3946 /* read dwarf information from a buffer */
3949 read_1_byte (bfd
*abfd
, char *buf
)
3951 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3955 read_1_signed_byte (bfd
*abfd
, char *buf
)
3957 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3961 read_2_bytes (bfd
*abfd
, char *buf
)
3963 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3967 read_2_signed_bytes (bfd
*abfd
, char *buf
)
3969 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3973 read_4_bytes (bfd
*abfd
, char *buf
)
3975 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3979 read_4_signed_bytes (bfd
*abfd
, char *buf
)
3981 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3984 static unsigned long
3985 read_8_bytes (bfd
*abfd
, char *buf
)
3987 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3991 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3994 CORE_ADDR retval
= 0;
3996 if (cu_header
->signed_addr_p
)
3998 switch (cu_header
->addr_size
)
4001 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4004 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4007 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
4010 internal_error (__FILE__
, __LINE__
,
4011 "read_address: bad switch, signed");
4016 switch (cu_header
->addr_size
)
4019 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4022 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4025 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4028 internal_error (__FILE__
, __LINE__
,
4029 "read_address: bad switch, unsigned");
4033 *bytes_read
= cu_header
->addr_size
;
4037 /* Read the initial length from a section. The (draft) DWARF 3
4038 specification allows the initial length to take up either 4 bytes
4039 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4040 bytes describe the length and all offsets will be 8 bytes in length
4043 An older, non-standard 64-bit format is also handled by this
4044 function. The older format in question stores the initial length
4045 as an 8-byte quantity without an escape value. Lengths greater
4046 than 2^32 aren't very common which means that the initial 4 bytes
4047 is almost always zero. Since a length value of zero doesn't make
4048 sense for the 32-bit format, this initial zero can be considered to
4049 be an escape value which indicates the presence of the older 64-bit
4050 format. As written, the code can't detect (old format) lengths
4051 greater than 4GB. If it becomes necessary to handle lengths somewhat
4052 larger than 4GB, we could allow other small values (such as the
4053 non-sensical values of 1, 2, and 3) to also be used as escape values
4054 indicating the presence of the old format.
4056 The value returned via bytes_read should be used to increment
4057 the relevant pointer after calling read_initial_length().
4059 As a side effect, this function sets the fields initial_length_size
4060 and offset_size in cu_header to the values appropriate for the
4061 length field. (The format of the initial length field determines
4062 the width of file offsets to be fetched later with fetch_offset().)
4064 [ Note: read_initial_length() and read_offset() are based on the
4065 document entitled "DWARF Debugging Information Format", revision
4066 3, draft 8, dated November 19, 2001. This document was obtained
4069 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4071 This document is only a draft and is subject to change. (So beware.)
4073 Details regarding the older, non-standard 64-bit format were
4074 determined empirically by examining 64-bit ELF files produced
4075 by the SGI toolchain on an IRIX 6.5 machine.
4077 - Kevin, July 16, 2002
4081 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4086 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4088 if (retval
== 0xffffffff)
4090 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4092 if (cu_header
!= NULL
)
4094 cu_header
->initial_length_size
= 12;
4095 cu_header
->offset_size
= 8;
4098 else if (retval
== 0)
4100 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4102 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4104 if (cu_header
!= NULL
)
4106 cu_header
->initial_length_size
= 8;
4107 cu_header
->offset_size
= 8;
4113 if (cu_header
!= NULL
)
4115 cu_header
->initial_length_size
= 4;
4116 cu_header
->offset_size
= 4;
4123 /* Read an offset from the data stream. The size of the offset is
4124 given by cu_header->offset_size. */
4127 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4132 switch (cu_header
->offset_size
)
4135 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4139 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4143 internal_error (__FILE__
, __LINE__
,
4144 "read_offset: bad switch");
4151 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4153 /* If the size of a host char is 8 bits, we can return a pointer
4154 to the buffer, otherwise we have to copy the data to a buffer
4155 allocated on the temporary obstack. */
4156 gdb_assert (HOST_CHAR_BIT
== 8);
4161 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4163 /* If the size of a host char is 8 bits, we can return a pointer
4164 to the string, otherwise we have to copy the string to a buffer
4165 allocated on the temporary obstack. */
4166 gdb_assert (HOST_CHAR_BIT
== 8);
4169 *bytes_read_ptr
= 1;
4172 *bytes_read_ptr
= strlen (buf
) + 1;
4177 read_indirect_string (bfd
*abfd
, char *buf
,
4178 const struct comp_unit_head
*cu_header
,
4179 unsigned int *bytes_read_ptr
)
4181 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4182 (int *) bytes_read_ptr
);
4184 if (dwarf_str_buffer
== NULL
)
4186 error ("DW_FORM_strp used without .debug_str section");
4189 if (str_offset
>= dwarf_str_size
)
4191 error ("DW_FORM_strp pointing outside of .debug_str section");
4194 gdb_assert (HOST_CHAR_BIT
== 8);
4195 if (dwarf_str_buffer
[str_offset
] == '\0')
4197 return dwarf_str_buffer
+ str_offset
;
4200 static unsigned long
4201 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4203 unsigned long result
;
4204 unsigned int num_read
;
4214 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4217 result
|= ((unsigned long)(byte
& 127) << shift
);
4218 if ((byte
& 128) == 0)
4224 *bytes_read_ptr
= num_read
;
4229 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4232 int i
, shift
, size
, num_read
;
4242 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4245 result
|= ((long)(byte
& 127) << shift
);
4247 if ((byte
& 128) == 0)
4252 if ((shift
< size
) && (byte
& 0x40))
4254 result
|= -(1 << shift
);
4256 *bytes_read_ptr
= num_read
;
4261 set_cu_language (unsigned int lang
)
4267 cu_language
= language_c
;
4269 case DW_LANG_C_plus_plus
:
4270 cu_language
= language_cplus
;
4272 case DW_LANG_Fortran77
:
4273 case DW_LANG_Fortran90
:
4274 case DW_LANG_Fortran95
:
4275 cu_language
= language_fortran
;
4277 case DW_LANG_Mips_Assembler
:
4278 cu_language
= language_asm
;
4281 cu_language
= language_java
;
4285 case DW_LANG_Cobol74
:
4286 case DW_LANG_Cobol85
:
4287 case DW_LANG_Pascal83
:
4288 case DW_LANG_Modula2
:
4290 cu_language
= language_unknown
;
4293 cu_language_defn
= language_def (cu_language
);
4296 /* Return the named attribute or NULL if not there. */
4298 static struct attribute
*
4299 dwarf_attr (struct die_info
*die
, unsigned int name
)
4302 struct attribute
*spec
= NULL
;
4304 for (i
= 0; i
< die
->num_attrs
; ++i
)
4306 if (die
->attrs
[i
].name
== name
)
4308 return &die
->attrs
[i
];
4310 if (die
->attrs
[i
].name
== DW_AT_specification
4311 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4312 spec
= &die
->attrs
[i
];
4316 struct die_info
*ref_die
=
4317 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4320 return dwarf_attr (ref_die
, name
);
4327 die_is_declaration (struct die_info
*die
)
4329 return (dwarf_attr (die
, DW_AT_declaration
)
4330 && ! dwarf_attr (die
, DW_AT_specification
));
4334 /* Free the line_header structure *LH, and any arrays and strings it
4337 free_line_header (struct line_header
*lh
)
4339 if (lh
->standard_opcode_lengths
)
4340 xfree (lh
->standard_opcode_lengths
);
4342 /* Remember that all the lh->file_names[i].name pointers are
4343 pointers into debug_line_buffer, and don't need to be freed. */
4345 xfree (lh
->file_names
);
4347 /* Similarly for the include directory names. */
4348 if (lh
->include_dirs
)
4349 xfree (lh
->include_dirs
);
4355 /* Add an entry to LH's include directory table. */
4357 add_include_dir (struct line_header
*lh
, char *include_dir
)
4359 /* Grow the array if necessary. */
4360 if (lh
->include_dirs_size
== 0)
4362 lh
->include_dirs_size
= 1; /* for testing */
4363 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4364 * sizeof (*lh
->include_dirs
));
4366 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4368 lh
->include_dirs_size
*= 2;
4369 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4370 (lh
->include_dirs_size
4371 * sizeof (*lh
->include_dirs
)));
4374 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4378 /* Add an entry to LH's file name table. */
4380 add_file_name (struct line_header
*lh
,
4382 unsigned int dir_index
,
4383 unsigned int mod_time
,
4384 unsigned int length
)
4386 struct file_entry
*fe
;
4388 /* Grow the array if necessary. */
4389 if (lh
->file_names_size
== 0)
4391 lh
->file_names_size
= 1; /* for testing */
4392 lh
->file_names
= xmalloc (lh
->file_names_size
4393 * sizeof (*lh
->file_names
));
4395 else if (lh
->num_file_names
>= lh
->file_names_size
)
4397 lh
->file_names_size
*= 2;
4398 lh
->file_names
= xrealloc (lh
->file_names
,
4399 (lh
->file_names_size
4400 * sizeof (*lh
->file_names
)));
4403 fe
= &lh
->file_names
[lh
->num_file_names
++];
4405 fe
->dir_index
= dir_index
;
4406 fe
->mod_time
= mod_time
;
4407 fe
->length
= length
;
4411 /* Read the statement program header starting at OFFSET in
4412 dwarf_line_buffer, according to the endianness of ABFD. Return a
4413 pointer to a struct line_header, allocated using xmalloc.
4415 NOTE: the strings in the include directory and file name tables of
4416 the returned object point into debug_line_buffer, and must not be
4418 static struct line_header
*
4419 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4420 const struct comp_unit_head
*cu_header
)
4422 struct cleanup
*back_to
;
4423 struct line_header
*lh
;
4427 char *cur_dir
, *cur_file
;
4429 if (dwarf_line_buffer
== NULL
)
4431 complain (&dwarf2_missing_line_number_section
);
4435 /* Make sure that at least there's room for the total_length field. That
4436 could be 12 bytes long, but we're just going to fudge that. */
4437 if (offset
+ 4 >= dwarf_line_size
)
4439 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4443 lh
= xmalloc (sizeof (*lh
));
4444 memset (lh
, 0, sizeof (*lh
));
4445 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4448 line_ptr
= dwarf_line_buffer
+ offset
;
4450 /* read in the header */
4451 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4452 line_ptr
+= bytes_read
;
4453 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4455 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4458 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4459 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4461 lh
->header_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
4462 line_ptr
+= bytes_read
;
4463 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4465 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4467 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4469 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4471 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4473 lh
->standard_opcode_lengths
4474 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4476 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4477 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4479 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4483 /* Read directory table */
4484 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4486 line_ptr
+= bytes_read
;
4487 add_include_dir (lh
, cur_dir
);
4489 line_ptr
+= bytes_read
;
4491 /* Read file name table */
4492 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4494 unsigned int dir_index
, mod_time
, length
;
4496 line_ptr
+= bytes_read
;
4497 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4498 line_ptr
+= bytes_read
;
4499 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4500 line_ptr
+= bytes_read
;
4501 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4502 line_ptr
+= bytes_read
;
4504 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4506 line_ptr
+= bytes_read
;
4507 lh
->statement_program_start
= line_ptr
;
4509 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4510 complain (&dwarf2_line_header_too_long
);
4512 discard_cleanups (back_to
);
4516 /* This function exists to work around a bug in certain compilers
4517 (particularly GCC 2.95), in which the first line number marker of a
4518 function does not show up until after the prologue, right before
4519 the second line number marker. This function shifts ADDRESS down
4520 to the beginning of the function if necessary, and is called on
4521 addresses passed to record_line. */
4524 check_cu_functions (CORE_ADDR address
)
4526 struct function_range
*fn
;
4528 /* Find the function_range containing address. */
4533 cu_cached_fn
= cu_first_fn
;
4537 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4543 while (fn
&& fn
!= cu_cached_fn
)
4544 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4554 if (address
!= fn
->lowpc
)
4555 complain (&dwarf2_misplaced_line_number
,
4556 (unsigned long) address
, fn
->name
);
4561 /* Decode the line number information for the compilation unit whose
4562 line number info is at OFFSET in the .debug_line section.
4563 The compilation directory of the file is passed in COMP_DIR. */
4566 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
4567 const struct comp_unit_head
*cu_header
)
4571 unsigned int i
, bytes_read
;
4573 unsigned char op_code
, extended_op
, adj_opcode
;
4575 line_ptr
= lh
->statement_program_start
;
4576 line_end
= lh
->statement_program_end
;
4578 /* Read the statement sequences until there's nothing left. */
4579 while (line_ptr
< line_end
)
4581 /* state machine registers */
4582 CORE_ADDR address
= 0;
4583 unsigned int file
= 1;
4584 unsigned int line
= 1;
4585 unsigned int column
= 0;
4586 int is_stmt
= lh
->default_is_stmt
;
4587 int basic_block
= 0;
4588 int end_sequence
= 0;
4590 /* Start a subfile for the current file of the state machine. */
4591 if (lh
->num_file_names
>= file
)
4593 /* lh->include_dirs and lh->file_names are 0-based, but the
4594 directory and file name numbers in the statement program
4596 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
4599 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4602 dwarf2_start_subfile (fe
->name
, dir
);
4605 /* Decode the table. */
4606 while (!end_sequence
)
4608 op_code
= read_1_byte (abfd
, line_ptr
);
4611 if (op_code
>= lh
->opcode_base
)
4612 { /* Special operand. */
4613 adj_opcode
= op_code
- lh
->opcode_base
;
4614 address
+= (adj_opcode
/ lh
->line_range
)
4615 * lh
->minimum_instruction_length
;
4616 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
4617 /* append row to matrix using current values */
4618 address
= check_cu_functions (address
);
4619 record_line (current_subfile
, line
, address
);
4622 else switch (op_code
)
4624 case DW_LNS_extended_op
:
4625 line_ptr
+= 1; /* ignore length */
4626 extended_op
= read_1_byte (abfd
, line_ptr
);
4628 switch (extended_op
)
4630 case DW_LNE_end_sequence
:
4632 record_line (current_subfile
, 0, address
);
4634 case DW_LNE_set_address
:
4635 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4636 line_ptr
+= bytes_read
;
4637 address
+= baseaddr
;
4639 case DW_LNE_define_file
:
4642 unsigned int dir_index
, mod_time
, length
;
4644 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
4645 line_ptr
+= bytes_read
;
4647 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4648 line_ptr
+= bytes_read
;
4650 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4651 line_ptr
+= bytes_read
;
4653 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4654 line_ptr
+= bytes_read
;
4655 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4659 complain (&dwarf2_mangled_line_number_section
);
4664 address
= check_cu_functions (address
);
4665 record_line (current_subfile
, line
, address
);
4668 case DW_LNS_advance_pc
:
4669 address
+= lh
->minimum_instruction_length
4670 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4671 line_ptr
+= bytes_read
;
4673 case DW_LNS_advance_line
:
4674 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4675 line_ptr
+= bytes_read
;
4677 case DW_LNS_set_file
:
4679 /* lh->include_dirs and lh->file_names are 0-based,
4680 but the directory and file name numbers in the
4681 statement program are 1-based. */
4682 struct file_entry
*fe
;
4684 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4685 line_ptr
+= bytes_read
;
4686 fe
= &lh
->file_names
[file
- 1];
4688 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4691 dwarf2_start_subfile (fe
->name
, dir
);
4694 case DW_LNS_set_column
:
4695 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4696 line_ptr
+= bytes_read
;
4698 case DW_LNS_negate_stmt
:
4699 is_stmt
= (!is_stmt
);
4701 case DW_LNS_set_basic_block
:
4704 /* Add to the address register of the state machine the
4705 address increment value corresponding to special opcode
4706 255. Ie, this value is scaled by the minimum instruction
4707 length since special opcode 255 would have scaled the
4709 case DW_LNS_const_add_pc
:
4710 address
+= (lh
->minimum_instruction_length
4711 * ((255 - lh
->opcode_base
) / lh
->line_range
));
4713 case DW_LNS_fixed_advance_pc
:
4714 address
+= read_2_bytes (abfd
, line_ptr
);
4718 { /* Unknown standard opcode, ignore it. */
4720 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
4722 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4723 line_ptr
+= bytes_read
;
4731 /* Start a subfile for DWARF. FILENAME is the name of the file and
4732 DIRNAME the name of the source directory which contains FILENAME
4733 or NULL if not known.
4734 This routine tries to keep line numbers from identical absolute and
4735 relative file names in a common subfile.
4737 Using the `list' example from the GDB testsuite, which resides in
4738 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4739 of /srcdir/list0.c yields the following debugging information for list0.c:
4741 DW_AT_name: /srcdir/list0.c
4742 DW_AT_comp_dir: /compdir
4743 files.files[0].name: list0.h
4744 files.files[0].dir: /srcdir
4745 files.files[1].name: list0.c
4746 files.files[1].dir: /srcdir
4748 The line number information for list0.c has to end up in a single
4749 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4752 dwarf2_start_subfile (char *filename
, char *dirname
)
4754 /* If the filename isn't absolute, try to match an existing subfile
4755 with the full pathname. */
4757 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4759 struct subfile
*subfile
;
4760 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4762 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4764 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4766 current_subfile
= subfile
;
4773 start_subfile (filename
, dirname
);
4776 /* Given a pointer to a DWARF information entry, figure out if we need
4777 to make a symbol table entry for it, and if so, create a new entry
4778 and return a pointer to it.
4779 If TYPE is NULL, determine symbol type from the die, otherwise
4780 used the passed type. */
4782 static struct symbol
*
4783 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4784 const struct comp_unit_head
*cu_header
)
4786 struct symbol
*sym
= NULL
;
4788 struct attribute
*attr
= NULL
;
4789 struct attribute
*attr2
= NULL
;
4792 name
= dwarf2_linkage_name (die
);
4795 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4796 sizeof (struct symbol
));
4797 OBJSTAT (objfile
, n_syms
++);
4798 memset (sym
, 0, sizeof (struct symbol
));
4799 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4800 &objfile
->symbol_obstack
);
4802 /* Default assumptions.
4803 Use the passed type or decode it from the die. */
4804 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4805 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4807 SYMBOL_TYPE (sym
) = type
;
4809 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4810 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4813 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4816 /* If this symbol is from a C++ compilation, then attempt to
4817 cache the demangled form for future reference. This is a
4818 typical time versus space tradeoff, that was decided in favor
4819 of time because it sped up C++ symbol lookups by a factor of
4822 SYMBOL_LANGUAGE (sym
) = cu_language
;
4823 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4827 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4830 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4832 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4834 case DW_TAG_subprogram
:
4835 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4837 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4838 attr2
= dwarf_attr (die
, DW_AT_external
);
4839 if (attr2
&& (DW_UNSND (attr2
) != 0))
4841 add_symbol_to_list (sym
, &global_symbols
);
4845 add_symbol_to_list (sym
, list_in_scope
);
4848 case DW_TAG_variable
:
4849 /* Compilation with minimal debug info may result in variables
4850 with missing type entries. Change the misleading `void' type
4851 to something sensible. */
4852 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4853 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4854 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4855 "<variable, no debug info>",
4857 attr
= dwarf_attr (die
, DW_AT_const_value
);
4860 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4861 attr2
= dwarf_attr (die
, DW_AT_external
);
4862 if (attr2
&& (DW_UNSND (attr2
) != 0))
4863 add_symbol_to_list (sym
, &global_symbols
);
4865 add_symbol_to_list (sym
, list_in_scope
);
4868 attr
= dwarf_attr (die
, DW_AT_location
);
4871 attr2
= dwarf_attr (die
, DW_AT_external
);
4872 if (attr2
&& (DW_UNSND (attr2
) != 0))
4874 /* Support the .debug_loc offsets */
4875 if (attr_form_is_block (attr
))
4877 SYMBOL_VALUE_ADDRESS (sym
) =
4878 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4880 else if (attr
->form
== DW_FORM_data4
4881 || attr
->form
== DW_FORM_data8
)
4883 complain (&dwarf2_complex_location_expr
);
4887 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4888 "external variable");
4890 add_symbol_to_list (sym
, &global_symbols
);
4891 if (is_thread_local
)
4893 /* SYMBOL_VALUE_ADDRESS contains at this point the
4894 offset of the variable within the thread local
4896 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
4897 SYMBOL_OBJFILE (sym
) = objfile
;
4900 /* In shared libraries the address of the variable
4901 in the location descriptor might still be relocatable,
4902 so its value could be zero.
4903 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4904 value is zero, the address of the variable will then
4905 be determined from the minimal symbol table whenever
4906 the variable is referenced. */
4907 else if (SYMBOL_VALUE_ADDRESS (sym
))
4909 fixup_symbol_section (sym
, objfile
);
4910 SYMBOL_VALUE_ADDRESS (sym
) +=
4911 ANOFFSET (objfile
->section_offsets
,
4912 SYMBOL_SECTION (sym
));
4913 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4916 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4920 /* Support the .debug_loc offsets */
4921 if (attr_form_is_block (attr
))
4923 SYMBOL_VALUE (sym
) = addr
=
4924 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4926 else if (attr
->form
== DW_FORM_data4
4927 || attr
->form
== DW_FORM_data8
)
4929 complain (&dwarf2_complex_location_expr
);
4933 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4934 "external variable");
4937 add_symbol_to_list (sym
, list_in_scope
);
4940 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4944 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4945 SYMBOL_VALUE (sym
) =
4946 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4950 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4951 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4955 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4957 else if (is_thread_local
)
4959 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
4960 SYMBOL_OBJFILE (sym
) = objfile
;
4964 fixup_symbol_section (sym
, objfile
);
4965 SYMBOL_VALUE_ADDRESS (sym
) =
4966 addr
+ ANOFFSET (objfile
->section_offsets
,
4967 SYMBOL_SECTION (sym
));
4968 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4974 /* We do not know the address of this symbol.
4975 If it is an external symbol and we have type information
4976 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4977 The address of the variable will then be determined from
4978 the minimal symbol table whenever the variable is
4980 attr2
= dwarf_attr (die
, DW_AT_external
);
4981 if (attr2
&& (DW_UNSND (attr2
) != 0)
4982 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4984 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4985 add_symbol_to_list (sym
, &global_symbols
);
4989 case DW_TAG_formal_parameter
:
4990 attr
= dwarf_attr (die
, DW_AT_location
);
4993 SYMBOL_VALUE (sym
) =
4994 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4997 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4998 SYMBOL_VALUE (sym
) =
4999 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
5005 if (basereg
!= frame_base_reg
)
5006 complain (&dwarf2_complex_location_expr
);
5007 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
5011 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
5012 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
5017 SYMBOL_CLASS (sym
) = LOC_ARG
;
5020 attr
= dwarf_attr (die
, DW_AT_const_value
);
5023 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5025 add_symbol_to_list (sym
, list_in_scope
);
5027 case DW_TAG_unspecified_parameters
:
5028 /* From varargs functions; gdb doesn't seem to have any
5029 interest in this information, so just ignore it for now.
5032 case DW_TAG_class_type
:
5033 case DW_TAG_structure_type
:
5034 case DW_TAG_union_type
:
5035 case DW_TAG_enumeration_type
:
5036 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5037 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
5038 add_symbol_to_list (sym
, list_in_scope
);
5040 /* The semantics of C++ state that "struct foo { ... }" also
5041 defines a typedef for "foo". Synthesize a typedef symbol so
5042 that "ptype foo" works as expected. */
5043 if (cu_language
== language_cplus
)
5045 struct symbol
*typedef_sym
= (struct symbol
*)
5046 obstack_alloc (&objfile
->symbol_obstack
,
5047 sizeof (struct symbol
));
5048 *typedef_sym
= *sym
;
5049 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
5050 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5051 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5052 obsavestring (SYMBOL_NAME (sym
),
5053 strlen (SYMBOL_NAME (sym
)),
5054 &objfile
->type_obstack
);
5055 add_symbol_to_list (typedef_sym
, list_in_scope
);
5058 case DW_TAG_typedef
:
5059 case DW_TAG_base_type
:
5060 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5061 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
5062 add_symbol_to_list (sym
, list_in_scope
);
5064 case DW_TAG_enumerator
:
5065 attr
= dwarf_attr (die
, DW_AT_const_value
);
5068 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5070 add_symbol_to_list (sym
, list_in_scope
);
5073 /* Not a tag we recognize. Hopefully we aren't processing
5074 trash data, but since we must specifically ignore things
5075 we don't recognize, there is nothing else we should do at
5077 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
5084 /* Copy constant value from an attribute to a symbol. */
5087 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5088 struct objfile
*objfile
,
5089 const struct comp_unit_head
*cu_header
)
5091 struct dwarf_block
*blk
;
5096 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5097 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
5098 cu_header
->addr_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
5099 SYMBOL_VALUE_BYTES (sym
) = (char *)
5100 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5101 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5103 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5105 case DW_FORM_block1
:
5106 case DW_FORM_block2
:
5107 case DW_FORM_block4
:
5109 blk
= DW_BLOCK (attr
);
5110 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5111 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
5112 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
5113 SYMBOL_VALUE_BYTES (sym
) = (char *)
5114 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5115 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5116 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5119 /* The DW_AT_const_value attributes are supposed to carry the
5120 symbol's value "represented as it would be on the target
5121 architecture." By the time we get here, it's already been
5122 converted to host endianness, so we just need to sign- or
5123 zero-extend it as appropriate. */
5125 dwarf2_const_value_data (attr
, sym
, 8);
5128 dwarf2_const_value_data (attr
, sym
, 16);
5131 dwarf2_const_value_data (attr
, sym
, 32);
5134 dwarf2_const_value_data (attr
, sym
, 64);
5138 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5139 SYMBOL_CLASS (sym
) = LOC_CONST
;
5143 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5144 SYMBOL_CLASS (sym
) = LOC_CONST
;
5148 complain (&dwarf2_unsupported_const_value_attr
,
5149 dwarf_form_name (attr
->form
));
5150 SYMBOL_VALUE (sym
) = 0;
5151 SYMBOL_CLASS (sym
) = LOC_CONST
;
5157 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5158 or zero-extend it as appropriate for the symbol's type. */
5160 dwarf2_const_value_data (struct attribute
*attr
,
5164 LONGEST l
= DW_UNSND (attr
);
5166 if (bits
< sizeof (l
) * 8)
5168 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5169 l
&= ((LONGEST
) 1 << bits
) - 1;
5171 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5174 SYMBOL_VALUE (sym
) = l
;
5175 SYMBOL_CLASS (sym
) = LOC_CONST
;
5179 /* Return the type of the die in question using its DW_AT_type attribute. */
5181 static struct type
*
5182 die_type (struct die_info
*die
, struct objfile
*objfile
,
5183 const struct comp_unit_head
*cu_header
)
5186 struct attribute
*type_attr
;
5187 struct die_info
*type_die
;
5190 type_attr
= dwarf_attr (die
, DW_AT_type
);
5193 /* A missing DW_AT_type represents a void type. */
5194 return dwarf2_fundamental_type (objfile
, FT_VOID
);
5198 ref
= dwarf2_get_ref_die_offset (type_attr
);
5199 type_die
= follow_die_ref (ref
);
5202 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5206 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5209 dump_die (type_die
);
5210 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
5215 /* Return the containing type of the die in question using its
5216 DW_AT_containing_type attribute. */
5218 static struct type
*
5219 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
5220 const struct comp_unit_head
*cu_header
)
5222 struct type
*type
= NULL
;
5223 struct attribute
*type_attr
;
5224 struct die_info
*type_die
= NULL
;
5227 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5230 ref
= dwarf2_get_ref_die_offset (type_attr
);
5231 type_die
= follow_die_ref (ref
);
5234 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5237 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5242 dump_die (type_die
);
5243 error ("Dwarf Error: Problem turning containing type into gdb type.");
5249 static struct type
*
5250 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
5252 struct die_info
*die
;
5255 die
= follow_die_ref (offset
);
5258 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5261 type
= tag_type_to_type (die
, objfile
);
5266 static struct type
*
5267 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
5268 const struct comp_unit_head
*cu_header
)
5276 read_type_die (die
, objfile
, cu_header
);
5280 error ("Dwarf Error: Cannot find type of die.");
5287 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
5288 const struct comp_unit_head
*cu_header
)
5292 case DW_TAG_class_type
:
5293 case DW_TAG_structure_type
:
5294 case DW_TAG_union_type
:
5295 read_structure_scope (die
, objfile
, cu_header
);
5297 case DW_TAG_enumeration_type
:
5298 read_enumeration (die
, objfile
, cu_header
);
5300 case DW_TAG_subprogram
:
5301 case DW_TAG_subroutine_type
:
5302 read_subroutine_type (die
, objfile
, cu_header
);
5304 case DW_TAG_array_type
:
5305 read_array_type (die
, objfile
, cu_header
);
5307 case DW_TAG_pointer_type
:
5308 read_tag_pointer_type (die
, objfile
, cu_header
);
5310 case DW_TAG_ptr_to_member_type
:
5311 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
5313 case DW_TAG_reference_type
:
5314 read_tag_reference_type (die
, objfile
, cu_header
);
5316 case DW_TAG_const_type
:
5317 read_tag_const_type (die
, objfile
, cu_header
);
5319 case DW_TAG_volatile_type
:
5320 read_tag_volatile_type (die
, objfile
, cu_header
);
5322 case DW_TAG_string_type
:
5323 read_tag_string_type (die
, objfile
);
5325 case DW_TAG_typedef
:
5326 read_typedef (die
, objfile
, cu_header
);
5328 case DW_TAG_base_type
:
5329 read_base_type (die
, objfile
);
5332 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
5337 static struct type
*
5338 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
5340 /* FIXME - this should not produce a new (struct type *)
5341 every time. It should cache base types. */
5345 case DW_ATE_address
:
5346 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5348 case DW_ATE_boolean
:
5349 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5351 case DW_ATE_complex_float
:
5354 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5358 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5364 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5368 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5375 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5378 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5382 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5386 case DW_ATE_signed_char
:
5387 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5389 case DW_ATE_unsigned
:
5393 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5396 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5400 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5404 case DW_ATE_unsigned_char
:
5405 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5408 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5415 copy_die (struct die_info
*old_die
)
5417 struct die_info
*new_die
;
5420 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5421 memset (new_die
, 0, sizeof (struct die_info
));
5423 new_die
->tag
= old_die
->tag
;
5424 new_die
->has_children
= old_die
->has_children
;
5425 new_die
->abbrev
= old_die
->abbrev
;
5426 new_die
->offset
= old_die
->offset
;
5427 new_die
->type
= NULL
;
5429 num_attrs
= old_die
->num_attrs
;
5430 new_die
->num_attrs
= num_attrs
;
5431 new_die
->attrs
= (struct attribute
*)
5432 xmalloc (num_attrs
* sizeof (struct attribute
));
5434 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5436 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5437 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5438 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5441 new_die
->next
= NULL
;
5446 /* Return sibling of die, NULL if no sibling. */
5448 static struct die_info
*
5449 sibling_die (struct die_info
*die
)
5451 int nesting_level
= 0;
5453 if (!die
->has_children
)
5455 if (die
->next
&& (die
->next
->tag
== 0))
5468 if (die
->has_children
)
5478 while (nesting_level
);
5479 if (die
&& (die
->tag
== 0))
5490 /* Get linkage name of a die, return NULL if not found. */
5493 dwarf2_linkage_name (struct die_info
*die
)
5495 struct attribute
*attr
;
5497 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5498 if (attr
&& DW_STRING (attr
))
5499 return DW_STRING (attr
);
5500 attr
= dwarf_attr (die
, DW_AT_name
);
5501 if (attr
&& DW_STRING (attr
))
5502 return DW_STRING (attr
);
5506 /* Convert a DIE tag into its string name. */
5509 dwarf_tag_name (register unsigned tag
)
5513 case DW_TAG_padding
:
5514 return "DW_TAG_padding";
5515 case DW_TAG_array_type
:
5516 return "DW_TAG_array_type";
5517 case DW_TAG_class_type
:
5518 return "DW_TAG_class_type";
5519 case DW_TAG_entry_point
:
5520 return "DW_TAG_entry_point";
5521 case DW_TAG_enumeration_type
:
5522 return "DW_TAG_enumeration_type";
5523 case DW_TAG_formal_parameter
:
5524 return "DW_TAG_formal_parameter";
5525 case DW_TAG_imported_declaration
:
5526 return "DW_TAG_imported_declaration";
5528 return "DW_TAG_label";
5529 case DW_TAG_lexical_block
:
5530 return "DW_TAG_lexical_block";
5532 return "DW_TAG_member";
5533 case DW_TAG_pointer_type
:
5534 return "DW_TAG_pointer_type";
5535 case DW_TAG_reference_type
:
5536 return "DW_TAG_reference_type";
5537 case DW_TAG_compile_unit
:
5538 return "DW_TAG_compile_unit";
5539 case DW_TAG_string_type
:
5540 return "DW_TAG_string_type";
5541 case DW_TAG_structure_type
:
5542 return "DW_TAG_structure_type";
5543 case DW_TAG_subroutine_type
:
5544 return "DW_TAG_subroutine_type";
5545 case DW_TAG_typedef
:
5546 return "DW_TAG_typedef";
5547 case DW_TAG_union_type
:
5548 return "DW_TAG_union_type";
5549 case DW_TAG_unspecified_parameters
:
5550 return "DW_TAG_unspecified_parameters";
5551 case DW_TAG_variant
:
5552 return "DW_TAG_variant";
5553 case DW_TAG_common_block
:
5554 return "DW_TAG_common_block";
5555 case DW_TAG_common_inclusion
:
5556 return "DW_TAG_common_inclusion";
5557 case DW_TAG_inheritance
:
5558 return "DW_TAG_inheritance";
5559 case DW_TAG_inlined_subroutine
:
5560 return "DW_TAG_inlined_subroutine";
5562 return "DW_TAG_module";
5563 case DW_TAG_ptr_to_member_type
:
5564 return "DW_TAG_ptr_to_member_type";
5565 case DW_TAG_set_type
:
5566 return "DW_TAG_set_type";
5567 case DW_TAG_subrange_type
:
5568 return "DW_TAG_subrange_type";
5569 case DW_TAG_with_stmt
:
5570 return "DW_TAG_with_stmt";
5571 case DW_TAG_access_declaration
:
5572 return "DW_TAG_access_declaration";
5573 case DW_TAG_base_type
:
5574 return "DW_TAG_base_type";
5575 case DW_TAG_catch_block
:
5576 return "DW_TAG_catch_block";
5577 case DW_TAG_const_type
:
5578 return "DW_TAG_const_type";
5579 case DW_TAG_constant
:
5580 return "DW_TAG_constant";
5581 case DW_TAG_enumerator
:
5582 return "DW_TAG_enumerator";
5583 case DW_TAG_file_type
:
5584 return "DW_TAG_file_type";
5586 return "DW_TAG_friend";
5587 case DW_TAG_namelist
:
5588 return "DW_TAG_namelist";
5589 case DW_TAG_namelist_item
:
5590 return "DW_TAG_namelist_item";
5591 case DW_TAG_packed_type
:
5592 return "DW_TAG_packed_type";
5593 case DW_TAG_subprogram
:
5594 return "DW_TAG_subprogram";
5595 case DW_TAG_template_type_param
:
5596 return "DW_TAG_template_type_param";
5597 case DW_TAG_template_value_param
:
5598 return "DW_TAG_template_value_param";
5599 case DW_TAG_thrown_type
:
5600 return "DW_TAG_thrown_type";
5601 case DW_TAG_try_block
:
5602 return "DW_TAG_try_block";
5603 case DW_TAG_variant_part
:
5604 return "DW_TAG_variant_part";
5605 case DW_TAG_variable
:
5606 return "DW_TAG_variable";
5607 case DW_TAG_volatile_type
:
5608 return "DW_TAG_volatile_type";
5609 case DW_TAG_dwarf_procedure
:
5610 return "DW_TAG_dwarf_procedure";
5611 case DW_TAG_restrict_type
:
5612 return "DW_TAG_restrict_type";
5613 case DW_TAG_interface_type
:
5614 return "DW_TAG_interface_type";
5615 case DW_TAG_namespace
:
5616 return "DW_TAG_namespace";
5617 case DW_TAG_imported_module
:
5618 return "DW_TAG_imported_module";
5619 case DW_TAG_unspecified_type
:
5620 return "DW_TAG_unspecified_type";
5621 case DW_TAG_partial_unit
:
5622 return "DW_TAG_partial_unit";
5623 case DW_TAG_imported_unit
:
5624 return "DW_TAG_imported_unit";
5625 case DW_TAG_MIPS_loop
:
5626 return "DW_TAG_MIPS_loop";
5627 case DW_TAG_format_label
:
5628 return "DW_TAG_format_label";
5629 case DW_TAG_function_template
:
5630 return "DW_TAG_function_template";
5631 case DW_TAG_class_template
:
5632 return "DW_TAG_class_template";
5634 return "DW_TAG_<unknown>";
5638 /* Convert a DWARF attribute code into its string name. */
5641 dwarf_attr_name (register unsigned attr
)
5646 return "DW_AT_sibling";
5647 case DW_AT_location
:
5648 return "DW_AT_location";
5650 return "DW_AT_name";
5651 case DW_AT_ordering
:
5652 return "DW_AT_ordering";
5653 case DW_AT_subscr_data
:
5654 return "DW_AT_subscr_data";
5655 case DW_AT_byte_size
:
5656 return "DW_AT_byte_size";
5657 case DW_AT_bit_offset
:
5658 return "DW_AT_bit_offset";
5659 case DW_AT_bit_size
:
5660 return "DW_AT_bit_size";
5661 case DW_AT_element_list
:
5662 return "DW_AT_element_list";
5663 case DW_AT_stmt_list
:
5664 return "DW_AT_stmt_list";
5666 return "DW_AT_low_pc";
5668 return "DW_AT_high_pc";
5669 case DW_AT_language
:
5670 return "DW_AT_language";
5672 return "DW_AT_member";
5674 return "DW_AT_discr";
5675 case DW_AT_discr_value
:
5676 return "DW_AT_discr_value";
5677 case DW_AT_visibility
:
5678 return "DW_AT_visibility";
5680 return "DW_AT_import";
5681 case DW_AT_string_length
:
5682 return "DW_AT_string_length";
5683 case DW_AT_common_reference
:
5684 return "DW_AT_common_reference";
5685 case DW_AT_comp_dir
:
5686 return "DW_AT_comp_dir";
5687 case DW_AT_const_value
:
5688 return "DW_AT_const_value";
5689 case DW_AT_containing_type
:
5690 return "DW_AT_containing_type";
5691 case DW_AT_default_value
:
5692 return "DW_AT_default_value";
5694 return "DW_AT_inline";
5695 case DW_AT_is_optional
:
5696 return "DW_AT_is_optional";
5697 case DW_AT_lower_bound
:
5698 return "DW_AT_lower_bound";
5699 case DW_AT_producer
:
5700 return "DW_AT_producer";
5701 case DW_AT_prototyped
:
5702 return "DW_AT_prototyped";
5703 case DW_AT_return_addr
:
5704 return "DW_AT_return_addr";
5705 case DW_AT_start_scope
:
5706 return "DW_AT_start_scope";
5707 case DW_AT_stride_size
:
5708 return "DW_AT_stride_size";
5709 case DW_AT_upper_bound
:
5710 return "DW_AT_upper_bound";
5711 case DW_AT_abstract_origin
:
5712 return "DW_AT_abstract_origin";
5713 case DW_AT_accessibility
:
5714 return "DW_AT_accessibility";
5715 case DW_AT_address_class
:
5716 return "DW_AT_address_class";
5717 case DW_AT_artificial
:
5718 return "DW_AT_artificial";
5719 case DW_AT_base_types
:
5720 return "DW_AT_base_types";
5721 case DW_AT_calling_convention
:
5722 return "DW_AT_calling_convention";
5724 return "DW_AT_count";
5725 case DW_AT_data_member_location
:
5726 return "DW_AT_data_member_location";
5727 case DW_AT_decl_column
:
5728 return "DW_AT_decl_column";
5729 case DW_AT_decl_file
:
5730 return "DW_AT_decl_file";
5731 case DW_AT_decl_line
:
5732 return "DW_AT_decl_line";
5733 case DW_AT_declaration
:
5734 return "DW_AT_declaration";
5735 case DW_AT_discr_list
:
5736 return "DW_AT_discr_list";
5737 case DW_AT_encoding
:
5738 return "DW_AT_encoding";
5739 case DW_AT_external
:
5740 return "DW_AT_external";
5741 case DW_AT_frame_base
:
5742 return "DW_AT_frame_base";
5744 return "DW_AT_friend";
5745 case DW_AT_identifier_case
:
5746 return "DW_AT_identifier_case";
5747 case DW_AT_macro_info
:
5748 return "DW_AT_macro_info";
5749 case DW_AT_namelist_items
:
5750 return "DW_AT_namelist_items";
5751 case DW_AT_priority
:
5752 return "DW_AT_priority";
5754 return "DW_AT_segment";
5755 case DW_AT_specification
:
5756 return "DW_AT_specification";
5757 case DW_AT_static_link
:
5758 return "DW_AT_static_link";
5760 return "DW_AT_type";
5761 case DW_AT_use_location
:
5762 return "DW_AT_use_location";
5763 case DW_AT_variable_parameter
:
5764 return "DW_AT_variable_parameter";
5765 case DW_AT_virtuality
:
5766 return "DW_AT_virtuality";
5767 case DW_AT_vtable_elem_location
:
5768 return "DW_AT_vtable_elem_location";
5769 case DW_AT_allocated
:
5770 return "DW_AT_allocated";
5771 case DW_AT_associated
:
5772 return "DW_AT_associated";
5773 case DW_AT_data_location
:
5774 return "DW_AT_data_location";
5776 return "DW_AT_stride";
5777 case DW_AT_entry_pc
:
5778 return "DW_AT_entry_pc";
5779 case DW_AT_use_UTF8
:
5780 return "DW_AT_use_UTF8";
5781 case DW_AT_extension
:
5782 return "DW_AT_extension";
5784 return "DW_AT_ranges";
5785 case DW_AT_trampoline
:
5786 return "DW_AT_trampoline";
5787 case DW_AT_call_column
:
5788 return "DW_AT_call_column";
5789 case DW_AT_call_file
:
5790 return "DW_AT_call_file";
5791 case DW_AT_call_line
:
5792 return "DW_AT_call_line";
5794 case DW_AT_MIPS_fde
:
5795 return "DW_AT_MIPS_fde";
5796 case DW_AT_MIPS_loop_begin
:
5797 return "DW_AT_MIPS_loop_begin";
5798 case DW_AT_MIPS_tail_loop_begin
:
5799 return "DW_AT_MIPS_tail_loop_begin";
5800 case DW_AT_MIPS_epilog_begin
:
5801 return "DW_AT_MIPS_epilog_begin";
5802 case DW_AT_MIPS_loop_unroll_factor
:
5803 return "DW_AT_MIPS_loop_unroll_factor";
5804 case DW_AT_MIPS_software_pipeline_depth
:
5805 return "DW_AT_MIPS_software_pipeline_depth";
5806 case DW_AT_MIPS_linkage_name
:
5807 return "DW_AT_MIPS_linkage_name";
5810 case DW_AT_sf_names
:
5811 return "DW_AT_sf_names";
5812 case DW_AT_src_info
:
5813 return "DW_AT_src_info";
5814 case DW_AT_mac_info
:
5815 return "DW_AT_mac_info";
5816 case DW_AT_src_coords
:
5817 return "DW_AT_src_coords";
5818 case DW_AT_body_begin
:
5819 return "DW_AT_body_begin";
5820 case DW_AT_body_end
:
5821 return "DW_AT_body_end";
5822 case DW_AT_GNU_vector
:
5823 return "DW_AT_GNU_vector";
5825 return "DW_AT_<unknown>";
5829 /* Convert a DWARF value form code into its string name. */
5832 dwarf_form_name (register unsigned form
)
5837 return "DW_FORM_addr";
5838 case DW_FORM_block2
:
5839 return "DW_FORM_block2";
5840 case DW_FORM_block4
:
5841 return "DW_FORM_block4";
5843 return "DW_FORM_data2";
5845 return "DW_FORM_data4";
5847 return "DW_FORM_data8";
5848 case DW_FORM_string
:
5849 return "DW_FORM_string";
5851 return "DW_FORM_block";
5852 case DW_FORM_block1
:
5853 return "DW_FORM_block1";
5855 return "DW_FORM_data1";
5857 return "DW_FORM_flag";
5859 return "DW_FORM_sdata";
5861 return "DW_FORM_strp";
5863 return "DW_FORM_udata";
5864 case DW_FORM_ref_addr
:
5865 return "DW_FORM_ref_addr";
5867 return "DW_FORM_ref1";
5869 return "DW_FORM_ref2";
5871 return "DW_FORM_ref4";
5873 return "DW_FORM_ref8";
5874 case DW_FORM_ref_udata
:
5875 return "DW_FORM_ref_udata";
5876 case DW_FORM_indirect
:
5877 return "DW_FORM_indirect";
5879 return "DW_FORM_<unknown>";
5883 /* Convert a DWARF stack opcode into its string name. */
5886 dwarf_stack_op_name (register unsigned op
)
5891 return "DW_OP_addr";
5893 return "DW_OP_deref";
5895 return "DW_OP_const1u";
5897 return "DW_OP_const1s";
5899 return "DW_OP_const2u";
5901 return "DW_OP_const2s";
5903 return "DW_OP_const4u";
5905 return "DW_OP_const4s";
5907 return "DW_OP_const8u";
5909 return "DW_OP_const8s";
5911 return "DW_OP_constu";
5913 return "DW_OP_consts";
5917 return "DW_OP_drop";
5919 return "DW_OP_over";
5921 return "DW_OP_pick";
5923 return "DW_OP_swap";
5927 return "DW_OP_xderef";
5935 return "DW_OP_minus";
5947 return "DW_OP_plus";
5948 case DW_OP_plus_uconst
:
5949 return "DW_OP_plus_uconst";
5955 return "DW_OP_shra";
5973 return "DW_OP_skip";
5975 return "DW_OP_lit0";
5977 return "DW_OP_lit1";
5979 return "DW_OP_lit2";
5981 return "DW_OP_lit3";
5983 return "DW_OP_lit4";
5985 return "DW_OP_lit5";
5987 return "DW_OP_lit6";
5989 return "DW_OP_lit7";
5991 return "DW_OP_lit8";
5993 return "DW_OP_lit9";
5995 return "DW_OP_lit10";
5997 return "DW_OP_lit11";
5999 return "DW_OP_lit12";
6001 return "DW_OP_lit13";
6003 return "DW_OP_lit14";
6005 return "DW_OP_lit15";
6007 return "DW_OP_lit16";
6009 return "DW_OP_lit17";
6011 return "DW_OP_lit18";
6013 return "DW_OP_lit19";
6015 return "DW_OP_lit20";
6017 return "DW_OP_lit21";
6019 return "DW_OP_lit22";
6021 return "DW_OP_lit23";
6023 return "DW_OP_lit24";
6025 return "DW_OP_lit25";
6027 return "DW_OP_lit26";
6029 return "DW_OP_lit27";
6031 return "DW_OP_lit28";
6033 return "DW_OP_lit29";
6035 return "DW_OP_lit30";
6037 return "DW_OP_lit31";
6039 return "DW_OP_reg0";
6041 return "DW_OP_reg1";
6043 return "DW_OP_reg2";
6045 return "DW_OP_reg3";
6047 return "DW_OP_reg4";
6049 return "DW_OP_reg5";
6051 return "DW_OP_reg6";
6053 return "DW_OP_reg7";
6055 return "DW_OP_reg8";
6057 return "DW_OP_reg9";
6059 return "DW_OP_reg10";
6061 return "DW_OP_reg11";
6063 return "DW_OP_reg12";
6065 return "DW_OP_reg13";
6067 return "DW_OP_reg14";
6069 return "DW_OP_reg15";
6071 return "DW_OP_reg16";
6073 return "DW_OP_reg17";
6075 return "DW_OP_reg18";
6077 return "DW_OP_reg19";
6079 return "DW_OP_reg20";
6081 return "DW_OP_reg21";
6083 return "DW_OP_reg22";
6085 return "DW_OP_reg23";
6087 return "DW_OP_reg24";
6089 return "DW_OP_reg25";
6091 return "DW_OP_reg26";
6093 return "DW_OP_reg27";
6095 return "DW_OP_reg28";
6097 return "DW_OP_reg29";
6099 return "DW_OP_reg30";
6101 return "DW_OP_reg31";
6103 return "DW_OP_breg0";
6105 return "DW_OP_breg1";
6107 return "DW_OP_breg2";
6109 return "DW_OP_breg3";
6111 return "DW_OP_breg4";
6113 return "DW_OP_breg5";
6115 return "DW_OP_breg6";
6117 return "DW_OP_breg7";
6119 return "DW_OP_breg8";
6121 return "DW_OP_breg9";
6123 return "DW_OP_breg10";
6125 return "DW_OP_breg11";
6127 return "DW_OP_breg12";
6129 return "DW_OP_breg13";
6131 return "DW_OP_breg14";
6133 return "DW_OP_breg15";
6135 return "DW_OP_breg16";
6137 return "DW_OP_breg17";
6139 return "DW_OP_breg18";
6141 return "DW_OP_breg19";
6143 return "DW_OP_breg20";
6145 return "DW_OP_breg21";
6147 return "DW_OP_breg22";
6149 return "DW_OP_breg23";
6151 return "DW_OP_breg24";
6153 return "DW_OP_breg25";
6155 return "DW_OP_breg26";
6157 return "DW_OP_breg27";
6159 return "DW_OP_breg28";
6161 return "DW_OP_breg29";
6163 return "DW_OP_breg30";
6165 return "DW_OP_breg31";
6167 return "DW_OP_regx";
6169 return "DW_OP_fbreg";
6171 return "DW_OP_bregx";
6173 return "DW_OP_piece";
6174 case DW_OP_deref_size
:
6175 return "DW_OP_deref_size";
6176 case DW_OP_xderef_size
:
6177 return "DW_OP_xderef_size";
6180 /* DWARF 3 extensions. */
6181 case DW_OP_push_object_address
:
6182 return "DW_OP_push_object_address";
6184 return "DW_OP_call2";
6186 return "DW_OP_call4";
6187 case DW_OP_call_ref
:
6188 return "DW_OP_call_ref";
6189 /* GNU extensions. */
6190 case DW_OP_GNU_push_tls_address
:
6191 return "DW_OP_GNU_push_tls_address";
6193 return "OP_<unknown>";
6198 dwarf_bool_name (unsigned mybool
)
6206 /* Convert a DWARF type code into its string name. */
6209 dwarf_type_encoding_name (register unsigned enc
)
6213 case DW_ATE_address
:
6214 return "DW_ATE_address";
6215 case DW_ATE_boolean
:
6216 return "DW_ATE_boolean";
6217 case DW_ATE_complex_float
:
6218 return "DW_ATE_complex_float";
6220 return "DW_ATE_float";
6222 return "DW_ATE_signed";
6223 case DW_ATE_signed_char
:
6224 return "DW_ATE_signed_char";
6225 case DW_ATE_unsigned
:
6226 return "DW_ATE_unsigned";
6227 case DW_ATE_unsigned_char
:
6228 return "DW_ATE_unsigned_char";
6229 case DW_ATE_imaginary_float
:
6230 return "DW_ATE_imaginary_float";
6232 return "DW_ATE_<unknown>";
6236 /* Convert a DWARF call frame info operation to its string name. */
6240 dwarf_cfi_name (register unsigned cfi_opc
)
6244 case DW_CFA_advance_loc
:
6245 return "DW_CFA_advance_loc";
6247 return "DW_CFA_offset";
6248 case DW_CFA_restore
:
6249 return "DW_CFA_restore";
6251 return "DW_CFA_nop";
6252 case DW_CFA_set_loc
:
6253 return "DW_CFA_set_loc";
6254 case DW_CFA_advance_loc1
:
6255 return "DW_CFA_advance_loc1";
6256 case DW_CFA_advance_loc2
:
6257 return "DW_CFA_advance_loc2";
6258 case DW_CFA_advance_loc4
:
6259 return "DW_CFA_advance_loc4";
6260 case DW_CFA_offset_extended
:
6261 return "DW_CFA_offset_extended";
6262 case DW_CFA_restore_extended
:
6263 return "DW_CFA_restore_extended";
6264 case DW_CFA_undefined
:
6265 return "DW_CFA_undefined";
6266 case DW_CFA_same_value
:
6267 return "DW_CFA_same_value";
6268 case DW_CFA_register
:
6269 return "DW_CFA_register";
6270 case DW_CFA_remember_state
:
6271 return "DW_CFA_remember_state";
6272 case DW_CFA_restore_state
:
6273 return "DW_CFA_restore_state";
6274 case DW_CFA_def_cfa
:
6275 return "DW_CFA_def_cfa";
6276 case DW_CFA_def_cfa_register
:
6277 return "DW_CFA_def_cfa_register";
6278 case DW_CFA_def_cfa_offset
:
6279 return "DW_CFA_def_cfa_offset";
6282 case DW_CFA_def_cfa_expression
:
6283 return "DW_CFA_def_cfa_expression";
6284 case DW_CFA_expression
:
6285 return "DW_CFA_expression";
6286 case DW_CFA_offset_extended_sf
:
6287 return "DW_CFA_offset_extended_sf";
6288 case DW_CFA_def_cfa_sf
:
6289 return "DW_CFA_def_cfa_sf";
6290 case DW_CFA_def_cfa_offset_sf
:
6291 return "DW_CFA_def_cfa_offset_sf";
6293 /* SGI/MIPS specific */
6294 case DW_CFA_MIPS_advance_loc8
:
6295 return "DW_CFA_MIPS_advance_loc8";
6297 /* GNU extensions */
6298 case DW_CFA_GNU_window_save
:
6299 return "DW_CFA_GNU_window_save";
6300 case DW_CFA_GNU_args_size
:
6301 return "DW_CFA_GNU_args_size";
6302 case DW_CFA_GNU_negative_offset_extended
:
6303 return "DW_CFA_GNU_negative_offset_extended";
6306 return "DW_CFA_<unknown>";
6312 dump_die (struct die_info
*die
)
6316 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6317 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6318 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6319 dwarf_bool_name (die
->has_children
));
6321 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6322 for (i
= 0; i
< die
->num_attrs
; ++i
)
6324 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6325 dwarf_attr_name (die
->attrs
[i
].name
),
6326 dwarf_form_name (die
->attrs
[i
].form
));
6327 switch (die
->attrs
[i
].form
)
6329 case DW_FORM_ref_addr
:
6331 fprintf_unfiltered (gdb_stderr
, "address: ");
6332 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6334 case DW_FORM_block2
:
6335 case DW_FORM_block4
:
6337 case DW_FORM_block1
:
6338 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6349 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6351 case DW_FORM_string
:
6353 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6354 DW_STRING (&die
->attrs
[i
])
6355 ? DW_STRING (&die
->attrs
[i
]) : "");
6358 if (DW_UNSND (&die
->attrs
[i
]))
6359 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6361 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6363 case DW_FORM_indirect
:
6364 /* the reader will have reduced the indirect form to
6365 the "base form" so this form should not occur */
6366 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6369 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6370 die
->attrs
[i
].form
);
6372 fprintf_unfiltered (gdb_stderr
, "\n");
6377 dump_die_list (struct die_info
*die
)
6387 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6390 struct die_info
*old
;
6392 h
= (offset
% REF_HASH_SIZE
);
6393 old
= die_ref_table
[h
];
6394 die
->next_ref
= old
;
6395 die_ref_table
[h
] = die
;
6400 dwarf2_empty_hash_tables (void)
6402 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6406 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6408 unsigned int result
= 0;
6412 case DW_FORM_ref_addr
:
6413 result
= DW_ADDR (attr
);
6419 case DW_FORM_ref_udata
:
6420 result
= cu_header_offset
+ DW_UNSND (attr
);
6423 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
6428 static struct die_info
*
6429 follow_die_ref (unsigned int offset
)
6431 struct die_info
*die
;
6434 h
= (offset
% REF_HASH_SIZE
);
6435 die
= die_ref_table
[h
];
6438 if (die
->offset
== offset
)
6442 die
= die
->next_ref
;
6447 static struct type
*
6448 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6450 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6452 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
6456 /* Look for this particular type in the fundamental type vector. If
6457 one is not found, create and install one appropriate for the
6458 current language and the current target machine. */
6460 if (ftypes
[typeid] == NULL
)
6462 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6465 return (ftypes
[typeid]);
6468 /* Decode simple location descriptions.
6469 Given a pointer to a dwarf block that defines a location, compute
6470 the location and return the value.
6472 FIXME: This is a kludge until we figure out a better
6473 way to handle the location descriptions.
6474 Gdb's design does not mesh well with the DWARF2 notion of a location
6475 computing interpreter, which is a shame because the flexibility goes unused.
6476 FIXME: Implement more operations as necessary.
6478 A location description containing no operations indicates that the
6479 object is optimized out. The global optimized_out flag is set for
6480 those, the return value is meaningless.
6482 When the result is a register number, the global isreg flag is set,
6483 otherwise it is cleared.
6485 When the result is a base register offset, the global offreg flag is set
6486 and the register number is returned in basereg, otherwise it is cleared.
6488 When the DW_OP_fbreg operation is encountered without a corresponding
6489 DW_AT_frame_base attribute, the global islocal flag is set.
6490 Hopefully the machine dependent code knows how to set up a virtual
6491 frame pointer for the local references.
6493 Note that stack[0] is unused except as a default error return.
6494 Note that stack overflow is not yet handled. */
6497 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
6498 const struct comp_unit_head
*cu_header
)
6501 int size
= blk
->size
;
6502 char *data
= blk
->data
;
6503 CORE_ADDR stack
[64];
6505 unsigned int bytes_read
, unsnd
;
6515 is_thread_local
= 0;
6556 stack
[++stacki
] = op
- DW_OP_lit0
;
6592 stack
[++stacki
] = op
- DW_OP_reg0
;
6597 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6599 stack
[++stacki
] = unsnd
;
6635 basereg
= op
- DW_OP_breg0
;
6636 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6642 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6644 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6649 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6651 if (frame_base_reg
>= 0)
6654 basereg
= frame_base_reg
;
6655 stack
[stacki
] += frame_base_offset
;
6659 complain (&dwarf2_missing_at_frame_base
);
6665 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
6666 cu_header
, &bytes_read
);
6671 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
6676 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
6681 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
6686 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
6691 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
6696 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
6701 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
6707 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6712 stack
[stacki
+ 1] = stack
[stacki
];
6717 stack
[stacki
- 1] += stack
[stacki
];
6721 case DW_OP_plus_uconst
:
6722 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6727 stack
[stacki
- 1] -= stack
[stacki
];
6733 /* If we're not the last op, then we definitely can't encode
6734 this using GDB's address_class enum. */
6736 complain (&dwarf2_complex_location_expr
);
6739 case DW_OP_GNU_push_tls_address
:
6740 is_thread_local
= 1;
6741 /* The top of the stack has the offset from the beginning
6742 of the thread control block at which the variable is located. */
6743 /* Nothing should follow this operator, so the top of stack would
6746 complain (&dwarf2_complex_location_expr
);
6750 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name (op
));
6751 return (stack
[stacki
]);
6754 return (stack
[stacki
]);
6757 /* memory allocation interface */
6761 dwarf2_free_tmp_obstack (PTR ignore
)
6763 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6766 static struct dwarf_block
*
6767 dwarf_alloc_block (void)
6769 struct dwarf_block
*blk
;
6771 blk
= (struct dwarf_block
*)
6772 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6776 static struct abbrev_info
*
6777 dwarf_alloc_abbrev (void)
6779 struct abbrev_info
*abbrev
;
6781 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6782 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6786 static struct die_info
*
6787 dwarf_alloc_die (void)
6789 struct die_info
*die
;
6791 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6792 memset (die
, 0, sizeof (struct die_info
));
6797 /* Macro support. */
6800 /* Return the full name of file number I in *LH's file name table.
6801 Use COMP_DIR as the name of the current directory of the
6802 compilation. The result is allocated using xmalloc; the caller is
6803 responsible for freeing it. */
6805 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
6807 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6809 if (IS_ABSOLUTE_PATH (fe
->name
))
6810 return xstrdup (fe
->name
);
6818 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6824 dir_len
= strlen (dir
);
6825 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
6826 strcpy (full_name
, dir
);
6827 full_name
[dir_len
] = '/';
6828 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
6832 return xstrdup (fe
->name
);
6837 static struct macro_source_file
*
6838 macro_start_file (int file
, int line
,
6839 struct macro_source_file
*current_file
,
6840 const char *comp_dir
,
6841 struct line_header
*lh
, struct objfile
*objfile
)
6843 /* The full name of this source file. */
6844 char *full_name
= file_full_name (file
, lh
, comp_dir
);
6846 /* We don't create a macro table for this compilation unit
6847 at all until we actually get a filename. */
6848 if (! pending_macros
)
6849 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
6850 objfile
->macro_cache
);
6853 /* If we have no current file, then this must be the start_file
6854 directive for the compilation unit's main source file. */
6855 current_file
= macro_set_main (pending_macros
, full_name
);
6857 current_file
= macro_include (current_file
, line
, full_name
);
6861 return current_file
;
6865 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
6866 followed by a null byte. */
6868 copy_string (const char *buf
, int len
)
6870 char *s
= xmalloc (len
+ 1);
6871 memcpy (s
, buf
, len
);
6879 consume_improper_spaces (const char *p
, const char *body
)
6883 complain (&dwarf2_macro_spaces_in_definition
, body
);
6894 parse_macro_definition (struct macro_source_file
*file
, int line
,
6899 /* The body string takes one of two forms. For object-like macro
6900 definitions, it should be:
6902 <macro name> " " <definition>
6904 For function-like macro definitions, it should be:
6906 <macro name> "() " <definition>
6908 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
6910 Spaces may appear only where explicitly indicated, and in the
6913 The Dwarf 2 spec says that an object-like macro's name is always
6914 followed by a space, but versions of GCC around March 2002 omit
6915 the space when the macro's definition is the empty string.
6917 The Dwarf 2 spec says that there should be no spaces between the
6918 formal arguments in a function-like macro's formal argument list,
6919 but versions of GCC around March 2002 include spaces after the
6923 /* Find the extent of the macro name. The macro name is terminated
6924 by either a space or null character (for an object-like macro) or
6925 an opening paren (for a function-like macro). */
6926 for (p
= body
; *p
; p
++)
6927 if (*p
== ' ' || *p
== '(')
6930 if (*p
== ' ' || *p
== '\0')
6932 /* It's an object-like macro. */
6933 int name_len
= p
- body
;
6934 char *name
= copy_string (body
, name_len
);
6935 const char *replacement
;
6938 replacement
= body
+ name_len
+ 1;
6941 complain (&dwarf2_macro_malformed_definition
, body
);
6942 replacement
= body
+ name_len
;
6945 macro_define_object (file
, line
, name
, replacement
);
6951 /* It's a function-like macro. */
6952 char *name
= copy_string (body
, p
- body
);
6955 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
6959 p
= consume_improper_spaces (p
, body
);
6961 /* Parse the formal argument list. */
6962 while (*p
&& *p
!= ')')
6964 /* Find the extent of the current argument name. */
6965 const char *arg_start
= p
;
6967 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
6970 if (! *p
|| p
== arg_start
)
6971 complain (&dwarf2_macro_malformed_definition
,
6975 /* Make sure argv has room for the new argument. */
6976 if (argc
>= argv_size
)
6979 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
6982 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
6985 p
= consume_improper_spaces (p
, body
);
6987 /* Consume the comma, if present. */
6992 p
= consume_improper_spaces (p
, body
);
7001 /* Perfectly formed definition, no complaints. */
7002 macro_define_function (file
, line
, name
,
7003 argc
, (const char **) argv
,
7005 else if (*p
== '\0')
7007 /* Complain, but do define it. */
7008 complain (&dwarf2_macro_malformed_definition
, body
);
7009 macro_define_function (file
, line
, name
,
7010 argc
, (const char **) argv
,
7014 /* Just complain. */
7015 complain (&dwarf2_macro_malformed_definition
, body
);
7018 /* Just complain. */
7019 complain (&dwarf2_macro_malformed_definition
, body
);
7025 for (i
= 0; i
< argc
; i
++)
7031 complain (&dwarf2_macro_malformed_definition
, body
);
7036 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7037 char *comp_dir
, bfd
*abfd
,
7038 const struct comp_unit_head
*cu_header
,
7039 struct objfile
*objfile
)
7041 char *mac_ptr
, *mac_end
;
7042 struct macro_source_file
*current_file
= 0;
7044 if (dwarf_macinfo_buffer
== NULL
)
7046 complain (&dwarf2_missing_macinfo_section
);
7050 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7051 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7055 enum dwarf_macinfo_record_type macinfo_type
;
7057 /* Do we at least have room for a macinfo type byte? */
7058 if (mac_ptr
>= mac_end
)
7060 complain (&dwarf2_macros_too_long
);
7064 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7067 switch (macinfo_type
)
7069 /* A zero macinfo type indicates the end of the macro
7074 case DW_MACINFO_define
:
7075 case DW_MACINFO_undef
:
7081 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7082 mac_ptr
+= bytes_read
;
7083 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7084 mac_ptr
+= bytes_read
;
7087 complain (&dwarf2_macro_outside_file
,
7088 macinfo_type
== DW_MACINFO_define
? "definition" :
7089 macinfo_type
== DW_MACINFO_undef
? "undefinition" :
7090 "something-or-other",
7094 if (macinfo_type
== DW_MACINFO_define
)
7095 parse_macro_definition (current_file
, line
, body
);
7096 else if (macinfo_type
== DW_MACINFO_undef
)
7097 macro_undef (current_file
, line
, body
);
7102 case DW_MACINFO_start_file
:
7107 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7108 mac_ptr
+= bytes_read
;
7109 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7110 mac_ptr
+= bytes_read
;
7112 current_file
= macro_start_file (file
, line
,
7113 current_file
, comp_dir
,
7118 case DW_MACINFO_end_file
:
7120 complain (&dwarf2_macro_unmatched_end_file
);
7123 current_file
= current_file
->included_by
;
7126 enum dwarf_macinfo_record_type next_type
;
7128 /* GCC circa March 2002 doesn't produce the zero
7129 type byte marking the end of the compilation
7130 unit. Complain if it's not there, but exit no
7133 /* Do we at least have room for a macinfo type byte? */
7134 if (mac_ptr
>= mac_end
)
7136 complain (&dwarf2_macros_too_long
);
7140 /* We don't increment mac_ptr here, so this is just
7142 next_type
= read_1_byte (abfd
, mac_ptr
);
7144 complain (&dwarf2_macros_not_terminated
);
7151 case DW_MACINFO_vendor_ext
:
7157 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7158 mac_ptr
+= bytes_read
;
7159 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7160 mac_ptr
+= bytes_read
;
7162 /* We don't recognize any vendor extensions. */
7169 /* Check if the attribute's form is a DW_FORM_block*
7170 if so return true else false. */
7172 attr_form_is_block (struct attribute
*attr
)
7174 return (attr
== NULL
? 0 :
7175 attr
->form
== DW_FORM_block1
7176 || attr
->form
== DW_FORM_block2
7177 || attr
->form
== DW_FORM_block4
7178 || attr
->form
== DW_FORM_block
);