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 /* The data in a compilation unit header, after target2host
166 translation, looks like this. */
167 struct comp_unit_head
169 unsigned long length
;
171 unsigned int abbrev_offset
;
172 unsigned char addr_size
;
173 unsigned char signed_addr_p
;
174 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
175 unsigned int initial_length_size
; /* size of the length field; either
179 /* The line number information for a compilation unit (found in the
180 .debug_line section) begins with a "statement program header",
181 which contains the following information. */
184 unsigned int total_length
;
185 unsigned short version
;
186 unsigned int header_length
;
187 unsigned char minimum_instruction_length
;
188 unsigned char default_is_stmt
;
190 unsigned char line_range
;
191 unsigned char opcode_base
;
193 /* standard_opcode_lengths[i] is the number of operands for the
194 standard opcode whose value is i. This means that
195 standard_opcode_lengths[0] is unused, and the last meaningful
196 element is standard_opcode_lengths[opcode_base - 1]. */
197 unsigned char *standard_opcode_lengths
;
199 /* The include_directories table. NOTE! These strings are not
200 allocated with xmalloc; instead, they are pointers into
201 debug_line_buffer. If you try to free them, `free' will get
203 unsigned int num_include_dirs
, include_dirs_size
;
206 /* The file_names table. NOTE! These strings are not allocated
207 with xmalloc; instead, they are pointers into debug_line_buffer.
208 Don't try to free them directly. */
209 unsigned int num_file_names
, file_names_size
;
213 unsigned int dir_index
;
214 unsigned int mod_time
;
218 /* The start and end of the statement program following this
219 header. These point into dwarf_line_buffer. */
220 char *statement_program_start
, *statement_program_end
;
223 /* When we construct a partial symbol table entry we only
224 need this much information. */
225 struct partial_die_info
228 unsigned char has_children
;
229 unsigned char is_external
;
230 unsigned char is_declaration
;
231 unsigned char has_type
;
238 struct dwarf_block
*locdesc
;
239 unsigned int language
;
243 /* This data structure holds the information of an abbrev. */
246 unsigned int number
; /* number identifying abbrev */
247 enum dwarf_tag tag
; /* dwarf tag */
248 int has_children
; /* boolean */
249 unsigned int num_attrs
; /* number of attributes */
250 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
251 struct abbrev_info
*next
; /* next in chain */
256 enum dwarf_attribute name
;
257 enum dwarf_form form
;
260 /* This data structure holds a complete die structure. */
263 enum dwarf_tag tag
; /* Tag indicating type of die */
264 unsigned short has_children
; /* Does the die have children */
265 unsigned int abbrev
; /* Abbrev number */
266 unsigned int offset
; /* Offset in .debug_info section */
267 unsigned int num_attrs
; /* Number of attributes */
268 struct attribute
*attrs
; /* An array of attributes */
269 struct die_info
*next_ref
; /* Next die in ref hash table */
270 struct die_info
*next
; /* Next die in linked list */
271 struct type
*type
; /* Cached type information */
274 /* Attributes have a name and a value */
277 enum dwarf_attribute name
;
278 enum dwarf_form form
;
282 struct dwarf_block
*blk
;
290 struct function_range
293 CORE_ADDR lowpc
, highpc
;
295 struct function_range
*next
;
298 static struct function_range
*cu_first_fn
, *cu_last_fn
, *cu_cached_fn
;
300 /* Get at parts of an attribute structure */
302 #define DW_STRING(attr) ((attr)->u.str)
303 #define DW_UNSND(attr) ((attr)->u.unsnd)
304 #define DW_BLOCK(attr) ((attr)->u.blk)
305 #define DW_SND(attr) ((attr)->u.snd)
306 #define DW_ADDR(attr) ((attr)->u.addr)
308 /* Blocks are a bunch of untyped bytes. */
315 /* We only hold one compilation unit's abbrevs in
316 memory at any one time. */
317 #ifndef ABBREV_HASH_SIZE
318 #define ABBREV_HASH_SIZE 121
320 #ifndef ATTR_ALLOC_CHUNK
321 #define ATTR_ALLOC_CHUNK 4
324 static struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
326 /* A hash table of die offsets for following references. */
327 #ifndef REF_HASH_SIZE
328 #define REF_HASH_SIZE 1021
331 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
333 /* Obstack for allocating temporary storage used during symbol reading. */
334 static struct obstack dwarf2_tmp_obstack
;
336 /* Offset to the first byte of the current compilation unit header,
337 for resolving relative reference dies. */
338 static unsigned int cu_header_offset
;
340 /* Allocate fields for structs, unions and enums in this size. */
341 #ifndef DW_FIELD_ALLOC_CHUNK
342 #define DW_FIELD_ALLOC_CHUNK 4
345 /* The language we are debugging. */
346 static enum language cu_language
;
347 static const struct language_defn
*cu_language_defn
;
349 /* Actually data from the sections. */
350 static char *dwarf_info_buffer
;
351 static char *dwarf_abbrev_buffer
;
352 static char *dwarf_line_buffer
;
353 static char *dwarf_str_buffer
;
354 static char *dwarf_macinfo_buffer
;
356 /* A zeroed version of a partial die for initialization purposes. */
357 static struct partial_die_info zeroed_partial_die
;
359 /* The generic symbol table building routines have separate lists for
360 file scope symbols and all all other scopes (local scopes). So
361 we need to select the right one to pass to add_symbol_to_list().
362 We do it by keeping a pointer to the correct list in list_in_scope.
364 FIXME: The original dwarf code just treated the file scope as the first
365 local scope, and all other local scopes as nested local scopes, and worked
366 fine. Check to see if we really need to distinguish these
368 static struct pending
**list_in_scope
= &file_symbols
;
370 /* FIXME: decode_locdesc sets these variables to describe the location
371 to the caller. These ought to be a structure or something. If
372 none of the flags are set, the object lives at the address returned
373 by decode_locdesc. */
375 static int optimized_out
; /* No ops in location in expression,
376 so object was optimized out. */
377 static int isreg
; /* Object lives in register.
378 decode_locdesc's return value is
379 the register number. */
380 static int offreg
; /* Object's address is the sum of the
381 register specified by basereg, plus
382 the offset returned. */
383 static int basereg
; /* See `offreg'. */
384 static int isderef
; /* Value described by flags above is
385 the address of a pointer to the object. */
386 static int islocal
; /* Variable is at the returned offset
387 from the frame start, but there's
388 no identified frame pointer for
389 this function, so we can't say
390 which register it's relative to;
393 /* DW_AT_frame_base values for the current function.
394 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
395 contains the register number for the frame register.
396 frame_base_offset is the offset from the frame register to the
397 virtual stack frame. */
398 static int frame_base_reg
;
399 static CORE_ADDR frame_base_offset
;
401 /* This value is added to each symbol value. FIXME: Generalize to
402 the section_offsets structure used by dbxread (once this is done,
403 pass the appropriate section number to end_symtab). */
404 static CORE_ADDR baseaddr
; /* Add to each symbol value */
406 /* We put a pointer to this structure in the read_symtab_private field
408 The complete dwarf information for an objfile is kept in the
409 psymbol_obstack, so that absolute die references can be handled.
410 Most of the information in this structure is related to an entire
411 object file and could be passed via the sym_private field of the objfile.
412 It is however conceivable that dwarf2 might not be the only type
413 of symbols read from an object file. */
417 /* Pointer to start of dwarf info buffer for the objfile. */
419 char *dwarf_info_buffer
;
421 /* Offset in dwarf_info_buffer for this compilation unit. */
423 unsigned long dwarf_info_offset
;
425 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
427 char *dwarf_abbrev_buffer
;
429 /* Size of dwarf abbreviation section for the objfile. */
431 unsigned int dwarf_abbrev_size
;
433 /* Pointer to start of dwarf line buffer for the objfile. */
435 char *dwarf_line_buffer
;
437 /* Size of dwarf_line_buffer, in bytes. */
439 unsigned int dwarf_line_size
;
441 /* Pointer to start of dwarf string buffer for the objfile. */
443 char *dwarf_str_buffer
;
445 /* Size of dwarf string section for the objfile. */
447 unsigned int dwarf_str_size
;
449 /* Pointer to start of dwarf macro buffer for the objfile. */
451 char *dwarf_macinfo_buffer
;
453 /* Size of dwarf macinfo section for the objfile. */
455 unsigned int dwarf_macinfo_size
;
459 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
460 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
461 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
462 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
463 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
464 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
465 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
466 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
467 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
468 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
469 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
471 /* Maintain an array of referenced fundamental types for the current
472 compilation unit being read. For DWARF version 1, we have to construct
473 the fundamental types on the fly, since no information about the
474 fundamental types is supplied. Each such fundamental type is created by
475 calling a language dependent routine to create the type, and then a
476 pointer to that type is then placed in the array at the index specified
477 by it's FT_<TYPENAME> value. The array has a fixed size set by the
478 FT_NUM_MEMBERS compile time constant, which is the number of predefined
479 fundamental types gdb knows how to construct. */
480 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
482 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
483 but this would require a corresponding change in unpack_field_as_long
485 static int bits_per_byte
= 8;
487 /* The routines that read and process dies for a C struct or C++ class
488 pass lists of data member fields and lists of member function fields
489 in an instance of a field_info structure, as defined below. */
492 /* List of data member and baseclasses fields. */
495 struct nextfield
*next
;
502 /* Number of fields. */
505 /* Number of baseclasses. */
508 /* Set if the accesibility of one of the fields is not public. */
509 int non_public_fields
;
511 /* Member function fields array, entries are allocated in the order they
512 are encountered in the object file. */
515 struct nextfnfield
*next
;
516 struct fn_field fnfield
;
520 /* Member function fieldlist array, contains name of possibly overloaded
521 member function, number of overloaded member functions and a pointer
522 to the head of the member function field chain. */
527 struct nextfnfield
*head
;
531 /* Number of entries in the fnfieldlists array. */
535 /* Various complaints about symbol reading that don't abort the process */
537 static struct complaint dwarf2_const_ignored
=
539 "type qualifier 'const' ignored", 0, 0
541 static struct complaint dwarf2_volatile_ignored
=
543 "type qualifier 'volatile' ignored", 0, 0
545 static struct complaint dwarf2_non_const_array_bound_ignored
=
547 "non-constant array bounds form '%s' ignored", 0, 0
549 static struct complaint dwarf2_missing_line_number_section
=
551 "missing .debug_line section", 0, 0
553 static struct complaint dwarf2_statement_list_fits_in_line_number_section
=
555 "statement list doesn't fit in .debug_line section", 0, 0
557 static struct complaint dwarf2_mangled_line_number_section
=
559 "mangled .debug_line section", 0, 0
561 static struct complaint dwarf2_unsupported_die_ref_attr
=
563 "unsupported die ref attribute form: '%s'", 0, 0
565 static struct complaint dwarf2_unsupported_stack_op
=
567 "unsupported stack op: '%s'", 0, 0
569 static struct complaint dwarf2_complex_location_expr
=
571 "location expression too complex", 0, 0
573 static struct complaint dwarf2_unsupported_tag
=
575 "unsupported tag: '%s'", 0, 0
577 static struct complaint dwarf2_unsupported_at_encoding
=
579 "unsupported DW_AT_encoding: '%s'", 0, 0
581 static struct complaint dwarf2_unsupported_at_frame_base
=
583 "unsupported DW_AT_frame_base for function '%s'", 0, 0
585 static struct complaint dwarf2_unexpected_tag
=
587 "unexepected tag in read_type_die: '%s'", 0, 0
589 static struct complaint dwarf2_missing_at_frame_base
=
591 "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
593 static struct complaint dwarf2_bad_static_member_name
=
595 "unrecognized static data member name '%s'", 0, 0
597 static struct complaint dwarf2_unsupported_accessibility
=
599 "unsupported accessibility %d", 0, 0
601 static struct complaint dwarf2_bad_member_name_complaint
=
603 "cannot extract member name from '%s'", 0, 0
605 static struct complaint dwarf2_missing_member_fn_type_complaint
=
607 "member function type missing for '%s'", 0, 0
609 static struct complaint dwarf2_vtbl_not_found_complaint
=
611 "virtual function table pointer not found when defining class '%s'", 0, 0
613 static struct complaint dwarf2_absolute_sibling_complaint
=
615 "ignoring absolute DW_AT_sibling", 0, 0
617 static struct complaint dwarf2_const_value_length_mismatch
=
619 "const value length mismatch for '%s', got %d, expected %d", 0, 0
621 static struct complaint dwarf2_unsupported_const_value_attr
=
623 "unsupported const value attribute form: '%s'", 0, 0
625 static struct complaint dwarf2_misplaced_line_number
=
627 "misplaced first line number at 0x%lx for '%s'", 0, 0
629 static struct complaint dwarf2_line_header_too_long
=
631 "line number info header doesn't fit in `.debug_line' section", 0, 0
633 static struct complaint dwarf2_missing_macinfo_section
=
635 "missing .debug_macinfo section", 0, 0
637 static struct complaint dwarf2_macros_too_long
=
639 "macro info runs off end of `.debug_macinfo' section", 0, 0
641 static struct complaint dwarf2_macros_not_terminated
=
643 "no terminating 0-type entry for macros in `.debug_macinfo' section", 0, 0
645 static struct complaint dwarf2_macro_outside_file
=
647 "debug info gives macro %s outside of any file: %s", 0, 0
649 static struct complaint dwarf2_macro_unmatched_end_file
=
651 "macro debug info has an unmatched `close_file' directive", 0, 0
653 static struct complaint dwarf2_macro_malformed_definition
=
655 "macro debug info contains a malformed macro definition:\n`%s'", 0, 0
657 static struct complaint dwarf2_macro_spaces_in_definition
=
659 "macro definition contains spaces in formal argument list:\n`%s'", 0, 0
661 static struct complaint dwarf2_invalid_attrib_class
=
663 "invalid attribute class or form for '%s' in '%s'", 0, 0
666 /* local function prototypes */
668 static void dwarf2_locate_sections (bfd
*, asection
*, PTR
);
671 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
674 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
676 static char *scan_partial_symbols (char *, struct objfile
*,
677 CORE_ADDR
*, CORE_ADDR
*,
678 const struct comp_unit_head
*);
680 static void add_partial_symbol (struct partial_die_info
*, struct objfile
*,
681 const struct comp_unit_head
*);
683 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
685 static void psymtab_to_symtab_1 (struct partial_symtab
*);
687 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int);
689 static void dwarf2_read_abbrevs (bfd
*, unsigned int);
691 static void dwarf2_empty_abbrev_table (PTR
);
693 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int);
695 static char *read_partial_die (struct partial_die_info
*,
697 const struct comp_unit_head
*);
699 static char *read_full_die (struct die_info
**, bfd
*, char *,
700 const struct comp_unit_head
*);
702 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
703 bfd
*, char *, const struct comp_unit_head
*);
705 static char *read_attribute_value (struct attribute
*, unsigned,
706 bfd
*, char *, const struct comp_unit_head
*);
708 static unsigned int read_1_byte (bfd
*, char *);
710 static int read_1_signed_byte (bfd
*, char *);
712 static unsigned int read_2_bytes (bfd
*, char *);
714 static unsigned int read_4_bytes (bfd
*, char *);
716 static unsigned long read_8_bytes (bfd
*, char *);
718 static CORE_ADDR
read_address (bfd
*, char *ptr
, const struct comp_unit_head
*,
721 static LONGEST
read_initial_length (bfd
*, char *,
722 struct comp_unit_head
*, int *bytes_read
);
724 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
727 static char *read_n_bytes (bfd
*, char *, unsigned int);
729 static char *read_string (bfd
*, char *, unsigned int *);
731 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
734 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
736 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
738 static void set_cu_language (unsigned int);
740 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
742 static int die_is_declaration (struct die_info
*);
744 static void free_line_header (struct line_header
*lh
);
746 static struct line_header
*(dwarf_decode_line_header
747 (unsigned int offset
,
749 const struct comp_unit_head
*cu_header
));
751 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
752 const struct comp_unit_head
*);
754 static void dwarf2_start_subfile (char *, char *);
756 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
757 struct objfile
*, const struct comp_unit_head
*);
759 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
760 struct objfile
*, const struct comp_unit_head
*);
762 static void dwarf2_const_value_data (struct attribute
*attr
,
766 static struct type
*die_type (struct die_info
*, struct objfile
*,
767 const struct comp_unit_head
*);
769 static struct type
*die_containing_type (struct die_info
*, struct objfile
*,
770 const struct comp_unit_head
*);
773 static struct type
*type_at_offset (unsigned int, struct objfile
*);
776 static struct type
*tag_type_to_type (struct die_info
*, struct objfile
*,
777 const struct comp_unit_head
*);
779 static void read_type_die (struct die_info
*, struct objfile
*,
780 const struct comp_unit_head
*);
782 static void read_typedef (struct die_info
*, struct objfile
*,
783 const struct comp_unit_head
*);
785 static void read_base_type (struct die_info
*, struct objfile
*);
787 static void read_file_scope (struct die_info
*, struct objfile
*,
788 const struct comp_unit_head
*);
790 static void read_func_scope (struct die_info
*, struct objfile
*,
791 const struct comp_unit_head
*);
793 static void read_lexical_block_scope (struct die_info
*, struct objfile
*,
794 const struct comp_unit_head
*);
796 static int dwarf2_get_pc_bounds (struct die_info
*,
797 CORE_ADDR
*, CORE_ADDR
*, struct objfile
*);
799 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
800 struct objfile
*, const struct comp_unit_head
*);
802 static void dwarf2_attach_fields_to_type (struct field_info
*,
803 struct type
*, struct objfile
*);
805 static void dwarf2_add_member_fn (struct field_info
*,
806 struct die_info
*, struct type
*,
807 struct objfile
*objfile
,
808 const struct comp_unit_head
*);
810 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
811 struct type
*, struct objfile
*);
813 static void read_structure_scope (struct die_info
*, struct objfile
*,
814 const struct comp_unit_head
*);
816 static void read_common_block (struct die_info
*, struct objfile
*,
817 const struct comp_unit_head
*);
819 static void read_enumeration (struct die_info
*, struct objfile
*,
820 const struct comp_unit_head
*);
822 static struct type
*dwarf_base_type (int, int, struct objfile
*);
824 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct objfile
*,
825 const struct comp_unit_head
*);
827 static void read_array_type (struct die_info
*, struct objfile
*,
828 const struct comp_unit_head
*);
830 static void read_tag_pointer_type (struct die_info
*, struct objfile
*,
831 const struct comp_unit_head
*);
833 static void read_tag_ptr_to_member_type (struct die_info
*, struct objfile
*,
834 const struct comp_unit_head
*);
836 static void read_tag_reference_type (struct die_info
*, struct objfile
*,
837 const struct comp_unit_head
*);
839 static void read_tag_const_type (struct die_info
*, struct objfile
*,
840 const struct comp_unit_head
*);
842 static void read_tag_volatile_type (struct die_info
*, struct objfile
*,
843 const struct comp_unit_head
*);
845 static void read_tag_string_type (struct die_info
*, struct objfile
*);
847 static void read_subroutine_type (struct die_info
*, struct objfile
*,
848 const struct comp_unit_head
*);
850 static struct die_info
*read_comp_unit (char *, bfd
*,
851 const struct comp_unit_head
*);
853 static void free_die_list (struct die_info
*);
855 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
857 static void process_die (struct die_info
*, struct objfile
*,
858 const struct comp_unit_head
*);
860 static char *dwarf2_linkage_name (struct die_info
*);
862 static char *dwarf_tag_name (unsigned int);
864 static char *dwarf_attr_name (unsigned int);
866 static char *dwarf_form_name (unsigned int);
868 static char *dwarf_stack_op_name (unsigned int);
870 static char *dwarf_bool_name (unsigned int);
872 static char *dwarf_type_encoding_name (unsigned int);
875 static char *dwarf_cfi_name (unsigned int);
877 struct die_info
*copy_die (struct die_info
*);
880 static struct die_info
*sibling_die (struct die_info
*);
882 static void dump_die (struct die_info
*);
884 static void dump_die_list (struct die_info
*);
886 static void store_in_ref_table (unsigned int, struct die_info
*);
888 static void dwarf2_empty_hash_tables (void);
890 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
892 static struct die_info
*follow_die_ref (unsigned int);
894 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
896 /* memory allocation interface */
898 static void dwarf2_free_tmp_obstack (PTR
);
900 static struct dwarf_block
*dwarf_alloc_block (void);
902 static struct abbrev_info
*dwarf_alloc_abbrev (void);
904 static struct die_info
*dwarf_alloc_die (void);
906 static void initialize_cu_func_list (void);
908 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
910 static void dwarf_decode_macros (struct line_header
*, unsigned int,
911 char *, bfd
*, const struct comp_unit_head
*,
914 static int attr_form_is_block (struct attribute
*);
916 /* Try to locate the sections we need for DWARF 2 debugging
917 information and return true if we have enough to do something. */
920 dwarf2_has_info (bfd
*abfd
)
922 dwarf_info_offset
= 0;
923 dwarf_abbrev_offset
= 0;
924 dwarf_line_offset
= 0;
925 dwarf_str_offset
= 0;
926 dwarf_macinfo_offset
= 0;
927 dwarf_frame_offset
= 0;
928 dwarf_eh_frame_offset
= 0;
929 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
930 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
940 /* This function is mapped across the sections and remembers the
941 offset and size of each of the debugging sections we are interested
945 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, PTR ignore_ptr
)
947 if (STREQ (sectp
->name
, INFO_SECTION
))
949 dwarf_info_offset
= sectp
->filepos
;
950 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
952 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
954 dwarf_abbrev_offset
= sectp
->filepos
;
955 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
957 else if (STREQ (sectp
->name
, LINE_SECTION
))
959 dwarf_line_offset
= sectp
->filepos
;
960 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
962 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
964 dwarf_pubnames_offset
= sectp
->filepos
;
965 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
967 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
969 dwarf_aranges_offset
= sectp
->filepos
;
970 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
972 else if (STREQ (sectp
->name
, LOC_SECTION
))
974 dwarf_loc_offset
= sectp
->filepos
;
975 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
977 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
979 dwarf_macinfo_offset
= sectp
->filepos
;
980 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
982 else if (STREQ (sectp
->name
, STR_SECTION
))
984 dwarf_str_offset
= sectp
->filepos
;
985 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
987 else if (STREQ (sectp
->name
, FRAME_SECTION
))
989 dwarf_frame_offset
= sectp
->filepos
;
990 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
992 else if (STREQ (sectp
->name
, EH_FRAME_SECTION
))
994 dwarf_eh_frame_offset
= sectp
->filepos
;
995 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
999 /* Build a partial symbol table. */
1002 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1005 /* We definitely need the .debug_info and .debug_abbrev sections */
1007 dwarf_info_buffer
= dwarf2_read_section (objfile
,
1010 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
1011 dwarf_abbrev_offset
,
1014 if (dwarf_line_offset
)
1015 dwarf_line_buffer
= dwarf2_read_section (objfile
,
1019 dwarf_line_buffer
= NULL
;
1021 if (dwarf_str_offset
)
1022 dwarf_str_buffer
= dwarf2_read_section (objfile
,
1026 dwarf_str_buffer
= NULL
;
1028 if (dwarf_macinfo_offset
)
1029 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1030 dwarf_macinfo_offset
,
1031 dwarf_macinfo_size
);
1033 dwarf_macinfo_buffer
= NULL
;
1036 || (objfile
->global_psymbols
.size
== 0
1037 && objfile
->static_psymbols
.size
== 0))
1039 init_psymbol_list (objfile
, 1024);
1043 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1045 /* Things are significantly easier if we have .debug_aranges and
1046 .debug_pubnames sections */
1048 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1052 /* only test this case for now */
1054 /* In this case we have to work a bit harder */
1055 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1060 /* Build the partial symbol table from the information in the
1061 .debug_pubnames and .debug_aranges sections. */
1064 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1066 bfd
*abfd
= objfile
->obfd
;
1067 char *aranges_buffer
, *pubnames_buffer
;
1068 char *aranges_ptr
, *pubnames_ptr
;
1069 unsigned int entry_length
, version
, info_offset
, info_size
;
1071 pubnames_buffer
= dwarf2_read_section (objfile
,
1072 dwarf_pubnames_offset
,
1073 dwarf_pubnames_size
);
1074 pubnames_ptr
= pubnames_buffer
;
1075 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1077 struct comp_unit_head cu_header
;
1080 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1082 pubnames_ptr
+= bytes_read
;
1083 version
= read_1_byte (abfd
, pubnames_ptr
);
1085 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1087 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1091 aranges_buffer
= dwarf2_read_section (objfile
,
1092 dwarf_aranges_offset
,
1093 dwarf_aranges_size
);
1098 /* Read in the comp unit header information from the debug_info at
1102 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1103 char *info_ptr
, bfd
*abfd
)
1107 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1109 info_ptr
+= bytes_read
;
1110 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1112 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1114 info_ptr
+= bytes_read
;
1115 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1117 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1118 if (signed_addr
< 0)
1119 internal_error (__FILE__
, __LINE__
,
1120 "read_comp_unit_head: dwarf from non elf file");
1121 cu_header
->signed_addr_p
= signed_addr
;
1125 /* Build the partial symbol table by doing a quick pass through the
1126 .debug_info and .debug_abbrev sections. */
1129 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1131 /* Instead of reading this into a big buffer, we should probably use
1132 mmap() on architectures that support it. (FIXME) */
1133 bfd
*abfd
= objfile
->obfd
;
1134 char *info_ptr
, *abbrev_ptr
;
1135 char *beg_of_comp_unit
;
1136 struct partial_die_info comp_unit_die
;
1137 struct partial_symtab
*pst
;
1138 struct cleanup
*back_to
;
1139 CORE_ADDR lowpc
, highpc
;
1141 info_ptr
= dwarf_info_buffer
;
1142 abbrev_ptr
= dwarf_abbrev_buffer
;
1144 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1145 the partial symbol scan, like attribute values.
1147 We could reduce our peak memory consumption during partial symbol
1148 table construction by freeing stuff from this obstack more often
1149 --- say, after processing each compilation unit, or each die ---
1150 but it turns out that this saves almost nothing. For an
1151 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1152 on dwarf2_tmp_obstack. Some investigation showed:
1154 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1155 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1156 all fixed-length values not requiring dynamic allocation.
1158 2) 30% of the attributes used the form DW_FORM_string. For
1159 DW_FORM_string, read_attribute simply hands back a pointer to
1160 the null-terminated string in dwarf_info_buffer, so no dynamic
1161 allocation is needed there either.
1163 3) The remaining 1% of the attributes all used DW_FORM_block1.
1164 75% of those were DW_AT_frame_base location lists for
1165 functions; the rest were DW_AT_location attributes, probably
1166 for the global variables.
1168 Anyway, what this all means is that the memory the dwarf2
1169 reader uses as temporary space reading partial symbols is about
1170 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1172 obstack_init (&dwarf2_tmp_obstack
);
1173 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1175 /* Since the objects we're extracting from dwarf_info_buffer vary in
1176 length, only the individual functions to extract them (like
1177 read_comp_unit_head and read_partial_die) can really know whether
1178 the buffer is large enough to hold another complete object.
1180 At the moment, they don't actually check that. If
1181 dwarf_info_buffer holds just one extra byte after the last
1182 compilation unit's dies, then read_comp_unit_head will happily
1183 read off the end of the buffer. read_partial_die is similarly
1184 casual. Those functions should be fixed.
1186 For this loop condition, simply checking whether there's any data
1187 left at all should be sufficient. */
1188 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1190 struct comp_unit_head cu_header
;
1191 beg_of_comp_unit
= info_ptr
;
1192 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1194 if (cu_header
.version
!= 2)
1196 error ("Dwarf Error: wrong version in compilation unit header.");
1199 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
1201 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6).",
1202 (long) cu_header
.abbrev_offset
,
1203 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1206 if (beg_of_comp_unit
+ cu_header
.length
+ cu_header
.initial_length_size
1207 > dwarf_info_buffer
+ dwarf_info_size
)
1209 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0).",
1210 (long) cu_header
.length
,
1211 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1214 /* Read the abbrevs for this compilation unit into a table */
1215 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1216 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1218 /* Read the compilation unit die */
1219 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1222 /* Set the language we're debugging */
1223 set_cu_language (comp_unit_die
.language
);
1225 /* Allocate a new partial symbol table structure */
1226 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1227 comp_unit_die
.name
? comp_unit_die
.name
: "",
1228 comp_unit_die
.lowpc
,
1229 objfile
->global_psymbols
.next
,
1230 objfile
->static_psymbols
.next
);
1232 pst
->read_symtab_private
= (char *)
1233 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1234 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1235 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1236 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1237 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1238 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1239 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1240 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1241 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1242 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1243 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1244 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1245 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1247 /* Store the function that reads in the rest of the symbol table */
1248 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1250 /* Check if comp unit has_children.
1251 If so, read the rest of the partial symbols from this comp unit.
1252 If not, there's no more debug_info for this comp unit. */
1253 if (comp_unit_die
.has_children
)
1255 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
,
1258 /* If the compilation unit didn't have an explicit address range,
1259 then use the information extracted from its child dies. */
1260 if (! comp_unit_die
.has_pc_info
)
1262 comp_unit_die
.lowpc
= lowpc
;
1263 comp_unit_die
.highpc
= highpc
;
1266 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1267 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1269 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1270 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1271 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1272 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1273 sort_pst_symbols (pst
);
1275 /* If there is already a psymtab or symtab for a file of this
1276 name, remove it. (If there is a symtab, more drastic things
1277 also happen.) This happens in VxWorks. */
1278 free_named_symtabs (pst
->filename
);
1280 info_ptr
= beg_of_comp_unit
+ cu_header
.length
1281 + cu_header
.initial_length_size
;
1283 do_cleanups (back_to
);
1286 /* Read in all interesting dies to the end of the compilation unit. */
1289 scan_partial_symbols (char *info_ptr
, struct objfile
*objfile
,
1290 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1291 const struct comp_unit_head
*cu_header
)
1293 bfd
*abfd
= objfile
->obfd
;
1294 struct partial_die_info pdi
;
1296 /* This function is called after we've read in the comp_unit_die in
1297 order to read its children. We start the nesting level at 1 since
1298 we have pushed 1 level down in order to read the comp unit's children.
1299 The comp unit itself is at level 0, so we stop reading when we pop
1300 back to that level. */
1302 int nesting_level
= 1;
1304 *lowpc
= ((CORE_ADDR
) -1);
1305 *highpc
= ((CORE_ADDR
) 0);
1307 while (nesting_level
)
1309 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1315 case DW_TAG_subprogram
:
1316 if (pdi
.has_pc_info
)
1318 if (pdi
.lowpc
< *lowpc
)
1322 if (pdi
.highpc
> *highpc
)
1324 *highpc
= pdi
.highpc
;
1326 if ((pdi
.is_external
|| nesting_level
== 1)
1327 && !pdi
.is_declaration
)
1329 add_partial_symbol (&pdi
, objfile
, cu_header
);
1333 case DW_TAG_variable
:
1334 case DW_TAG_typedef
:
1335 case DW_TAG_class_type
:
1336 case DW_TAG_structure_type
:
1337 case DW_TAG_union_type
:
1338 case DW_TAG_enumeration_type
:
1339 if ((pdi
.is_external
|| nesting_level
== 1)
1340 && !pdi
.is_declaration
)
1342 add_partial_symbol (&pdi
, objfile
, cu_header
);
1345 case DW_TAG_enumerator
:
1346 /* File scope enumerators are added to the partial symbol
1348 if (nesting_level
== 2)
1349 add_partial_symbol (&pdi
, objfile
, cu_header
);
1351 case DW_TAG_base_type
:
1352 /* File scope base type definitions are added to the partial
1354 if (nesting_level
== 1)
1355 add_partial_symbol (&pdi
, objfile
, cu_header
);
1362 /* If the die has a sibling, skip to the sibling.
1363 Do not skip enumeration types, we want to record their
1365 if (pdi
.sibling
&& pdi
.tag
!= DW_TAG_enumeration_type
)
1367 info_ptr
= pdi
.sibling
;
1369 else if (pdi
.has_children
)
1371 /* Die has children, but the optional DW_AT_sibling attribute
1382 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1383 from `maint check'. */
1384 if (*lowpc
== ((CORE_ADDR
) -1))
1390 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1391 const struct comp_unit_head
*cu_header
)
1397 case DW_TAG_subprogram
:
1398 if (pdi
->is_external
)
1400 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1401 mst_text, objfile); */
1402 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1403 VAR_NAMESPACE
, LOC_BLOCK
,
1404 &objfile
->global_psymbols
,
1405 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1409 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1410 mst_file_text, objfile); */
1411 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1412 VAR_NAMESPACE
, LOC_BLOCK
,
1413 &objfile
->static_psymbols
,
1414 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1417 case DW_TAG_variable
:
1418 if (pdi
->is_external
)
1421 Don't enter into the minimal symbol tables as there is
1422 a minimal symbol table entry from the ELF symbols already.
1423 Enter into partial symbol table if it has a location
1424 descriptor or a type.
1425 If the location descriptor is missing, new_symbol will create
1426 a LOC_UNRESOLVED symbol, the address of the variable will then
1427 be determined from the minimal symbol table whenever the variable
1429 The address for the partial symbol table entry is not
1430 used by GDB, but it comes in handy for debugging partial symbol
1434 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1435 if (pdi
->locdesc
|| pdi
->has_type
)
1436 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1437 VAR_NAMESPACE
, LOC_STATIC
,
1438 &objfile
->global_psymbols
,
1439 0, addr
+ baseaddr
, cu_language
, objfile
);
1443 /* Static Variable. Skip symbols without location descriptors. */
1444 if (pdi
->locdesc
== NULL
)
1446 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1447 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1448 mst_file_data, objfile); */
1449 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1450 VAR_NAMESPACE
, LOC_STATIC
,
1451 &objfile
->static_psymbols
,
1452 0, addr
+ baseaddr
, cu_language
, objfile
);
1455 case DW_TAG_typedef
:
1456 case DW_TAG_base_type
:
1457 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1458 VAR_NAMESPACE
, LOC_TYPEDEF
,
1459 &objfile
->static_psymbols
,
1460 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1462 case DW_TAG_class_type
:
1463 case DW_TAG_structure_type
:
1464 case DW_TAG_union_type
:
1465 case DW_TAG_enumeration_type
:
1466 /* Skip aggregate types without children, these are external
1468 if (pdi
->has_children
== 0)
1470 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1471 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1472 &objfile
->static_psymbols
,
1473 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1475 if (cu_language
== language_cplus
)
1477 /* For C++, these implicitly act as typedefs as well. */
1478 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1479 VAR_NAMESPACE
, LOC_TYPEDEF
,
1480 &objfile
->static_psymbols
,
1481 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1484 case DW_TAG_enumerator
:
1485 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1486 VAR_NAMESPACE
, LOC_CONST
,
1487 &objfile
->static_psymbols
,
1488 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1495 /* Expand this partial symbol table into a full symbol table. */
1498 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1500 /* FIXME: This is barely more than a stub. */
1505 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1511 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1512 gdb_flush (gdb_stdout
);
1515 psymtab_to_symtab_1 (pst
);
1517 /* Finish up the debug error message. */
1519 printf_filtered ("done.\n");
1525 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1527 struct objfile
*objfile
= pst
->objfile
;
1528 bfd
*abfd
= objfile
->obfd
;
1529 struct comp_unit_head cu_header
;
1530 struct die_info
*dies
;
1531 unsigned long offset
;
1532 CORE_ADDR lowpc
, highpc
;
1533 struct die_info
*child_die
;
1535 struct symtab
*symtab
;
1536 struct cleanup
*back_to
;
1538 /* Set local variables from the partial symbol table info. */
1539 offset
= DWARF_INFO_OFFSET (pst
);
1540 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1541 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1542 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1543 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1544 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1545 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1546 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1547 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1548 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1549 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1550 cu_header_offset
= offset
;
1551 info_ptr
= dwarf_info_buffer
+ offset
;
1553 obstack_init (&dwarf2_tmp_obstack
);
1554 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1557 make_cleanup (really_free_pendings
, NULL
);
1559 /* read in the comp_unit header */
1560 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1562 /* Read the abbrevs for this compilation unit */
1563 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1564 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1566 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
1568 make_cleanup_free_die_list (dies
);
1570 /* Do line number decoding in read_file_scope () */
1571 process_die (dies
, objfile
, &cu_header
);
1573 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1575 /* Some compilers don't define a DW_AT_high_pc attribute for
1576 the compilation unit. If the DW_AT_high_pc is missing,
1577 synthesize it, by scanning the DIE's below the compilation unit. */
1579 if (dies
->has_children
)
1581 child_die
= dies
->next
;
1582 while (child_die
&& child_die
->tag
)
1584 if (child_die
->tag
== DW_TAG_subprogram
)
1586 CORE_ADDR low
, high
;
1588 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1590 highpc
= max (highpc
, high
);
1593 child_die
= sibling_die (child_die
);
1597 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1599 /* Set symtab language to language from DW_AT_language.
1600 If the compilation is from a C file generated by language preprocessors,
1601 do not set the language if it was already deduced by start_subfile. */
1603 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1605 symtab
->language
= cu_language
;
1607 pst
->symtab
= symtab
;
1609 sort_symtab_syms (pst
->symtab
);
1611 do_cleanups (back_to
);
1614 /* Process a die and its children. */
1617 process_die (struct die_info
*die
, struct objfile
*objfile
,
1618 const struct comp_unit_head
*cu_header
)
1622 case DW_TAG_padding
:
1624 case DW_TAG_compile_unit
:
1625 read_file_scope (die
, objfile
, cu_header
);
1627 case DW_TAG_subprogram
:
1628 read_subroutine_type (die
, objfile
, cu_header
);
1629 read_func_scope (die
, objfile
, cu_header
);
1631 case DW_TAG_inlined_subroutine
:
1632 /* FIXME: These are ignored for now.
1633 They could be used to set breakpoints on all inlined instances
1634 of a function and make GDB `next' properly over inlined functions. */
1636 case DW_TAG_lexical_block
:
1637 read_lexical_block_scope (die
, objfile
, cu_header
);
1639 case DW_TAG_class_type
:
1640 case DW_TAG_structure_type
:
1641 case DW_TAG_union_type
:
1642 read_structure_scope (die
, objfile
, cu_header
);
1644 case DW_TAG_enumeration_type
:
1645 read_enumeration (die
, objfile
, cu_header
);
1647 case DW_TAG_subroutine_type
:
1648 read_subroutine_type (die
, objfile
, cu_header
);
1650 case DW_TAG_array_type
:
1651 read_array_type (die
, objfile
, cu_header
);
1653 case DW_TAG_pointer_type
:
1654 read_tag_pointer_type (die
, objfile
, cu_header
);
1656 case DW_TAG_ptr_to_member_type
:
1657 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1659 case DW_TAG_reference_type
:
1660 read_tag_reference_type (die
, objfile
, cu_header
);
1662 case DW_TAG_string_type
:
1663 read_tag_string_type (die
, objfile
);
1665 case DW_TAG_base_type
:
1666 read_base_type (die
, objfile
);
1667 if (dwarf_attr (die
, DW_AT_name
))
1669 /* Add a typedef symbol for the base type definition. */
1670 new_symbol (die
, die
->type
, objfile
, cu_header
);
1673 case DW_TAG_common_block
:
1674 read_common_block (die
, objfile
, cu_header
);
1676 case DW_TAG_common_inclusion
:
1679 new_symbol (die
, NULL
, objfile
, cu_header
);
1685 initialize_cu_func_list (void)
1687 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1691 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1692 const struct comp_unit_head
*cu_header
)
1694 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1695 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1696 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1697 struct attribute
*attr
;
1698 char *name
= "<unknown>";
1699 char *comp_dir
= NULL
;
1700 struct die_info
*child_die
;
1701 bfd
*abfd
= objfile
->obfd
;
1702 struct line_header
*line_header
= 0;
1704 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1706 if (die
->has_children
)
1708 child_die
= die
->next
;
1709 while (child_die
&& child_die
->tag
)
1711 if (child_die
->tag
== DW_TAG_subprogram
)
1713 CORE_ADDR low
, high
;
1715 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1717 lowpc
= min (lowpc
, low
);
1718 highpc
= max (highpc
, high
);
1721 child_die
= sibling_die (child_die
);
1726 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1727 from finish_block. */
1728 if (lowpc
== ((CORE_ADDR
) -1))
1733 attr
= dwarf_attr (die
, DW_AT_name
);
1736 name
= DW_STRING (attr
);
1738 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1741 comp_dir
= DW_STRING (attr
);
1744 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1745 directory, get rid of it. */
1746 char *cp
= strchr (comp_dir
, ':');
1748 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1753 if (objfile
->ei
.entry_point
>= lowpc
&&
1754 objfile
->ei
.entry_point
< highpc
)
1756 objfile
->ei
.entry_file_lowpc
= lowpc
;
1757 objfile
->ei
.entry_file_highpc
= highpc
;
1760 attr
= dwarf_attr (die
, DW_AT_language
);
1763 set_cu_language (DW_UNSND (attr
));
1766 /* We assume that we're processing GCC output. */
1767 processing_gcc_compilation
= 2;
1769 /* FIXME:Do something here. */
1770 if (dip
->at_producer
!= NULL
)
1772 handle_producer (dip
->at_producer
);
1776 /* The compilation unit may be in a different language or objfile,
1777 zero out all remembered fundamental types. */
1778 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1780 start_symtab (name
, comp_dir
, lowpc
);
1781 record_debugformat ("DWARF 2");
1783 initialize_cu_func_list ();
1785 /* Process all dies in compilation unit. */
1786 if (die
->has_children
)
1788 child_die
= die
->next
;
1789 while (child_die
&& child_die
->tag
)
1791 process_die (child_die
, objfile
, cu_header
);
1792 child_die
= sibling_die (child_die
);
1796 /* Decode line number information if present. */
1797 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1800 unsigned int line_offset
= DW_UNSND (attr
);
1801 line_header
= dwarf_decode_line_header (line_offset
,
1805 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
1806 (void *) line_header
);
1807 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu_header
);
1811 /* Decode macro information, if present. Dwarf 2 macro information
1812 refers to information in the line number info statement program
1813 header, so we can only read it if we've read the header
1815 attr
= dwarf_attr (die
, DW_AT_macro_info
);
1816 if (attr
&& line_header
)
1818 unsigned int macro_offset
= DW_UNSND (attr
);
1819 dwarf_decode_macros (line_header
, macro_offset
,
1820 comp_dir
, abfd
, cu_header
, objfile
);
1822 do_cleanups (back_to
);
1826 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
1828 struct function_range
*thisfn
;
1830 thisfn
= (struct function_range
*)
1831 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
1832 thisfn
->name
= name
;
1833 thisfn
->lowpc
= lowpc
;
1834 thisfn
->highpc
= highpc
;
1835 thisfn
->seen_line
= 0;
1836 thisfn
->next
= NULL
;
1838 if (cu_last_fn
== NULL
)
1839 cu_first_fn
= thisfn
;
1841 cu_last_fn
->next
= thisfn
;
1843 cu_last_fn
= thisfn
;
1847 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
1848 const struct comp_unit_head
*cu_header
)
1850 register struct context_stack
*new;
1853 struct die_info
*child_die
;
1854 struct attribute
*attr
;
1857 name
= dwarf2_linkage_name (die
);
1859 /* Ignore functions with missing or empty names and functions with
1860 missing or invalid low and high pc attributes. */
1861 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1867 /* Record the function range for dwarf_decode_lines. */
1868 add_to_cu_func_list (name
, lowpc
, highpc
);
1870 if (objfile
->ei
.entry_point
>= lowpc
&&
1871 objfile
->ei
.entry_point
< highpc
)
1873 objfile
->ei
.entry_func_lowpc
= lowpc
;
1874 objfile
->ei
.entry_func_highpc
= highpc
;
1877 /* Decode DW_AT_frame_base location descriptor if present, keep result
1878 for DW_OP_fbreg operands in decode_locdesc. */
1879 frame_base_reg
= -1;
1880 frame_base_offset
= 0;
1881 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1886 /* Support the .debug_loc offsets */
1887 if (attr_form_is_block (attr
))
1889 addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
1891 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
1893 complain (&dwarf2_complex_location_expr
);
1898 complain (&dwarf2_invalid_attrib_class
, "DW_AT_frame_base", name
);
1903 complain (&dwarf2_unsupported_at_frame_base
, name
);
1905 frame_base_reg
= addr
;
1908 frame_base_reg
= basereg
;
1909 frame_base_offset
= addr
;
1912 complain (&dwarf2_unsupported_at_frame_base
, name
);
1915 new = push_context (0, lowpc
);
1916 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
1917 list_in_scope
= &local_symbols
;
1919 if (die
->has_children
)
1921 child_die
= die
->next
;
1922 while (child_die
&& child_die
->tag
)
1924 process_die (child_die
, objfile
, cu_header
);
1925 child_die
= sibling_die (child_die
);
1929 new = pop_context ();
1930 /* Make a block for the local symbols within. */
1931 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1932 lowpc
, highpc
, objfile
);
1933 list_in_scope
= &file_symbols
;
1936 /* Process all the DIES contained within a lexical block scope. Start
1937 a new scope, process the dies, and then close the scope. */
1940 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
1941 const struct comp_unit_head
*cu_header
)
1943 register struct context_stack
*new;
1944 CORE_ADDR lowpc
, highpc
;
1945 struct die_info
*child_die
;
1947 /* Ignore blocks with missing or invalid low and high pc attributes. */
1948 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1953 push_context (0, lowpc
);
1954 if (die
->has_children
)
1956 child_die
= die
->next
;
1957 while (child_die
&& child_die
->tag
)
1959 process_die (child_die
, objfile
, cu_header
);
1960 child_die
= sibling_die (child_die
);
1963 new = pop_context ();
1965 if (local_symbols
!= NULL
)
1967 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
1970 local_symbols
= new->locals
;
1973 /* Get low and high pc attributes from a die.
1974 Return 1 if the attributes are present and valid, otherwise, return 0. */
1977 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1978 struct objfile
*objfile
)
1980 struct attribute
*attr
;
1984 attr
= dwarf_attr (die
, DW_AT_low_pc
);
1986 low
= DW_ADDR (attr
);
1989 attr
= dwarf_attr (die
, DW_AT_high_pc
);
1991 high
= DW_ADDR (attr
);
1998 /* When using the GNU linker, .gnu.linkonce. sections are used to
1999 eliminate duplicate copies of functions and vtables and such.
2000 The linker will arbitrarily choose one and discard the others.
2001 The AT_*_pc values for such functions refer to local labels in
2002 these sections. If the section from that file was discarded, the
2003 labels are not in the output, so the relocs get a value of 0.
2004 If this is a discarded function, mark the pc bounds as invalid,
2005 so that GDB will ignore it. */
2006 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
2014 /* Add an aggregate field to the field list. */
2017 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2018 struct objfile
*objfile
,
2019 const struct comp_unit_head
*cu_header
)
2021 struct nextfield
*new_field
;
2022 struct attribute
*attr
;
2024 char *fieldname
= "";
2026 /* Allocate a new field list entry and link it in. */
2027 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2028 make_cleanup (xfree
, new_field
);
2029 memset (new_field
, 0, sizeof (struct nextfield
));
2030 new_field
->next
= fip
->fields
;
2031 fip
->fields
= new_field
;
2034 /* Handle accessibility and virtuality of field.
2035 The default accessibility for members is public, the default
2036 accessibility for inheritance is private. */
2037 if (die
->tag
!= DW_TAG_inheritance
)
2038 new_field
->accessibility
= DW_ACCESS_public
;
2040 new_field
->accessibility
= DW_ACCESS_private
;
2041 new_field
->virtuality
= DW_VIRTUALITY_none
;
2043 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2045 new_field
->accessibility
= DW_UNSND (attr
);
2046 if (new_field
->accessibility
!= DW_ACCESS_public
)
2047 fip
->non_public_fields
= 1;
2048 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2050 new_field
->virtuality
= DW_UNSND (attr
);
2052 fp
= &new_field
->field
;
2053 if (die
->tag
== DW_TAG_member
)
2055 /* Get type of field. */
2056 fp
->type
= die_type (die
, objfile
, cu_header
);
2058 /* Get bit size of field (zero if none). */
2059 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2062 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2066 FIELD_BITSIZE (*fp
) = 0;
2069 /* Get bit offset of field. */
2070 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2073 FIELD_BITPOS (*fp
) =
2074 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
2077 FIELD_BITPOS (*fp
) = 0;
2078 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2081 if (BITS_BIG_ENDIAN
)
2083 /* For big endian bits, the DW_AT_bit_offset gives the
2084 additional bit offset from the MSB of the containing
2085 anonymous object to the MSB of the field. We don't
2086 have to do anything special since we don't need to
2087 know the size of the anonymous object. */
2088 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2092 /* For little endian bits, compute the bit offset to the
2093 MSB of the anonymous object, subtract off the number of
2094 bits from the MSB of the field to the MSB of the
2095 object, and then subtract off the number of bits of
2096 the field itself. The result is the bit offset of
2097 the LSB of the field. */
2099 int bit_offset
= DW_UNSND (attr
);
2101 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2104 /* The size of the anonymous object containing
2105 the bit field is explicit, so use the
2106 indicated size (in bytes). */
2107 anonymous_size
= DW_UNSND (attr
);
2111 /* The size of the anonymous object containing
2112 the bit field must be inferred from the type
2113 attribute of the data member containing the
2115 anonymous_size
= TYPE_LENGTH (fp
->type
);
2117 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2118 - bit_offset
- FIELD_BITSIZE (*fp
);
2122 /* Get name of field. */
2123 attr
= dwarf_attr (die
, DW_AT_name
);
2124 if (attr
&& DW_STRING (attr
))
2125 fieldname
= DW_STRING (attr
);
2126 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2127 &objfile
->type_obstack
);
2129 /* Change accessibility for artificial fields (e.g. virtual table
2130 pointer or virtual base class pointer) to private. */
2131 if (dwarf_attr (die
, DW_AT_artificial
))
2133 new_field
->accessibility
= DW_ACCESS_private
;
2134 fip
->non_public_fields
= 1;
2137 else if (die
->tag
== DW_TAG_variable
)
2141 /* C++ static member.
2142 Get name of field. */
2143 attr
= dwarf_attr (die
, DW_AT_name
);
2144 if (attr
&& DW_STRING (attr
))
2145 fieldname
= DW_STRING (attr
);
2149 /* Get physical name. */
2150 physname
= dwarf2_linkage_name (die
);
2152 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2153 &objfile
->type_obstack
));
2154 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2155 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2156 &objfile
->type_obstack
);
2158 else if (die
->tag
== DW_TAG_inheritance
)
2160 /* C++ base class field. */
2161 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2163 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
2165 FIELD_BITSIZE (*fp
) = 0;
2166 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2167 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2168 fip
->nbaseclasses
++;
2172 /* Create the vector of fields, and attach it to the type. */
2175 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2176 struct objfile
*objfile
)
2178 int nfields
= fip
->nfields
;
2180 /* Record the field count, allocate space for the array of fields,
2181 and create blank accessibility bitfields if necessary. */
2182 TYPE_NFIELDS (type
) = nfields
;
2183 TYPE_FIELDS (type
) = (struct field
*)
2184 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2185 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2187 if (fip
->non_public_fields
)
2189 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2191 TYPE_FIELD_PRIVATE_BITS (type
) =
2192 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2193 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2195 TYPE_FIELD_PROTECTED_BITS (type
) =
2196 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2197 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2199 TYPE_FIELD_IGNORE_BITS (type
) =
2200 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2201 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2204 /* If the type has baseclasses, allocate and clear a bit vector for
2205 TYPE_FIELD_VIRTUAL_BITS. */
2206 if (fip
->nbaseclasses
)
2208 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2211 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2212 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2213 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2214 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2215 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2218 /* Copy the saved-up fields into the field vector. Start from the head
2219 of the list, adding to the tail of the field array, so that they end
2220 up in the same order in the array in which they were added to the list. */
2221 while (nfields
-- > 0)
2223 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2224 switch (fip
->fields
->accessibility
)
2226 case DW_ACCESS_private
:
2227 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2230 case DW_ACCESS_protected
:
2231 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2234 case DW_ACCESS_public
:
2238 /* Unknown accessibility. Complain and treat it as public. */
2240 complain (&dwarf2_unsupported_accessibility
,
2241 fip
->fields
->accessibility
);
2245 if (nfields
< fip
->nbaseclasses
)
2247 switch (fip
->fields
->virtuality
)
2249 case DW_VIRTUALITY_virtual
:
2250 case DW_VIRTUALITY_pure_virtual
:
2251 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2255 fip
->fields
= fip
->fields
->next
;
2259 /* Add a member function to the proper fieldlist. */
2262 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2263 struct type
*type
, struct objfile
*objfile
,
2264 const struct comp_unit_head
*cu_header
)
2266 struct attribute
*attr
;
2267 struct fnfieldlist
*flp
;
2269 struct fn_field
*fnp
;
2272 struct nextfnfield
*new_fnfield
;
2274 /* Get name of member function. */
2275 attr
= dwarf_attr (die
, DW_AT_name
);
2276 if (attr
&& DW_STRING (attr
))
2277 fieldname
= DW_STRING (attr
);
2281 /* Get the mangled name. */
2282 physname
= dwarf2_linkage_name (die
);
2284 /* Look up member function name in fieldlist. */
2285 for (i
= 0; i
< fip
->nfnfields
; i
++)
2287 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2291 /* Create new list element if necessary. */
2292 if (i
< fip
->nfnfields
)
2293 flp
= &fip
->fnfieldlists
[i
];
2296 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2298 fip
->fnfieldlists
= (struct fnfieldlist
*)
2299 xrealloc (fip
->fnfieldlists
,
2300 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2301 * sizeof (struct fnfieldlist
));
2302 if (fip
->nfnfields
== 0)
2303 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2305 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2306 flp
->name
= fieldname
;
2312 /* Create a new member function field and chain it to the field list
2314 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2315 make_cleanup (xfree
, new_fnfield
);
2316 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2317 new_fnfield
->next
= flp
->head
;
2318 flp
->head
= new_fnfield
;
2321 /* Fill in the member function field info. */
2322 fnp
= &new_fnfield
->fnfield
;
2323 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2324 &objfile
->type_obstack
);
2325 fnp
->type
= alloc_type (objfile
);
2326 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2328 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2329 int nparams
= TYPE_NFIELDS (die
->type
);
2331 /* TYPE is the domain of this method, and DIE->TYPE is the type
2332 of the method itself (TYPE_CODE_METHOD). */
2333 smash_to_method_type (fnp
->type
, type
,
2334 TYPE_TARGET_TYPE (die
->type
),
2335 TYPE_FIELDS (die
->type
),
2336 TYPE_NFIELDS (die
->type
),
2337 TYPE_VARARGS (die
->type
));
2339 /* Handle static member functions.
2340 Dwarf2 has no clean way to discern C++ static and non-static
2341 member functions. G++ helps GDB by marking the first
2342 parameter for non-static member functions (which is the
2343 this pointer) as artificial. We obtain this information
2344 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2345 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2346 fnp
->voffset
= VOFFSET_STATIC
;
2349 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2351 /* Get fcontext from DW_AT_containing_type if present. */
2352 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2353 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2355 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2356 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2358 /* Get accessibility. */
2359 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2362 switch (DW_UNSND (attr
))
2364 case DW_ACCESS_private
:
2365 fnp
->is_private
= 1;
2367 case DW_ACCESS_protected
:
2368 fnp
->is_protected
= 1;
2373 /* Check for artificial methods. */
2374 attr
= dwarf_attr (die
, DW_AT_artificial
);
2375 if (attr
&& DW_UNSND (attr
) != 0)
2376 fnp
->is_artificial
= 1;
2378 /* Get index in virtual function table if it is a virtual member function. */
2379 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2382 /* Support the .debug_loc offsets */
2383 if (attr_form_is_block (attr
))
2385 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2387 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2389 complain (&dwarf2_complex_location_expr
);
2393 complain (&dwarf2_invalid_attrib_class
, "DW_AT_vtable_elem_location",
2399 /* Create the vector of member function fields, and attach it to the type. */
2402 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2403 struct objfile
*objfile
)
2405 struct fnfieldlist
*flp
;
2406 int total_length
= 0;
2409 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2410 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2411 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2413 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2415 struct nextfnfield
*nfp
= flp
->head
;
2416 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2419 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2420 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2421 fn_flp
->fn_fields
= (struct fn_field
*)
2422 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2423 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2424 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2426 total_length
+= flp
->length
;
2429 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2430 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2433 /* Called when we find the DIE that starts a structure or union scope
2434 (definition) to process all dies that define the members of the
2437 NOTE: we need to call struct_type regardless of whether or not the
2438 DIE has an at_name attribute, since it might be an anonymous
2439 structure or union. This gets the type entered into our set of
2442 However, if the structure is incomplete (an opaque struct/union)
2443 then suppress creating a symbol table entry for it since gdb only
2444 wants to find the one with the complete definition. Note that if
2445 it is complete, we just call new_symbol, which does it's own
2446 checking about whether the struct/union is anonymous or not (and
2447 suppresses creating a symbol table entry itself). */
2450 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2451 const struct comp_unit_head
*cu_header
)
2454 struct attribute
*attr
;
2456 type
= alloc_type (objfile
);
2458 INIT_CPLUS_SPECIFIC (type
);
2459 attr
= dwarf_attr (die
, DW_AT_name
);
2460 if (attr
&& DW_STRING (attr
))
2462 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2463 strlen (DW_STRING (attr
)),
2464 &objfile
->type_obstack
);
2467 if (die
->tag
== DW_TAG_structure_type
)
2469 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2471 else if (die
->tag
== DW_TAG_union_type
)
2473 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2477 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2479 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2482 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2485 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2489 TYPE_LENGTH (type
) = 0;
2492 /* We need to add the type field to the die immediately so we don't
2493 infinitely recurse when dealing with pointers to the structure
2494 type within the structure itself. */
2497 if (die
->has_children
&& ! die_is_declaration (die
))
2499 struct field_info fi
;
2500 struct die_info
*child_die
;
2501 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2503 memset (&fi
, 0, sizeof (struct field_info
));
2505 child_die
= die
->next
;
2507 while (child_die
&& child_die
->tag
)
2509 if (child_die
->tag
== DW_TAG_member
)
2511 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2513 else if (child_die
->tag
== DW_TAG_variable
)
2515 /* C++ static member. */
2516 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2518 else if (child_die
->tag
== DW_TAG_subprogram
)
2520 /* C++ member function. */
2521 process_die (child_die
, objfile
, cu_header
);
2522 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2524 else if (child_die
->tag
== DW_TAG_inheritance
)
2526 /* C++ base class field. */
2527 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2531 process_die (child_die
, objfile
, cu_header
);
2533 child_die
= sibling_die (child_die
);
2536 /* Attach fields and member functions to the type. */
2538 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2541 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2543 /* Get the type which refers to the base class (possibly this
2544 class itself) which contains the vtable pointer for the current
2545 class from the DW_AT_containing_type attribute. */
2547 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2549 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2551 TYPE_VPTR_BASETYPE (type
) = t
;
2554 static const char vptr_name
[] =
2555 {'_', 'v', 'p', 't', 'r', '\0'};
2558 /* Our own class provides vtbl ptr. */
2559 for (i
= TYPE_NFIELDS (t
) - 1;
2560 i
>= TYPE_N_BASECLASSES (t
);
2563 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2565 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2566 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2568 TYPE_VPTR_FIELDNO (type
) = i
;
2573 /* Complain if virtual function table field not found. */
2574 if (i
< TYPE_N_BASECLASSES (t
))
2575 complain (&dwarf2_vtbl_not_found_complaint
,
2576 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2580 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2585 new_symbol (die
, type
, objfile
, cu_header
);
2587 do_cleanups (back_to
);
2591 /* No children, must be stub. */
2592 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2596 /* Given a pointer to a die which begins an enumeration, process all
2597 the dies that define the members of the enumeration.
2599 This will be much nicer in draft 6 of the DWARF spec when our
2600 members will be dies instead squished into the DW_AT_element_list
2603 NOTE: We reverse the order of the element list. */
2606 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2607 const struct comp_unit_head
*cu_header
)
2609 struct die_info
*child_die
;
2611 struct field
*fields
;
2612 struct attribute
*attr
;
2615 int unsigned_enum
= 1;
2617 type
= alloc_type (objfile
);
2619 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2620 attr
= dwarf_attr (die
, DW_AT_name
);
2621 if (attr
&& DW_STRING (attr
))
2623 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2624 strlen (DW_STRING (attr
)),
2625 &objfile
->type_obstack
);
2628 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2631 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2635 TYPE_LENGTH (type
) = 0;
2640 if (die
->has_children
)
2642 child_die
= die
->next
;
2643 while (child_die
&& child_die
->tag
)
2645 if (child_die
->tag
!= DW_TAG_enumerator
)
2647 process_die (child_die
, objfile
, cu_header
);
2651 attr
= dwarf_attr (child_die
, DW_AT_name
);
2654 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2655 if (SYMBOL_VALUE (sym
) < 0)
2658 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2660 fields
= (struct field
*)
2662 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2663 * sizeof (struct field
));
2666 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2667 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2668 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2669 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2675 child_die
= sibling_die (child_die
);
2680 TYPE_NFIELDS (type
) = num_fields
;
2681 TYPE_FIELDS (type
) = (struct field
*)
2682 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2683 memcpy (TYPE_FIELDS (type
), fields
,
2684 sizeof (struct field
) * num_fields
);
2688 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2691 new_symbol (die
, type
, objfile
, cu_header
);
2694 /* Extract all information from a DW_TAG_array_type DIE and put it in
2695 the DIE's type field. For now, this only handles one dimensional
2699 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2700 const struct comp_unit_head
*cu_header
)
2702 struct die_info
*child_die
;
2703 struct type
*type
= NULL
;
2704 struct type
*element_type
, *range_type
, *index_type
;
2705 struct type
**range_types
= NULL
;
2706 struct attribute
*attr
;
2708 struct cleanup
*back_to
;
2710 /* Return if we've already decoded this type. */
2716 element_type
= die_type (die
, objfile
, cu_header
);
2718 /* Irix 6.2 native cc creates array types without children for
2719 arrays with unspecified length. */
2720 if (die
->has_children
== 0)
2722 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2723 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2724 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2728 back_to
= make_cleanup (null_cleanup
, NULL
);
2729 child_die
= die
->next
;
2730 while (child_die
&& child_die
->tag
)
2732 if (child_die
->tag
== DW_TAG_subrange_type
)
2734 unsigned int low
, high
;
2736 /* Default bounds to an array with unspecified length. */
2739 if (cu_language
== language_fortran
)
2741 /* FORTRAN implies a lower bound of 1, if not given. */
2745 index_type
= die_type (child_die
, objfile
, cu_header
);
2746 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2749 if (attr
->form
== DW_FORM_sdata
)
2751 low
= DW_SND (attr
);
2753 else if (attr
->form
== DW_FORM_udata
2754 || attr
->form
== DW_FORM_data1
2755 || attr
->form
== DW_FORM_data2
2756 || attr
->form
== DW_FORM_data4
2757 || attr
->form
== DW_FORM_data8
)
2759 low
= DW_UNSND (attr
);
2763 complain (&dwarf2_non_const_array_bound_ignored
,
2764 dwarf_form_name (attr
->form
));
2766 die
->type
= lookup_pointer_type (element_type
);
2773 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2776 if (attr
->form
== DW_FORM_sdata
)
2778 high
= DW_SND (attr
);
2780 else if (attr
->form
== DW_FORM_udata
2781 || attr
->form
== DW_FORM_data1
2782 || attr
->form
== DW_FORM_data2
2783 || attr
->form
== DW_FORM_data4
2784 || attr
->form
== DW_FORM_data8
)
2786 high
= DW_UNSND (attr
);
2788 else if (attr
->form
== DW_FORM_block1
)
2790 /* GCC encodes arrays with unspecified or dynamic length
2791 with a DW_FORM_block1 attribute.
2792 FIXME: GDB does not yet know how to handle dynamic
2793 arrays properly, treat them as arrays with unspecified
2799 complain (&dwarf2_non_const_array_bound_ignored
,
2800 dwarf_form_name (attr
->form
));
2802 die
->type
= lookup_pointer_type (element_type
);
2810 /* Create a range type and save it for array type creation. */
2811 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2813 range_types
= (struct type
**)
2814 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2815 * sizeof (struct type
*));
2817 make_cleanup (free_current_contents
, &range_types
);
2819 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2821 child_die
= sibling_die (child_die
);
2824 /* Dwarf2 dimensions are output from left to right, create the
2825 necessary array types in backwards order. */
2826 type
= element_type
;
2828 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2830 /* Understand Dwarf2 support for vector types (like they occur on
2831 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
2832 array type. This is not part of the Dwarf2/3 standard yet, but a
2833 custom vendor extension. The main difference between a regular
2834 array and the vector variant is that vectors are passed by value
2836 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
2838 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
2840 do_cleanups (back_to
);
2842 /* Install the type in the die. */
2846 /* First cut: install each common block member as a global variable. */
2849 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
2850 const struct comp_unit_head
*cu_header
)
2852 struct die_info
*child_die
;
2853 struct attribute
*attr
;
2855 CORE_ADDR base
= (CORE_ADDR
) 0;
2857 attr
= dwarf_attr (die
, DW_AT_location
);
2860 /* Support the .debug_loc offsets */
2861 if (attr_form_is_block (attr
))
2863 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2865 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2867 complain (&dwarf2_complex_location_expr
);
2871 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
2872 "common block member");
2875 if (die
->has_children
)
2877 child_die
= die
->next
;
2878 while (child_die
&& child_die
->tag
)
2880 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
2881 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2884 SYMBOL_VALUE_ADDRESS (sym
) =
2885 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2886 add_symbol_to_list (sym
, &global_symbols
);
2888 child_die
= sibling_die (child_die
);
2893 /* Extract all information from a DW_TAG_pointer_type DIE and add to
2894 the user defined type vector. */
2897 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
2898 const struct comp_unit_head
*cu_header
)
2901 struct attribute
*attr
;
2908 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
2909 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2912 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2916 TYPE_LENGTH (type
) = cu_header
->addr_size
;
2921 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
2922 the user defined type vector. */
2925 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
2926 const struct comp_unit_head
*cu_header
)
2929 struct type
*to_type
;
2930 struct type
*domain
;
2937 type
= alloc_type (objfile
);
2938 to_type
= die_type (die
, objfile
, cu_header
);
2939 domain
= die_containing_type (die
, objfile
, cu_header
);
2940 smash_to_member_type (type
, domain
, to_type
);
2945 /* Extract all information from a DW_TAG_reference_type DIE and add to
2946 the user defined type vector. */
2949 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
2950 const struct comp_unit_head
*cu_header
)
2953 struct attribute
*attr
;
2960 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
2961 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2964 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2968 TYPE_LENGTH (type
) = cu_header
->addr_size
;
2974 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
2975 const struct comp_unit_head
*cu_header
)
2977 struct type
*base_type
;
2984 base_type
= die_type (die
, objfile
, cu_header
);
2985 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
2989 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
2990 const struct comp_unit_head
*cu_header
)
2992 struct type
*base_type
;
2999 base_type
= die_type (die
, objfile
, cu_header
);
3000 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3003 /* Extract all information from a DW_TAG_string_type DIE and add to
3004 the user defined type vector. It isn't really a user defined type,
3005 but it behaves like one, with other DIE's using an AT_user_def_type
3006 attribute to reference it. */
3009 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
3011 struct type
*type
, *range_type
, *index_type
, *char_type
;
3012 struct attribute
*attr
;
3013 unsigned int length
;
3020 attr
= dwarf_attr (die
, DW_AT_string_length
);
3023 length
= DW_UNSND (attr
);
3027 /* check for the DW_AT_byte_size attribute */
3028 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3031 length
= DW_UNSND (attr
);
3038 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3039 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3040 if (cu_language
== language_fortran
)
3042 /* Need to create a unique string type for bounds
3044 type
= create_string_type (0, range_type
);
3048 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3049 type
= create_string_type (char_type
, range_type
);
3054 /* Handle DIES due to C code like:
3058 int (*funcp)(int a, long l);
3062 ('funcp' generates a DW_TAG_subroutine_type DIE)
3066 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
3067 const struct comp_unit_head
*cu_header
)
3069 struct type
*type
; /* Type that this function returns */
3070 struct type
*ftype
; /* Function that returns above type */
3071 struct attribute
*attr
;
3073 /* Decode the type that this subroutine returns */
3078 type
= die_type (die
, objfile
, cu_header
);
3079 ftype
= lookup_function_type (type
);
3081 /* All functions in C++ have prototypes. */
3082 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3083 if ((attr
&& (DW_UNSND (attr
) != 0))
3084 || cu_language
== language_cplus
)
3085 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3087 if (die
->has_children
)
3089 struct die_info
*child_die
;
3093 /* Count the number of parameters.
3094 FIXME: GDB currently ignores vararg functions, but knows about
3095 vararg member functions. */
3096 child_die
= die
->next
;
3097 while (child_die
&& child_die
->tag
)
3099 if (child_die
->tag
== DW_TAG_formal_parameter
)
3101 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3102 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3103 child_die
= sibling_die (child_die
);
3106 /* Allocate storage for parameters and fill them in. */
3107 TYPE_NFIELDS (ftype
) = nparams
;
3108 TYPE_FIELDS (ftype
) = (struct field
*)
3109 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3111 child_die
= die
->next
;
3112 while (child_die
&& child_die
->tag
)
3114 if (child_die
->tag
== DW_TAG_formal_parameter
)
3116 /* Dwarf2 has no clean way to discern C++ static and non-static
3117 member functions. G++ helps GDB by marking the first
3118 parameter for non-static member functions (which is the
3119 this pointer) as artificial. We pass this information
3120 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3121 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3123 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3125 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3126 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
3130 child_die
= sibling_die (child_die
);
3138 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
3139 const struct comp_unit_head
*cu_header
)
3141 struct attribute
*attr
;
3146 attr
= dwarf_attr (die
, DW_AT_name
);
3147 if (attr
&& DW_STRING (attr
))
3149 name
= DW_STRING (attr
);
3151 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3152 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
3156 /* Find a representation of a given base type and install
3157 it in the TYPE field of the die. */
3160 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
3163 struct attribute
*attr
;
3164 int encoding
= 0, size
= 0;
3166 /* If we've already decoded this die, this is a no-op. */
3172 attr
= dwarf_attr (die
, DW_AT_encoding
);
3175 encoding
= DW_UNSND (attr
);
3177 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3180 size
= DW_UNSND (attr
);
3182 attr
= dwarf_attr (die
, DW_AT_name
);
3183 if (attr
&& DW_STRING (attr
))
3185 enum type_code code
= TYPE_CODE_INT
;
3190 case DW_ATE_address
:
3191 /* Turn DW_ATE_address into a void * pointer. */
3192 code
= TYPE_CODE_PTR
;
3193 type_flags
|= TYPE_FLAG_UNSIGNED
;
3195 case DW_ATE_boolean
:
3196 code
= TYPE_CODE_BOOL
;
3197 type_flags
|= TYPE_FLAG_UNSIGNED
;
3199 case DW_ATE_complex_float
:
3200 code
= TYPE_CODE_COMPLEX
;
3203 code
= TYPE_CODE_FLT
;
3206 case DW_ATE_signed_char
:
3208 case DW_ATE_unsigned
:
3209 case DW_ATE_unsigned_char
:
3210 type_flags
|= TYPE_FLAG_UNSIGNED
;
3213 complain (&dwarf2_unsupported_at_encoding
,
3214 dwarf_type_encoding_name (encoding
));
3217 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3218 if (encoding
== DW_ATE_address
)
3219 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3220 else if (encoding
== DW_ATE_complex_float
)
3223 TYPE_TARGET_TYPE (type
)
3224 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3225 else if (size
== 16)
3226 TYPE_TARGET_TYPE (type
)
3227 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3229 TYPE_TARGET_TYPE (type
)
3230 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3235 type
= dwarf_base_type (encoding
, size
, objfile
);
3240 /* Read a whole compilation unit into a linked list of dies. */
3242 static struct die_info
*
3243 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3244 const struct comp_unit_head
*cu_header
)
3246 struct die_info
*first_die
, *last_die
, *die
;
3250 /* Reset die reference table; we are
3251 building new ones now. */
3252 dwarf2_empty_hash_tables ();
3256 first_die
= last_die
= NULL
;
3259 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3260 if (die
->has_children
)
3271 /* Enter die in reference hash table */
3272 store_in_ref_table (die
->offset
, die
);
3276 first_die
= last_die
= die
;
3280 last_die
->next
= die
;
3284 while (nesting_level
> 0);
3288 /* Free a linked list of dies. */
3291 free_die_list (struct die_info
*dies
)
3293 struct die_info
*die
, *next
;
3306 do_free_die_list_cleanup (void *dies
)
3308 free_die_list (dies
);
3311 static struct cleanup
*
3312 make_cleanup_free_die_list (struct die_info
*dies
)
3314 return make_cleanup (do_free_die_list_cleanup
, dies
);
3318 /* Read the contents of the section at OFFSET and of size SIZE from the
3319 object file specified by OBJFILE into the psymbol_obstack and return it. */
3322 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3325 bfd
*abfd
= objfile
->obfd
;
3331 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3332 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3333 (bfd_bread (buf
, size
, abfd
) != size
))
3336 error ("Dwarf Error: Can't read DWARF data from '%s'",
3337 bfd_get_filename (abfd
));
3342 /* In DWARF version 2, the description of the debugging information is
3343 stored in a separate .debug_abbrev section. Before we read any
3344 dies from a section we read in all abbreviations and install them
3348 dwarf2_read_abbrevs (bfd
*abfd
, unsigned int offset
)
3351 struct abbrev_info
*cur_abbrev
;
3352 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3353 unsigned int abbrev_form
, hash_number
;
3355 /* empty the table */
3356 dwarf2_empty_abbrev_table (NULL
);
3358 abbrev_ptr
= dwarf_abbrev_buffer
+ offset
;
3359 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3360 abbrev_ptr
+= bytes_read
;
3362 /* loop until we reach an abbrev number of 0 */
3363 while (abbrev_number
)
3365 cur_abbrev
= dwarf_alloc_abbrev ();
3367 /* read in abbrev header */
3368 cur_abbrev
->number
= abbrev_number
;
3369 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3370 abbrev_ptr
+= bytes_read
;
3371 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3374 /* now read in declarations */
3375 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3376 abbrev_ptr
+= bytes_read
;
3377 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3378 abbrev_ptr
+= bytes_read
;
3381 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3383 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3384 xrealloc (cur_abbrev
->attrs
,
3385 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3386 * sizeof (struct attr_abbrev
));
3388 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3389 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3390 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3391 abbrev_ptr
+= bytes_read
;
3392 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3393 abbrev_ptr
+= bytes_read
;
3396 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3397 cur_abbrev
->next
= dwarf2_abbrevs
[hash_number
];
3398 dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3400 /* Get next abbreviation.
3401 Under Irix6 the abbreviations for a compilation unit are not
3402 always properly terminated with an abbrev number of 0.
3403 Exit loop if we encounter an abbreviation which we have
3404 already read (which means we are about to read the abbreviations
3405 for the next compile unit) or if the end of the abbreviation
3406 table is reached. */
3407 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3408 >= dwarf_abbrev_size
)
3410 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3411 abbrev_ptr
+= bytes_read
;
3412 if (dwarf2_lookup_abbrev (abbrev_number
) != NULL
)
3417 /* Empty the abbrev table for a new compilation unit. */
3421 dwarf2_empty_abbrev_table (PTR ignore
)
3424 struct abbrev_info
*abbrev
, *next
;
3426 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3429 abbrev
= dwarf2_abbrevs
[i
];
3432 next
= abbrev
->next
;
3433 xfree (abbrev
->attrs
);
3437 dwarf2_abbrevs
[i
] = NULL
;
3441 /* Lookup an abbrev_info structure in the abbrev hash table. */
3443 static struct abbrev_info
*
3444 dwarf2_lookup_abbrev (unsigned int number
)
3446 unsigned int hash_number
;
3447 struct abbrev_info
*abbrev
;
3449 hash_number
= number
% ABBREV_HASH_SIZE
;
3450 abbrev
= dwarf2_abbrevs
[hash_number
];
3454 if (abbrev
->number
== number
)
3457 abbrev
= abbrev
->next
;
3462 /* Read a minimal amount of information into the minimal die structure. */
3465 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3466 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3468 unsigned int abbrev_number
, bytes_read
, i
;
3469 struct abbrev_info
*abbrev
;
3470 struct attribute attr
;
3471 struct attribute spec_attr
;
3472 int found_spec_attr
= 0;
3473 int has_low_pc_attr
= 0;
3474 int has_high_pc_attr
= 0;
3476 *part_die
= zeroed_partial_die
;
3477 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3478 info_ptr
+= bytes_read
;
3482 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3485 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3487 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3488 part_die
->tag
= abbrev
->tag
;
3489 part_die
->has_children
= abbrev
->has_children
;
3490 part_die
->abbrev
= abbrev_number
;
3492 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3494 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3495 info_ptr
, cu_header
);
3497 /* Store the data if it is of an attribute we want to keep in a
3498 partial symbol table. */
3503 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3504 if (part_die
->name
== NULL
)
3505 part_die
->name
= DW_STRING (&attr
);
3507 case DW_AT_MIPS_linkage_name
:
3508 part_die
->name
= DW_STRING (&attr
);
3511 has_low_pc_attr
= 1;
3512 part_die
->lowpc
= DW_ADDR (&attr
);
3515 has_high_pc_attr
= 1;
3516 part_die
->highpc
= DW_ADDR (&attr
);
3518 case DW_AT_location
:
3519 /* Support the .debug_loc offsets */
3520 if (attr_form_is_block (&attr
))
3522 part_die
->locdesc
= DW_BLOCK (&attr
);
3524 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
3526 complain (&dwarf2_complex_location_expr
);
3530 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
3531 "partial symbol information");
3534 case DW_AT_language
:
3535 part_die
->language
= DW_UNSND (&attr
);
3537 case DW_AT_external
:
3538 part_die
->is_external
= DW_UNSND (&attr
);
3540 case DW_AT_declaration
:
3541 part_die
->is_declaration
= DW_UNSND (&attr
);
3544 part_die
->has_type
= 1;
3546 case DW_AT_abstract_origin
:
3547 case DW_AT_specification
:
3548 found_spec_attr
= 1;
3552 /* Ignore absolute siblings, they might point outside of
3553 the current compile unit. */
3554 if (attr
.form
== DW_FORM_ref_addr
)
3555 complain (&dwarf2_absolute_sibling_complaint
);
3558 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3565 /* If we found a reference attribute and the die has no name, try
3566 to find a name in the referred to die. */
3568 if (found_spec_attr
&& part_die
->name
== NULL
)
3570 struct partial_die_info spec_die
;
3574 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3575 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3578 part_die
->name
= spec_die
.name
;
3580 /* Copy DW_AT_external attribute if it is set. */
3581 if (spec_die
.is_external
)
3582 part_die
->is_external
= spec_die
.is_external
;
3586 /* When using the GNU linker, .gnu.linkonce. sections are used to
3587 eliminate duplicate copies of functions and vtables and such.
3588 The linker will arbitrarily choose one and discard the others.
3589 The AT_*_pc values for such functions refer to local labels in
3590 these sections. If the section from that file was discarded, the
3591 labels are not in the output, so the relocs get a value of 0.
3592 If this is a discarded function, mark the pc bounds as invalid,
3593 so that GDB will ignore it. */
3594 if (has_low_pc_attr
&& has_high_pc_attr
3595 && part_die
->lowpc
< part_die
->highpc
3596 && (part_die
->lowpc
!= 0
3597 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3598 part_die
->has_pc_info
= 1;
3602 /* Read the die from the .debug_info section buffer. And set diep to
3603 point to a newly allocated die with its information. */
3606 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3607 const struct comp_unit_head
*cu_header
)
3609 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3610 struct abbrev_info
*abbrev
;
3611 struct die_info
*die
;
3613 offset
= info_ptr
- dwarf_info_buffer
;
3614 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3615 info_ptr
+= bytes_read
;
3618 die
= dwarf_alloc_die ();
3620 die
->abbrev
= abbrev_number
;
3626 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3629 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3631 die
= dwarf_alloc_die ();
3632 die
->offset
= offset
;
3633 die
->tag
= abbrev
->tag
;
3634 die
->has_children
= abbrev
->has_children
;
3635 die
->abbrev
= abbrev_number
;
3638 die
->num_attrs
= abbrev
->num_attrs
;
3639 die
->attrs
= (struct attribute
*)
3640 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3642 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3644 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3645 abfd
, info_ptr
, cu_header
);
3652 /* Read an attribute value described by an attribute form. */
3655 read_attribute_value (struct attribute
*attr
, unsigned form
,
3656 bfd
*abfd
, char *info_ptr
,
3657 const struct comp_unit_head
*cu_header
)
3659 unsigned int bytes_read
;
3660 struct dwarf_block
*blk
;
3666 case DW_FORM_ref_addr
:
3667 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3668 info_ptr
+= bytes_read
;
3670 case DW_FORM_block2
:
3671 blk
= dwarf_alloc_block ();
3672 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3674 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3675 info_ptr
+= blk
->size
;
3676 DW_BLOCK (attr
) = blk
;
3678 case DW_FORM_block4
:
3679 blk
= dwarf_alloc_block ();
3680 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3682 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3683 info_ptr
+= blk
->size
;
3684 DW_BLOCK (attr
) = blk
;
3687 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3691 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3695 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3698 case DW_FORM_string
:
3699 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3700 info_ptr
+= bytes_read
;
3703 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
3705 info_ptr
+= bytes_read
;
3708 blk
= dwarf_alloc_block ();
3709 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3710 info_ptr
+= bytes_read
;
3711 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3712 info_ptr
+= blk
->size
;
3713 DW_BLOCK (attr
) = blk
;
3715 case DW_FORM_block1
:
3716 blk
= dwarf_alloc_block ();
3717 blk
->size
= read_1_byte (abfd
, info_ptr
);
3719 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3720 info_ptr
+= blk
->size
;
3721 DW_BLOCK (attr
) = blk
;
3724 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3728 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3732 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3733 info_ptr
+= bytes_read
;
3736 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3737 info_ptr
+= bytes_read
;
3740 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3744 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3748 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3752 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3755 case DW_FORM_ref_udata
:
3756 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3757 info_ptr
+= bytes_read
;
3759 case DW_FORM_indirect
:
3760 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3761 info_ptr
+= bytes_read
;
3762 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
3765 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3766 dwarf_form_name (form
));
3771 /* Read an attribute described by an abbreviated attribute. */
3774 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
3775 bfd
*abfd
, char *info_ptr
,
3776 const struct comp_unit_head
*cu_header
)
3778 attr
->name
= abbrev
->name
;
3779 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
3782 /* read dwarf information from a buffer */
3785 read_1_byte (bfd
*abfd
, char *buf
)
3787 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3791 read_1_signed_byte (bfd
*abfd
, char *buf
)
3793 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3797 read_2_bytes (bfd
*abfd
, char *buf
)
3799 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3803 read_2_signed_bytes (bfd
*abfd
, char *buf
)
3805 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3809 read_4_bytes (bfd
*abfd
, char *buf
)
3811 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3815 read_4_signed_bytes (bfd
*abfd
, char *buf
)
3817 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3820 static unsigned long
3821 read_8_bytes (bfd
*abfd
, char *buf
)
3823 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3827 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3830 CORE_ADDR retval
= 0;
3832 if (cu_header
->signed_addr_p
)
3834 switch (cu_header
->addr_size
)
3837 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3840 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3843 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
3846 internal_error (__FILE__
, __LINE__
,
3847 "read_address: bad switch, signed");
3852 switch (cu_header
->addr_size
)
3855 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3858 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3861 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3864 internal_error (__FILE__
, __LINE__
,
3865 "read_address: bad switch, unsigned");
3869 *bytes_read
= cu_header
->addr_size
;
3873 /* Read the initial length from a section. The (draft) DWARF 3
3874 specification allows the initial length to take up either 4 bytes
3875 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
3876 bytes describe the length and all offsets will be 8 bytes in length
3879 An older, non-standard 64-bit format is also handled by this
3880 function. The older format in question stores the initial length
3881 as an 8-byte quantity without an escape value. Lengths greater
3882 than 2^32 aren't very common which means that the initial 4 bytes
3883 is almost always zero. Since a length value of zero doesn't make
3884 sense for the 32-bit format, this initial zero can be considered to
3885 be an escape value which indicates the presence of the older 64-bit
3886 format. As written, the code can't detect (old format) lengths
3887 greater than 4GB. If it becomes necessary to handle lengths somewhat
3888 larger than 4GB, we could allow other small values (such as the
3889 non-sensical values of 1, 2, and 3) to also be used as escape values
3890 indicating the presence of the old format.
3892 The value returned via bytes_read should be used to increment
3893 the relevant pointer after calling read_initial_length().
3895 As a side effect, this function sets the fields initial_length_size
3896 and offset_size in cu_header to the values appropriate for the
3897 length field. (The format of the initial length field determines
3898 the width of file offsets to be fetched later with fetch_offset().)
3900 [ Note: read_initial_length() and read_offset() are based on the
3901 document entitled "DWARF Debugging Information Format", revision
3902 3, draft 8, dated November 19, 2001. This document was obtained
3905 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
3907 This document is only a draft and is subject to change. (So beware.)
3909 Details regarding the older, non-standard 64-bit format were
3910 determined empirically by examining 64-bit ELF files produced
3911 by the SGI toolchain on an IRIX 6.5 machine.
3913 - Kevin, July 16, 2002
3917 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
3922 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3924 if (retval
== 0xffffffff)
3926 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
3928 if (cu_header
!= NULL
)
3930 cu_header
->initial_length_size
= 12;
3931 cu_header
->offset_size
= 8;
3934 else if (retval
== 0)
3936 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
3938 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3940 if (cu_header
!= NULL
)
3942 cu_header
->initial_length_size
= 8;
3943 cu_header
->offset_size
= 8;
3949 if (cu_header
!= NULL
)
3951 cu_header
->initial_length_size
= 4;
3952 cu_header
->offset_size
= 4;
3959 /* Read an offset from the data stream. The size of the offset is
3960 given by cu_header->offset_size. */
3963 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3968 switch (cu_header
->offset_size
)
3971 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3975 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3979 internal_error (__FILE__
, __LINE__
,
3980 "read_offset: bad switch");
3987 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
3989 /* If the size of a host char is 8 bits, we can return a pointer
3990 to the buffer, otherwise we have to copy the data to a buffer
3991 allocated on the temporary obstack. */
3992 gdb_assert (HOST_CHAR_BIT
== 8);
3997 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3999 /* If the size of a host char is 8 bits, we can return a pointer
4000 to the string, otherwise we have to copy the string to a buffer
4001 allocated on the temporary obstack. */
4002 gdb_assert (HOST_CHAR_BIT
== 8);
4005 *bytes_read_ptr
= 1;
4008 *bytes_read_ptr
= strlen (buf
) + 1;
4013 read_indirect_string (bfd
*abfd
, char *buf
,
4014 const struct comp_unit_head
*cu_header
,
4015 unsigned int *bytes_read_ptr
)
4017 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4018 (int *) bytes_read_ptr
);
4020 if (dwarf_str_buffer
== NULL
)
4022 error ("DW_FORM_strp used without .debug_str section");
4025 if (str_offset
>= dwarf_str_size
)
4027 error ("DW_FORM_strp pointing outside of .debug_str section");
4030 gdb_assert (HOST_CHAR_BIT
== 8);
4031 if (dwarf_str_buffer
[str_offset
] == '\0')
4033 return dwarf_str_buffer
+ str_offset
;
4036 static unsigned long
4037 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4039 unsigned long result
;
4040 unsigned int num_read
;
4050 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4053 result
|= ((unsigned long)(byte
& 127) << shift
);
4054 if ((byte
& 128) == 0)
4060 *bytes_read_ptr
= num_read
;
4065 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4068 int i
, shift
, size
, num_read
;
4078 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4081 result
|= ((long)(byte
& 127) << shift
);
4083 if ((byte
& 128) == 0)
4088 if ((shift
< size
) && (byte
& 0x40))
4090 result
|= -(1 << shift
);
4092 *bytes_read_ptr
= num_read
;
4097 set_cu_language (unsigned int lang
)
4103 cu_language
= language_c
;
4105 case DW_LANG_C_plus_plus
:
4106 cu_language
= language_cplus
;
4108 case DW_LANG_Fortran77
:
4109 case DW_LANG_Fortran90
:
4110 case DW_LANG_Fortran95
:
4111 cu_language
= language_fortran
;
4113 case DW_LANG_Mips_Assembler
:
4114 cu_language
= language_asm
;
4117 cu_language
= language_java
;
4121 case DW_LANG_Cobol74
:
4122 case DW_LANG_Cobol85
:
4123 case DW_LANG_Pascal83
:
4124 case DW_LANG_Modula2
:
4126 cu_language
= language_unknown
;
4129 cu_language_defn
= language_def (cu_language
);
4132 /* Return the named attribute or NULL if not there. */
4134 static struct attribute
*
4135 dwarf_attr (struct die_info
*die
, unsigned int name
)
4138 struct attribute
*spec
= NULL
;
4140 for (i
= 0; i
< die
->num_attrs
; ++i
)
4142 if (die
->attrs
[i
].name
== name
)
4144 return &die
->attrs
[i
];
4146 if (die
->attrs
[i
].name
== DW_AT_specification
4147 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4148 spec
= &die
->attrs
[i
];
4152 struct die_info
*ref_die
=
4153 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4156 return dwarf_attr (ref_die
, name
);
4163 die_is_declaration (struct die_info
*die
)
4165 return (dwarf_attr (die
, DW_AT_declaration
)
4166 && ! dwarf_attr (die
, DW_AT_specification
));
4170 /* Free the line_header structure *LH, and any arrays and strings it
4173 free_line_header (struct line_header
*lh
)
4175 if (lh
->standard_opcode_lengths
)
4176 xfree (lh
->standard_opcode_lengths
);
4178 /* Remember that all the lh->file_names[i].name pointers are
4179 pointers into debug_line_buffer, and don't need to be freed. */
4181 xfree (lh
->file_names
);
4183 /* Similarly for the include directory names. */
4184 if (lh
->include_dirs
)
4185 xfree (lh
->include_dirs
);
4191 /* Add an entry to LH's include directory table. */
4193 add_include_dir (struct line_header
*lh
, char *include_dir
)
4195 /* Grow the array if necessary. */
4196 if (lh
->include_dirs_size
== 0)
4198 lh
->include_dirs_size
= 1; /* for testing */
4199 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4200 * sizeof (*lh
->include_dirs
));
4202 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4204 lh
->include_dirs_size
*= 2;
4205 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4206 (lh
->include_dirs_size
4207 * sizeof (*lh
->include_dirs
)));
4210 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4214 /* Add an entry to LH's file name table. */
4216 add_file_name (struct line_header
*lh
,
4218 unsigned int dir_index
,
4219 unsigned int mod_time
,
4220 unsigned int length
)
4222 struct file_entry
*fe
;
4224 /* Grow the array if necessary. */
4225 if (lh
->file_names_size
== 0)
4227 lh
->file_names_size
= 1; /* for testing */
4228 lh
->file_names
= xmalloc (lh
->file_names_size
4229 * sizeof (*lh
->file_names
));
4231 else if (lh
->num_file_names
>= lh
->file_names_size
)
4233 lh
->file_names_size
*= 2;
4234 lh
->file_names
= xrealloc (lh
->file_names
,
4235 (lh
->file_names_size
4236 * sizeof (*lh
->file_names
)));
4239 fe
= &lh
->file_names
[lh
->num_file_names
++];
4241 fe
->dir_index
= dir_index
;
4242 fe
->mod_time
= mod_time
;
4243 fe
->length
= length
;
4247 /* Read the statement program header starting at OFFSET in
4248 dwarf_line_buffer, according to the endianness of ABFD. Return a
4249 pointer to a struct line_header, allocated using xmalloc.
4251 NOTE: the strings in the include directory and file name tables of
4252 the returned object point into debug_line_buffer, and must not be
4254 static struct line_header
*
4255 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4256 const struct comp_unit_head
*cu_header
)
4258 struct cleanup
*back_to
;
4259 struct line_header
*lh
;
4263 char *cur_dir
, *cur_file
;
4265 if (dwarf_line_buffer
== NULL
)
4267 complain (&dwarf2_missing_line_number_section
);
4271 /* Make sure that at least there's room for the total_length field. That
4272 could be 12 bytes long, but we're just going to fudge that. */
4273 if (offset
+ 4 >= dwarf_line_size
)
4275 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4279 lh
= xmalloc (sizeof (*lh
));
4280 memset (lh
, 0, sizeof (*lh
));
4281 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4284 line_ptr
= dwarf_line_buffer
+ offset
;
4286 /* read in the header */
4287 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4288 line_ptr
+= bytes_read
;
4289 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4291 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4294 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4295 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4297 lh
->header_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
4298 line_ptr
+= bytes_read
;
4299 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4301 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4303 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4305 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4307 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4309 lh
->standard_opcode_lengths
4310 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4312 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4313 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4315 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4319 /* Read directory table */
4320 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4322 line_ptr
+= bytes_read
;
4323 add_include_dir (lh
, cur_dir
);
4325 line_ptr
+= bytes_read
;
4327 /* Read file name table */
4328 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4330 unsigned int dir_index
, mod_time
, length
;
4332 line_ptr
+= bytes_read
;
4333 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4334 line_ptr
+= bytes_read
;
4335 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4336 line_ptr
+= bytes_read
;
4337 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4338 line_ptr
+= bytes_read
;
4340 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4342 line_ptr
+= bytes_read
;
4343 lh
->statement_program_start
= line_ptr
;
4345 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4346 complain (&dwarf2_line_header_too_long
);
4348 discard_cleanups (back_to
);
4352 /* This function exists to work around a bug in certain compilers
4353 (particularly GCC 2.95), in which the first line number marker of a
4354 function does not show up until after the prologue, right before
4355 the second line number marker. This function shifts ADDRESS down
4356 to the beginning of the function if necessary, and is called on
4357 addresses passed to record_line. */
4360 check_cu_functions (CORE_ADDR address
)
4362 struct function_range
*fn
;
4364 /* Find the function_range containing address. */
4369 cu_cached_fn
= cu_first_fn
;
4373 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4379 while (fn
&& fn
!= cu_cached_fn
)
4380 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4390 if (address
!= fn
->lowpc
)
4391 complain (&dwarf2_misplaced_line_number
,
4392 (unsigned long) address
, fn
->name
);
4397 /* Decode the line number information for the compilation unit whose
4398 line number info is at OFFSET in the .debug_line section.
4399 The compilation directory of the file is passed in COMP_DIR. */
4402 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
4403 const struct comp_unit_head
*cu_header
)
4407 unsigned int i
, bytes_read
;
4409 unsigned char op_code
, extended_op
, adj_opcode
;
4411 line_ptr
= lh
->statement_program_start
;
4412 line_end
= lh
->statement_program_end
;
4414 /* Read the statement sequences until there's nothing left. */
4415 while (line_ptr
< line_end
)
4417 /* state machine registers */
4418 CORE_ADDR address
= 0;
4419 unsigned int file
= 1;
4420 unsigned int line
= 1;
4421 unsigned int column
= 0;
4422 int is_stmt
= lh
->default_is_stmt
;
4423 int basic_block
= 0;
4424 int end_sequence
= 0;
4426 /* Start a subfile for the current file of the state machine. */
4427 if (lh
->num_file_names
>= file
)
4429 /* lh->include_dirs and lh->file_names are 0-based, but the
4430 directory and file name numbers in the statement program
4432 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
4435 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4438 dwarf2_start_subfile (fe
->name
, dir
);
4441 /* Decode the table. */
4442 while (!end_sequence
)
4444 op_code
= read_1_byte (abfd
, line_ptr
);
4447 if (op_code
>= lh
->opcode_base
)
4448 { /* Special operand. */
4449 adj_opcode
= op_code
- lh
->opcode_base
;
4450 address
+= (adj_opcode
/ lh
->line_range
)
4451 * lh
->minimum_instruction_length
;
4452 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
4453 /* append row to matrix using current values */
4454 address
= check_cu_functions (address
);
4455 record_line (current_subfile
, line
, address
);
4458 else switch (op_code
)
4460 case DW_LNS_extended_op
:
4461 line_ptr
+= 1; /* ignore length */
4462 extended_op
= read_1_byte (abfd
, line_ptr
);
4464 switch (extended_op
)
4466 case DW_LNE_end_sequence
:
4468 record_line (current_subfile
, 0, address
);
4470 case DW_LNE_set_address
:
4471 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4472 line_ptr
+= bytes_read
;
4473 address
+= baseaddr
;
4475 case DW_LNE_define_file
:
4478 unsigned int dir_index
, mod_time
, length
;
4480 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
4481 line_ptr
+= bytes_read
;
4483 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4484 line_ptr
+= bytes_read
;
4486 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4487 line_ptr
+= bytes_read
;
4489 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4490 line_ptr
+= bytes_read
;
4491 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4495 complain (&dwarf2_mangled_line_number_section
);
4500 address
= check_cu_functions (address
);
4501 record_line (current_subfile
, line
, address
);
4504 case DW_LNS_advance_pc
:
4505 address
+= lh
->minimum_instruction_length
4506 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4507 line_ptr
+= bytes_read
;
4509 case DW_LNS_advance_line
:
4510 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4511 line_ptr
+= bytes_read
;
4513 case DW_LNS_set_file
:
4515 /* lh->include_dirs and lh->file_names are 0-based,
4516 but the directory and file name numbers in the
4517 statement program are 1-based. */
4518 struct file_entry
*fe
;
4520 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4521 line_ptr
+= bytes_read
;
4522 fe
= &lh
->file_names
[file
- 1];
4524 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4527 dwarf2_start_subfile (fe
->name
, dir
);
4530 case DW_LNS_set_column
:
4531 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4532 line_ptr
+= bytes_read
;
4534 case DW_LNS_negate_stmt
:
4535 is_stmt
= (!is_stmt
);
4537 case DW_LNS_set_basic_block
:
4540 /* Add to the address register of the state machine the
4541 address increment value corresponding to special opcode
4542 255. Ie, this value is scaled by the minimum instruction
4543 length since special opcode 255 would have scaled the
4545 case DW_LNS_const_add_pc
:
4546 address
+= (lh
->minimum_instruction_length
4547 * ((255 - lh
->opcode_base
) / lh
->line_range
));
4549 case DW_LNS_fixed_advance_pc
:
4550 address
+= read_2_bytes (abfd
, line_ptr
);
4554 { /* Unknown standard opcode, ignore it. */
4556 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
4558 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4559 line_ptr
+= bytes_read
;
4567 /* Start a subfile for DWARF. FILENAME is the name of the file and
4568 DIRNAME the name of the source directory which contains FILENAME
4569 or NULL if not known.
4570 This routine tries to keep line numbers from identical absolute and
4571 relative file names in a common subfile.
4573 Using the `list' example from the GDB testsuite, which resides in
4574 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4575 of /srcdir/list0.c yields the following debugging information for list0.c:
4577 DW_AT_name: /srcdir/list0.c
4578 DW_AT_comp_dir: /compdir
4579 files.files[0].name: list0.h
4580 files.files[0].dir: /srcdir
4581 files.files[1].name: list0.c
4582 files.files[1].dir: /srcdir
4584 The line number information for list0.c has to end up in a single
4585 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4588 dwarf2_start_subfile (char *filename
, char *dirname
)
4590 /* If the filename isn't absolute, try to match an existing subfile
4591 with the full pathname. */
4593 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4595 struct subfile
*subfile
;
4596 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4598 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4600 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4602 current_subfile
= subfile
;
4609 start_subfile (filename
, dirname
);
4612 /* Given a pointer to a DWARF information entry, figure out if we need
4613 to make a symbol table entry for it, and if so, create a new entry
4614 and return a pointer to it.
4615 If TYPE is NULL, determine symbol type from the die, otherwise
4616 used the passed type. */
4618 static struct symbol
*
4619 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4620 const struct comp_unit_head
*cu_header
)
4622 struct symbol
*sym
= NULL
;
4624 struct attribute
*attr
= NULL
;
4625 struct attribute
*attr2
= NULL
;
4628 name
= dwarf2_linkage_name (die
);
4631 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4632 sizeof (struct symbol
));
4633 OBJSTAT (objfile
, n_syms
++);
4634 memset (sym
, 0, sizeof (struct symbol
));
4635 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4636 &objfile
->symbol_obstack
);
4638 /* Default assumptions.
4639 Use the passed type or decode it from the die. */
4640 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4641 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4643 SYMBOL_TYPE (sym
) = type
;
4645 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4646 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4649 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4652 /* If this symbol is from a C++ compilation, then attempt to
4653 cache the demangled form for future reference. This is a
4654 typical time versus space tradeoff, that was decided in favor
4655 of time because it sped up C++ symbol lookups by a factor of
4658 SYMBOL_LANGUAGE (sym
) = cu_language
;
4659 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4663 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4666 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4668 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4670 case DW_TAG_subprogram
:
4671 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4673 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4674 attr2
= dwarf_attr (die
, DW_AT_external
);
4675 if (attr2
&& (DW_UNSND (attr2
) != 0))
4677 add_symbol_to_list (sym
, &global_symbols
);
4681 add_symbol_to_list (sym
, list_in_scope
);
4684 case DW_TAG_variable
:
4685 /* Compilation with minimal debug info may result in variables
4686 with missing type entries. Change the misleading `void' type
4687 to something sensible. */
4688 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4689 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4690 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4691 "<variable, no debug info>",
4693 attr
= dwarf_attr (die
, DW_AT_const_value
);
4696 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4697 attr2
= dwarf_attr (die
, DW_AT_external
);
4698 if (attr2
&& (DW_UNSND (attr2
) != 0))
4699 add_symbol_to_list (sym
, &global_symbols
);
4701 add_symbol_to_list (sym
, list_in_scope
);
4704 attr
= dwarf_attr (die
, DW_AT_location
);
4707 attr2
= dwarf_attr (die
, DW_AT_external
);
4708 if (attr2
&& (DW_UNSND (attr2
) != 0))
4710 /* Support the .debug_loc offsets */
4711 if (attr_form_is_block (attr
))
4713 SYMBOL_VALUE_ADDRESS (sym
) =
4714 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4716 else if (attr
->form
== DW_FORM_data4
4717 || attr
->form
== DW_FORM_data8
)
4719 complain (&dwarf2_complex_location_expr
);
4723 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4724 "external variable");
4726 add_symbol_to_list (sym
, &global_symbols
);
4728 /* In shared libraries the address of the variable
4729 in the location descriptor might still be relocatable,
4730 so its value could be zero.
4731 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4732 value is zero, the address of the variable will then
4733 be determined from the minimal symbol table whenever
4734 the variable is referenced. */
4735 if (SYMBOL_VALUE_ADDRESS (sym
))
4737 fixup_symbol_section (sym
, objfile
);
4738 SYMBOL_VALUE_ADDRESS (sym
) +=
4739 ANOFFSET (objfile
->section_offsets
,
4740 SYMBOL_SECTION (sym
));
4741 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4744 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4748 /* Support the .debug_loc offsets */
4749 if (attr_form_is_block (attr
))
4751 SYMBOL_VALUE (sym
) = addr
=
4752 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4754 else if (attr
->form
== DW_FORM_data4
4755 || attr
->form
== DW_FORM_data8
)
4757 complain (&dwarf2_complex_location_expr
);
4761 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4762 "external variable");
4765 add_symbol_to_list (sym
, list_in_scope
);
4768 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4772 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4773 SYMBOL_VALUE (sym
) =
4774 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4778 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4779 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4783 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4787 fixup_symbol_section (sym
, objfile
);
4788 SYMBOL_VALUE_ADDRESS (sym
) =
4789 addr
+ ANOFFSET (objfile
->section_offsets
,
4790 SYMBOL_SECTION (sym
));
4791 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4797 /* We do not know the address of this symbol.
4798 If it is an external symbol and we have type information
4799 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4800 The address of the variable will then be determined from
4801 the minimal symbol table whenever the variable is
4803 attr2
= dwarf_attr (die
, DW_AT_external
);
4804 if (attr2
&& (DW_UNSND (attr2
) != 0)
4805 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4807 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4808 add_symbol_to_list (sym
, &global_symbols
);
4812 case DW_TAG_formal_parameter
:
4813 attr
= dwarf_attr (die
, DW_AT_location
);
4816 SYMBOL_VALUE (sym
) =
4817 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4820 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4821 SYMBOL_VALUE (sym
) =
4822 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4828 if (basereg
!= frame_base_reg
)
4829 complain (&dwarf2_complex_location_expr
);
4830 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
4834 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4835 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4840 SYMBOL_CLASS (sym
) = LOC_ARG
;
4843 attr
= dwarf_attr (die
, DW_AT_const_value
);
4846 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4848 add_symbol_to_list (sym
, list_in_scope
);
4850 case DW_TAG_unspecified_parameters
:
4851 /* From varargs functions; gdb doesn't seem to have any
4852 interest in this information, so just ignore it for now.
4855 case DW_TAG_class_type
:
4856 case DW_TAG_structure_type
:
4857 case DW_TAG_union_type
:
4858 case DW_TAG_enumeration_type
:
4859 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4860 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
4861 add_symbol_to_list (sym
, list_in_scope
);
4863 /* The semantics of C++ state that "struct foo { ... }" also
4864 defines a typedef for "foo". Synthesize a typedef symbol so
4865 that "ptype foo" works as expected. */
4866 if (cu_language
== language_cplus
)
4868 struct symbol
*typedef_sym
= (struct symbol
*)
4869 obstack_alloc (&objfile
->symbol_obstack
,
4870 sizeof (struct symbol
));
4871 *typedef_sym
= *sym
;
4872 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
4873 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
4874 TYPE_NAME (SYMBOL_TYPE (sym
)) =
4875 obsavestring (SYMBOL_NAME (sym
),
4876 strlen (SYMBOL_NAME (sym
)),
4877 &objfile
->type_obstack
);
4878 add_symbol_to_list (typedef_sym
, list_in_scope
);
4881 case DW_TAG_typedef
:
4882 case DW_TAG_base_type
:
4883 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4884 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4885 add_symbol_to_list (sym
, list_in_scope
);
4887 case DW_TAG_enumerator
:
4888 attr
= dwarf_attr (die
, DW_AT_const_value
);
4891 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4893 add_symbol_to_list (sym
, list_in_scope
);
4896 /* Not a tag we recognize. Hopefully we aren't processing
4897 trash data, but since we must specifically ignore things
4898 we don't recognize, there is nothing else we should do at
4900 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
4907 /* Copy constant value from an attribute to a symbol. */
4910 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
4911 struct objfile
*objfile
,
4912 const struct comp_unit_head
*cu_header
)
4914 struct dwarf_block
*blk
;
4919 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
4920 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4921 cu_header
->addr_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4922 SYMBOL_VALUE_BYTES (sym
) = (char *)
4923 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
4924 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
4926 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4928 case DW_FORM_block1
:
4929 case DW_FORM_block2
:
4930 case DW_FORM_block4
:
4932 blk
= DW_BLOCK (attr
);
4933 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
4934 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4935 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4936 SYMBOL_VALUE_BYTES (sym
) = (char *)
4937 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
4938 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
4939 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4942 /* The DW_AT_const_value attributes are supposed to carry the
4943 symbol's value "represented as it would be on the target
4944 architecture." By the time we get here, it's already been
4945 converted to host endianness, so we just need to sign- or
4946 zero-extend it as appropriate. */
4948 dwarf2_const_value_data (attr
, sym
, 8);
4951 dwarf2_const_value_data (attr
, sym
, 16);
4954 dwarf2_const_value_data (attr
, sym
, 32);
4957 dwarf2_const_value_data (attr
, sym
, 64);
4961 SYMBOL_VALUE (sym
) = DW_SND (attr
);
4962 SYMBOL_CLASS (sym
) = LOC_CONST
;
4966 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
4967 SYMBOL_CLASS (sym
) = LOC_CONST
;
4971 complain (&dwarf2_unsupported_const_value_attr
,
4972 dwarf_form_name (attr
->form
));
4973 SYMBOL_VALUE (sym
) = 0;
4974 SYMBOL_CLASS (sym
) = LOC_CONST
;
4980 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
4981 or zero-extend it as appropriate for the symbol's type. */
4983 dwarf2_const_value_data (struct attribute
*attr
,
4987 LONGEST l
= DW_UNSND (attr
);
4989 if (bits
< sizeof (l
) * 8)
4991 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
4992 l
&= ((LONGEST
) 1 << bits
) - 1;
4994 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
4997 SYMBOL_VALUE (sym
) = l
;
4998 SYMBOL_CLASS (sym
) = LOC_CONST
;
5002 /* Return the type of the die in question using its DW_AT_type attribute. */
5004 static struct type
*
5005 die_type (struct die_info
*die
, struct objfile
*objfile
,
5006 const struct comp_unit_head
*cu_header
)
5009 struct attribute
*type_attr
;
5010 struct die_info
*type_die
;
5013 type_attr
= dwarf_attr (die
, DW_AT_type
);
5016 /* A missing DW_AT_type represents a void type. */
5017 return dwarf2_fundamental_type (objfile
, FT_VOID
);
5021 ref
= dwarf2_get_ref_die_offset (type_attr
);
5022 type_die
= follow_die_ref (ref
);
5025 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5029 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5032 dump_die (type_die
);
5033 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
5038 /* Return the containing type of the die in question using its
5039 DW_AT_containing_type attribute. */
5041 static struct type
*
5042 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
5043 const struct comp_unit_head
*cu_header
)
5045 struct type
*type
= NULL
;
5046 struct attribute
*type_attr
;
5047 struct die_info
*type_die
= NULL
;
5050 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5053 ref
= dwarf2_get_ref_die_offset (type_attr
);
5054 type_die
= follow_die_ref (ref
);
5057 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5060 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5065 dump_die (type_die
);
5066 error ("Dwarf Error: Problem turning containing type into gdb type.");
5072 static struct type
*
5073 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
5075 struct die_info
*die
;
5078 die
= follow_die_ref (offset
);
5081 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5084 type
= tag_type_to_type (die
, objfile
);
5089 static struct type
*
5090 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
5091 const struct comp_unit_head
*cu_header
)
5099 read_type_die (die
, objfile
, cu_header
);
5103 error ("Dwarf Error: Cannot find type of die.");
5110 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
5111 const struct comp_unit_head
*cu_header
)
5115 case DW_TAG_class_type
:
5116 case DW_TAG_structure_type
:
5117 case DW_TAG_union_type
:
5118 read_structure_scope (die
, objfile
, cu_header
);
5120 case DW_TAG_enumeration_type
:
5121 read_enumeration (die
, objfile
, cu_header
);
5123 case DW_TAG_subprogram
:
5124 case DW_TAG_subroutine_type
:
5125 read_subroutine_type (die
, objfile
, cu_header
);
5127 case DW_TAG_array_type
:
5128 read_array_type (die
, objfile
, cu_header
);
5130 case DW_TAG_pointer_type
:
5131 read_tag_pointer_type (die
, objfile
, cu_header
);
5133 case DW_TAG_ptr_to_member_type
:
5134 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
5136 case DW_TAG_reference_type
:
5137 read_tag_reference_type (die
, objfile
, cu_header
);
5139 case DW_TAG_const_type
:
5140 read_tag_const_type (die
, objfile
, cu_header
);
5142 case DW_TAG_volatile_type
:
5143 read_tag_volatile_type (die
, objfile
, cu_header
);
5145 case DW_TAG_string_type
:
5146 read_tag_string_type (die
, objfile
);
5148 case DW_TAG_typedef
:
5149 read_typedef (die
, objfile
, cu_header
);
5151 case DW_TAG_base_type
:
5152 read_base_type (die
, objfile
);
5155 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
5160 static struct type
*
5161 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
5163 /* FIXME - this should not produce a new (struct type *)
5164 every time. It should cache base types. */
5168 case DW_ATE_address
:
5169 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5171 case DW_ATE_boolean
:
5172 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5174 case DW_ATE_complex_float
:
5177 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5181 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5187 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5191 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5198 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5201 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5205 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5209 case DW_ATE_signed_char
:
5210 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5212 case DW_ATE_unsigned
:
5216 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5219 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5223 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5227 case DW_ATE_unsigned_char
:
5228 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5231 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5238 copy_die (struct die_info
*old_die
)
5240 struct die_info
*new_die
;
5243 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5244 memset (new_die
, 0, sizeof (struct die_info
));
5246 new_die
->tag
= old_die
->tag
;
5247 new_die
->has_children
= old_die
->has_children
;
5248 new_die
->abbrev
= old_die
->abbrev
;
5249 new_die
->offset
= old_die
->offset
;
5250 new_die
->type
= NULL
;
5252 num_attrs
= old_die
->num_attrs
;
5253 new_die
->num_attrs
= num_attrs
;
5254 new_die
->attrs
= (struct attribute
*)
5255 xmalloc (num_attrs
* sizeof (struct attribute
));
5257 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5259 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5260 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5261 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5264 new_die
->next
= NULL
;
5269 /* Return sibling of die, NULL if no sibling. */
5271 static struct die_info
*
5272 sibling_die (struct die_info
*die
)
5274 int nesting_level
= 0;
5276 if (!die
->has_children
)
5278 if (die
->next
&& (die
->next
->tag
== 0))
5291 if (die
->has_children
)
5301 while (nesting_level
);
5302 if (die
&& (die
->tag
== 0))
5313 /* Get linkage name of a die, return NULL if not found. */
5316 dwarf2_linkage_name (struct die_info
*die
)
5318 struct attribute
*attr
;
5320 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5321 if (attr
&& DW_STRING (attr
))
5322 return DW_STRING (attr
);
5323 attr
= dwarf_attr (die
, DW_AT_name
);
5324 if (attr
&& DW_STRING (attr
))
5325 return DW_STRING (attr
);
5329 /* Convert a DIE tag into its string name. */
5332 dwarf_tag_name (register unsigned tag
)
5336 case DW_TAG_padding
:
5337 return "DW_TAG_padding";
5338 case DW_TAG_array_type
:
5339 return "DW_TAG_array_type";
5340 case DW_TAG_class_type
:
5341 return "DW_TAG_class_type";
5342 case DW_TAG_entry_point
:
5343 return "DW_TAG_entry_point";
5344 case DW_TAG_enumeration_type
:
5345 return "DW_TAG_enumeration_type";
5346 case DW_TAG_formal_parameter
:
5347 return "DW_TAG_formal_parameter";
5348 case DW_TAG_imported_declaration
:
5349 return "DW_TAG_imported_declaration";
5351 return "DW_TAG_label";
5352 case DW_TAG_lexical_block
:
5353 return "DW_TAG_lexical_block";
5355 return "DW_TAG_member";
5356 case DW_TAG_pointer_type
:
5357 return "DW_TAG_pointer_type";
5358 case DW_TAG_reference_type
:
5359 return "DW_TAG_reference_type";
5360 case DW_TAG_compile_unit
:
5361 return "DW_TAG_compile_unit";
5362 case DW_TAG_string_type
:
5363 return "DW_TAG_string_type";
5364 case DW_TAG_structure_type
:
5365 return "DW_TAG_structure_type";
5366 case DW_TAG_subroutine_type
:
5367 return "DW_TAG_subroutine_type";
5368 case DW_TAG_typedef
:
5369 return "DW_TAG_typedef";
5370 case DW_TAG_union_type
:
5371 return "DW_TAG_union_type";
5372 case DW_TAG_unspecified_parameters
:
5373 return "DW_TAG_unspecified_parameters";
5374 case DW_TAG_variant
:
5375 return "DW_TAG_variant";
5376 case DW_TAG_common_block
:
5377 return "DW_TAG_common_block";
5378 case DW_TAG_common_inclusion
:
5379 return "DW_TAG_common_inclusion";
5380 case DW_TAG_inheritance
:
5381 return "DW_TAG_inheritance";
5382 case DW_TAG_inlined_subroutine
:
5383 return "DW_TAG_inlined_subroutine";
5385 return "DW_TAG_module";
5386 case DW_TAG_ptr_to_member_type
:
5387 return "DW_TAG_ptr_to_member_type";
5388 case DW_TAG_set_type
:
5389 return "DW_TAG_set_type";
5390 case DW_TAG_subrange_type
:
5391 return "DW_TAG_subrange_type";
5392 case DW_TAG_with_stmt
:
5393 return "DW_TAG_with_stmt";
5394 case DW_TAG_access_declaration
:
5395 return "DW_TAG_access_declaration";
5396 case DW_TAG_base_type
:
5397 return "DW_TAG_base_type";
5398 case DW_TAG_catch_block
:
5399 return "DW_TAG_catch_block";
5400 case DW_TAG_const_type
:
5401 return "DW_TAG_const_type";
5402 case DW_TAG_constant
:
5403 return "DW_TAG_constant";
5404 case DW_TAG_enumerator
:
5405 return "DW_TAG_enumerator";
5406 case DW_TAG_file_type
:
5407 return "DW_TAG_file_type";
5409 return "DW_TAG_friend";
5410 case DW_TAG_namelist
:
5411 return "DW_TAG_namelist";
5412 case DW_TAG_namelist_item
:
5413 return "DW_TAG_namelist_item";
5414 case DW_TAG_packed_type
:
5415 return "DW_TAG_packed_type";
5416 case DW_TAG_subprogram
:
5417 return "DW_TAG_subprogram";
5418 case DW_TAG_template_type_param
:
5419 return "DW_TAG_template_type_param";
5420 case DW_TAG_template_value_param
:
5421 return "DW_TAG_template_value_param";
5422 case DW_TAG_thrown_type
:
5423 return "DW_TAG_thrown_type";
5424 case DW_TAG_try_block
:
5425 return "DW_TAG_try_block";
5426 case DW_TAG_variant_part
:
5427 return "DW_TAG_variant_part";
5428 case DW_TAG_variable
:
5429 return "DW_TAG_variable";
5430 case DW_TAG_volatile_type
:
5431 return "DW_TAG_volatile_type";
5432 case DW_TAG_MIPS_loop
:
5433 return "DW_TAG_MIPS_loop";
5434 case DW_TAG_format_label
:
5435 return "DW_TAG_format_label";
5436 case DW_TAG_function_template
:
5437 return "DW_TAG_function_template";
5438 case DW_TAG_class_template
:
5439 return "DW_TAG_class_template";
5441 return "DW_TAG_<unknown>";
5445 /* Convert a DWARF attribute code into its string name. */
5448 dwarf_attr_name (register unsigned attr
)
5453 return "DW_AT_sibling";
5454 case DW_AT_location
:
5455 return "DW_AT_location";
5457 return "DW_AT_name";
5458 case DW_AT_ordering
:
5459 return "DW_AT_ordering";
5460 case DW_AT_subscr_data
:
5461 return "DW_AT_subscr_data";
5462 case DW_AT_byte_size
:
5463 return "DW_AT_byte_size";
5464 case DW_AT_bit_offset
:
5465 return "DW_AT_bit_offset";
5466 case DW_AT_bit_size
:
5467 return "DW_AT_bit_size";
5468 case DW_AT_element_list
:
5469 return "DW_AT_element_list";
5470 case DW_AT_stmt_list
:
5471 return "DW_AT_stmt_list";
5473 return "DW_AT_low_pc";
5475 return "DW_AT_high_pc";
5476 case DW_AT_language
:
5477 return "DW_AT_language";
5479 return "DW_AT_member";
5481 return "DW_AT_discr";
5482 case DW_AT_discr_value
:
5483 return "DW_AT_discr_value";
5484 case DW_AT_visibility
:
5485 return "DW_AT_visibility";
5487 return "DW_AT_import";
5488 case DW_AT_string_length
:
5489 return "DW_AT_string_length";
5490 case DW_AT_common_reference
:
5491 return "DW_AT_common_reference";
5492 case DW_AT_comp_dir
:
5493 return "DW_AT_comp_dir";
5494 case DW_AT_const_value
:
5495 return "DW_AT_const_value";
5496 case DW_AT_containing_type
:
5497 return "DW_AT_containing_type";
5498 case DW_AT_default_value
:
5499 return "DW_AT_default_value";
5501 return "DW_AT_inline";
5502 case DW_AT_is_optional
:
5503 return "DW_AT_is_optional";
5504 case DW_AT_lower_bound
:
5505 return "DW_AT_lower_bound";
5506 case DW_AT_producer
:
5507 return "DW_AT_producer";
5508 case DW_AT_prototyped
:
5509 return "DW_AT_prototyped";
5510 case DW_AT_return_addr
:
5511 return "DW_AT_return_addr";
5512 case DW_AT_start_scope
:
5513 return "DW_AT_start_scope";
5514 case DW_AT_stride_size
:
5515 return "DW_AT_stride_size";
5516 case DW_AT_upper_bound
:
5517 return "DW_AT_upper_bound";
5518 case DW_AT_abstract_origin
:
5519 return "DW_AT_abstract_origin";
5520 case DW_AT_accessibility
:
5521 return "DW_AT_accessibility";
5522 case DW_AT_address_class
:
5523 return "DW_AT_address_class";
5524 case DW_AT_artificial
:
5525 return "DW_AT_artificial";
5526 case DW_AT_base_types
:
5527 return "DW_AT_base_types";
5528 case DW_AT_calling_convention
:
5529 return "DW_AT_calling_convention";
5531 return "DW_AT_count";
5532 case DW_AT_data_member_location
:
5533 return "DW_AT_data_member_location";
5534 case DW_AT_decl_column
:
5535 return "DW_AT_decl_column";
5536 case DW_AT_decl_file
:
5537 return "DW_AT_decl_file";
5538 case DW_AT_decl_line
:
5539 return "DW_AT_decl_line";
5540 case DW_AT_declaration
:
5541 return "DW_AT_declaration";
5542 case DW_AT_discr_list
:
5543 return "DW_AT_discr_list";
5544 case DW_AT_encoding
:
5545 return "DW_AT_encoding";
5546 case DW_AT_external
:
5547 return "DW_AT_external";
5548 case DW_AT_frame_base
:
5549 return "DW_AT_frame_base";
5551 return "DW_AT_friend";
5552 case DW_AT_identifier_case
:
5553 return "DW_AT_identifier_case";
5554 case DW_AT_macro_info
:
5555 return "DW_AT_macro_info";
5556 case DW_AT_namelist_items
:
5557 return "DW_AT_namelist_items";
5558 case DW_AT_priority
:
5559 return "DW_AT_priority";
5561 return "DW_AT_segment";
5562 case DW_AT_specification
:
5563 return "DW_AT_specification";
5564 case DW_AT_static_link
:
5565 return "DW_AT_static_link";
5567 return "DW_AT_type";
5568 case DW_AT_use_location
:
5569 return "DW_AT_use_location";
5570 case DW_AT_variable_parameter
:
5571 return "DW_AT_variable_parameter";
5572 case DW_AT_virtuality
:
5573 return "DW_AT_virtuality";
5574 case DW_AT_vtable_elem_location
:
5575 return "DW_AT_vtable_elem_location";
5578 case DW_AT_MIPS_fde
:
5579 return "DW_AT_MIPS_fde";
5580 case DW_AT_MIPS_loop_begin
:
5581 return "DW_AT_MIPS_loop_begin";
5582 case DW_AT_MIPS_tail_loop_begin
:
5583 return "DW_AT_MIPS_tail_loop_begin";
5584 case DW_AT_MIPS_epilog_begin
:
5585 return "DW_AT_MIPS_epilog_begin";
5586 case DW_AT_MIPS_loop_unroll_factor
:
5587 return "DW_AT_MIPS_loop_unroll_factor";
5588 case DW_AT_MIPS_software_pipeline_depth
:
5589 return "DW_AT_MIPS_software_pipeline_depth";
5590 case DW_AT_MIPS_linkage_name
:
5591 return "DW_AT_MIPS_linkage_name";
5594 case DW_AT_sf_names
:
5595 return "DW_AT_sf_names";
5596 case DW_AT_src_info
:
5597 return "DW_AT_src_info";
5598 case DW_AT_mac_info
:
5599 return "DW_AT_mac_info";
5600 case DW_AT_src_coords
:
5601 return "DW_AT_src_coords";
5602 case DW_AT_body_begin
:
5603 return "DW_AT_body_begin";
5604 case DW_AT_body_end
:
5605 return "DW_AT_body_end";
5606 case DW_AT_GNU_vector
:
5607 return "DW_AT_GNU_vector";
5609 return "DW_AT_<unknown>";
5613 /* Convert a DWARF value form code into its string name. */
5616 dwarf_form_name (register unsigned form
)
5621 return "DW_FORM_addr";
5622 case DW_FORM_block2
:
5623 return "DW_FORM_block2";
5624 case DW_FORM_block4
:
5625 return "DW_FORM_block4";
5627 return "DW_FORM_data2";
5629 return "DW_FORM_data4";
5631 return "DW_FORM_data8";
5632 case DW_FORM_string
:
5633 return "DW_FORM_string";
5635 return "DW_FORM_block";
5636 case DW_FORM_block1
:
5637 return "DW_FORM_block1";
5639 return "DW_FORM_data1";
5641 return "DW_FORM_flag";
5643 return "DW_FORM_sdata";
5645 return "DW_FORM_strp";
5647 return "DW_FORM_udata";
5648 case DW_FORM_ref_addr
:
5649 return "DW_FORM_ref_addr";
5651 return "DW_FORM_ref1";
5653 return "DW_FORM_ref2";
5655 return "DW_FORM_ref4";
5657 return "DW_FORM_ref8";
5658 case DW_FORM_ref_udata
:
5659 return "DW_FORM_ref_udata";
5660 case DW_FORM_indirect
:
5661 return "DW_FORM_indirect";
5663 return "DW_FORM_<unknown>";
5667 /* Convert a DWARF stack opcode into its string name. */
5670 dwarf_stack_op_name (register unsigned op
)
5675 return "DW_OP_addr";
5677 return "DW_OP_deref";
5679 return "DW_OP_const1u";
5681 return "DW_OP_const1s";
5683 return "DW_OP_const2u";
5685 return "DW_OP_const2s";
5687 return "DW_OP_const4u";
5689 return "DW_OP_const4s";
5691 return "DW_OP_const8u";
5693 return "DW_OP_const8s";
5695 return "DW_OP_constu";
5697 return "DW_OP_consts";
5701 return "DW_OP_drop";
5703 return "DW_OP_over";
5705 return "DW_OP_pick";
5707 return "DW_OP_swap";
5711 return "DW_OP_xderef";
5719 return "DW_OP_minus";
5731 return "DW_OP_plus";
5732 case DW_OP_plus_uconst
:
5733 return "DW_OP_plus_uconst";
5739 return "DW_OP_shra";
5757 return "DW_OP_skip";
5759 return "DW_OP_lit0";
5761 return "DW_OP_lit1";
5763 return "DW_OP_lit2";
5765 return "DW_OP_lit3";
5767 return "DW_OP_lit4";
5769 return "DW_OP_lit5";
5771 return "DW_OP_lit6";
5773 return "DW_OP_lit7";
5775 return "DW_OP_lit8";
5777 return "DW_OP_lit9";
5779 return "DW_OP_lit10";
5781 return "DW_OP_lit11";
5783 return "DW_OP_lit12";
5785 return "DW_OP_lit13";
5787 return "DW_OP_lit14";
5789 return "DW_OP_lit15";
5791 return "DW_OP_lit16";
5793 return "DW_OP_lit17";
5795 return "DW_OP_lit18";
5797 return "DW_OP_lit19";
5799 return "DW_OP_lit20";
5801 return "DW_OP_lit21";
5803 return "DW_OP_lit22";
5805 return "DW_OP_lit23";
5807 return "DW_OP_lit24";
5809 return "DW_OP_lit25";
5811 return "DW_OP_lit26";
5813 return "DW_OP_lit27";
5815 return "DW_OP_lit28";
5817 return "DW_OP_lit29";
5819 return "DW_OP_lit30";
5821 return "DW_OP_lit31";
5823 return "DW_OP_reg0";
5825 return "DW_OP_reg1";
5827 return "DW_OP_reg2";
5829 return "DW_OP_reg3";
5831 return "DW_OP_reg4";
5833 return "DW_OP_reg5";
5835 return "DW_OP_reg6";
5837 return "DW_OP_reg7";
5839 return "DW_OP_reg8";
5841 return "DW_OP_reg9";
5843 return "DW_OP_reg10";
5845 return "DW_OP_reg11";
5847 return "DW_OP_reg12";
5849 return "DW_OP_reg13";
5851 return "DW_OP_reg14";
5853 return "DW_OP_reg15";
5855 return "DW_OP_reg16";
5857 return "DW_OP_reg17";
5859 return "DW_OP_reg18";
5861 return "DW_OP_reg19";
5863 return "DW_OP_reg20";
5865 return "DW_OP_reg21";
5867 return "DW_OP_reg22";
5869 return "DW_OP_reg23";
5871 return "DW_OP_reg24";
5873 return "DW_OP_reg25";
5875 return "DW_OP_reg26";
5877 return "DW_OP_reg27";
5879 return "DW_OP_reg28";
5881 return "DW_OP_reg29";
5883 return "DW_OP_reg30";
5885 return "DW_OP_reg31";
5887 return "DW_OP_breg0";
5889 return "DW_OP_breg1";
5891 return "DW_OP_breg2";
5893 return "DW_OP_breg3";
5895 return "DW_OP_breg4";
5897 return "DW_OP_breg5";
5899 return "DW_OP_breg6";
5901 return "DW_OP_breg7";
5903 return "DW_OP_breg8";
5905 return "DW_OP_breg9";
5907 return "DW_OP_breg10";
5909 return "DW_OP_breg11";
5911 return "DW_OP_breg12";
5913 return "DW_OP_breg13";
5915 return "DW_OP_breg14";
5917 return "DW_OP_breg15";
5919 return "DW_OP_breg16";
5921 return "DW_OP_breg17";
5923 return "DW_OP_breg18";
5925 return "DW_OP_breg19";
5927 return "DW_OP_breg20";
5929 return "DW_OP_breg21";
5931 return "DW_OP_breg22";
5933 return "DW_OP_breg23";
5935 return "DW_OP_breg24";
5937 return "DW_OP_breg25";
5939 return "DW_OP_breg26";
5941 return "DW_OP_breg27";
5943 return "DW_OP_breg28";
5945 return "DW_OP_breg29";
5947 return "DW_OP_breg30";
5949 return "DW_OP_breg31";
5951 return "DW_OP_regx";
5953 return "DW_OP_fbreg";
5955 return "DW_OP_bregx";
5957 return "DW_OP_piece";
5958 case DW_OP_deref_size
:
5959 return "DW_OP_deref_size";
5960 case DW_OP_xderef_size
:
5961 return "DW_OP_xderef_size";
5965 return "OP_<unknown>";
5970 dwarf_bool_name (unsigned mybool
)
5978 /* Convert a DWARF type code into its string name. */
5981 dwarf_type_encoding_name (register unsigned enc
)
5985 case DW_ATE_address
:
5986 return "DW_ATE_address";
5987 case DW_ATE_boolean
:
5988 return "DW_ATE_boolean";
5989 case DW_ATE_complex_float
:
5990 return "DW_ATE_complex_float";
5992 return "DW_ATE_float";
5994 return "DW_ATE_signed";
5995 case DW_ATE_signed_char
:
5996 return "DW_ATE_signed_char";
5997 case DW_ATE_unsigned
:
5998 return "DW_ATE_unsigned";
5999 case DW_ATE_unsigned_char
:
6000 return "DW_ATE_unsigned_char";
6002 return "DW_ATE_<unknown>";
6006 /* Convert a DWARF call frame info operation to its string name. */
6010 dwarf_cfi_name (register unsigned cfi_opc
)
6014 case DW_CFA_advance_loc
:
6015 return "DW_CFA_advance_loc";
6017 return "DW_CFA_offset";
6018 case DW_CFA_restore
:
6019 return "DW_CFA_restore";
6021 return "DW_CFA_nop";
6022 case DW_CFA_set_loc
:
6023 return "DW_CFA_set_loc";
6024 case DW_CFA_advance_loc1
:
6025 return "DW_CFA_advance_loc1";
6026 case DW_CFA_advance_loc2
:
6027 return "DW_CFA_advance_loc2";
6028 case DW_CFA_advance_loc4
:
6029 return "DW_CFA_advance_loc4";
6030 case DW_CFA_offset_extended
:
6031 return "DW_CFA_offset_extended";
6032 case DW_CFA_restore_extended
:
6033 return "DW_CFA_restore_extended";
6034 case DW_CFA_undefined
:
6035 return "DW_CFA_undefined";
6036 case DW_CFA_same_value
:
6037 return "DW_CFA_same_value";
6038 case DW_CFA_register
:
6039 return "DW_CFA_register";
6040 case DW_CFA_remember_state
:
6041 return "DW_CFA_remember_state";
6042 case DW_CFA_restore_state
:
6043 return "DW_CFA_restore_state";
6044 case DW_CFA_def_cfa
:
6045 return "DW_CFA_def_cfa";
6046 case DW_CFA_def_cfa_register
:
6047 return "DW_CFA_def_cfa_register";
6048 case DW_CFA_def_cfa_offset
:
6049 return "DW_CFA_def_cfa_offset";
6052 case DW_CFA_def_cfa_expression
:
6053 return "DW_CFA_def_cfa_expression";
6054 case DW_CFA_expression
:
6055 return "DW_CFA_expression";
6056 case DW_CFA_offset_extended_sf
:
6057 return "DW_CFA_offset_extended_sf";
6058 case DW_CFA_def_cfa_sf
:
6059 return "DW_CFA_def_cfa_sf";
6060 case DW_CFA_def_cfa_offset_sf
:
6061 return "DW_CFA_def_cfa_offset_sf";
6063 /* SGI/MIPS specific */
6064 case DW_CFA_MIPS_advance_loc8
:
6065 return "DW_CFA_MIPS_advance_loc8";
6067 /* GNU extensions */
6068 case DW_CFA_GNU_window_save
:
6069 return "DW_CFA_GNU_window_save";
6070 case DW_CFA_GNU_args_size
:
6071 return "DW_CFA_GNU_args_size";
6072 case DW_CFA_GNU_negative_offset_extended
:
6073 return "DW_CFA_GNU_negative_offset_extended";
6076 return "DW_CFA_<unknown>";
6082 dump_die (struct die_info
*die
)
6086 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6087 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6088 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6089 dwarf_bool_name (die
->has_children
));
6091 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6092 for (i
= 0; i
< die
->num_attrs
; ++i
)
6094 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6095 dwarf_attr_name (die
->attrs
[i
].name
),
6096 dwarf_form_name (die
->attrs
[i
].form
));
6097 switch (die
->attrs
[i
].form
)
6099 case DW_FORM_ref_addr
:
6101 fprintf_unfiltered (gdb_stderr
, "address: ");
6102 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6104 case DW_FORM_block2
:
6105 case DW_FORM_block4
:
6107 case DW_FORM_block1
:
6108 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6119 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6121 case DW_FORM_string
:
6123 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6124 DW_STRING (&die
->attrs
[i
])
6125 ? DW_STRING (&die
->attrs
[i
]) : "");
6128 if (DW_UNSND (&die
->attrs
[i
]))
6129 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6131 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6133 case DW_FORM_indirect
:
6134 /* the reader will have reduced the indirect form to
6135 the "base form" so this form should not occur */
6136 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6139 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6140 die
->attrs
[i
].form
);
6142 fprintf_unfiltered (gdb_stderr
, "\n");
6147 dump_die_list (struct die_info
*die
)
6157 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6160 struct die_info
*old
;
6162 h
= (offset
% REF_HASH_SIZE
);
6163 old
= die_ref_table
[h
];
6164 die
->next_ref
= old
;
6165 die_ref_table
[h
] = die
;
6170 dwarf2_empty_hash_tables (void)
6172 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6176 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6178 unsigned int result
= 0;
6182 case DW_FORM_ref_addr
:
6183 result
= DW_ADDR (attr
);
6189 case DW_FORM_ref_udata
:
6190 result
= cu_header_offset
+ DW_UNSND (attr
);
6193 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
6198 static struct die_info
*
6199 follow_die_ref (unsigned int offset
)
6201 struct die_info
*die
;
6204 h
= (offset
% REF_HASH_SIZE
);
6205 die
= die_ref_table
[h
];
6208 if (die
->offset
== offset
)
6212 die
= die
->next_ref
;
6217 static struct type
*
6218 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6220 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6222 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
6226 /* Look for this particular type in the fundamental type vector. If
6227 one is not found, create and install one appropriate for the
6228 current language and the current target machine. */
6230 if (ftypes
[typeid] == NULL
)
6232 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6235 return (ftypes
[typeid]);
6238 /* Decode simple location descriptions.
6239 Given a pointer to a dwarf block that defines a location, compute
6240 the location and return the value.
6242 FIXME: This is a kludge until we figure out a better
6243 way to handle the location descriptions.
6244 Gdb's design does not mesh well with the DWARF2 notion of a location
6245 computing interpreter, which is a shame because the flexibility goes unused.
6246 FIXME: Implement more operations as necessary.
6248 A location description containing no operations indicates that the
6249 object is optimized out. The global optimized_out flag is set for
6250 those, the return value is meaningless.
6252 When the result is a register number, the global isreg flag is set,
6253 otherwise it is cleared.
6255 When the result is a base register offset, the global offreg flag is set
6256 and the register number is returned in basereg, otherwise it is cleared.
6258 When the DW_OP_fbreg operation is encountered without a corresponding
6259 DW_AT_frame_base attribute, the global islocal flag is set.
6260 Hopefully the machine dependent code knows how to set up a virtual
6261 frame pointer for the local references.
6263 Note that stack[0] is unused except as a default error return.
6264 Note that stack overflow is not yet handled. */
6267 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
6268 const struct comp_unit_head
*cu_header
)
6271 int size
= blk
->size
;
6272 char *data
= blk
->data
;
6273 CORE_ADDR stack
[64];
6275 unsigned int bytes_read
, unsnd
;
6325 stack
[++stacki
] = op
- DW_OP_lit0
;
6361 stack
[++stacki
] = op
- DW_OP_reg0
;
6366 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6368 stack
[++stacki
] = unsnd
;
6404 basereg
= op
- DW_OP_breg0
;
6405 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6411 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6413 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6418 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6420 if (frame_base_reg
>= 0)
6423 basereg
= frame_base_reg
;
6424 stack
[stacki
] += frame_base_offset
;
6428 complain (&dwarf2_missing_at_frame_base
);
6434 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
6435 cu_header
, &bytes_read
);
6440 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
6445 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
6450 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
6455 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
6460 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
6465 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
6470 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
6476 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6481 stack
[stacki
+ 1] = stack
[stacki
];
6486 stack
[stacki
- 1] += stack
[stacki
];
6490 case DW_OP_plus_uconst
:
6491 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6496 stack
[stacki
- 1] -= stack
[stacki
];
6502 /* If we're not the last op, then we definitely can't encode
6503 this using GDB's address_class enum. */
6505 complain (&dwarf2_complex_location_expr
);
6509 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name (op
));
6510 return (stack
[stacki
]);
6513 return (stack
[stacki
]);
6516 /* memory allocation interface */
6520 dwarf2_free_tmp_obstack (PTR ignore
)
6522 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6525 static struct dwarf_block
*
6526 dwarf_alloc_block (void)
6528 struct dwarf_block
*blk
;
6530 blk
= (struct dwarf_block
*)
6531 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6535 static struct abbrev_info
*
6536 dwarf_alloc_abbrev (void)
6538 struct abbrev_info
*abbrev
;
6540 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6541 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6545 static struct die_info
*
6546 dwarf_alloc_die (void)
6548 struct die_info
*die
;
6550 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6551 memset (die
, 0, sizeof (struct die_info
));
6556 /* Macro support. */
6559 /* Return the full name of file number I in *LH's file name table.
6560 Use COMP_DIR as the name of the current directory of the
6561 compilation. The result is allocated using xmalloc; the caller is
6562 responsible for freeing it. */
6564 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
6566 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6568 if (IS_ABSOLUTE_PATH (fe
->name
))
6569 return xstrdup (fe
->name
);
6577 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6583 dir_len
= strlen (dir
);
6584 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
6585 strcpy (full_name
, dir
);
6586 full_name
[dir_len
] = '/';
6587 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
6591 return xstrdup (fe
->name
);
6596 static struct macro_source_file
*
6597 macro_start_file (int file
, int line
,
6598 struct macro_source_file
*current_file
,
6599 const char *comp_dir
,
6600 struct line_header
*lh
, struct objfile
*objfile
)
6602 /* The full name of this source file. */
6603 char *full_name
= file_full_name (file
, lh
, comp_dir
);
6605 /* We don't create a macro table for this compilation unit
6606 at all until we actually get a filename. */
6607 if (! pending_macros
)
6608 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
6609 objfile
->macro_cache
);
6612 /* If we have no current file, then this must be the start_file
6613 directive for the compilation unit's main source file. */
6614 current_file
= macro_set_main (pending_macros
, full_name
);
6616 current_file
= macro_include (current_file
, line
, full_name
);
6620 return current_file
;
6624 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
6625 followed by a null byte. */
6627 copy_string (const char *buf
, int len
)
6629 char *s
= xmalloc (len
+ 1);
6630 memcpy (s
, buf
, len
);
6638 consume_improper_spaces (const char *p
, const char *body
)
6642 complain (&dwarf2_macro_spaces_in_definition
, body
);
6653 parse_macro_definition (struct macro_source_file
*file
, int line
,
6658 /* The body string takes one of two forms. For object-like macro
6659 definitions, it should be:
6661 <macro name> " " <definition>
6663 For function-like macro definitions, it should be:
6665 <macro name> "() " <definition>
6667 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
6669 Spaces may appear only where explicitly indicated, and in the
6672 The Dwarf 2 spec says that an object-like macro's name is always
6673 followed by a space, but versions of GCC around March 2002 omit
6674 the space when the macro's definition is the empty string.
6676 The Dwarf 2 spec says that there should be no spaces between the
6677 formal arguments in a function-like macro's formal argument list,
6678 but versions of GCC around March 2002 include spaces after the
6682 /* Find the extent of the macro name. The macro name is terminated
6683 by either a space or null character (for an object-like macro) or
6684 an opening paren (for a function-like macro). */
6685 for (p
= body
; *p
; p
++)
6686 if (*p
== ' ' || *p
== '(')
6689 if (*p
== ' ' || *p
== '\0')
6691 /* It's an object-like macro. */
6692 int name_len
= p
- body
;
6693 char *name
= copy_string (body
, name_len
);
6694 const char *replacement
;
6697 replacement
= body
+ name_len
+ 1;
6700 complain (&dwarf2_macro_malformed_definition
, body
);
6701 replacement
= body
+ name_len
;
6704 macro_define_object (file
, line
, name
, replacement
);
6710 /* It's a function-like macro. */
6711 char *name
= copy_string (body
, p
- body
);
6714 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
6718 p
= consume_improper_spaces (p
, body
);
6720 /* Parse the formal argument list. */
6721 while (*p
&& *p
!= ')')
6723 /* Find the extent of the current argument name. */
6724 const char *arg_start
= p
;
6726 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
6729 if (! *p
|| p
== arg_start
)
6730 complain (&dwarf2_macro_malformed_definition
,
6734 /* Make sure argv has room for the new argument. */
6735 if (argc
>= argv_size
)
6738 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
6741 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
6744 p
= consume_improper_spaces (p
, body
);
6746 /* Consume the comma, if present. */
6751 p
= consume_improper_spaces (p
, body
);
6760 /* Perfectly formed definition, no complaints. */
6761 macro_define_function (file
, line
, name
,
6762 argc
, (const char **) argv
,
6764 else if (*p
== '\0')
6766 /* Complain, but do define it. */
6767 complain (&dwarf2_macro_malformed_definition
, body
);
6768 macro_define_function (file
, line
, name
,
6769 argc
, (const char **) argv
,
6773 /* Just complain. */
6774 complain (&dwarf2_macro_malformed_definition
, body
);
6777 /* Just complain. */
6778 complain (&dwarf2_macro_malformed_definition
, body
);
6784 for (i
= 0; i
< argc
; i
++)
6790 complain (&dwarf2_macro_malformed_definition
, body
);
6795 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
6796 char *comp_dir
, bfd
*abfd
,
6797 const struct comp_unit_head
*cu_header
,
6798 struct objfile
*objfile
)
6800 char *mac_ptr
, *mac_end
;
6801 struct macro_source_file
*current_file
= 0;
6803 if (dwarf_macinfo_buffer
== NULL
)
6805 complain (&dwarf2_missing_macinfo_section
);
6809 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
6810 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
6814 enum dwarf_macinfo_record_type macinfo_type
;
6816 /* Do we at least have room for a macinfo type byte? */
6817 if (mac_ptr
>= mac_end
)
6819 complain (&dwarf2_macros_too_long
);
6823 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
6826 switch (macinfo_type
)
6828 /* A zero macinfo type indicates the end of the macro
6833 case DW_MACINFO_define
:
6834 case DW_MACINFO_undef
:
6840 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6841 mac_ptr
+= bytes_read
;
6842 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
6843 mac_ptr
+= bytes_read
;
6846 complain (&dwarf2_macro_outside_file
,
6847 macinfo_type
== DW_MACINFO_define
? "definition" :
6848 macinfo_type
== DW_MACINFO_undef
? "undefinition" :
6849 "something-or-other",
6853 if (macinfo_type
== DW_MACINFO_define
)
6854 parse_macro_definition (current_file
, line
, body
);
6855 else if (macinfo_type
== DW_MACINFO_undef
)
6856 macro_undef (current_file
, line
, body
);
6861 case DW_MACINFO_start_file
:
6866 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6867 mac_ptr
+= bytes_read
;
6868 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6869 mac_ptr
+= bytes_read
;
6871 current_file
= macro_start_file (file
, line
,
6872 current_file
, comp_dir
,
6877 case DW_MACINFO_end_file
:
6879 complain (&dwarf2_macro_unmatched_end_file
);
6882 current_file
= current_file
->included_by
;
6885 enum dwarf_macinfo_record_type next_type
;
6887 /* GCC circa March 2002 doesn't produce the zero
6888 type byte marking the end of the compilation
6889 unit. Complain if it's not there, but exit no
6892 /* Do we at least have room for a macinfo type byte? */
6893 if (mac_ptr
>= mac_end
)
6895 complain (&dwarf2_macros_too_long
);
6899 /* We don't increment mac_ptr here, so this is just
6901 next_type
= read_1_byte (abfd
, mac_ptr
);
6903 complain (&dwarf2_macros_not_terminated
);
6910 case DW_MACINFO_vendor_ext
:
6916 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6917 mac_ptr
+= bytes_read
;
6918 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
6919 mac_ptr
+= bytes_read
;
6921 /* We don't recognize any vendor extensions. */
6928 /* Check if the attribute's form is a DW_FORM_block*
6929 if so return true else false. */
6931 attr_form_is_block (struct attribute
*attr
)
6933 return (attr
== NULL
? 0 :
6934 attr
->form
== DW_FORM_block1
6935 || attr
->form
== DW_FORM_block2
6936 || attr
->form
== DW_FORM_block4
6937 || attr
->form
== DW_FORM_block
);