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 complaint dwarf2_const_ignored
=
566 "type qualifier 'const' ignored", 0, 0
568 static struct complaint dwarf2_volatile_ignored
=
570 "type qualifier 'volatile' ignored", 0, 0
572 static struct complaint dwarf2_non_const_array_bound_ignored
=
574 "non-constant array bounds form '%s' ignored", 0, 0
576 static struct complaint dwarf2_missing_line_number_section
=
578 "missing .debug_line section", 0, 0
580 static struct complaint dwarf2_statement_list_fits_in_line_number_section
=
582 "statement list doesn't fit in .debug_line section", 0, 0
584 static struct complaint dwarf2_mangled_line_number_section
=
586 "mangled .debug_line section", 0, 0
588 static struct complaint dwarf2_unsupported_die_ref_attr
=
590 "unsupported die ref attribute form: '%s'", 0, 0
592 static struct complaint dwarf2_unsupported_stack_op
=
594 "unsupported stack op: '%s'", 0, 0
596 static struct complaint dwarf2_complex_location_expr
=
598 "location expression too complex", 0, 0
600 static struct complaint dwarf2_unsupported_tag
=
602 "unsupported tag: '%s'", 0, 0
604 static struct complaint dwarf2_unsupported_at_encoding
=
606 "unsupported DW_AT_encoding: '%s'", 0, 0
608 static struct complaint dwarf2_unsupported_at_frame_base
=
610 "unsupported DW_AT_frame_base for function '%s'", 0, 0
612 static struct complaint dwarf2_unexpected_tag
=
614 "unexepected tag in read_type_die: '%s'", 0, 0
616 static struct complaint dwarf2_missing_at_frame_base
=
618 "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
620 static struct complaint dwarf2_bad_static_member_name
=
622 "unrecognized static data member name '%s'", 0, 0
624 static struct complaint dwarf2_unsupported_accessibility
=
626 "unsupported accessibility %d", 0, 0
628 static struct complaint dwarf2_bad_member_name_complaint
=
630 "cannot extract member name from '%s'", 0, 0
632 static struct complaint dwarf2_missing_member_fn_type_complaint
=
634 "member function type missing for '%s'", 0, 0
636 static struct complaint dwarf2_vtbl_not_found_complaint
=
638 "virtual function table pointer not found when defining class '%s'", 0, 0
640 static struct complaint dwarf2_absolute_sibling_complaint
=
642 "ignoring absolute DW_AT_sibling", 0, 0
644 static struct complaint dwarf2_const_value_length_mismatch
=
646 "const value length mismatch for '%s', got %d, expected %d", 0, 0
648 static struct complaint dwarf2_unsupported_const_value_attr
=
650 "unsupported const value attribute form: '%s'", 0, 0
652 static struct complaint dwarf2_misplaced_line_number
=
654 "misplaced first line number at 0x%lx for '%s'", 0, 0
656 static struct complaint dwarf2_line_header_too_long
=
658 "line number info header doesn't fit in `.debug_line' section", 0, 0
660 static struct complaint dwarf2_missing_macinfo_section
=
662 "missing .debug_macinfo section", 0, 0
664 static struct complaint dwarf2_macros_too_long
=
666 "macro info runs off end of `.debug_macinfo' section", 0, 0
668 static struct complaint dwarf2_macros_not_terminated
=
670 "no terminating 0-type entry for macros in `.debug_macinfo' section", 0, 0
672 static struct complaint dwarf2_macro_outside_file
=
674 "debug info gives macro %s outside of any file: %s", 0, 0
676 static struct complaint dwarf2_macro_unmatched_end_file
=
678 "macro debug info has an unmatched `close_file' directive", 0, 0
680 static struct complaint dwarf2_macro_malformed_definition
=
682 "macro debug info contains a malformed macro definition:\n`%s'", 0, 0
684 static struct complaint dwarf2_macro_spaces_in_definition
=
686 "macro definition contains spaces in formal argument list:\n`%s'", 0, 0
688 static struct complaint dwarf2_invalid_attrib_class
=
690 "invalid attribute class or form for '%s' in '%s'", 0, 0
692 static struct 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_enumeration (struct die_info
*, struct objfile
*,
852 const struct comp_unit_head
*);
854 static struct type
*dwarf_base_type (int, int, struct objfile
*);
856 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct objfile
*,
857 const struct comp_unit_head
*);
859 static void read_array_type (struct die_info
*, struct objfile
*,
860 const struct comp_unit_head
*);
862 static void read_tag_pointer_type (struct die_info
*, struct objfile
*,
863 const struct comp_unit_head
*);
865 static void read_tag_ptr_to_member_type (struct die_info
*, struct objfile
*,
866 const struct comp_unit_head
*);
868 static void read_tag_reference_type (struct die_info
*, struct objfile
*,
869 const struct comp_unit_head
*);
871 static void read_tag_const_type (struct die_info
*, struct objfile
*,
872 const struct comp_unit_head
*);
874 static void read_tag_volatile_type (struct die_info
*, struct objfile
*,
875 const struct comp_unit_head
*);
877 static void read_tag_string_type (struct die_info
*, struct objfile
*);
879 static void read_subroutine_type (struct die_info
*, struct objfile
*,
880 const struct comp_unit_head
*);
882 static struct die_info
*read_comp_unit (char *, bfd
*,
883 const struct comp_unit_head
*);
885 static void free_die_list (struct die_info
*);
887 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
889 static void process_die (struct die_info
*, struct objfile
*,
890 const struct comp_unit_head
*);
892 static char *dwarf2_linkage_name (struct die_info
*);
894 static char *dwarf_tag_name (unsigned int);
896 static char *dwarf_attr_name (unsigned int);
898 static char *dwarf_form_name (unsigned int);
900 static char *dwarf_stack_op_name (unsigned int);
902 static char *dwarf_bool_name (unsigned int);
904 static char *dwarf_type_encoding_name (unsigned int);
907 static char *dwarf_cfi_name (unsigned int);
909 struct die_info
*copy_die (struct die_info
*);
912 static struct die_info
*sibling_die (struct die_info
*);
914 static void dump_die (struct die_info
*);
916 static void dump_die_list (struct die_info
*);
918 static void store_in_ref_table (unsigned int, struct die_info
*);
920 static void dwarf2_empty_hash_tables (void);
922 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
924 static struct die_info
*follow_die_ref (unsigned int);
926 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
928 /* memory allocation interface */
930 static void dwarf2_free_tmp_obstack (PTR
);
932 static struct dwarf_block
*dwarf_alloc_block (void);
934 static struct abbrev_info
*dwarf_alloc_abbrev (void);
936 static struct die_info
*dwarf_alloc_die (void);
938 static void initialize_cu_func_list (void);
940 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
942 static void dwarf_decode_macros (struct line_header
*, unsigned int,
943 char *, bfd
*, const struct comp_unit_head
*,
946 static int attr_form_is_block (struct attribute
*);
948 /* Try to locate the sections we need for DWARF 2 debugging
949 information and return true if we have enough to do something. */
952 dwarf2_has_info (bfd
*abfd
)
954 dwarf_info_offset
= 0;
955 dwarf_abbrev_offset
= 0;
956 dwarf_line_offset
= 0;
957 dwarf_str_offset
= 0;
958 dwarf_macinfo_offset
= 0;
959 dwarf_frame_offset
= 0;
960 dwarf_eh_frame_offset
= 0;
961 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
962 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
972 /* This function is mapped across the sections and remembers the
973 offset and size of each of the debugging sections we are interested
977 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, PTR ignore_ptr
)
979 if (STREQ (sectp
->name
, INFO_SECTION
))
981 dwarf_info_offset
= sectp
->filepos
;
982 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
984 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
986 dwarf_abbrev_offset
= sectp
->filepos
;
987 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
989 else if (STREQ (sectp
->name
, LINE_SECTION
))
991 dwarf_line_offset
= sectp
->filepos
;
992 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
994 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
996 dwarf_pubnames_offset
= sectp
->filepos
;
997 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
999 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
1001 dwarf_aranges_offset
= sectp
->filepos
;
1002 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
1004 else if (STREQ (sectp
->name
, LOC_SECTION
))
1006 dwarf_loc_offset
= sectp
->filepos
;
1007 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
1009 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
1011 dwarf_macinfo_offset
= sectp
->filepos
;
1012 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
1014 else if (STREQ (sectp
->name
, STR_SECTION
))
1016 dwarf_str_offset
= sectp
->filepos
;
1017 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
1019 else if (STREQ (sectp
->name
, FRAME_SECTION
))
1021 dwarf_frame_offset
= sectp
->filepos
;
1022 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1024 else if (STREQ (sectp
->name
, EH_FRAME_SECTION
))
1026 dwarf_eh_frame_offset
= sectp
->filepos
;
1027 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1031 /* Build a partial symbol table. */
1034 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1037 /* We definitely need the .debug_info and .debug_abbrev sections */
1039 dwarf_info_buffer
= dwarf2_read_section (objfile
,
1042 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
1043 dwarf_abbrev_offset
,
1046 if (dwarf_line_offset
)
1047 dwarf_line_buffer
= dwarf2_read_section (objfile
,
1051 dwarf_line_buffer
= NULL
;
1053 if (dwarf_str_offset
)
1054 dwarf_str_buffer
= dwarf2_read_section (objfile
,
1058 dwarf_str_buffer
= NULL
;
1060 if (dwarf_macinfo_offset
)
1061 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1062 dwarf_macinfo_offset
,
1063 dwarf_macinfo_size
);
1065 dwarf_macinfo_buffer
= NULL
;
1068 || (objfile
->global_psymbols
.size
== 0
1069 && objfile
->static_psymbols
.size
== 0))
1071 init_psymbol_list (objfile
, 1024);
1075 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1077 /* Things are significantly easier if we have .debug_aranges and
1078 .debug_pubnames sections */
1080 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1084 /* only test this case for now */
1086 /* In this case we have to work a bit harder */
1087 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1092 /* Build the partial symbol table from the information in the
1093 .debug_pubnames and .debug_aranges sections. */
1096 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1098 bfd
*abfd
= objfile
->obfd
;
1099 char *aranges_buffer
, *pubnames_buffer
;
1100 char *aranges_ptr
, *pubnames_ptr
;
1101 unsigned int entry_length
, version
, info_offset
, info_size
;
1103 pubnames_buffer
= dwarf2_read_section (objfile
,
1104 dwarf_pubnames_offset
,
1105 dwarf_pubnames_size
);
1106 pubnames_ptr
= pubnames_buffer
;
1107 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1109 struct comp_unit_head cu_header
;
1112 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1114 pubnames_ptr
+= bytes_read
;
1115 version
= read_1_byte (abfd
, pubnames_ptr
);
1117 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1119 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1123 aranges_buffer
= dwarf2_read_section (objfile
,
1124 dwarf_aranges_offset
,
1125 dwarf_aranges_size
);
1130 /* Read in the comp unit header information from the debug_info at
1134 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1135 char *info_ptr
, bfd
*abfd
)
1139 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1141 info_ptr
+= bytes_read
;
1142 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1144 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1146 info_ptr
+= bytes_read
;
1147 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1149 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1150 if (signed_addr
< 0)
1151 internal_error (__FILE__
, __LINE__
,
1152 "read_comp_unit_head: dwarf from non elf file");
1153 cu_header
->signed_addr_p
= signed_addr
;
1157 /* Build the partial symbol table by doing a quick pass through the
1158 .debug_info and .debug_abbrev sections. */
1161 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1163 /* Instead of reading this into a big buffer, we should probably use
1164 mmap() on architectures that support it. (FIXME) */
1165 bfd
*abfd
= objfile
->obfd
;
1166 char *info_ptr
, *abbrev_ptr
;
1167 char *beg_of_comp_unit
;
1168 struct partial_die_info comp_unit_die
;
1169 struct partial_symtab
*pst
;
1170 struct cleanup
*back_to
;
1171 CORE_ADDR lowpc
, highpc
;
1173 info_ptr
= dwarf_info_buffer
;
1174 abbrev_ptr
= dwarf_abbrev_buffer
;
1176 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1177 the partial symbol scan, like attribute values.
1179 We could reduce our peak memory consumption during partial symbol
1180 table construction by freeing stuff from this obstack more often
1181 --- say, after processing each compilation unit, or each die ---
1182 but it turns out that this saves almost nothing. For an
1183 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1184 on dwarf2_tmp_obstack. Some investigation showed:
1186 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1187 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1188 all fixed-length values not requiring dynamic allocation.
1190 2) 30% of the attributes used the form DW_FORM_string. For
1191 DW_FORM_string, read_attribute simply hands back a pointer to
1192 the null-terminated string in dwarf_info_buffer, so no dynamic
1193 allocation is needed there either.
1195 3) The remaining 1% of the attributes all used DW_FORM_block1.
1196 75% of those were DW_AT_frame_base location lists for
1197 functions; the rest were DW_AT_location attributes, probably
1198 for the global variables.
1200 Anyway, what this all means is that the memory the dwarf2
1201 reader uses as temporary space reading partial symbols is about
1202 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1204 obstack_init (&dwarf2_tmp_obstack
);
1205 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1207 /* Since the objects we're extracting from dwarf_info_buffer vary in
1208 length, only the individual functions to extract them (like
1209 read_comp_unit_head and read_partial_die) can really know whether
1210 the buffer is large enough to hold another complete object.
1212 At the moment, they don't actually check that. If
1213 dwarf_info_buffer holds just one extra byte after the last
1214 compilation unit's dies, then read_comp_unit_head will happily
1215 read off the end of the buffer. read_partial_die is similarly
1216 casual. Those functions should be fixed.
1218 For this loop condition, simply checking whether there's any data
1219 left at all should be sufficient. */
1220 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1222 struct comp_unit_head cu_header
;
1223 beg_of_comp_unit
= info_ptr
;
1224 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1226 if (cu_header
.version
!= 2)
1228 error ("Dwarf Error: wrong version in compilation unit header.");
1231 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
1233 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6).",
1234 (long) cu_header
.abbrev_offset
,
1235 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1238 if (beg_of_comp_unit
+ cu_header
.length
+ cu_header
.initial_length_size
1239 > dwarf_info_buffer
+ dwarf_info_size
)
1241 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0).",
1242 (long) cu_header
.length
,
1243 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1246 /* Complete the cu_header */
1247 cu_header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1248 cu_header
.first_die_ptr
= info_ptr
;
1249 cu_header
.cu_head_ptr
= beg_of_comp_unit
;
1251 /* Read the abbrevs for this compilation unit into a table */
1252 dwarf2_read_abbrevs (abfd
, &cu_header
);
1253 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1255 /* Read the compilation unit die */
1256 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1259 /* Set the language we're debugging */
1260 set_cu_language (comp_unit_die
.language
);
1262 /* Allocate a new partial symbol table structure */
1263 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1264 comp_unit_die
.name
? comp_unit_die
.name
: "",
1265 comp_unit_die
.lowpc
,
1266 objfile
->global_psymbols
.next
,
1267 objfile
->static_psymbols
.next
);
1269 pst
->read_symtab_private
= (char *)
1270 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1271 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1272 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1273 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1274 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1275 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1276 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1277 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1278 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1279 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1280 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1281 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1282 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1284 /* Store the function that reads in the rest of the symbol table */
1285 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1287 /* Check if comp unit has_children.
1288 If so, read the rest of the partial symbols from this comp unit.
1289 If not, there's no more debug_info for this comp unit. */
1290 if (comp_unit_die
.has_children
)
1292 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
,
1295 /* If the compilation unit didn't have an explicit address range,
1296 then use the information extracted from its child dies. */
1297 if (! comp_unit_die
.has_pc_info
)
1299 comp_unit_die
.lowpc
= lowpc
;
1300 comp_unit_die
.highpc
= highpc
;
1303 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1304 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1306 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1307 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1308 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1309 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1310 sort_pst_symbols (pst
);
1312 /* If there is already a psymtab or symtab for a file of this
1313 name, remove it. (If there is a symtab, more drastic things
1314 also happen.) This happens in VxWorks. */
1315 free_named_symtabs (pst
->filename
);
1317 info_ptr
= beg_of_comp_unit
+ cu_header
.length
1318 + cu_header
.initial_length_size
;
1320 do_cleanups (back_to
);
1323 /* Read in all interesting dies to the end of the compilation unit. */
1326 scan_partial_symbols (char *info_ptr
, struct objfile
*objfile
,
1327 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1328 const struct comp_unit_head
*cu_header
)
1330 bfd
*abfd
= objfile
->obfd
;
1331 struct partial_die_info pdi
;
1333 /* This function is called after we've read in the comp_unit_die in
1334 order to read its children. We start the nesting level at 1 since
1335 we have pushed 1 level down in order to read the comp unit's children.
1336 The comp unit itself is at level 0, so we stop reading when we pop
1337 back to that level. */
1339 int nesting_level
= 1;
1341 *lowpc
= ((CORE_ADDR
) -1);
1342 *highpc
= ((CORE_ADDR
) 0);
1344 while (nesting_level
)
1346 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1352 case DW_TAG_subprogram
:
1353 if (pdi
.has_pc_info
)
1355 if (pdi
.lowpc
< *lowpc
)
1359 if (pdi
.highpc
> *highpc
)
1361 *highpc
= pdi
.highpc
;
1363 if ((pdi
.is_external
|| nesting_level
== 1)
1364 && !pdi
.is_declaration
)
1366 add_partial_symbol (&pdi
, objfile
, cu_header
);
1370 case DW_TAG_variable
:
1371 case DW_TAG_typedef
:
1372 case DW_TAG_class_type
:
1373 case DW_TAG_structure_type
:
1374 case DW_TAG_union_type
:
1375 case DW_TAG_enumeration_type
:
1376 if ((pdi
.is_external
|| nesting_level
== 1)
1377 && !pdi
.is_declaration
)
1379 add_partial_symbol (&pdi
, objfile
, cu_header
);
1382 case DW_TAG_enumerator
:
1383 /* File scope enumerators are added to the partial symbol
1385 if (nesting_level
== 2)
1386 add_partial_symbol (&pdi
, objfile
, cu_header
);
1388 case DW_TAG_base_type
:
1389 /* File scope base type definitions are added to the partial
1391 if (nesting_level
== 1)
1392 add_partial_symbol (&pdi
, objfile
, cu_header
);
1399 /* If the die has a sibling, skip to the sibling.
1400 Do not skip enumeration types, we want to record their
1402 if (pdi
.sibling
&& pdi
.tag
!= DW_TAG_enumeration_type
)
1404 info_ptr
= pdi
.sibling
;
1406 else if (pdi
.has_children
)
1408 /* Die has children, but the optional DW_AT_sibling attribute
1419 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1420 from `maint check'. */
1421 if (*lowpc
== ((CORE_ADDR
) -1))
1427 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1428 const struct comp_unit_head
*cu_header
)
1434 case DW_TAG_subprogram
:
1435 if (pdi
->is_external
)
1437 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1438 mst_text, objfile); */
1439 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1440 VAR_NAMESPACE
, LOC_BLOCK
,
1441 &objfile
->global_psymbols
,
1442 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1446 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1447 mst_file_text, objfile); */
1448 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1449 VAR_NAMESPACE
, LOC_BLOCK
,
1450 &objfile
->static_psymbols
,
1451 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1454 case DW_TAG_variable
:
1455 if (pdi
->is_external
)
1458 Don't enter into the minimal symbol tables as there is
1459 a minimal symbol table entry from the ELF symbols already.
1460 Enter into partial symbol table if it has a location
1461 descriptor or a type.
1462 If the location descriptor is missing, new_symbol will create
1463 a LOC_UNRESOLVED symbol, the address of the variable will then
1464 be determined from the minimal symbol table whenever the variable
1466 The address for the partial symbol table entry is not
1467 used by GDB, but it comes in handy for debugging partial symbol
1471 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1472 if (pdi
->locdesc
|| pdi
->has_type
)
1473 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1474 VAR_NAMESPACE
, LOC_STATIC
,
1475 &objfile
->global_psymbols
,
1476 0, addr
+ baseaddr
, cu_language
, objfile
);
1480 /* Static Variable. Skip symbols without location descriptors. */
1481 if (pdi
->locdesc
== NULL
)
1483 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1484 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1485 mst_file_data, objfile); */
1486 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1487 VAR_NAMESPACE
, LOC_STATIC
,
1488 &objfile
->static_psymbols
,
1489 0, addr
+ baseaddr
, cu_language
, objfile
);
1492 case DW_TAG_typedef
:
1493 case DW_TAG_base_type
:
1494 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1495 VAR_NAMESPACE
, LOC_TYPEDEF
,
1496 &objfile
->static_psymbols
,
1497 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1499 case DW_TAG_class_type
:
1500 case DW_TAG_structure_type
:
1501 case DW_TAG_union_type
:
1502 case DW_TAG_enumeration_type
:
1503 /* Skip aggregate types without children, these are external
1505 if (pdi
->has_children
== 0)
1507 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1508 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1509 &objfile
->static_psymbols
,
1510 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1512 if (cu_language
== language_cplus
)
1514 /* For C++, these implicitly act as typedefs as well. */
1515 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1516 VAR_NAMESPACE
, LOC_TYPEDEF
,
1517 &objfile
->static_psymbols
,
1518 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1521 case DW_TAG_enumerator
:
1522 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1523 VAR_NAMESPACE
, LOC_CONST
,
1524 &objfile
->static_psymbols
,
1525 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1532 /* Expand this partial symbol table into a full symbol table. */
1535 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1537 /* FIXME: This is barely more than a stub. */
1542 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1548 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1549 gdb_flush (gdb_stdout
);
1552 psymtab_to_symtab_1 (pst
);
1554 /* Finish up the debug error message. */
1556 printf_filtered ("done.\n");
1562 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1564 struct objfile
*objfile
= pst
->objfile
;
1565 bfd
*abfd
= objfile
->obfd
;
1566 struct comp_unit_head cu_header
;
1567 struct die_info
*dies
;
1568 unsigned long offset
;
1569 CORE_ADDR lowpc
, highpc
;
1570 struct die_info
*child_die
;
1572 struct symtab
*symtab
;
1573 struct cleanup
*back_to
;
1575 /* Set local variables from the partial symbol table info. */
1576 offset
= DWARF_INFO_OFFSET (pst
);
1577 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1578 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1579 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1580 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1581 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1582 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1583 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1584 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1585 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1586 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1587 cu_header_offset
= offset
;
1588 info_ptr
= dwarf_info_buffer
+ offset
;
1590 obstack_init (&dwarf2_tmp_obstack
);
1591 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1594 make_cleanup (really_free_pendings
, NULL
);
1596 /* read in the comp_unit header */
1597 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1599 /* Read the abbrevs for this compilation unit */
1600 dwarf2_read_abbrevs (abfd
, &cu_header
);
1601 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1603 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
1605 make_cleanup_free_die_list (dies
);
1607 /* Do line number decoding in read_file_scope () */
1608 process_die (dies
, objfile
, &cu_header
);
1610 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1612 /* Some compilers don't define a DW_AT_high_pc attribute for
1613 the compilation unit. If the DW_AT_high_pc is missing,
1614 synthesize it, by scanning the DIE's below the compilation unit. */
1616 if (dies
->has_children
)
1618 child_die
= dies
->next
;
1619 while (child_die
&& child_die
->tag
)
1621 if (child_die
->tag
== DW_TAG_subprogram
)
1623 CORE_ADDR low
, high
;
1625 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1627 highpc
= max (highpc
, high
);
1630 child_die
= sibling_die (child_die
);
1634 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1636 /* Set symtab language to language from DW_AT_language.
1637 If the compilation is from a C file generated by language preprocessors,
1638 do not set the language if it was already deduced by start_subfile. */
1640 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1642 symtab
->language
= cu_language
;
1644 pst
->symtab
= symtab
;
1646 sort_symtab_syms (pst
->symtab
);
1648 do_cleanups (back_to
);
1651 /* Process a die and its children. */
1654 process_die (struct die_info
*die
, struct objfile
*objfile
,
1655 const struct comp_unit_head
*cu_header
)
1659 case DW_TAG_padding
:
1661 case DW_TAG_compile_unit
:
1662 read_file_scope (die
, objfile
, cu_header
);
1664 case DW_TAG_subprogram
:
1665 read_subroutine_type (die
, objfile
, cu_header
);
1666 read_func_scope (die
, objfile
, cu_header
);
1668 case DW_TAG_inlined_subroutine
:
1669 /* FIXME: These are ignored for now.
1670 They could be used to set breakpoints on all inlined instances
1671 of a function and make GDB `next' properly over inlined functions. */
1673 case DW_TAG_lexical_block
:
1674 read_lexical_block_scope (die
, objfile
, cu_header
);
1676 case DW_TAG_class_type
:
1677 case DW_TAG_structure_type
:
1678 case DW_TAG_union_type
:
1679 read_structure_scope (die
, objfile
, cu_header
);
1681 case DW_TAG_enumeration_type
:
1682 read_enumeration (die
, objfile
, cu_header
);
1684 case DW_TAG_subroutine_type
:
1685 read_subroutine_type (die
, objfile
, cu_header
);
1687 case DW_TAG_array_type
:
1688 read_array_type (die
, objfile
, cu_header
);
1690 case DW_TAG_pointer_type
:
1691 read_tag_pointer_type (die
, objfile
, cu_header
);
1693 case DW_TAG_ptr_to_member_type
:
1694 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1696 case DW_TAG_reference_type
:
1697 read_tag_reference_type (die
, objfile
, cu_header
);
1699 case DW_TAG_string_type
:
1700 read_tag_string_type (die
, objfile
);
1702 case DW_TAG_base_type
:
1703 read_base_type (die
, objfile
);
1704 if (dwarf_attr (die
, DW_AT_name
))
1706 /* Add a typedef symbol for the base type definition. */
1707 new_symbol (die
, die
->type
, objfile
, cu_header
);
1710 case DW_TAG_common_block
:
1711 read_common_block (die
, objfile
, cu_header
);
1713 case DW_TAG_common_inclusion
:
1716 new_symbol (die
, NULL
, objfile
, cu_header
);
1722 initialize_cu_func_list (void)
1724 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1728 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1729 const struct comp_unit_head
*cu_header
)
1731 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1732 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1733 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1734 struct attribute
*attr
;
1735 char *name
= "<unknown>";
1736 char *comp_dir
= NULL
;
1737 struct die_info
*child_die
;
1738 bfd
*abfd
= objfile
->obfd
;
1739 struct line_header
*line_header
= 0;
1741 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1743 if (die
->has_children
)
1745 child_die
= die
->next
;
1746 while (child_die
&& child_die
->tag
)
1748 if (child_die
->tag
== DW_TAG_subprogram
)
1750 CORE_ADDR low
, high
;
1752 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1754 lowpc
= min (lowpc
, low
);
1755 highpc
= max (highpc
, high
);
1758 child_die
= sibling_die (child_die
);
1763 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1764 from finish_block. */
1765 if (lowpc
== ((CORE_ADDR
) -1))
1770 attr
= dwarf_attr (die
, DW_AT_name
);
1773 name
= DW_STRING (attr
);
1775 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1778 comp_dir
= DW_STRING (attr
);
1781 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1782 directory, get rid of it. */
1783 char *cp
= strchr (comp_dir
, ':');
1785 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1790 if (objfile
->ei
.entry_point
>= lowpc
&&
1791 objfile
->ei
.entry_point
< highpc
)
1793 objfile
->ei
.entry_file_lowpc
= lowpc
;
1794 objfile
->ei
.entry_file_highpc
= highpc
;
1797 attr
= dwarf_attr (die
, DW_AT_language
);
1800 set_cu_language (DW_UNSND (attr
));
1803 /* We assume that we're processing GCC output. */
1804 processing_gcc_compilation
= 2;
1806 /* FIXME:Do something here. */
1807 if (dip
->at_producer
!= NULL
)
1809 handle_producer (dip
->at_producer
);
1813 /* The compilation unit may be in a different language or objfile,
1814 zero out all remembered fundamental types. */
1815 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1817 start_symtab (name
, comp_dir
, lowpc
);
1818 record_debugformat ("DWARF 2");
1820 initialize_cu_func_list ();
1822 /* Process all dies in compilation unit. */
1823 if (die
->has_children
)
1825 child_die
= die
->next
;
1826 while (child_die
&& child_die
->tag
)
1828 process_die (child_die
, objfile
, cu_header
);
1829 child_die
= sibling_die (child_die
);
1833 /* Decode line number information if present. */
1834 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1837 unsigned int line_offset
= DW_UNSND (attr
);
1838 line_header
= dwarf_decode_line_header (line_offset
,
1842 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
1843 (void *) line_header
);
1844 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu_header
);
1848 /* Decode macro information, if present. Dwarf 2 macro information
1849 refers to information in the line number info statement program
1850 header, so we can only read it if we've read the header
1852 attr
= dwarf_attr (die
, DW_AT_macro_info
);
1853 if (attr
&& line_header
)
1855 unsigned int macro_offset
= DW_UNSND (attr
);
1856 dwarf_decode_macros (line_header
, macro_offset
,
1857 comp_dir
, abfd
, cu_header
, objfile
);
1859 do_cleanups (back_to
);
1863 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
1865 struct function_range
*thisfn
;
1867 thisfn
= (struct function_range
*)
1868 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
1869 thisfn
->name
= name
;
1870 thisfn
->lowpc
= lowpc
;
1871 thisfn
->highpc
= highpc
;
1872 thisfn
->seen_line
= 0;
1873 thisfn
->next
= NULL
;
1875 if (cu_last_fn
== NULL
)
1876 cu_first_fn
= thisfn
;
1878 cu_last_fn
->next
= thisfn
;
1880 cu_last_fn
= thisfn
;
1884 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
1885 const struct comp_unit_head
*cu_header
)
1887 register struct context_stack
*new;
1890 struct die_info
*child_die
;
1891 struct attribute
*attr
;
1894 name
= dwarf2_linkage_name (die
);
1896 /* Ignore functions with missing or empty names and functions with
1897 missing or invalid low and high pc attributes. */
1898 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1904 /* Record the function range for dwarf_decode_lines. */
1905 add_to_cu_func_list (name
, lowpc
, highpc
);
1907 if (objfile
->ei
.entry_point
>= lowpc
&&
1908 objfile
->ei
.entry_point
< highpc
)
1910 objfile
->ei
.entry_func_lowpc
= lowpc
;
1911 objfile
->ei
.entry_func_highpc
= highpc
;
1914 /* Decode DW_AT_frame_base location descriptor if present, keep result
1915 for DW_OP_fbreg operands in decode_locdesc. */
1916 frame_base_reg
= -1;
1917 frame_base_offset
= 0;
1918 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1923 /* Support the .debug_loc offsets */
1924 if (attr_form_is_block (attr
))
1926 addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
1928 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
1930 complain (&dwarf2_complex_location_expr
);
1935 complain (&dwarf2_invalid_attrib_class
, "DW_AT_frame_base", name
);
1940 complain (&dwarf2_unsupported_at_frame_base
, name
);
1942 frame_base_reg
= addr
;
1945 frame_base_reg
= basereg
;
1946 frame_base_offset
= addr
;
1949 complain (&dwarf2_unsupported_at_frame_base
, name
);
1952 new = push_context (0, lowpc
);
1953 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
1954 list_in_scope
= &local_symbols
;
1956 if (die
->has_children
)
1958 child_die
= die
->next
;
1959 while (child_die
&& child_die
->tag
)
1961 process_die (child_die
, objfile
, cu_header
);
1962 child_die
= sibling_die (child_die
);
1966 new = pop_context ();
1967 /* Make a block for the local symbols within. */
1968 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1969 lowpc
, highpc
, objfile
);
1970 list_in_scope
= &file_symbols
;
1973 /* Process all the DIES contained within a lexical block scope. Start
1974 a new scope, process the dies, and then close the scope. */
1977 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
1978 const struct comp_unit_head
*cu_header
)
1980 register struct context_stack
*new;
1981 CORE_ADDR lowpc
, highpc
;
1982 struct die_info
*child_die
;
1984 /* Ignore blocks with missing or invalid low and high pc attributes. */
1985 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1990 push_context (0, lowpc
);
1991 if (die
->has_children
)
1993 child_die
= die
->next
;
1994 while (child_die
&& child_die
->tag
)
1996 process_die (child_die
, objfile
, cu_header
);
1997 child_die
= sibling_die (child_die
);
2000 new = pop_context ();
2002 if (local_symbols
!= NULL
)
2004 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2007 local_symbols
= new->locals
;
2010 /* Get low and high pc attributes from a die.
2011 Return 1 if the attributes are present and valid, otherwise, return 0. */
2014 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2015 struct objfile
*objfile
)
2017 struct attribute
*attr
;
2021 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2023 low
= DW_ADDR (attr
);
2026 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2028 high
= DW_ADDR (attr
);
2035 /* When using the GNU linker, .gnu.linkonce. sections are used to
2036 eliminate duplicate copies of functions and vtables and such.
2037 The linker will arbitrarily choose one and discard the others.
2038 The AT_*_pc values for such functions refer to local labels in
2039 these sections. If the section from that file was discarded, the
2040 labels are not in the output, so the relocs get a value of 0.
2041 If this is a discarded function, mark the pc bounds as invalid,
2042 so that GDB will ignore it. */
2043 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
2051 /* Add an aggregate field to the field list. */
2054 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2055 struct objfile
*objfile
,
2056 const struct comp_unit_head
*cu_header
)
2058 struct nextfield
*new_field
;
2059 struct attribute
*attr
;
2061 char *fieldname
= "";
2063 /* Allocate a new field list entry and link it in. */
2064 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2065 make_cleanup (xfree
, new_field
);
2066 memset (new_field
, 0, sizeof (struct nextfield
));
2067 new_field
->next
= fip
->fields
;
2068 fip
->fields
= new_field
;
2071 /* Handle accessibility and virtuality of field.
2072 The default accessibility for members is public, the default
2073 accessibility for inheritance is private. */
2074 if (die
->tag
!= DW_TAG_inheritance
)
2075 new_field
->accessibility
= DW_ACCESS_public
;
2077 new_field
->accessibility
= DW_ACCESS_private
;
2078 new_field
->virtuality
= DW_VIRTUALITY_none
;
2080 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2082 new_field
->accessibility
= DW_UNSND (attr
);
2083 if (new_field
->accessibility
!= DW_ACCESS_public
)
2084 fip
->non_public_fields
= 1;
2085 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2087 new_field
->virtuality
= DW_UNSND (attr
);
2089 fp
= &new_field
->field
;
2090 if (die
->tag
== DW_TAG_member
)
2092 /* Get type of field. */
2093 fp
->type
= die_type (die
, objfile
, cu_header
);
2095 /* Get bit size of field (zero if none). */
2096 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2099 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2103 FIELD_BITSIZE (*fp
) = 0;
2106 /* Get bit offset of field. */
2107 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2110 FIELD_BITPOS (*fp
) =
2111 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
2114 FIELD_BITPOS (*fp
) = 0;
2115 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2118 if (BITS_BIG_ENDIAN
)
2120 /* For big endian bits, the DW_AT_bit_offset gives the
2121 additional bit offset from the MSB of the containing
2122 anonymous object to the MSB of the field. We don't
2123 have to do anything special since we don't need to
2124 know the size of the anonymous object. */
2125 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2129 /* For little endian bits, compute the bit offset to the
2130 MSB of the anonymous object, subtract off the number of
2131 bits from the MSB of the field to the MSB of the
2132 object, and then subtract off the number of bits of
2133 the field itself. The result is the bit offset of
2134 the LSB of the field. */
2136 int bit_offset
= DW_UNSND (attr
);
2138 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2141 /* The size of the anonymous object containing
2142 the bit field is explicit, so use the
2143 indicated size (in bytes). */
2144 anonymous_size
= DW_UNSND (attr
);
2148 /* The size of the anonymous object containing
2149 the bit field must be inferred from the type
2150 attribute of the data member containing the
2152 anonymous_size
= TYPE_LENGTH (fp
->type
);
2154 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2155 - bit_offset
- FIELD_BITSIZE (*fp
);
2159 /* Get name of field. */
2160 attr
= dwarf_attr (die
, DW_AT_name
);
2161 if (attr
&& DW_STRING (attr
))
2162 fieldname
= DW_STRING (attr
);
2163 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2164 &objfile
->type_obstack
);
2166 /* Change accessibility for artificial fields (e.g. virtual table
2167 pointer or virtual base class pointer) to private. */
2168 if (dwarf_attr (die
, DW_AT_artificial
))
2170 new_field
->accessibility
= DW_ACCESS_private
;
2171 fip
->non_public_fields
= 1;
2174 else if (die
->tag
== DW_TAG_variable
)
2178 /* C++ static member.
2179 Get name of field. */
2180 attr
= dwarf_attr (die
, DW_AT_name
);
2181 if (attr
&& DW_STRING (attr
))
2182 fieldname
= DW_STRING (attr
);
2186 /* Get physical name. */
2187 physname
= dwarf2_linkage_name (die
);
2189 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2190 &objfile
->type_obstack
));
2191 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2192 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2193 &objfile
->type_obstack
);
2195 else if (die
->tag
== DW_TAG_inheritance
)
2197 /* C++ base class field. */
2198 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2200 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
2202 FIELD_BITSIZE (*fp
) = 0;
2203 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2204 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2205 fip
->nbaseclasses
++;
2209 /* Create the vector of fields, and attach it to the type. */
2212 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2213 struct objfile
*objfile
)
2215 int nfields
= fip
->nfields
;
2217 /* Record the field count, allocate space for the array of fields,
2218 and create blank accessibility bitfields if necessary. */
2219 TYPE_NFIELDS (type
) = nfields
;
2220 TYPE_FIELDS (type
) = (struct field
*)
2221 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2222 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2224 if (fip
->non_public_fields
)
2226 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2228 TYPE_FIELD_PRIVATE_BITS (type
) =
2229 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2230 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2232 TYPE_FIELD_PROTECTED_BITS (type
) =
2233 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2234 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2236 TYPE_FIELD_IGNORE_BITS (type
) =
2237 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2238 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2241 /* If the type has baseclasses, allocate and clear a bit vector for
2242 TYPE_FIELD_VIRTUAL_BITS. */
2243 if (fip
->nbaseclasses
)
2245 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2248 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2249 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2250 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2251 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2252 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2255 /* Copy the saved-up fields into the field vector. Start from the head
2256 of the list, adding to the tail of the field array, so that they end
2257 up in the same order in the array in which they were added to the list. */
2258 while (nfields
-- > 0)
2260 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2261 switch (fip
->fields
->accessibility
)
2263 case DW_ACCESS_private
:
2264 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2267 case DW_ACCESS_protected
:
2268 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2271 case DW_ACCESS_public
:
2275 /* Unknown accessibility. Complain and treat it as public. */
2277 complain (&dwarf2_unsupported_accessibility
,
2278 fip
->fields
->accessibility
);
2282 if (nfields
< fip
->nbaseclasses
)
2284 switch (fip
->fields
->virtuality
)
2286 case DW_VIRTUALITY_virtual
:
2287 case DW_VIRTUALITY_pure_virtual
:
2288 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2292 fip
->fields
= fip
->fields
->next
;
2296 /* Add a member function to the proper fieldlist. */
2299 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2300 struct type
*type
, struct objfile
*objfile
,
2301 const struct comp_unit_head
*cu_header
)
2303 struct attribute
*attr
;
2304 struct fnfieldlist
*flp
;
2306 struct fn_field
*fnp
;
2309 struct nextfnfield
*new_fnfield
;
2311 /* Get name of member function. */
2312 attr
= dwarf_attr (die
, DW_AT_name
);
2313 if (attr
&& DW_STRING (attr
))
2314 fieldname
= DW_STRING (attr
);
2318 /* Get the mangled name. */
2319 physname
= dwarf2_linkage_name (die
);
2321 /* Look up member function name in fieldlist. */
2322 for (i
= 0; i
< fip
->nfnfields
; i
++)
2324 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2328 /* Create new list element if necessary. */
2329 if (i
< fip
->nfnfields
)
2330 flp
= &fip
->fnfieldlists
[i
];
2333 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2335 fip
->fnfieldlists
= (struct fnfieldlist
*)
2336 xrealloc (fip
->fnfieldlists
,
2337 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2338 * sizeof (struct fnfieldlist
));
2339 if (fip
->nfnfields
== 0)
2340 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2342 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2343 flp
->name
= fieldname
;
2349 /* Create a new member function field and chain it to the field list
2351 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2352 make_cleanup (xfree
, new_fnfield
);
2353 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2354 new_fnfield
->next
= flp
->head
;
2355 flp
->head
= new_fnfield
;
2358 /* Fill in the member function field info. */
2359 fnp
= &new_fnfield
->fnfield
;
2360 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2361 &objfile
->type_obstack
);
2362 fnp
->type
= alloc_type (objfile
);
2363 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2365 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2366 int nparams
= TYPE_NFIELDS (die
->type
);
2368 /* TYPE is the domain of this method, and DIE->TYPE is the type
2369 of the method itself (TYPE_CODE_METHOD). */
2370 smash_to_method_type (fnp
->type
, type
,
2371 TYPE_TARGET_TYPE (die
->type
),
2372 TYPE_FIELDS (die
->type
),
2373 TYPE_NFIELDS (die
->type
),
2374 TYPE_VARARGS (die
->type
));
2376 /* Handle static member functions.
2377 Dwarf2 has no clean way to discern C++ static and non-static
2378 member functions. G++ helps GDB by marking the first
2379 parameter for non-static member functions (which is the
2380 this pointer) as artificial. We obtain this information
2381 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2382 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2383 fnp
->voffset
= VOFFSET_STATIC
;
2386 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2388 /* Get fcontext from DW_AT_containing_type if present. */
2389 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2390 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2392 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2393 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2395 /* Get accessibility. */
2396 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2399 switch (DW_UNSND (attr
))
2401 case DW_ACCESS_private
:
2402 fnp
->is_private
= 1;
2404 case DW_ACCESS_protected
:
2405 fnp
->is_protected
= 1;
2410 /* Check for artificial methods. */
2411 attr
= dwarf_attr (die
, DW_AT_artificial
);
2412 if (attr
&& DW_UNSND (attr
) != 0)
2413 fnp
->is_artificial
= 1;
2415 /* Get index in virtual function table if it is a virtual member function. */
2416 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2419 /* Support the .debug_loc offsets */
2420 if (attr_form_is_block (attr
))
2422 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2424 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2426 complain (&dwarf2_complex_location_expr
);
2430 complain (&dwarf2_invalid_attrib_class
, "DW_AT_vtable_elem_location",
2436 /* Create the vector of member function fields, and attach it to the type. */
2439 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2440 struct objfile
*objfile
)
2442 struct fnfieldlist
*flp
;
2443 int total_length
= 0;
2446 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2447 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2448 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2450 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2452 struct nextfnfield
*nfp
= flp
->head
;
2453 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2456 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2457 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2458 fn_flp
->fn_fields
= (struct fn_field
*)
2459 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2460 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2461 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2463 total_length
+= flp
->length
;
2466 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2467 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2470 /* Called when we find the DIE that starts a structure or union scope
2471 (definition) to process all dies that define the members of the
2474 NOTE: we need to call struct_type regardless of whether or not the
2475 DIE has an at_name attribute, since it might be an anonymous
2476 structure or union. This gets the type entered into our set of
2479 However, if the structure is incomplete (an opaque struct/union)
2480 then suppress creating a symbol table entry for it since gdb only
2481 wants to find the one with the complete definition. Note that if
2482 it is complete, we just call new_symbol, which does it's own
2483 checking about whether the struct/union is anonymous or not (and
2484 suppresses creating a symbol table entry itself). */
2487 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2488 const struct comp_unit_head
*cu_header
)
2491 struct attribute
*attr
;
2493 type
= alloc_type (objfile
);
2495 INIT_CPLUS_SPECIFIC (type
);
2496 attr
= dwarf_attr (die
, DW_AT_name
);
2497 if (attr
&& DW_STRING (attr
))
2499 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2500 strlen (DW_STRING (attr
)),
2501 &objfile
->type_obstack
);
2504 if (die
->tag
== DW_TAG_structure_type
)
2506 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2508 else if (die
->tag
== DW_TAG_union_type
)
2510 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2514 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2516 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2519 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2522 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2526 TYPE_LENGTH (type
) = 0;
2529 /* We need to add the type field to the die immediately so we don't
2530 infinitely recurse when dealing with pointers to the structure
2531 type within the structure itself. */
2534 if (die
->has_children
&& ! die_is_declaration (die
))
2536 struct field_info fi
;
2537 struct die_info
*child_die
;
2538 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2540 memset (&fi
, 0, sizeof (struct field_info
));
2542 child_die
= die
->next
;
2544 while (child_die
&& child_die
->tag
)
2546 if (child_die
->tag
== DW_TAG_member
)
2548 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2550 else if (child_die
->tag
== DW_TAG_variable
)
2552 /* C++ static member. */
2553 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2555 else if (child_die
->tag
== DW_TAG_subprogram
)
2557 /* C++ member function. */
2558 process_die (child_die
, objfile
, cu_header
);
2559 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2561 else if (child_die
->tag
== DW_TAG_inheritance
)
2563 /* C++ base class field. */
2564 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2568 process_die (child_die
, objfile
, cu_header
);
2570 child_die
= sibling_die (child_die
);
2573 /* Attach fields and member functions to the type. */
2575 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2578 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2580 /* Get the type which refers to the base class (possibly this
2581 class itself) which contains the vtable pointer for the current
2582 class from the DW_AT_containing_type attribute. */
2584 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2586 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2588 TYPE_VPTR_BASETYPE (type
) = t
;
2591 static const char vptr_name
[] =
2592 {'_', 'v', 'p', 't', 'r', '\0'};
2595 /* Our own class provides vtbl ptr. */
2596 for (i
= TYPE_NFIELDS (t
) - 1;
2597 i
>= TYPE_N_BASECLASSES (t
);
2600 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2602 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2603 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2605 TYPE_VPTR_FIELDNO (type
) = i
;
2610 /* Complain if virtual function table field not found. */
2611 if (i
< TYPE_N_BASECLASSES (t
))
2612 complain (&dwarf2_vtbl_not_found_complaint
,
2613 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2617 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2622 new_symbol (die
, type
, objfile
, cu_header
);
2624 do_cleanups (back_to
);
2628 /* No children, must be stub. */
2629 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2633 /* Given a pointer to a die which begins an enumeration, process all
2634 the dies that define the members of the enumeration.
2636 This will be much nicer in draft 6 of the DWARF spec when our
2637 members will be dies instead squished into the DW_AT_element_list
2640 NOTE: We reverse the order of the element list. */
2643 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2644 const struct comp_unit_head
*cu_header
)
2646 struct die_info
*child_die
;
2648 struct field
*fields
;
2649 struct attribute
*attr
;
2652 int unsigned_enum
= 1;
2654 type
= alloc_type (objfile
);
2656 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2657 attr
= dwarf_attr (die
, DW_AT_name
);
2658 if (attr
&& DW_STRING (attr
))
2660 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2661 strlen (DW_STRING (attr
)),
2662 &objfile
->type_obstack
);
2665 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2668 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2672 TYPE_LENGTH (type
) = 0;
2677 if (die
->has_children
)
2679 child_die
= die
->next
;
2680 while (child_die
&& child_die
->tag
)
2682 if (child_die
->tag
!= DW_TAG_enumerator
)
2684 process_die (child_die
, objfile
, cu_header
);
2688 attr
= dwarf_attr (child_die
, DW_AT_name
);
2691 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2692 if (SYMBOL_VALUE (sym
) < 0)
2695 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2697 fields
= (struct field
*)
2699 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2700 * sizeof (struct field
));
2703 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2704 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2705 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2706 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2712 child_die
= sibling_die (child_die
);
2717 TYPE_NFIELDS (type
) = num_fields
;
2718 TYPE_FIELDS (type
) = (struct field
*)
2719 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2720 memcpy (TYPE_FIELDS (type
), fields
,
2721 sizeof (struct field
) * num_fields
);
2725 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2728 new_symbol (die
, type
, objfile
, cu_header
);
2731 /* Extract all information from a DW_TAG_array_type DIE and put it in
2732 the DIE's type field. For now, this only handles one dimensional
2736 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2737 const struct comp_unit_head
*cu_header
)
2739 struct die_info
*child_die
;
2740 struct type
*type
= NULL
;
2741 struct type
*element_type
, *range_type
, *index_type
;
2742 struct type
**range_types
= NULL
;
2743 struct attribute
*attr
;
2745 struct cleanup
*back_to
;
2747 /* Return if we've already decoded this type. */
2753 element_type
= die_type (die
, objfile
, cu_header
);
2755 /* Irix 6.2 native cc creates array types without children for
2756 arrays with unspecified length. */
2757 if (die
->has_children
== 0)
2759 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2760 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2761 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2765 back_to
= make_cleanup (null_cleanup
, NULL
);
2766 child_die
= die
->next
;
2767 while (child_die
&& child_die
->tag
)
2769 if (child_die
->tag
== DW_TAG_subrange_type
)
2771 unsigned int low
, high
;
2773 /* Default bounds to an array with unspecified length. */
2776 if (cu_language
== language_fortran
)
2778 /* FORTRAN implies a lower bound of 1, if not given. */
2782 index_type
= die_type (child_die
, objfile
, cu_header
);
2783 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2786 if (attr
->form
== DW_FORM_sdata
)
2788 low
= DW_SND (attr
);
2790 else if (attr
->form
== DW_FORM_udata
2791 || attr
->form
== DW_FORM_data1
2792 || attr
->form
== DW_FORM_data2
2793 || attr
->form
== DW_FORM_data4
2794 || attr
->form
== DW_FORM_data8
)
2796 low
= DW_UNSND (attr
);
2800 complain (&dwarf2_non_const_array_bound_ignored
,
2801 dwarf_form_name (attr
->form
));
2803 die
->type
= lookup_pointer_type (element_type
);
2810 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2813 if (attr
->form
== DW_FORM_sdata
)
2815 high
= DW_SND (attr
);
2817 else if (attr
->form
== DW_FORM_udata
2818 || attr
->form
== DW_FORM_data1
2819 || attr
->form
== DW_FORM_data2
2820 || attr
->form
== DW_FORM_data4
2821 || attr
->form
== DW_FORM_data8
)
2823 high
= DW_UNSND (attr
);
2825 else if (attr
->form
== DW_FORM_block1
)
2827 /* GCC encodes arrays with unspecified or dynamic length
2828 with a DW_FORM_block1 attribute.
2829 FIXME: GDB does not yet know how to handle dynamic
2830 arrays properly, treat them as arrays with unspecified
2836 complain (&dwarf2_non_const_array_bound_ignored
,
2837 dwarf_form_name (attr
->form
));
2839 die
->type
= lookup_pointer_type (element_type
);
2847 /* Create a range type and save it for array type creation. */
2848 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2850 range_types
= (struct type
**)
2851 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2852 * sizeof (struct type
*));
2854 make_cleanup (free_current_contents
, &range_types
);
2856 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2858 child_die
= sibling_die (child_die
);
2861 /* Dwarf2 dimensions are output from left to right, create the
2862 necessary array types in backwards order. */
2863 type
= element_type
;
2865 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2867 /* Understand Dwarf2 support for vector types (like they occur on
2868 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
2869 array type. This is not part of the Dwarf2/3 standard yet, but a
2870 custom vendor extension. The main difference between a regular
2871 array and the vector variant is that vectors are passed by value
2873 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
2875 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
2877 do_cleanups (back_to
);
2879 /* Install the type in the die. */
2883 /* First cut: install each common block member as a global variable. */
2886 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
2887 const struct comp_unit_head
*cu_header
)
2889 struct die_info
*child_die
;
2890 struct attribute
*attr
;
2892 CORE_ADDR base
= (CORE_ADDR
) 0;
2894 attr
= dwarf_attr (die
, DW_AT_location
);
2897 /* Support the .debug_loc offsets */
2898 if (attr_form_is_block (attr
))
2900 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2902 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2904 complain (&dwarf2_complex_location_expr
);
2908 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
2909 "common block member");
2912 if (die
->has_children
)
2914 child_die
= die
->next
;
2915 while (child_die
&& child_die
->tag
)
2917 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
2918 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2921 SYMBOL_VALUE_ADDRESS (sym
) =
2922 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2923 add_symbol_to_list (sym
, &global_symbols
);
2925 child_die
= sibling_die (child_die
);
2930 /* Extract all information from a DW_TAG_pointer_type DIE and add to
2931 the user defined type vector. */
2934 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
2935 const struct comp_unit_head
*cu_header
)
2938 struct attribute
*attr_byte_size
;
2939 struct attribute
*attr_address_class
;
2940 int byte_size
, addr_class
;
2947 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
2949 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
2951 byte_size
= DW_UNSND (attr_byte_size
);
2953 byte_size
= cu_header
->addr_size
;
2955 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
2956 if (attr_address_class
)
2957 addr_class
= DW_UNSND (attr_address_class
);
2959 addr_class
= DW_ADDR_none
;
2961 /* If the pointer size or address class is different than the
2962 default, create a type variant marked as such and set the
2963 length accordingly. */
2964 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
2966 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
2970 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
2971 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
2972 type
= make_type_with_address_space (type
, type_flags
);
2974 else if (TYPE_LENGTH (type
) != byte_size
)
2976 complain (&dwarf2_invalid_pointer_size
, byte_size
);
2979 /* Should we also complain about unhandled address classes? */
2983 TYPE_LENGTH (type
) = byte_size
;
2987 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
2988 the user defined type vector. */
2991 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
2992 const struct comp_unit_head
*cu_header
)
2995 struct type
*to_type
;
2996 struct type
*domain
;
3003 type
= alloc_type (objfile
);
3004 to_type
= die_type (die
, objfile
, cu_header
);
3005 domain
= die_containing_type (die
, objfile
, cu_header
);
3006 smash_to_member_type (type
, domain
, to_type
);
3011 /* Extract all information from a DW_TAG_reference_type DIE and add to
3012 the user defined type vector. */
3015 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
3016 const struct comp_unit_head
*cu_header
)
3019 struct attribute
*attr
;
3026 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
3027 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3030 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3034 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3040 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
3041 const struct comp_unit_head
*cu_header
)
3043 struct type
*base_type
;
3050 base_type
= die_type (die
, objfile
, cu_header
);
3051 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3055 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
3056 const struct comp_unit_head
*cu_header
)
3058 struct type
*base_type
;
3065 base_type
= die_type (die
, objfile
, cu_header
);
3066 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3069 /* Extract all information from a DW_TAG_string_type DIE and add to
3070 the user defined type vector. It isn't really a user defined type,
3071 but it behaves like one, with other DIE's using an AT_user_def_type
3072 attribute to reference it. */
3075 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
3077 struct type
*type
, *range_type
, *index_type
, *char_type
;
3078 struct attribute
*attr
;
3079 unsigned int length
;
3086 attr
= dwarf_attr (die
, DW_AT_string_length
);
3089 length
= DW_UNSND (attr
);
3093 /* check for the DW_AT_byte_size attribute */
3094 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3097 length
= DW_UNSND (attr
);
3104 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3105 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3106 if (cu_language
== language_fortran
)
3108 /* Need to create a unique string type for bounds
3110 type
= create_string_type (0, range_type
);
3114 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3115 type
= create_string_type (char_type
, range_type
);
3120 /* Handle DIES due to C code like:
3124 int (*funcp)(int a, long l);
3128 ('funcp' generates a DW_TAG_subroutine_type DIE)
3132 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
3133 const struct comp_unit_head
*cu_header
)
3135 struct type
*type
; /* Type that this function returns */
3136 struct type
*ftype
; /* Function that returns above type */
3137 struct attribute
*attr
;
3139 /* Decode the type that this subroutine returns */
3144 type
= die_type (die
, objfile
, cu_header
);
3145 ftype
= lookup_function_type (type
);
3147 /* All functions in C++ have prototypes. */
3148 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3149 if ((attr
&& (DW_UNSND (attr
) != 0))
3150 || cu_language
== language_cplus
)
3151 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3153 if (die
->has_children
)
3155 struct die_info
*child_die
;
3159 /* Count the number of parameters.
3160 FIXME: GDB currently ignores vararg functions, but knows about
3161 vararg member functions. */
3162 child_die
= die
->next
;
3163 while (child_die
&& child_die
->tag
)
3165 if (child_die
->tag
== DW_TAG_formal_parameter
)
3167 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3168 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3169 child_die
= sibling_die (child_die
);
3172 /* Allocate storage for parameters and fill them in. */
3173 TYPE_NFIELDS (ftype
) = nparams
;
3174 TYPE_FIELDS (ftype
) = (struct field
*)
3175 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3177 child_die
= die
->next
;
3178 while (child_die
&& child_die
->tag
)
3180 if (child_die
->tag
== DW_TAG_formal_parameter
)
3182 /* Dwarf2 has no clean way to discern C++ static and non-static
3183 member functions. G++ helps GDB by marking the first
3184 parameter for non-static member functions (which is the
3185 this pointer) as artificial. We pass this information
3186 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3187 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3189 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3191 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3192 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
3196 child_die
= sibling_die (child_die
);
3204 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
3205 const struct comp_unit_head
*cu_header
)
3207 struct attribute
*attr
;
3212 attr
= dwarf_attr (die
, DW_AT_name
);
3213 if (attr
&& DW_STRING (attr
))
3215 name
= DW_STRING (attr
);
3217 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3218 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
3222 /* Find a representation of a given base type and install
3223 it in the TYPE field of the die. */
3226 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
3229 struct attribute
*attr
;
3230 int encoding
= 0, size
= 0;
3232 /* If we've already decoded this die, this is a no-op. */
3238 attr
= dwarf_attr (die
, DW_AT_encoding
);
3241 encoding
= DW_UNSND (attr
);
3243 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3246 size
= DW_UNSND (attr
);
3248 attr
= dwarf_attr (die
, DW_AT_name
);
3249 if (attr
&& DW_STRING (attr
))
3251 enum type_code code
= TYPE_CODE_INT
;
3256 case DW_ATE_address
:
3257 /* Turn DW_ATE_address into a void * pointer. */
3258 code
= TYPE_CODE_PTR
;
3259 type_flags
|= TYPE_FLAG_UNSIGNED
;
3261 case DW_ATE_boolean
:
3262 code
= TYPE_CODE_BOOL
;
3263 type_flags
|= TYPE_FLAG_UNSIGNED
;
3265 case DW_ATE_complex_float
:
3266 code
= TYPE_CODE_COMPLEX
;
3269 code
= TYPE_CODE_FLT
;
3272 case DW_ATE_signed_char
:
3274 case DW_ATE_unsigned
:
3275 case DW_ATE_unsigned_char
:
3276 type_flags
|= TYPE_FLAG_UNSIGNED
;
3279 complain (&dwarf2_unsupported_at_encoding
,
3280 dwarf_type_encoding_name (encoding
));
3283 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3284 if (encoding
== DW_ATE_address
)
3285 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3286 else if (encoding
== DW_ATE_complex_float
)
3289 TYPE_TARGET_TYPE (type
)
3290 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3291 else if (size
== 16)
3292 TYPE_TARGET_TYPE (type
)
3293 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3295 TYPE_TARGET_TYPE (type
)
3296 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3301 type
= dwarf_base_type (encoding
, size
, objfile
);
3306 /* Read a whole compilation unit into a linked list of dies. */
3308 static struct die_info
*
3309 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3310 const struct comp_unit_head
*cu_header
)
3312 struct die_info
*first_die
, *last_die
, *die
;
3316 /* Reset die reference table; we are
3317 building new ones now. */
3318 dwarf2_empty_hash_tables ();
3322 first_die
= last_die
= NULL
;
3325 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3326 if (die
->has_children
)
3337 /* Enter die in reference hash table */
3338 store_in_ref_table (die
->offset
, die
);
3342 first_die
= last_die
= die
;
3346 last_die
->next
= die
;
3350 while (nesting_level
> 0);
3354 /* Free a linked list of dies. */
3357 free_die_list (struct die_info
*dies
)
3359 struct die_info
*die
, *next
;
3372 do_free_die_list_cleanup (void *dies
)
3374 free_die_list (dies
);
3377 static struct cleanup
*
3378 make_cleanup_free_die_list (struct die_info
*dies
)
3380 return make_cleanup (do_free_die_list_cleanup
, dies
);
3384 /* Read the contents of the section at OFFSET and of size SIZE from the
3385 object file specified by OBJFILE into the psymbol_obstack and return it. */
3388 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3391 bfd
*abfd
= objfile
->obfd
;
3397 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3398 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3399 (bfd_bread (buf
, size
, abfd
) != size
))
3402 error ("Dwarf Error: Can't read DWARF data from '%s'",
3403 bfd_get_filename (abfd
));
3408 /* In DWARF version 2, the description of the debugging information is
3409 stored in a separate .debug_abbrev section. Before we read any
3410 dies from a section we read in all abbreviations and install them
3414 dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
)
3417 struct abbrev_info
*cur_abbrev
;
3418 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3419 unsigned int abbrev_form
, hash_number
;
3421 /* Initialize dwarf2 abbrevs */
3422 memset (cu_header
->dwarf2_abbrevs
, 0,
3423 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
3425 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
3426 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3427 abbrev_ptr
+= bytes_read
;
3429 /* loop until we reach an abbrev number of 0 */
3430 while (abbrev_number
)
3432 cur_abbrev
= dwarf_alloc_abbrev ();
3434 /* read in abbrev header */
3435 cur_abbrev
->number
= abbrev_number
;
3436 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3437 abbrev_ptr
+= bytes_read
;
3438 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3441 /* now read in declarations */
3442 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3443 abbrev_ptr
+= bytes_read
;
3444 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3445 abbrev_ptr
+= bytes_read
;
3448 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3450 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3451 xrealloc (cur_abbrev
->attrs
,
3452 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3453 * sizeof (struct attr_abbrev
));
3455 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3456 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3457 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3458 abbrev_ptr
+= bytes_read
;
3459 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3460 abbrev_ptr
+= bytes_read
;
3463 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3464 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
3465 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3467 /* Get next abbreviation.
3468 Under Irix6 the abbreviations for a compilation unit are not
3469 always properly terminated with an abbrev number of 0.
3470 Exit loop if we encounter an abbreviation which we have
3471 already read (which means we are about to read the abbreviations
3472 for the next compile unit) or if the end of the abbreviation
3473 table is reached. */
3474 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3475 >= dwarf_abbrev_size
)
3477 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3478 abbrev_ptr
+= bytes_read
;
3479 if (dwarf2_lookup_abbrev (abbrev_number
, cu_header
) != NULL
)
3484 /* Empty the abbrev table for a new compilation unit. */
3488 dwarf2_empty_abbrev_table (PTR ptr_to_abbrevs_table
)
3491 struct abbrev_info
*abbrev
, *next
;
3492 struct abbrev_info
**abbrevs
;
3494 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
3496 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3499 abbrev
= abbrevs
[i
];
3502 next
= abbrev
->next
;
3503 xfree (abbrev
->attrs
);
3511 /* Lookup an abbrev_info structure in the abbrev hash table. */
3513 static struct abbrev_info
*
3514 dwarf2_lookup_abbrev (unsigned int number
, const struct comp_unit_head
*cu_header
)
3516 unsigned int hash_number
;
3517 struct abbrev_info
*abbrev
;
3519 hash_number
= number
% ABBREV_HASH_SIZE
;
3520 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
3524 if (abbrev
->number
== number
)
3527 abbrev
= abbrev
->next
;
3532 /* Read a minimal amount of information into the minimal die structure. */
3535 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3536 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3538 unsigned int abbrev_number
, bytes_read
, i
;
3539 struct abbrev_info
*abbrev
;
3540 struct attribute attr
;
3541 struct attribute spec_attr
;
3542 int found_spec_attr
= 0;
3543 int has_low_pc_attr
= 0;
3544 int has_high_pc_attr
= 0;
3546 *part_die
= zeroed_partial_die
;
3547 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3548 info_ptr
+= bytes_read
;
3552 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3555 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3557 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3558 part_die
->tag
= abbrev
->tag
;
3559 part_die
->has_children
= abbrev
->has_children
;
3560 part_die
->abbrev
= abbrev_number
;
3562 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3564 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3565 info_ptr
, cu_header
);
3567 /* Store the data if it is of an attribute we want to keep in a
3568 partial symbol table. */
3573 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3574 if (part_die
->name
== NULL
)
3575 part_die
->name
= DW_STRING (&attr
);
3577 case DW_AT_MIPS_linkage_name
:
3578 part_die
->name
= DW_STRING (&attr
);
3581 has_low_pc_attr
= 1;
3582 part_die
->lowpc
= DW_ADDR (&attr
);
3585 has_high_pc_attr
= 1;
3586 part_die
->highpc
= DW_ADDR (&attr
);
3588 case DW_AT_location
:
3589 /* Support the .debug_loc offsets */
3590 if (attr_form_is_block (&attr
))
3592 part_die
->locdesc
= DW_BLOCK (&attr
);
3594 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
3596 complain (&dwarf2_complex_location_expr
);
3600 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
3601 "partial symbol information");
3604 case DW_AT_language
:
3605 part_die
->language
= DW_UNSND (&attr
);
3607 case DW_AT_external
:
3608 part_die
->is_external
= DW_UNSND (&attr
);
3610 case DW_AT_declaration
:
3611 part_die
->is_declaration
= DW_UNSND (&attr
);
3614 part_die
->has_type
= 1;
3616 case DW_AT_abstract_origin
:
3617 case DW_AT_specification
:
3618 found_spec_attr
= 1;
3622 /* Ignore absolute siblings, they might point outside of
3623 the current compile unit. */
3624 if (attr
.form
== DW_FORM_ref_addr
)
3625 complain (&dwarf2_absolute_sibling_complaint
);
3628 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3635 /* If we found a reference attribute and the die has no name, try
3636 to find a name in the referred to die. */
3638 if (found_spec_attr
&& part_die
->name
== NULL
)
3640 struct partial_die_info spec_die
;
3644 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3645 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3648 part_die
->name
= spec_die
.name
;
3650 /* Copy DW_AT_external attribute if it is set. */
3651 if (spec_die
.is_external
)
3652 part_die
->is_external
= spec_die
.is_external
;
3656 /* When using the GNU linker, .gnu.linkonce. sections are used to
3657 eliminate duplicate copies of functions and vtables and such.
3658 The linker will arbitrarily choose one and discard the others.
3659 The AT_*_pc values for such functions refer to local labels in
3660 these sections. If the section from that file was discarded, the
3661 labels are not in the output, so the relocs get a value of 0.
3662 If this is a discarded function, mark the pc bounds as invalid,
3663 so that GDB will ignore it. */
3664 if (has_low_pc_attr
&& has_high_pc_attr
3665 && part_die
->lowpc
< part_die
->highpc
3666 && (part_die
->lowpc
!= 0
3667 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3668 part_die
->has_pc_info
= 1;
3672 /* Read the die from the .debug_info section buffer. And set diep to
3673 point to a newly allocated die with its information. */
3676 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3677 const struct comp_unit_head
*cu_header
)
3679 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3680 struct abbrev_info
*abbrev
;
3681 struct die_info
*die
;
3683 offset
= info_ptr
- dwarf_info_buffer
;
3684 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3685 info_ptr
+= bytes_read
;
3688 die
= dwarf_alloc_die ();
3690 die
->abbrev
= abbrev_number
;
3696 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3699 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3701 die
= dwarf_alloc_die ();
3702 die
->offset
= offset
;
3703 die
->tag
= abbrev
->tag
;
3704 die
->has_children
= abbrev
->has_children
;
3705 die
->abbrev
= abbrev_number
;
3708 die
->num_attrs
= abbrev
->num_attrs
;
3709 die
->attrs
= (struct attribute
*)
3710 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3712 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3714 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3715 abfd
, info_ptr
, cu_header
);
3722 /* Read an attribute value described by an attribute form. */
3725 read_attribute_value (struct attribute
*attr
, unsigned form
,
3726 bfd
*abfd
, char *info_ptr
,
3727 const struct comp_unit_head
*cu_header
)
3729 unsigned int bytes_read
;
3730 struct dwarf_block
*blk
;
3736 case DW_FORM_ref_addr
:
3737 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3738 info_ptr
+= bytes_read
;
3740 case DW_FORM_block2
:
3741 blk
= dwarf_alloc_block ();
3742 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3744 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3745 info_ptr
+= blk
->size
;
3746 DW_BLOCK (attr
) = blk
;
3748 case DW_FORM_block4
:
3749 blk
= dwarf_alloc_block ();
3750 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3752 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3753 info_ptr
+= blk
->size
;
3754 DW_BLOCK (attr
) = blk
;
3757 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3761 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3765 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3768 case DW_FORM_string
:
3769 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3770 info_ptr
+= bytes_read
;
3773 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
3775 info_ptr
+= bytes_read
;
3778 blk
= dwarf_alloc_block ();
3779 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3780 info_ptr
+= bytes_read
;
3781 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3782 info_ptr
+= blk
->size
;
3783 DW_BLOCK (attr
) = blk
;
3785 case DW_FORM_block1
:
3786 blk
= dwarf_alloc_block ();
3787 blk
->size
= read_1_byte (abfd
, info_ptr
);
3789 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3790 info_ptr
+= blk
->size
;
3791 DW_BLOCK (attr
) = blk
;
3794 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3798 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3802 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3803 info_ptr
+= bytes_read
;
3806 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3807 info_ptr
+= bytes_read
;
3810 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3814 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3818 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3822 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3825 case DW_FORM_ref_udata
:
3826 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3827 info_ptr
+= bytes_read
;
3829 case DW_FORM_indirect
:
3830 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3831 info_ptr
+= bytes_read
;
3832 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
3835 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3836 dwarf_form_name (form
));
3841 /* Read an attribute described by an abbreviated attribute. */
3844 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
3845 bfd
*abfd
, char *info_ptr
,
3846 const struct comp_unit_head
*cu_header
)
3848 attr
->name
= abbrev
->name
;
3849 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
3852 /* read dwarf information from a buffer */
3855 read_1_byte (bfd
*abfd
, char *buf
)
3857 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3861 read_1_signed_byte (bfd
*abfd
, char *buf
)
3863 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3867 read_2_bytes (bfd
*abfd
, char *buf
)
3869 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3873 read_2_signed_bytes (bfd
*abfd
, char *buf
)
3875 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3879 read_4_bytes (bfd
*abfd
, char *buf
)
3881 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3885 read_4_signed_bytes (bfd
*abfd
, char *buf
)
3887 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3890 static unsigned long
3891 read_8_bytes (bfd
*abfd
, char *buf
)
3893 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3897 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3900 CORE_ADDR retval
= 0;
3902 if (cu_header
->signed_addr_p
)
3904 switch (cu_header
->addr_size
)
3907 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3910 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3913 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
3916 internal_error (__FILE__
, __LINE__
,
3917 "read_address: bad switch, signed");
3922 switch (cu_header
->addr_size
)
3925 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3928 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3931 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3934 internal_error (__FILE__
, __LINE__
,
3935 "read_address: bad switch, unsigned");
3939 *bytes_read
= cu_header
->addr_size
;
3943 /* Read the initial length from a section. The (draft) DWARF 3
3944 specification allows the initial length to take up either 4 bytes
3945 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
3946 bytes describe the length and all offsets will be 8 bytes in length
3949 An older, non-standard 64-bit format is also handled by this
3950 function. The older format in question stores the initial length
3951 as an 8-byte quantity without an escape value. Lengths greater
3952 than 2^32 aren't very common which means that the initial 4 bytes
3953 is almost always zero. Since a length value of zero doesn't make
3954 sense for the 32-bit format, this initial zero can be considered to
3955 be an escape value which indicates the presence of the older 64-bit
3956 format. As written, the code can't detect (old format) lengths
3957 greater than 4GB. If it becomes necessary to handle lengths somewhat
3958 larger than 4GB, we could allow other small values (such as the
3959 non-sensical values of 1, 2, and 3) to also be used as escape values
3960 indicating the presence of the old format.
3962 The value returned via bytes_read should be used to increment
3963 the relevant pointer after calling read_initial_length().
3965 As a side effect, this function sets the fields initial_length_size
3966 and offset_size in cu_header to the values appropriate for the
3967 length field. (The format of the initial length field determines
3968 the width of file offsets to be fetched later with fetch_offset().)
3970 [ Note: read_initial_length() and read_offset() are based on the
3971 document entitled "DWARF Debugging Information Format", revision
3972 3, draft 8, dated November 19, 2001. This document was obtained
3975 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
3977 This document is only a draft and is subject to change. (So beware.)
3979 Details regarding the older, non-standard 64-bit format were
3980 determined empirically by examining 64-bit ELF files produced
3981 by the SGI toolchain on an IRIX 6.5 machine.
3983 - Kevin, July 16, 2002
3987 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
3992 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3994 if (retval
== 0xffffffff)
3996 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
3998 if (cu_header
!= NULL
)
4000 cu_header
->initial_length_size
= 12;
4001 cu_header
->offset_size
= 8;
4004 else if (retval
== 0)
4006 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4008 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4010 if (cu_header
!= NULL
)
4012 cu_header
->initial_length_size
= 8;
4013 cu_header
->offset_size
= 8;
4019 if (cu_header
!= NULL
)
4021 cu_header
->initial_length_size
= 4;
4022 cu_header
->offset_size
= 4;
4029 /* Read an offset from the data stream. The size of the offset is
4030 given by cu_header->offset_size. */
4033 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4038 switch (cu_header
->offset_size
)
4041 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4045 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4049 internal_error (__FILE__
, __LINE__
,
4050 "read_offset: bad switch");
4057 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4059 /* If the size of a host char is 8 bits, we can return a pointer
4060 to the buffer, otherwise we have to copy the data to a buffer
4061 allocated on the temporary obstack. */
4062 gdb_assert (HOST_CHAR_BIT
== 8);
4067 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4069 /* If the size of a host char is 8 bits, we can return a pointer
4070 to the string, otherwise we have to copy the string to a buffer
4071 allocated on the temporary obstack. */
4072 gdb_assert (HOST_CHAR_BIT
== 8);
4075 *bytes_read_ptr
= 1;
4078 *bytes_read_ptr
= strlen (buf
) + 1;
4083 read_indirect_string (bfd
*abfd
, char *buf
,
4084 const struct comp_unit_head
*cu_header
,
4085 unsigned int *bytes_read_ptr
)
4087 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4088 (int *) bytes_read_ptr
);
4090 if (dwarf_str_buffer
== NULL
)
4092 error ("DW_FORM_strp used without .debug_str section");
4095 if (str_offset
>= dwarf_str_size
)
4097 error ("DW_FORM_strp pointing outside of .debug_str section");
4100 gdb_assert (HOST_CHAR_BIT
== 8);
4101 if (dwarf_str_buffer
[str_offset
] == '\0')
4103 return dwarf_str_buffer
+ str_offset
;
4106 static unsigned long
4107 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4109 unsigned long result
;
4110 unsigned int num_read
;
4120 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4123 result
|= ((unsigned long)(byte
& 127) << shift
);
4124 if ((byte
& 128) == 0)
4130 *bytes_read_ptr
= num_read
;
4135 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4138 int i
, shift
, size
, num_read
;
4148 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4151 result
|= ((long)(byte
& 127) << shift
);
4153 if ((byte
& 128) == 0)
4158 if ((shift
< size
) && (byte
& 0x40))
4160 result
|= -(1 << shift
);
4162 *bytes_read_ptr
= num_read
;
4167 set_cu_language (unsigned int lang
)
4173 cu_language
= language_c
;
4175 case DW_LANG_C_plus_plus
:
4176 cu_language
= language_cplus
;
4178 case DW_LANG_Fortran77
:
4179 case DW_LANG_Fortran90
:
4180 case DW_LANG_Fortran95
:
4181 cu_language
= language_fortran
;
4183 case DW_LANG_Mips_Assembler
:
4184 cu_language
= language_asm
;
4187 cu_language
= language_java
;
4191 case DW_LANG_Cobol74
:
4192 case DW_LANG_Cobol85
:
4193 case DW_LANG_Pascal83
:
4194 case DW_LANG_Modula2
:
4196 cu_language
= language_unknown
;
4199 cu_language_defn
= language_def (cu_language
);
4202 /* Return the named attribute or NULL if not there. */
4204 static struct attribute
*
4205 dwarf_attr (struct die_info
*die
, unsigned int name
)
4208 struct attribute
*spec
= NULL
;
4210 for (i
= 0; i
< die
->num_attrs
; ++i
)
4212 if (die
->attrs
[i
].name
== name
)
4214 return &die
->attrs
[i
];
4216 if (die
->attrs
[i
].name
== DW_AT_specification
4217 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4218 spec
= &die
->attrs
[i
];
4222 struct die_info
*ref_die
=
4223 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4226 return dwarf_attr (ref_die
, name
);
4233 die_is_declaration (struct die_info
*die
)
4235 return (dwarf_attr (die
, DW_AT_declaration
)
4236 && ! dwarf_attr (die
, DW_AT_specification
));
4240 /* Free the line_header structure *LH, and any arrays and strings it
4243 free_line_header (struct line_header
*lh
)
4245 if (lh
->standard_opcode_lengths
)
4246 xfree (lh
->standard_opcode_lengths
);
4248 /* Remember that all the lh->file_names[i].name pointers are
4249 pointers into debug_line_buffer, and don't need to be freed. */
4251 xfree (lh
->file_names
);
4253 /* Similarly for the include directory names. */
4254 if (lh
->include_dirs
)
4255 xfree (lh
->include_dirs
);
4261 /* Add an entry to LH's include directory table. */
4263 add_include_dir (struct line_header
*lh
, char *include_dir
)
4265 /* Grow the array if necessary. */
4266 if (lh
->include_dirs_size
== 0)
4268 lh
->include_dirs_size
= 1; /* for testing */
4269 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4270 * sizeof (*lh
->include_dirs
));
4272 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4274 lh
->include_dirs_size
*= 2;
4275 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4276 (lh
->include_dirs_size
4277 * sizeof (*lh
->include_dirs
)));
4280 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4284 /* Add an entry to LH's file name table. */
4286 add_file_name (struct line_header
*lh
,
4288 unsigned int dir_index
,
4289 unsigned int mod_time
,
4290 unsigned int length
)
4292 struct file_entry
*fe
;
4294 /* Grow the array if necessary. */
4295 if (lh
->file_names_size
== 0)
4297 lh
->file_names_size
= 1; /* for testing */
4298 lh
->file_names
= xmalloc (lh
->file_names_size
4299 * sizeof (*lh
->file_names
));
4301 else if (lh
->num_file_names
>= lh
->file_names_size
)
4303 lh
->file_names_size
*= 2;
4304 lh
->file_names
= xrealloc (lh
->file_names
,
4305 (lh
->file_names_size
4306 * sizeof (*lh
->file_names
)));
4309 fe
= &lh
->file_names
[lh
->num_file_names
++];
4311 fe
->dir_index
= dir_index
;
4312 fe
->mod_time
= mod_time
;
4313 fe
->length
= length
;
4317 /* Read the statement program header starting at OFFSET in
4318 dwarf_line_buffer, according to the endianness of ABFD. Return a
4319 pointer to a struct line_header, allocated using xmalloc.
4321 NOTE: the strings in the include directory and file name tables of
4322 the returned object point into debug_line_buffer, and must not be
4324 static struct line_header
*
4325 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4326 const struct comp_unit_head
*cu_header
)
4328 struct cleanup
*back_to
;
4329 struct line_header
*lh
;
4333 char *cur_dir
, *cur_file
;
4335 if (dwarf_line_buffer
== NULL
)
4337 complain (&dwarf2_missing_line_number_section
);
4341 /* Make sure that at least there's room for the total_length field. That
4342 could be 12 bytes long, but we're just going to fudge that. */
4343 if (offset
+ 4 >= dwarf_line_size
)
4345 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4349 lh
= xmalloc (sizeof (*lh
));
4350 memset (lh
, 0, sizeof (*lh
));
4351 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4354 line_ptr
= dwarf_line_buffer
+ offset
;
4356 /* read in the header */
4357 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4358 line_ptr
+= bytes_read
;
4359 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4361 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4364 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4365 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4367 lh
->header_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
4368 line_ptr
+= bytes_read
;
4369 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4371 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4373 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4375 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4377 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4379 lh
->standard_opcode_lengths
4380 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4382 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4383 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4385 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4389 /* Read directory table */
4390 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4392 line_ptr
+= bytes_read
;
4393 add_include_dir (lh
, cur_dir
);
4395 line_ptr
+= bytes_read
;
4397 /* Read file name table */
4398 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4400 unsigned int dir_index
, mod_time
, length
;
4402 line_ptr
+= bytes_read
;
4403 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4404 line_ptr
+= bytes_read
;
4405 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4406 line_ptr
+= bytes_read
;
4407 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4408 line_ptr
+= bytes_read
;
4410 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4412 line_ptr
+= bytes_read
;
4413 lh
->statement_program_start
= line_ptr
;
4415 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4416 complain (&dwarf2_line_header_too_long
);
4418 discard_cleanups (back_to
);
4422 /* This function exists to work around a bug in certain compilers
4423 (particularly GCC 2.95), in which the first line number marker of a
4424 function does not show up until after the prologue, right before
4425 the second line number marker. This function shifts ADDRESS down
4426 to the beginning of the function if necessary, and is called on
4427 addresses passed to record_line. */
4430 check_cu_functions (CORE_ADDR address
)
4432 struct function_range
*fn
;
4434 /* Find the function_range containing address. */
4439 cu_cached_fn
= cu_first_fn
;
4443 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4449 while (fn
&& fn
!= cu_cached_fn
)
4450 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4460 if (address
!= fn
->lowpc
)
4461 complain (&dwarf2_misplaced_line_number
,
4462 (unsigned long) address
, fn
->name
);
4467 /* Decode the line number information for the compilation unit whose
4468 line number info is at OFFSET in the .debug_line section.
4469 The compilation directory of the file is passed in COMP_DIR. */
4472 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
4473 const struct comp_unit_head
*cu_header
)
4477 unsigned int i
, bytes_read
;
4479 unsigned char op_code
, extended_op
, adj_opcode
;
4481 line_ptr
= lh
->statement_program_start
;
4482 line_end
= lh
->statement_program_end
;
4484 /* Read the statement sequences until there's nothing left. */
4485 while (line_ptr
< line_end
)
4487 /* state machine registers */
4488 CORE_ADDR address
= 0;
4489 unsigned int file
= 1;
4490 unsigned int line
= 1;
4491 unsigned int column
= 0;
4492 int is_stmt
= lh
->default_is_stmt
;
4493 int basic_block
= 0;
4494 int end_sequence
= 0;
4496 /* Start a subfile for the current file of the state machine. */
4497 if (lh
->num_file_names
>= file
)
4499 /* lh->include_dirs and lh->file_names are 0-based, but the
4500 directory and file name numbers in the statement program
4502 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
4505 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4508 dwarf2_start_subfile (fe
->name
, dir
);
4511 /* Decode the table. */
4512 while (!end_sequence
)
4514 op_code
= read_1_byte (abfd
, line_ptr
);
4517 if (op_code
>= lh
->opcode_base
)
4518 { /* Special operand. */
4519 adj_opcode
= op_code
- lh
->opcode_base
;
4520 address
+= (adj_opcode
/ lh
->line_range
)
4521 * lh
->minimum_instruction_length
;
4522 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
4523 /* append row to matrix using current values */
4524 address
= check_cu_functions (address
);
4525 record_line (current_subfile
, line
, address
);
4528 else switch (op_code
)
4530 case DW_LNS_extended_op
:
4531 line_ptr
+= 1; /* ignore length */
4532 extended_op
= read_1_byte (abfd
, line_ptr
);
4534 switch (extended_op
)
4536 case DW_LNE_end_sequence
:
4538 record_line (current_subfile
, 0, address
);
4540 case DW_LNE_set_address
:
4541 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4542 line_ptr
+= bytes_read
;
4543 address
+= baseaddr
;
4545 case DW_LNE_define_file
:
4548 unsigned int dir_index
, mod_time
, length
;
4550 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
4551 line_ptr
+= bytes_read
;
4553 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4554 line_ptr
+= bytes_read
;
4556 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4557 line_ptr
+= bytes_read
;
4559 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4560 line_ptr
+= bytes_read
;
4561 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4565 complain (&dwarf2_mangled_line_number_section
);
4570 address
= check_cu_functions (address
);
4571 record_line (current_subfile
, line
, address
);
4574 case DW_LNS_advance_pc
:
4575 address
+= lh
->minimum_instruction_length
4576 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4577 line_ptr
+= bytes_read
;
4579 case DW_LNS_advance_line
:
4580 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4581 line_ptr
+= bytes_read
;
4583 case DW_LNS_set_file
:
4585 /* lh->include_dirs and lh->file_names are 0-based,
4586 but the directory and file name numbers in the
4587 statement program are 1-based. */
4588 struct file_entry
*fe
;
4590 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4591 line_ptr
+= bytes_read
;
4592 fe
= &lh
->file_names
[file
- 1];
4594 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4597 dwarf2_start_subfile (fe
->name
, dir
);
4600 case DW_LNS_set_column
:
4601 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4602 line_ptr
+= bytes_read
;
4604 case DW_LNS_negate_stmt
:
4605 is_stmt
= (!is_stmt
);
4607 case DW_LNS_set_basic_block
:
4610 /* Add to the address register of the state machine the
4611 address increment value corresponding to special opcode
4612 255. Ie, this value is scaled by the minimum instruction
4613 length since special opcode 255 would have scaled the
4615 case DW_LNS_const_add_pc
:
4616 address
+= (lh
->minimum_instruction_length
4617 * ((255 - lh
->opcode_base
) / lh
->line_range
));
4619 case DW_LNS_fixed_advance_pc
:
4620 address
+= read_2_bytes (abfd
, line_ptr
);
4624 { /* Unknown standard opcode, ignore it. */
4626 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
4628 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4629 line_ptr
+= bytes_read
;
4637 /* Start a subfile for DWARF. FILENAME is the name of the file and
4638 DIRNAME the name of the source directory which contains FILENAME
4639 or NULL if not known.
4640 This routine tries to keep line numbers from identical absolute and
4641 relative file names in a common subfile.
4643 Using the `list' example from the GDB testsuite, which resides in
4644 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4645 of /srcdir/list0.c yields the following debugging information for list0.c:
4647 DW_AT_name: /srcdir/list0.c
4648 DW_AT_comp_dir: /compdir
4649 files.files[0].name: list0.h
4650 files.files[0].dir: /srcdir
4651 files.files[1].name: list0.c
4652 files.files[1].dir: /srcdir
4654 The line number information for list0.c has to end up in a single
4655 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4658 dwarf2_start_subfile (char *filename
, char *dirname
)
4660 /* If the filename isn't absolute, try to match an existing subfile
4661 with the full pathname. */
4663 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4665 struct subfile
*subfile
;
4666 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4668 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4670 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4672 current_subfile
= subfile
;
4679 start_subfile (filename
, dirname
);
4682 /* Given a pointer to a DWARF information entry, figure out if we need
4683 to make a symbol table entry for it, and if so, create a new entry
4684 and return a pointer to it.
4685 If TYPE is NULL, determine symbol type from the die, otherwise
4686 used the passed type. */
4688 static struct symbol
*
4689 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4690 const struct comp_unit_head
*cu_header
)
4692 struct symbol
*sym
= NULL
;
4694 struct attribute
*attr
= NULL
;
4695 struct attribute
*attr2
= NULL
;
4698 name
= dwarf2_linkage_name (die
);
4701 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4702 sizeof (struct symbol
));
4703 OBJSTAT (objfile
, n_syms
++);
4704 memset (sym
, 0, sizeof (struct symbol
));
4705 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4706 &objfile
->symbol_obstack
);
4708 /* Default assumptions.
4709 Use the passed type or decode it from the die. */
4710 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4711 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4713 SYMBOL_TYPE (sym
) = type
;
4715 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4716 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4719 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4722 /* If this symbol is from a C++ compilation, then attempt to
4723 cache the demangled form for future reference. This is a
4724 typical time versus space tradeoff, that was decided in favor
4725 of time because it sped up C++ symbol lookups by a factor of
4728 SYMBOL_LANGUAGE (sym
) = cu_language
;
4729 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4733 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4736 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4738 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4740 case DW_TAG_subprogram
:
4741 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4743 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4744 attr2
= dwarf_attr (die
, DW_AT_external
);
4745 if (attr2
&& (DW_UNSND (attr2
) != 0))
4747 add_symbol_to_list (sym
, &global_symbols
);
4751 add_symbol_to_list (sym
, list_in_scope
);
4754 case DW_TAG_variable
:
4755 /* Compilation with minimal debug info may result in variables
4756 with missing type entries. Change the misleading `void' type
4757 to something sensible. */
4758 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4759 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4760 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4761 "<variable, no debug info>",
4763 attr
= dwarf_attr (die
, DW_AT_const_value
);
4766 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4767 attr2
= dwarf_attr (die
, DW_AT_external
);
4768 if (attr2
&& (DW_UNSND (attr2
) != 0))
4769 add_symbol_to_list (sym
, &global_symbols
);
4771 add_symbol_to_list (sym
, list_in_scope
);
4774 attr
= dwarf_attr (die
, DW_AT_location
);
4777 attr2
= dwarf_attr (die
, DW_AT_external
);
4778 if (attr2
&& (DW_UNSND (attr2
) != 0))
4780 /* Support the .debug_loc offsets */
4781 if (attr_form_is_block (attr
))
4783 SYMBOL_VALUE_ADDRESS (sym
) =
4784 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4786 else if (attr
->form
== DW_FORM_data4
4787 || attr
->form
== DW_FORM_data8
)
4789 complain (&dwarf2_complex_location_expr
);
4793 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4794 "external variable");
4796 add_symbol_to_list (sym
, &global_symbols
);
4797 if (is_thread_local
)
4799 /* SYMBOL_VALUE_ADDRESS contains at this point the
4800 offset of the variable within the thread local
4802 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
4803 SYMBOL_OBJFILE (sym
) = objfile
;
4806 /* In shared libraries the address of the variable
4807 in the location descriptor might still be relocatable,
4808 so its value could be zero.
4809 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4810 value is zero, the address of the variable will then
4811 be determined from the minimal symbol table whenever
4812 the variable is referenced. */
4813 else if (SYMBOL_VALUE_ADDRESS (sym
))
4815 fixup_symbol_section (sym
, objfile
);
4816 SYMBOL_VALUE_ADDRESS (sym
) +=
4817 ANOFFSET (objfile
->section_offsets
,
4818 SYMBOL_SECTION (sym
));
4819 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4822 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4826 /* Support the .debug_loc offsets */
4827 if (attr_form_is_block (attr
))
4829 SYMBOL_VALUE (sym
) = addr
=
4830 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4832 else if (attr
->form
== DW_FORM_data4
4833 || attr
->form
== DW_FORM_data8
)
4835 complain (&dwarf2_complex_location_expr
);
4839 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4840 "external variable");
4843 add_symbol_to_list (sym
, list_in_scope
);
4846 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4850 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4851 SYMBOL_VALUE (sym
) =
4852 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4856 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4857 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4861 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4863 else if (is_thread_local
)
4865 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
4866 SYMBOL_OBJFILE (sym
) = objfile
;
4870 fixup_symbol_section (sym
, objfile
);
4871 SYMBOL_VALUE_ADDRESS (sym
) =
4872 addr
+ ANOFFSET (objfile
->section_offsets
,
4873 SYMBOL_SECTION (sym
));
4874 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4880 /* We do not know the address of this symbol.
4881 If it is an external symbol and we have type information
4882 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4883 The address of the variable will then be determined from
4884 the minimal symbol table whenever the variable is
4886 attr2
= dwarf_attr (die
, DW_AT_external
);
4887 if (attr2
&& (DW_UNSND (attr2
) != 0)
4888 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4890 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4891 add_symbol_to_list (sym
, &global_symbols
);
4895 case DW_TAG_formal_parameter
:
4896 attr
= dwarf_attr (die
, DW_AT_location
);
4899 SYMBOL_VALUE (sym
) =
4900 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4903 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4904 SYMBOL_VALUE (sym
) =
4905 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4911 if (basereg
!= frame_base_reg
)
4912 complain (&dwarf2_complex_location_expr
);
4913 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
4917 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4918 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4923 SYMBOL_CLASS (sym
) = LOC_ARG
;
4926 attr
= dwarf_attr (die
, DW_AT_const_value
);
4929 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4931 add_symbol_to_list (sym
, list_in_scope
);
4933 case DW_TAG_unspecified_parameters
:
4934 /* From varargs functions; gdb doesn't seem to have any
4935 interest in this information, so just ignore it for now.
4938 case DW_TAG_class_type
:
4939 case DW_TAG_structure_type
:
4940 case DW_TAG_union_type
:
4941 case DW_TAG_enumeration_type
:
4942 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4943 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
4944 add_symbol_to_list (sym
, list_in_scope
);
4946 /* The semantics of C++ state that "struct foo { ... }" also
4947 defines a typedef for "foo". Synthesize a typedef symbol so
4948 that "ptype foo" works as expected. */
4949 if (cu_language
== language_cplus
)
4951 struct symbol
*typedef_sym
= (struct symbol
*)
4952 obstack_alloc (&objfile
->symbol_obstack
,
4953 sizeof (struct symbol
));
4954 *typedef_sym
= *sym
;
4955 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
4956 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
4957 TYPE_NAME (SYMBOL_TYPE (sym
)) =
4958 obsavestring (SYMBOL_NAME (sym
),
4959 strlen (SYMBOL_NAME (sym
)),
4960 &objfile
->type_obstack
);
4961 add_symbol_to_list (typedef_sym
, list_in_scope
);
4964 case DW_TAG_typedef
:
4965 case DW_TAG_base_type
:
4966 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4967 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4968 add_symbol_to_list (sym
, list_in_scope
);
4970 case DW_TAG_enumerator
:
4971 attr
= dwarf_attr (die
, DW_AT_const_value
);
4974 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4976 add_symbol_to_list (sym
, list_in_scope
);
4979 /* Not a tag we recognize. Hopefully we aren't processing
4980 trash data, but since we must specifically ignore things
4981 we don't recognize, there is nothing else we should do at
4983 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
4990 /* Copy constant value from an attribute to a symbol. */
4993 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
4994 struct objfile
*objfile
,
4995 const struct comp_unit_head
*cu_header
)
4997 struct dwarf_block
*blk
;
5002 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5003 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
5004 cu_header
->addr_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
5005 SYMBOL_VALUE_BYTES (sym
) = (char *)
5006 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5007 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5009 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5011 case DW_FORM_block1
:
5012 case DW_FORM_block2
:
5013 case DW_FORM_block4
:
5015 blk
= DW_BLOCK (attr
);
5016 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5017 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
5018 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
5019 SYMBOL_VALUE_BYTES (sym
) = (char *)
5020 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5021 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5022 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5025 /* The DW_AT_const_value attributes are supposed to carry the
5026 symbol's value "represented as it would be on the target
5027 architecture." By the time we get here, it's already been
5028 converted to host endianness, so we just need to sign- or
5029 zero-extend it as appropriate. */
5031 dwarf2_const_value_data (attr
, sym
, 8);
5034 dwarf2_const_value_data (attr
, sym
, 16);
5037 dwarf2_const_value_data (attr
, sym
, 32);
5040 dwarf2_const_value_data (attr
, sym
, 64);
5044 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5045 SYMBOL_CLASS (sym
) = LOC_CONST
;
5049 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5050 SYMBOL_CLASS (sym
) = LOC_CONST
;
5054 complain (&dwarf2_unsupported_const_value_attr
,
5055 dwarf_form_name (attr
->form
));
5056 SYMBOL_VALUE (sym
) = 0;
5057 SYMBOL_CLASS (sym
) = LOC_CONST
;
5063 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5064 or zero-extend it as appropriate for the symbol's type. */
5066 dwarf2_const_value_data (struct attribute
*attr
,
5070 LONGEST l
= DW_UNSND (attr
);
5072 if (bits
< sizeof (l
) * 8)
5074 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5075 l
&= ((LONGEST
) 1 << bits
) - 1;
5077 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5080 SYMBOL_VALUE (sym
) = l
;
5081 SYMBOL_CLASS (sym
) = LOC_CONST
;
5085 /* Return the type of the die in question using its DW_AT_type attribute. */
5087 static struct type
*
5088 die_type (struct die_info
*die
, struct objfile
*objfile
,
5089 const struct comp_unit_head
*cu_header
)
5092 struct attribute
*type_attr
;
5093 struct die_info
*type_die
;
5096 type_attr
= dwarf_attr (die
, DW_AT_type
);
5099 /* A missing DW_AT_type represents a void type. */
5100 return dwarf2_fundamental_type (objfile
, FT_VOID
);
5104 ref
= dwarf2_get_ref_die_offset (type_attr
);
5105 type_die
= follow_die_ref (ref
);
5108 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5112 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5115 dump_die (type_die
);
5116 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
5121 /* Return the containing type of the die in question using its
5122 DW_AT_containing_type attribute. */
5124 static struct type
*
5125 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
5126 const struct comp_unit_head
*cu_header
)
5128 struct type
*type
= NULL
;
5129 struct attribute
*type_attr
;
5130 struct die_info
*type_die
= NULL
;
5133 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5136 ref
= dwarf2_get_ref_die_offset (type_attr
);
5137 type_die
= follow_die_ref (ref
);
5140 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5143 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5148 dump_die (type_die
);
5149 error ("Dwarf Error: Problem turning containing type into gdb type.");
5155 static struct type
*
5156 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
5158 struct die_info
*die
;
5161 die
= follow_die_ref (offset
);
5164 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5167 type
= tag_type_to_type (die
, objfile
);
5172 static struct type
*
5173 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
5174 const struct comp_unit_head
*cu_header
)
5182 read_type_die (die
, objfile
, cu_header
);
5186 error ("Dwarf Error: Cannot find type of die.");
5193 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
5194 const struct comp_unit_head
*cu_header
)
5198 case DW_TAG_class_type
:
5199 case DW_TAG_structure_type
:
5200 case DW_TAG_union_type
:
5201 read_structure_scope (die
, objfile
, cu_header
);
5203 case DW_TAG_enumeration_type
:
5204 read_enumeration (die
, objfile
, cu_header
);
5206 case DW_TAG_subprogram
:
5207 case DW_TAG_subroutine_type
:
5208 read_subroutine_type (die
, objfile
, cu_header
);
5210 case DW_TAG_array_type
:
5211 read_array_type (die
, objfile
, cu_header
);
5213 case DW_TAG_pointer_type
:
5214 read_tag_pointer_type (die
, objfile
, cu_header
);
5216 case DW_TAG_ptr_to_member_type
:
5217 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
5219 case DW_TAG_reference_type
:
5220 read_tag_reference_type (die
, objfile
, cu_header
);
5222 case DW_TAG_const_type
:
5223 read_tag_const_type (die
, objfile
, cu_header
);
5225 case DW_TAG_volatile_type
:
5226 read_tag_volatile_type (die
, objfile
, cu_header
);
5228 case DW_TAG_string_type
:
5229 read_tag_string_type (die
, objfile
);
5231 case DW_TAG_typedef
:
5232 read_typedef (die
, objfile
, cu_header
);
5234 case DW_TAG_base_type
:
5235 read_base_type (die
, objfile
);
5238 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
5243 static struct type
*
5244 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
5246 /* FIXME - this should not produce a new (struct type *)
5247 every time. It should cache base types. */
5251 case DW_ATE_address
:
5252 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5254 case DW_ATE_boolean
:
5255 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5257 case DW_ATE_complex_float
:
5260 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5264 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5270 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5274 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5281 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5284 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5288 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5292 case DW_ATE_signed_char
:
5293 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5295 case DW_ATE_unsigned
:
5299 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5302 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5306 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5310 case DW_ATE_unsigned_char
:
5311 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5314 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5321 copy_die (struct die_info
*old_die
)
5323 struct die_info
*new_die
;
5326 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5327 memset (new_die
, 0, sizeof (struct die_info
));
5329 new_die
->tag
= old_die
->tag
;
5330 new_die
->has_children
= old_die
->has_children
;
5331 new_die
->abbrev
= old_die
->abbrev
;
5332 new_die
->offset
= old_die
->offset
;
5333 new_die
->type
= NULL
;
5335 num_attrs
= old_die
->num_attrs
;
5336 new_die
->num_attrs
= num_attrs
;
5337 new_die
->attrs
= (struct attribute
*)
5338 xmalloc (num_attrs
* sizeof (struct attribute
));
5340 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5342 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5343 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5344 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5347 new_die
->next
= NULL
;
5352 /* Return sibling of die, NULL if no sibling. */
5354 static struct die_info
*
5355 sibling_die (struct die_info
*die
)
5357 int nesting_level
= 0;
5359 if (!die
->has_children
)
5361 if (die
->next
&& (die
->next
->tag
== 0))
5374 if (die
->has_children
)
5384 while (nesting_level
);
5385 if (die
&& (die
->tag
== 0))
5396 /* Get linkage name of a die, return NULL if not found. */
5399 dwarf2_linkage_name (struct die_info
*die
)
5401 struct attribute
*attr
;
5403 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5404 if (attr
&& DW_STRING (attr
))
5405 return DW_STRING (attr
);
5406 attr
= dwarf_attr (die
, DW_AT_name
);
5407 if (attr
&& DW_STRING (attr
))
5408 return DW_STRING (attr
);
5412 /* Convert a DIE tag into its string name. */
5415 dwarf_tag_name (register unsigned tag
)
5419 case DW_TAG_padding
:
5420 return "DW_TAG_padding";
5421 case DW_TAG_array_type
:
5422 return "DW_TAG_array_type";
5423 case DW_TAG_class_type
:
5424 return "DW_TAG_class_type";
5425 case DW_TAG_entry_point
:
5426 return "DW_TAG_entry_point";
5427 case DW_TAG_enumeration_type
:
5428 return "DW_TAG_enumeration_type";
5429 case DW_TAG_formal_parameter
:
5430 return "DW_TAG_formal_parameter";
5431 case DW_TAG_imported_declaration
:
5432 return "DW_TAG_imported_declaration";
5434 return "DW_TAG_label";
5435 case DW_TAG_lexical_block
:
5436 return "DW_TAG_lexical_block";
5438 return "DW_TAG_member";
5439 case DW_TAG_pointer_type
:
5440 return "DW_TAG_pointer_type";
5441 case DW_TAG_reference_type
:
5442 return "DW_TAG_reference_type";
5443 case DW_TAG_compile_unit
:
5444 return "DW_TAG_compile_unit";
5445 case DW_TAG_string_type
:
5446 return "DW_TAG_string_type";
5447 case DW_TAG_structure_type
:
5448 return "DW_TAG_structure_type";
5449 case DW_TAG_subroutine_type
:
5450 return "DW_TAG_subroutine_type";
5451 case DW_TAG_typedef
:
5452 return "DW_TAG_typedef";
5453 case DW_TAG_union_type
:
5454 return "DW_TAG_union_type";
5455 case DW_TAG_unspecified_parameters
:
5456 return "DW_TAG_unspecified_parameters";
5457 case DW_TAG_variant
:
5458 return "DW_TAG_variant";
5459 case DW_TAG_common_block
:
5460 return "DW_TAG_common_block";
5461 case DW_TAG_common_inclusion
:
5462 return "DW_TAG_common_inclusion";
5463 case DW_TAG_inheritance
:
5464 return "DW_TAG_inheritance";
5465 case DW_TAG_inlined_subroutine
:
5466 return "DW_TAG_inlined_subroutine";
5468 return "DW_TAG_module";
5469 case DW_TAG_ptr_to_member_type
:
5470 return "DW_TAG_ptr_to_member_type";
5471 case DW_TAG_set_type
:
5472 return "DW_TAG_set_type";
5473 case DW_TAG_subrange_type
:
5474 return "DW_TAG_subrange_type";
5475 case DW_TAG_with_stmt
:
5476 return "DW_TAG_with_stmt";
5477 case DW_TAG_access_declaration
:
5478 return "DW_TAG_access_declaration";
5479 case DW_TAG_base_type
:
5480 return "DW_TAG_base_type";
5481 case DW_TAG_catch_block
:
5482 return "DW_TAG_catch_block";
5483 case DW_TAG_const_type
:
5484 return "DW_TAG_const_type";
5485 case DW_TAG_constant
:
5486 return "DW_TAG_constant";
5487 case DW_TAG_enumerator
:
5488 return "DW_TAG_enumerator";
5489 case DW_TAG_file_type
:
5490 return "DW_TAG_file_type";
5492 return "DW_TAG_friend";
5493 case DW_TAG_namelist
:
5494 return "DW_TAG_namelist";
5495 case DW_TAG_namelist_item
:
5496 return "DW_TAG_namelist_item";
5497 case DW_TAG_packed_type
:
5498 return "DW_TAG_packed_type";
5499 case DW_TAG_subprogram
:
5500 return "DW_TAG_subprogram";
5501 case DW_TAG_template_type_param
:
5502 return "DW_TAG_template_type_param";
5503 case DW_TAG_template_value_param
:
5504 return "DW_TAG_template_value_param";
5505 case DW_TAG_thrown_type
:
5506 return "DW_TAG_thrown_type";
5507 case DW_TAG_try_block
:
5508 return "DW_TAG_try_block";
5509 case DW_TAG_variant_part
:
5510 return "DW_TAG_variant_part";
5511 case DW_TAG_variable
:
5512 return "DW_TAG_variable";
5513 case DW_TAG_volatile_type
:
5514 return "DW_TAG_volatile_type";
5515 case DW_TAG_MIPS_loop
:
5516 return "DW_TAG_MIPS_loop";
5517 case DW_TAG_format_label
:
5518 return "DW_TAG_format_label";
5519 case DW_TAG_function_template
:
5520 return "DW_TAG_function_template";
5521 case DW_TAG_class_template
:
5522 return "DW_TAG_class_template";
5524 return "DW_TAG_<unknown>";
5528 /* Convert a DWARF attribute code into its string name. */
5531 dwarf_attr_name (register unsigned attr
)
5536 return "DW_AT_sibling";
5537 case DW_AT_location
:
5538 return "DW_AT_location";
5540 return "DW_AT_name";
5541 case DW_AT_ordering
:
5542 return "DW_AT_ordering";
5543 case DW_AT_subscr_data
:
5544 return "DW_AT_subscr_data";
5545 case DW_AT_byte_size
:
5546 return "DW_AT_byte_size";
5547 case DW_AT_bit_offset
:
5548 return "DW_AT_bit_offset";
5549 case DW_AT_bit_size
:
5550 return "DW_AT_bit_size";
5551 case DW_AT_element_list
:
5552 return "DW_AT_element_list";
5553 case DW_AT_stmt_list
:
5554 return "DW_AT_stmt_list";
5556 return "DW_AT_low_pc";
5558 return "DW_AT_high_pc";
5559 case DW_AT_language
:
5560 return "DW_AT_language";
5562 return "DW_AT_member";
5564 return "DW_AT_discr";
5565 case DW_AT_discr_value
:
5566 return "DW_AT_discr_value";
5567 case DW_AT_visibility
:
5568 return "DW_AT_visibility";
5570 return "DW_AT_import";
5571 case DW_AT_string_length
:
5572 return "DW_AT_string_length";
5573 case DW_AT_common_reference
:
5574 return "DW_AT_common_reference";
5575 case DW_AT_comp_dir
:
5576 return "DW_AT_comp_dir";
5577 case DW_AT_const_value
:
5578 return "DW_AT_const_value";
5579 case DW_AT_containing_type
:
5580 return "DW_AT_containing_type";
5581 case DW_AT_default_value
:
5582 return "DW_AT_default_value";
5584 return "DW_AT_inline";
5585 case DW_AT_is_optional
:
5586 return "DW_AT_is_optional";
5587 case DW_AT_lower_bound
:
5588 return "DW_AT_lower_bound";
5589 case DW_AT_producer
:
5590 return "DW_AT_producer";
5591 case DW_AT_prototyped
:
5592 return "DW_AT_prototyped";
5593 case DW_AT_return_addr
:
5594 return "DW_AT_return_addr";
5595 case DW_AT_start_scope
:
5596 return "DW_AT_start_scope";
5597 case DW_AT_stride_size
:
5598 return "DW_AT_stride_size";
5599 case DW_AT_upper_bound
:
5600 return "DW_AT_upper_bound";
5601 case DW_AT_abstract_origin
:
5602 return "DW_AT_abstract_origin";
5603 case DW_AT_accessibility
:
5604 return "DW_AT_accessibility";
5605 case DW_AT_address_class
:
5606 return "DW_AT_address_class";
5607 case DW_AT_artificial
:
5608 return "DW_AT_artificial";
5609 case DW_AT_base_types
:
5610 return "DW_AT_base_types";
5611 case DW_AT_calling_convention
:
5612 return "DW_AT_calling_convention";
5614 return "DW_AT_count";
5615 case DW_AT_data_member_location
:
5616 return "DW_AT_data_member_location";
5617 case DW_AT_decl_column
:
5618 return "DW_AT_decl_column";
5619 case DW_AT_decl_file
:
5620 return "DW_AT_decl_file";
5621 case DW_AT_decl_line
:
5622 return "DW_AT_decl_line";
5623 case DW_AT_declaration
:
5624 return "DW_AT_declaration";
5625 case DW_AT_discr_list
:
5626 return "DW_AT_discr_list";
5627 case DW_AT_encoding
:
5628 return "DW_AT_encoding";
5629 case DW_AT_external
:
5630 return "DW_AT_external";
5631 case DW_AT_frame_base
:
5632 return "DW_AT_frame_base";
5634 return "DW_AT_friend";
5635 case DW_AT_identifier_case
:
5636 return "DW_AT_identifier_case";
5637 case DW_AT_macro_info
:
5638 return "DW_AT_macro_info";
5639 case DW_AT_namelist_items
:
5640 return "DW_AT_namelist_items";
5641 case DW_AT_priority
:
5642 return "DW_AT_priority";
5644 return "DW_AT_segment";
5645 case DW_AT_specification
:
5646 return "DW_AT_specification";
5647 case DW_AT_static_link
:
5648 return "DW_AT_static_link";
5650 return "DW_AT_type";
5651 case DW_AT_use_location
:
5652 return "DW_AT_use_location";
5653 case DW_AT_variable_parameter
:
5654 return "DW_AT_variable_parameter";
5655 case DW_AT_virtuality
:
5656 return "DW_AT_virtuality";
5657 case DW_AT_vtable_elem_location
:
5658 return "DW_AT_vtable_elem_location";
5661 case DW_AT_MIPS_fde
:
5662 return "DW_AT_MIPS_fde";
5663 case DW_AT_MIPS_loop_begin
:
5664 return "DW_AT_MIPS_loop_begin";
5665 case DW_AT_MIPS_tail_loop_begin
:
5666 return "DW_AT_MIPS_tail_loop_begin";
5667 case DW_AT_MIPS_epilog_begin
:
5668 return "DW_AT_MIPS_epilog_begin";
5669 case DW_AT_MIPS_loop_unroll_factor
:
5670 return "DW_AT_MIPS_loop_unroll_factor";
5671 case DW_AT_MIPS_software_pipeline_depth
:
5672 return "DW_AT_MIPS_software_pipeline_depth";
5673 case DW_AT_MIPS_linkage_name
:
5674 return "DW_AT_MIPS_linkage_name";
5677 case DW_AT_sf_names
:
5678 return "DW_AT_sf_names";
5679 case DW_AT_src_info
:
5680 return "DW_AT_src_info";
5681 case DW_AT_mac_info
:
5682 return "DW_AT_mac_info";
5683 case DW_AT_src_coords
:
5684 return "DW_AT_src_coords";
5685 case DW_AT_body_begin
:
5686 return "DW_AT_body_begin";
5687 case DW_AT_body_end
:
5688 return "DW_AT_body_end";
5689 case DW_AT_GNU_vector
:
5690 return "DW_AT_GNU_vector";
5692 return "DW_AT_<unknown>";
5696 /* Convert a DWARF value form code into its string name. */
5699 dwarf_form_name (register unsigned form
)
5704 return "DW_FORM_addr";
5705 case DW_FORM_block2
:
5706 return "DW_FORM_block2";
5707 case DW_FORM_block4
:
5708 return "DW_FORM_block4";
5710 return "DW_FORM_data2";
5712 return "DW_FORM_data4";
5714 return "DW_FORM_data8";
5715 case DW_FORM_string
:
5716 return "DW_FORM_string";
5718 return "DW_FORM_block";
5719 case DW_FORM_block1
:
5720 return "DW_FORM_block1";
5722 return "DW_FORM_data1";
5724 return "DW_FORM_flag";
5726 return "DW_FORM_sdata";
5728 return "DW_FORM_strp";
5730 return "DW_FORM_udata";
5731 case DW_FORM_ref_addr
:
5732 return "DW_FORM_ref_addr";
5734 return "DW_FORM_ref1";
5736 return "DW_FORM_ref2";
5738 return "DW_FORM_ref4";
5740 return "DW_FORM_ref8";
5741 case DW_FORM_ref_udata
:
5742 return "DW_FORM_ref_udata";
5743 case DW_FORM_indirect
:
5744 return "DW_FORM_indirect";
5746 return "DW_FORM_<unknown>";
5750 /* Convert a DWARF stack opcode into its string name. */
5753 dwarf_stack_op_name (register unsigned op
)
5758 return "DW_OP_addr";
5760 return "DW_OP_deref";
5762 return "DW_OP_const1u";
5764 return "DW_OP_const1s";
5766 return "DW_OP_const2u";
5768 return "DW_OP_const2s";
5770 return "DW_OP_const4u";
5772 return "DW_OP_const4s";
5774 return "DW_OP_const8u";
5776 return "DW_OP_const8s";
5778 return "DW_OP_constu";
5780 return "DW_OP_consts";
5784 return "DW_OP_drop";
5786 return "DW_OP_over";
5788 return "DW_OP_pick";
5790 return "DW_OP_swap";
5794 return "DW_OP_xderef";
5802 return "DW_OP_minus";
5814 return "DW_OP_plus";
5815 case DW_OP_plus_uconst
:
5816 return "DW_OP_plus_uconst";
5822 return "DW_OP_shra";
5840 return "DW_OP_skip";
5842 return "DW_OP_lit0";
5844 return "DW_OP_lit1";
5846 return "DW_OP_lit2";
5848 return "DW_OP_lit3";
5850 return "DW_OP_lit4";
5852 return "DW_OP_lit5";
5854 return "DW_OP_lit6";
5856 return "DW_OP_lit7";
5858 return "DW_OP_lit8";
5860 return "DW_OP_lit9";
5862 return "DW_OP_lit10";
5864 return "DW_OP_lit11";
5866 return "DW_OP_lit12";
5868 return "DW_OP_lit13";
5870 return "DW_OP_lit14";
5872 return "DW_OP_lit15";
5874 return "DW_OP_lit16";
5876 return "DW_OP_lit17";
5878 return "DW_OP_lit18";
5880 return "DW_OP_lit19";
5882 return "DW_OP_lit20";
5884 return "DW_OP_lit21";
5886 return "DW_OP_lit22";
5888 return "DW_OP_lit23";
5890 return "DW_OP_lit24";
5892 return "DW_OP_lit25";
5894 return "DW_OP_lit26";
5896 return "DW_OP_lit27";
5898 return "DW_OP_lit28";
5900 return "DW_OP_lit29";
5902 return "DW_OP_lit30";
5904 return "DW_OP_lit31";
5906 return "DW_OP_reg0";
5908 return "DW_OP_reg1";
5910 return "DW_OP_reg2";
5912 return "DW_OP_reg3";
5914 return "DW_OP_reg4";
5916 return "DW_OP_reg5";
5918 return "DW_OP_reg6";
5920 return "DW_OP_reg7";
5922 return "DW_OP_reg8";
5924 return "DW_OP_reg9";
5926 return "DW_OP_reg10";
5928 return "DW_OP_reg11";
5930 return "DW_OP_reg12";
5932 return "DW_OP_reg13";
5934 return "DW_OP_reg14";
5936 return "DW_OP_reg15";
5938 return "DW_OP_reg16";
5940 return "DW_OP_reg17";
5942 return "DW_OP_reg18";
5944 return "DW_OP_reg19";
5946 return "DW_OP_reg20";
5948 return "DW_OP_reg21";
5950 return "DW_OP_reg22";
5952 return "DW_OP_reg23";
5954 return "DW_OP_reg24";
5956 return "DW_OP_reg25";
5958 return "DW_OP_reg26";
5960 return "DW_OP_reg27";
5962 return "DW_OP_reg28";
5964 return "DW_OP_reg29";
5966 return "DW_OP_reg30";
5968 return "DW_OP_reg31";
5970 return "DW_OP_breg0";
5972 return "DW_OP_breg1";
5974 return "DW_OP_breg2";
5976 return "DW_OP_breg3";
5978 return "DW_OP_breg4";
5980 return "DW_OP_breg5";
5982 return "DW_OP_breg6";
5984 return "DW_OP_breg7";
5986 return "DW_OP_breg8";
5988 return "DW_OP_breg9";
5990 return "DW_OP_breg10";
5992 return "DW_OP_breg11";
5994 return "DW_OP_breg12";
5996 return "DW_OP_breg13";
5998 return "DW_OP_breg14";
6000 return "DW_OP_breg15";
6002 return "DW_OP_breg16";
6004 return "DW_OP_breg17";
6006 return "DW_OP_breg18";
6008 return "DW_OP_breg19";
6010 return "DW_OP_breg20";
6012 return "DW_OP_breg21";
6014 return "DW_OP_breg22";
6016 return "DW_OP_breg23";
6018 return "DW_OP_breg24";
6020 return "DW_OP_breg25";
6022 return "DW_OP_breg26";
6024 return "DW_OP_breg27";
6026 return "DW_OP_breg28";
6028 return "DW_OP_breg29";
6030 return "DW_OP_breg30";
6032 return "DW_OP_breg31";
6034 return "DW_OP_regx";
6036 return "DW_OP_fbreg";
6038 return "DW_OP_bregx";
6040 return "DW_OP_piece";
6041 case DW_OP_deref_size
:
6042 return "DW_OP_deref_size";
6043 case DW_OP_xderef_size
:
6044 return "DW_OP_xderef_size";
6047 /* DWARF 3 extensions. */
6048 case DW_OP_push_object_address
:
6049 return "DW_OP_push_object_address";
6051 return "DW_OP_call2";
6053 return "DW_OP_call4";
6054 case DW_OP_call_ref
:
6055 return "DW_OP_call_ref";
6056 /* GNU extensions. */
6057 case DW_OP_GNU_push_tls_address
:
6058 return "DW_OP_GNU_push_tls_address";
6060 return "OP_<unknown>";
6065 dwarf_bool_name (unsigned mybool
)
6073 /* Convert a DWARF type code into its string name. */
6076 dwarf_type_encoding_name (register unsigned enc
)
6080 case DW_ATE_address
:
6081 return "DW_ATE_address";
6082 case DW_ATE_boolean
:
6083 return "DW_ATE_boolean";
6084 case DW_ATE_complex_float
:
6085 return "DW_ATE_complex_float";
6087 return "DW_ATE_float";
6089 return "DW_ATE_signed";
6090 case DW_ATE_signed_char
:
6091 return "DW_ATE_signed_char";
6092 case DW_ATE_unsigned
:
6093 return "DW_ATE_unsigned";
6094 case DW_ATE_unsigned_char
:
6095 return "DW_ATE_unsigned_char";
6097 return "DW_ATE_<unknown>";
6101 /* Convert a DWARF call frame info operation to its string name. */
6105 dwarf_cfi_name (register unsigned cfi_opc
)
6109 case DW_CFA_advance_loc
:
6110 return "DW_CFA_advance_loc";
6112 return "DW_CFA_offset";
6113 case DW_CFA_restore
:
6114 return "DW_CFA_restore";
6116 return "DW_CFA_nop";
6117 case DW_CFA_set_loc
:
6118 return "DW_CFA_set_loc";
6119 case DW_CFA_advance_loc1
:
6120 return "DW_CFA_advance_loc1";
6121 case DW_CFA_advance_loc2
:
6122 return "DW_CFA_advance_loc2";
6123 case DW_CFA_advance_loc4
:
6124 return "DW_CFA_advance_loc4";
6125 case DW_CFA_offset_extended
:
6126 return "DW_CFA_offset_extended";
6127 case DW_CFA_restore_extended
:
6128 return "DW_CFA_restore_extended";
6129 case DW_CFA_undefined
:
6130 return "DW_CFA_undefined";
6131 case DW_CFA_same_value
:
6132 return "DW_CFA_same_value";
6133 case DW_CFA_register
:
6134 return "DW_CFA_register";
6135 case DW_CFA_remember_state
:
6136 return "DW_CFA_remember_state";
6137 case DW_CFA_restore_state
:
6138 return "DW_CFA_restore_state";
6139 case DW_CFA_def_cfa
:
6140 return "DW_CFA_def_cfa";
6141 case DW_CFA_def_cfa_register
:
6142 return "DW_CFA_def_cfa_register";
6143 case DW_CFA_def_cfa_offset
:
6144 return "DW_CFA_def_cfa_offset";
6147 case DW_CFA_def_cfa_expression
:
6148 return "DW_CFA_def_cfa_expression";
6149 case DW_CFA_expression
:
6150 return "DW_CFA_expression";
6151 case DW_CFA_offset_extended_sf
:
6152 return "DW_CFA_offset_extended_sf";
6153 case DW_CFA_def_cfa_sf
:
6154 return "DW_CFA_def_cfa_sf";
6155 case DW_CFA_def_cfa_offset_sf
:
6156 return "DW_CFA_def_cfa_offset_sf";
6158 /* SGI/MIPS specific */
6159 case DW_CFA_MIPS_advance_loc8
:
6160 return "DW_CFA_MIPS_advance_loc8";
6162 /* GNU extensions */
6163 case DW_CFA_GNU_window_save
:
6164 return "DW_CFA_GNU_window_save";
6165 case DW_CFA_GNU_args_size
:
6166 return "DW_CFA_GNU_args_size";
6167 case DW_CFA_GNU_negative_offset_extended
:
6168 return "DW_CFA_GNU_negative_offset_extended";
6171 return "DW_CFA_<unknown>";
6177 dump_die (struct die_info
*die
)
6181 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6182 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6183 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6184 dwarf_bool_name (die
->has_children
));
6186 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6187 for (i
= 0; i
< die
->num_attrs
; ++i
)
6189 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6190 dwarf_attr_name (die
->attrs
[i
].name
),
6191 dwarf_form_name (die
->attrs
[i
].form
));
6192 switch (die
->attrs
[i
].form
)
6194 case DW_FORM_ref_addr
:
6196 fprintf_unfiltered (gdb_stderr
, "address: ");
6197 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6199 case DW_FORM_block2
:
6200 case DW_FORM_block4
:
6202 case DW_FORM_block1
:
6203 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6214 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6216 case DW_FORM_string
:
6218 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6219 DW_STRING (&die
->attrs
[i
])
6220 ? DW_STRING (&die
->attrs
[i
]) : "");
6223 if (DW_UNSND (&die
->attrs
[i
]))
6224 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6226 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6228 case DW_FORM_indirect
:
6229 /* the reader will have reduced the indirect form to
6230 the "base form" so this form should not occur */
6231 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6234 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6235 die
->attrs
[i
].form
);
6237 fprintf_unfiltered (gdb_stderr
, "\n");
6242 dump_die_list (struct die_info
*die
)
6252 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6255 struct die_info
*old
;
6257 h
= (offset
% REF_HASH_SIZE
);
6258 old
= die_ref_table
[h
];
6259 die
->next_ref
= old
;
6260 die_ref_table
[h
] = die
;
6265 dwarf2_empty_hash_tables (void)
6267 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6271 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6273 unsigned int result
= 0;
6277 case DW_FORM_ref_addr
:
6278 result
= DW_ADDR (attr
);
6284 case DW_FORM_ref_udata
:
6285 result
= cu_header_offset
+ DW_UNSND (attr
);
6288 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
6293 static struct die_info
*
6294 follow_die_ref (unsigned int offset
)
6296 struct die_info
*die
;
6299 h
= (offset
% REF_HASH_SIZE
);
6300 die
= die_ref_table
[h
];
6303 if (die
->offset
== offset
)
6307 die
= die
->next_ref
;
6312 static struct type
*
6313 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6315 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6317 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
6321 /* Look for this particular type in the fundamental type vector. If
6322 one is not found, create and install one appropriate for the
6323 current language and the current target machine. */
6325 if (ftypes
[typeid] == NULL
)
6327 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6330 return (ftypes
[typeid]);
6333 /* Decode simple location descriptions.
6334 Given a pointer to a dwarf block that defines a location, compute
6335 the location and return the value.
6337 FIXME: This is a kludge until we figure out a better
6338 way to handle the location descriptions.
6339 Gdb's design does not mesh well with the DWARF2 notion of a location
6340 computing interpreter, which is a shame because the flexibility goes unused.
6341 FIXME: Implement more operations as necessary.
6343 A location description containing no operations indicates that the
6344 object is optimized out. The global optimized_out flag is set for
6345 those, the return value is meaningless.
6347 When the result is a register number, the global isreg flag is set,
6348 otherwise it is cleared.
6350 When the result is a base register offset, the global offreg flag is set
6351 and the register number is returned in basereg, otherwise it is cleared.
6353 When the DW_OP_fbreg operation is encountered without a corresponding
6354 DW_AT_frame_base attribute, the global islocal flag is set.
6355 Hopefully the machine dependent code knows how to set up a virtual
6356 frame pointer for the local references.
6358 Note that stack[0] is unused except as a default error return.
6359 Note that stack overflow is not yet handled. */
6362 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
6363 const struct comp_unit_head
*cu_header
)
6366 int size
= blk
->size
;
6367 char *data
= blk
->data
;
6368 CORE_ADDR stack
[64];
6370 unsigned int bytes_read
, unsnd
;
6380 is_thread_local
= 0;
6421 stack
[++stacki
] = op
- DW_OP_lit0
;
6457 stack
[++stacki
] = op
- DW_OP_reg0
;
6462 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6464 stack
[++stacki
] = unsnd
;
6500 basereg
= op
- DW_OP_breg0
;
6501 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6507 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6509 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6514 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6516 if (frame_base_reg
>= 0)
6519 basereg
= frame_base_reg
;
6520 stack
[stacki
] += frame_base_offset
;
6524 complain (&dwarf2_missing_at_frame_base
);
6530 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
6531 cu_header
, &bytes_read
);
6536 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
6541 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
6546 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
6551 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
6556 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
6561 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
6566 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
6572 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6577 stack
[stacki
+ 1] = stack
[stacki
];
6582 stack
[stacki
- 1] += stack
[stacki
];
6586 case DW_OP_plus_uconst
:
6587 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6592 stack
[stacki
- 1] -= stack
[stacki
];
6598 /* If we're not the last op, then we definitely can't encode
6599 this using GDB's address_class enum. */
6601 complain (&dwarf2_complex_location_expr
);
6604 case DW_OP_GNU_push_tls_address
:
6605 is_thread_local
= 1;
6606 /* The top of the stack has the offset from the beginning
6607 of the thread control block at which the variable is located. */
6608 /* Nothing should follow this operator, so the top of stack would
6611 complain (&dwarf2_complex_location_expr
);
6615 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name (op
));
6616 return (stack
[stacki
]);
6619 return (stack
[stacki
]);
6622 /* memory allocation interface */
6626 dwarf2_free_tmp_obstack (PTR ignore
)
6628 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6631 static struct dwarf_block
*
6632 dwarf_alloc_block (void)
6634 struct dwarf_block
*blk
;
6636 blk
= (struct dwarf_block
*)
6637 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6641 static struct abbrev_info
*
6642 dwarf_alloc_abbrev (void)
6644 struct abbrev_info
*abbrev
;
6646 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6647 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6651 static struct die_info
*
6652 dwarf_alloc_die (void)
6654 struct die_info
*die
;
6656 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6657 memset (die
, 0, sizeof (struct die_info
));
6662 /* Macro support. */
6665 /* Return the full name of file number I in *LH's file name table.
6666 Use COMP_DIR as the name of the current directory of the
6667 compilation. The result is allocated using xmalloc; the caller is
6668 responsible for freeing it. */
6670 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
6672 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6674 if (IS_ABSOLUTE_PATH (fe
->name
))
6675 return xstrdup (fe
->name
);
6683 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6689 dir_len
= strlen (dir
);
6690 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
6691 strcpy (full_name
, dir
);
6692 full_name
[dir_len
] = '/';
6693 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
6697 return xstrdup (fe
->name
);
6702 static struct macro_source_file
*
6703 macro_start_file (int file
, int line
,
6704 struct macro_source_file
*current_file
,
6705 const char *comp_dir
,
6706 struct line_header
*lh
, struct objfile
*objfile
)
6708 /* The full name of this source file. */
6709 char *full_name
= file_full_name (file
, lh
, comp_dir
);
6711 /* We don't create a macro table for this compilation unit
6712 at all until we actually get a filename. */
6713 if (! pending_macros
)
6714 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
6715 objfile
->macro_cache
);
6718 /* If we have no current file, then this must be the start_file
6719 directive for the compilation unit's main source file. */
6720 current_file
= macro_set_main (pending_macros
, full_name
);
6722 current_file
= macro_include (current_file
, line
, full_name
);
6726 return current_file
;
6730 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
6731 followed by a null byte. */
6733 copy_string (const char *buf
, int len
)
6735 char *s
= xmalloc (len
+ 1);
6736 memcpy (s
, buf
, len
);
6744 consume_improper_spaces (const char *p
, const char *body
)
6748 complain (&dwarf2_macro_spaces_in_definition
, body
);
6759 parse_macro_definition (struct macro_source_file
*file
, int line
,
6764 /* The body string takes one of two forms. For object-like macro
6765 definitions, it should be:
6767 <macro name> " " <definition>
6769 For function-like macro definitions, it should be:
6771 <macro name> "() " <definition>
6773 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
6775 Spaces may appear only where explicitly indicated, and in the
6778 The Dwarf 2 spec says that an object-like macro's name is always
6779 followed by a space, but versions of GCC around March 2002 omit
6780 the space when the macro's definition is the empty string.
6782 The Dwarf 2 spec says that there should be no spaces between the
6783 formal arguments in a function-like macro's formal argument list,
6784 but versions of GCC around March 2002 include spaces after the
6788 /* Find the extent of the macro name. The macro name is terminated
6789 by either a space or null character (for an object-like macro) or
6790 an opening paren (for a function-like macro). */
6791 for (p
= body
; *p
; p
++)
6792 if (*p
== ' ' || *p
== '(')
6795 if (*p
== ' ' || *p
== '\0')
6797 /* It's an object-like macro. */
6798 int name_len
= p
- body
;
6799 char *name
= copy_string (body
, name_len
);
6800 const char *replacement
;
6803 replacement
= body
+ name_len
+ 1;
6806 complain (&dwarf2_macro_malformed_definition
, body
);
6807 replacement
= body
+ name_len
;
6810 macro_define_object (file
, line
, name
, replacement
);
6816 /* It's a function-like macro. */
6817 char *name
= copy_string (body
, p
- body
);
6820 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
6824 p
= consume_improper_spaces (p
, body
);
6826 /* Parse the formal argument list. */
6827 while (*p
&& *p
!= ')')
6829 /* Find the extent of the current argument name. */
6830 const char *arg_start
= p
;
6832 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
6835 if (! *p
|| p
== arg_start
)
6836 complain (&dwarf2_macro_malformed_definition
,
6840 /* Make sure argv has room for the new argument. */
6841 if (argc
>= argv_size
)
6844 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
6847 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
6850 p
= consume_improper_spaces (p
, body
);
6852 /* Consume the comma, if present. */
6857 p
= consume_improper_spaces (p
, body
);
6866 /* Perfectly formed definition, no complaints. */
6867 macro_define_function (file
, line
, name
,
6868 argc
, (const char **) argv
,
6870 else if (*p
== '\0')
6872 /* Complain, but do define it. */
6873 complain (&dwarf2_macro_malformed_definition
, body
);
6874 macro_define_function (file
, line
, name
,
6875 argc
, (const char **) argv
,
6879 /* Just complain. */
6880 complain (&dwarf2_macro_malformed_definition
, body
);
6883 /* Just complain. */
6884 complain (&dwarf2_macro_malformed_definition
, body
);
6890 for (i
= 0; i
< argc
; i
++)
6896 complain (&dwarf2_macro_malformed_definition
, body
);
6901 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
6902 char *comp_dir
, bfd
*abfd
,
6903 const struct comp_unit_head
*cu_header
,
6904 struct objfile
*objfile
)
6906 char *mac_ptr
, *mac_end
;
6907 struct macro_source_file
*current_file
= 0;
6909 if (dwarf_macinfo_buffer
== NULL
)
6911 complain (&dwarf2_missing_macinfo_section
);
6915 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
6916 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
6920 enum dwarf_macinfo_record_type macinfo_type
;
6922 /* Do we at least have room for a macinfo type byte? */
6923 if (mac_ptr
>= mac_end
)
6925 complain (&dwarf2_macros_too_long
);
6929 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
6932 switch (macinfo_type
)
6934 /* A zero macinfo type indicates the end of the macro
6939 case DW_MACINFO_define
:
6940 case DW_MACINFO_undef
:
6946 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6947 mac_ptr
+= bytes_read
;
6948 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
6949 mac_ptr
+= bytes_read
;
6952 complain (&dwarf2_macro_outside_file
,
6953 macinfo_type
== DW_MACINFO_define
? "definition" :
6954 macinfo_type
== DW_MACINFO_undef
? "undefinition" :
6955 "something-or-other",
6959 if (macinfo_type
== DW_MACINFO_define
)
6960 parse_macro_definition (current_file
, line
, body
);
6961 else if (macinfo_type
== DW_MACINFO_undef
)
6962 macro_undef (current_file
, line
, body
);
6967 case DW_MACINFO_start_file
:
6972 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6973 mac_ptr
+= bytes_read
;
6974 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6975 mac_ptr
+= bytes_read
;
6977 current_file
= macro_start_file (file
, line
,
6978 current_file
, comp_dir
,
6983 case DW_MACINFO_end_file
:
6985 complain (&dwarf2_macro_unmatched_end_file
);
6988 current_file
= current_file
->included_by
;
6991 enum dwarf_macinfo_record_type next_type
;
6993 /* GCC circa March 2002 doesn't produce the zero
6994 type byte marking the end of the compilation
6995 unit. Complain if it's not there, but exit no
6998 /* Do we at least have room for a macinfo type byte? */
6999 if (mac_ptr
>= mac_end
)
7001 complain (&dwarf2_macros_too_long
);
7005 /* We don't increment mac_ptr here, so this is just
7007 next_type
= read_1_byte (abfd
, mac_ptr
);
7009 complain (&dwarf2_macros_not_terminated
);
7016 case DW_MACINFO_vendor_ext
:
7022 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7023 mac_ptr
+= bytes_read
;
7024 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7025 mac_ptr
+= bytes_read
;
7027 /* We don't recognize any vendor extensions. */
7034 /* Check if the attribute's form is a DW_FORM_block*
7035 if so return true else false. */
7037 attr_form_is_block (struct attribute
*attr
)
7039 return (attr
== NULL
? 0 :
7040 attr
->form
== DW_FORM_block1
7041 || attr
->form
== DW_FORM_block2
7042 || attr
->form
== DW_FORM_block4
7043 || attr
->form
== DW_FORM_block
);