1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
4 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
5 Inc. with support from Florida State University (under contract
6 with the Ada Joint Program Office), and Silicon Graphics, Inc.
7 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
8 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
11 This file is part of GDB.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or (at
16 your option) any later version.
18 This program is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
33 #include "elf/dwarf2.h"
36 #include "expression.h"
38 #include "complaints.h"
41 #include "gdb_string.h"
42 #include <sys/types.h>
44 /* .debug_info header for a compilation unit
45 Because of alignment constraints, this structure has padding and cannot
46 be mapped directly onto the beginning of the .debug_info section. */
47 typedef struct comp_unit_header
49 unsigned int length
; /* length of the .debug_info
51 unsigned short version
; /* version number -- 2 for DWARF
53 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
54 unsigned char addr_size
; /* byte size of an address -- 4 */
57 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
59 /* .debug_pubnames header
60 Because of alignment constraints, this structure has padding and cannot
61 be mapped directly onto the beginning of the .debug_info section. */
62 typedef struct pubnames_header
64 unsigned int length
; /* length of the .debug_pubnames
66 unsigned char version
; /* version number -- 2 for DWARF
68 unsigned int info_offset
; /* offset into .debug_info section */
69 unsigned int info_size
; /* byte size of .debug_info section
73 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
75 /* .debug_pubnames header
76 Because of alignment constraints, this structure has padding and cannot
77 be mapped directly onto the beginning of the .debug_info section. */
78 typedef struct aranges_header
80 unsigned int length
; /* byte len of the .debug_aranges
82 unsigned short version
; /* version number -- 2 for DWARF
84 unsigned int info_offset
; /* offset into .debug_info section */
85 unsigned char addr_size
; /* byte size of an address */
86 unsigned char seg_size
; /* byte size of segment descriptor */
89 #define _ACTUAL_ARANGES_HEADER_SIZE 12
91 /* .debug_line statement program prologue
92 Because of alignment constraints, this structure has padding and cannot
93 be mapped directly onto the beginning of the .debug_info section. */
94 typedef struct statement_prologue
96 unsigned int total_length
; /* byte length of the statement
98 unsigned short version
; /* version number -- 2 for DWARF
100 unsigned int prologue_length
; /* # bytes between prologue &
102 unsigned char minimum_instruction_length
; /* byte size of
104 unsigned char default_is_stmt
; /* initial value of is_stmt
107 unsigned char line_range
;
108 unsigned char opcode_base
; /* number assigned to first special
110 unsigned char *standard_opcode_lengths
;
114 /* offsets and sizes of debugging sections */
116 static file_ptr dwarf_info_offset
;
117 static file_ptr dwarf_abbrev_offset
;
118 static file_ptr dwarf_line_offset
;
119 static file_ptr dwarf_pubnames_offset
;
120 static file_ptr dwarf_aranges_offset
;
121 static file_ptr dwarf_loc_offset
;
122 static file_ptr dwarf_macinfo_offset
;
123 static file_ptr dwarf_str_offset
;
125 static unsigned int dwarf_info_size
;
126 static unsigned int dwarf_abbrev_size
;
127 static unsigned int dwarf_line_size
;
128 static unsigned int dwarf_pubnames_size
;
129 static unsigned int dwarf_aranges_size
;
130 static unsigned int dwarf_loc_size
;
131 static unsigned int dwarf_macinfo_size
;
132 static unsigned int dwarf_str_size
;
134 /* names of the debugging sections */
136 #define INFO_SECTION ".debug_info"
137 #define ABBREV_SECTION ".debug_abbrev"
138 #define LINE_SECTION ".debug_line"
139 #define PUBNAMES_SECTION ".debug_pubnames"
140 #define ARANGES_SECTION ".debug_aranges"
141 #define LOC_SECTION ".debug_loc"
142 #define MACINFO_SECTION ".debug_macinfo"
143 #define STR_SECTION ".debug_str"
145 /* local data types */
147 /* The data in a compilation unit header looks like this. */
148 struct comp_unit_head
153 unsigned char addr_size
;
156 /* The data in the .debug_line statement prologue looks like this. */
159 unsigned int total_length
;
160 unsigned short version
;
161 unsigned int prologue_length
;
162 unsigned char minimum_instruction_length
;
163 unsigned char default_is_stmt
;
165 unsigned char line_range
;
166 unsigned char opcode_base
;
167 unsigned char *standard_opcode_lengths
;
170 /* When we construct a partial symbol table entry we only
171 need this much information. */
172 struct partial_die_info
175 unsigned char has_children
;
176 unsigned char is_external
;
177 unsigned char is_declaration
;
178 unsigned char has_type
;
184 struct dwarf_block
*locdesc
;
185 unsigned int language
;
189 /* This data structure holds the information of an abbrev. */
192 unsigned int number
; /* number identifying abbrev */
193 enum dwarf_tag tag
; /* dwarf tag */
194 int has_children
; /* boolean */
195 unsigned int num_attrs
; /* number of attributes */
196 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
197 struct abbrev_info
*next
; /* next in chain */
202 enum dwarf_attribute name
;
203 enum dwarf_form form
;
206 /* This data structure holds a complete die structure. */
209 enum dwarf_tag tag
; /* Tag indicating type of die */
210 unsigned short has_children
; /* Does the die have children */
211 unsigned int abbrev
; /* Abbrev number */
212 unsigned int offset
; /* Offset in .debug_info section */
213 unsigned int num_attrs
; /* Number of attributes */
214 struct attribute
*attrs
; /* An array of attributes */
215 struct die_info
*next_ref
; /* Next die in ref hash table */
216 struct die_info
*next
; /* Next die in linked list */
217 struct type
*type
; /* Cached type information */
220 /* Attributes have a name and a value */
223 enum dwarf_attribute name
;
224 enum dwarf_form form
;
228 struct dwarf_block
*blk
;
236 /* Get at parts of an attribute structure */
238 #define DW_STRING(attr) ((attr)->u.str)
239 #define DW_UNSND(attr) ((attr)->u.unsnd)
240 #define DW_BLOCK(attr) ((attr)->u.blk)
241 #define DW_SND(attr) ((attr)->u.snd)
242 #define DW_ADDR(attr) ((attr)->u.addr)
244 /* Blocks are a bunch of untyped bytes. */
251 /* We only hold one compilation unit's abbrevs in
252 memory at any one time. */
253 #ifndef ABBREV_HASH_SIZE
254 #define ABBREV_HASH_SIZE 121
256 #ifndef ATTR_ALLOC_CHUNK
257 #define ATTR_ALLOC_CHUNK 4
260 static struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
262 /* A hash table of die offsets for following references. */
263 #ifndef REF_HASH_SIZE
264 #define REF_HASH_SIZE 1021
267 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
269 /* Obstack for allocating temporary storage used during symbol reading. */
270 static struct obstack dwarf2_tmp_obstack
;
272 /* Offset to the first byte of the current compilation unit header,
273 for resolving relative reference dies. */
274 static unsigned int cu_header_offset
;
276 /* Allocate fields for structs, unions and enums in this size. */
277 #ifndef DW_FIELD_ALLOC_CHUNK
278 #define DW_FIELD_ALLOC_CHUNK 4
281 /* The language we are debugging. */
282 static enum language cu_language
;
283 static const struct language_defn
*cu_language_defn
;
285 /* Actually data from the sections. */
286 static char *dwarf_info_buffer
;
287 static char *dwarf_abbrev_buffer
;
288 static char *dwarf_line_buffer
;
290 /* A zeroed version of a partial die for initialization purposes. */
291 static struct partial_die_info zeroed_partial_die
;
293 /* The generic symbol table building routines have separate lists for
294 file scope symbols and all all other scopes (local scopes). So
295 we need to select the right one to pass to add_symbol_to_list().
296 We do it by keeping a pointer to the correct list in list_in_scope.
298 FIXME: The original dwarf code just treated the file scope as the first
299 local scope, and all other local scopes as nested local scopes, and worked
300 fine. Check to see if we really need to distinguish these
302 static struct pending
**list_in_scope
= &file_symbols
;
304 /* FIXME: The following variables pass additional information from
305 decode_locdesc to the caller. */
306 static int optimized_out
; /* Kludge to identify optimized out variables */
307 static int isreg
; /* Kludge to identify register variables */
308 static int offreg
; /* Kludge to identify basereg references */
309 static int basereg
; /* Which base register is it relative to? */
310 static int islocal
; /* Kludge to identify local variables */
312 /* DW_AT_frame_base values for the current function.
313 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
314 contains the register number for the frame register.
315 frame_base_offset is the offset from the frame register to the
316 virtual stack frame. */
317 static int frame_base_reg
;
318 static CORE_ADDR frame_base_offset
;
320 /* This value is added to each symbol value. FIXME: Generalize to
321 the section_offsets structure used by dbxread (once this is done,
322 pass the appropriate section number to end_symtab). */
323 static CORE_ADDR baseaddr
; /* Add to each symbol value */
325 /* We put a pointer to this structure in the read_symtab_private field
327 The complete dwarf information for an objfile is kept in the
328 psymbol_obstack, so that absolute die references can be handled.
329 Most of the information in this structure is related to an entire
330 object file and could be passed via the sym_private field of the objfile.
331 It is however conceivable that dwarf2 might not be the only type
332 of symbols read from an object file. */
336 /* Pointer to start of dwarf info buffer for the objfile. */
338 char *dwarf_info_buffer
;
340 /* Offset in dwarf_info_buffer for this compilation unit. */
342 unsigned long dwarf_info_offset
;
344 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
346 char *dwarf_abbrev_buffer
;
348 /* Size of dwarf abbreviation section for the objfile. */
350 unsigned int dwarf_abbrev_size
;
352 /* Pointer to start of dwarf line buffer for the objfile. */
354 char *dwarf_line_buffer
;
357 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
358 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
359 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
360 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
361 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
362 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
364 /* Maintain an array of referenced fundamental types for the current
365 compilation unit being read. For DWARF version 1, we have to construct
366 the fundamental types on the fly, since no information about the
367 fundamental types is supplied. Each such fundamental type is created by
368 calling a language dependent routine to create the type, and then a
369 pointer to that type is then placed in the array at the index specified
370 by it's FT_<TYPENAME> value. The array has a fixed size set by the
371 FT_NUM_MEMBERS compile time constant, which is the number of predefined
372 fundamental types gdb knows how to construct. */
373 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
375 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
376 but this would require a corresponding change in unpack_field_as_long
378 static int bits_per_byte
= 8;
380 /* The routines that read and process dies for a C struct or C++ class
381 pass lists of data member fields and lists of member function fields
382 in an instance of a field_info structure, as defined below. */
385 /* List of data member and baseclasses fields. */
388 struct nextfield
*next
;
394 /* Number of fields. */
397 /* Number of baseclasses. */
400 /* Set if the accesibility of one of the fields is not public. */
401 int non_public_fields
;
403 /* Member function fields array, entries are allocated in the order they
404 are encountered in the object file. */
407 struct nextfnfield
*next
;
408 struct fn_field fnfield
;
411 /* Member function fieldlist array, contains name of possibly overloaded
412 member function, number of overloaded member functions and a pointer
413 to the head of the member function field chain. */
418 struct nextfnfield
*head
;
421 /* Number of entries in the fnfieldlists array. */
425 /* FIXME: Kludge to mark a varargs function type for C++ member function
426 argument processing. */
427 #define TYPE_FLAG_VARARGS (1 << 10)
429 /* Dwarf2 has no clean way to discern C++ static and non-static member
430 functions. G++ helps GDB by marking the first parameter for non-static
431 member functions (which is the this pointer) as artificial.
432 We pass this information between dwarf2_add_member_fn and
433 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
434 #define TYPE_FIELD_ARTIFICIAL TYPE_FIELD_BITPOS
436 /* Various complaints about symbol reading that don't abort the process */
438 static struct complaint dwarf2_const_ignored
=
440 "type qualifier 'const' ignored", 0, 0
442 static struct complaint dwarf2_volatile_ignored
=
444 "type qualifier 'volatile' ignored", 0, 0
446 static struct complaint dwarf2_non_const_array_bound_ignored
=
448 "non-constant array bounds form '%s' ignored", 0, 0
450 static struct complaint dwarf2_missing_line_number_section
=
452 "missing .debug_line section", 0, 0
454 static struct complaint dwarf2_mangled_line_number_section
=
456 "mangled .debug_line section", 0, 0
458 static struct complaint dwarf2_unsupported_die_ref_attr
=
460 "unsupported die ref attribute form: '%s'", 0, 0
462 static struct complaint dwarf2_unsupported_stack_op
=
464 "unsupported stack op: '%s'", 0, 0
466 static struct complaint dwarf2_unsupported_tag
=
468 "unsupported tag: '%s'", 0, 0
470 static struct complaint dwarf2_unsupported_at_encoding
=
472 "unsupported DW_AT_encoding: '%s'", 0, 0
474 static struct complaint dwarf2_unsupported_at_frame_base
=
476 "unsupported DW_AT_frame_base for function '%s'", 0, 0
478 static struct complaint dwarf2_unexpected_tag
=
480 "unexepected tag in read_type_die: '%s'", 0, 0
482 static struct complaint dwarf2_missing_at_frame_base
=
484 "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
486 static struct complaint dwarf2_bad_static_member_name
=
488 "unrecognized static data member name '%s'", 0, 0
490 static struct complaint dwarf2_unsupported_accessibility
=
492 "unsupported accessibility %d", 0, 0
494 static struct complaint dwarf2_bad_member_name_complaint
=
496 "cannot extract member name from '%s'", 0, 0
498 static struct complaint dwarf2_missing_member_fn_type_complaint
=
500 "member function type missing for '%s'", 0, 0
502 static struct complaint dwarf2_vtbl_not_found_complaint
=
504 "virtual function table pointer not found when defining class '%s'", 0, 0
506 static struct complaint dwarf2_absolute_sibling_complaint
=
508 "ignoring absolute DW_AT_sibling", 0, 0
510 static struct complaint dwarf2_const_value_length_mismatch
=
512 "const value length mismatch for '%s', got %d, expected %d", 0, 0
514 static struct complaint dwarf2_unsupported_const_value_attr
=
516 "unsupported const value attribute form: '%s'", 0, 0
519 /* Remember the addr_size read from the dwarf.
520 If a target expects to link compilation units with differing address
521 sizes, gdb needs to be sure that the appropriate size is here for
522 whatever scope is currently getting read. */
523 static int address_size
;
525 /* Externals references. */
526 extern int info_verbose
; /* From main.c; nonzero => verbose */
528 /* local function prototypes */
530 static void dwarf2_locate_sections
PARAMS ((bfd
*, asection
*, PTR
));
533 static void dwarf2_build_psymtabs_easy
PARAMS ((struct objfile
*,
534 struct section_offsets
*,
538 static void dwarf2_build_psymtabs_hard
PARAMS ((struct objfile
*,
539 struct section_offsets
*,
542 static char *scan_partial_symbols
PARAMS ((char *, struct objfile
*,
543 CORE_ADDR
*, CORE_ADDR
*));
545 static void add_partial_symbol
PARAMS ((struct partial_die_info
*,
548 static void dwarf2_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
550 static void psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
552 static char *dwarf2_read_section
PARAMS ((struct objfile
*, file_ptr
,
555 static void dwarf2_read_abbrevs
PARAMS ((bfd
*, unsigned int));
557 static void dwarf2_empty_abbrev_table
PARAMS ((PTR
));
559 static struct abbrev_info
*dwarf2_lookup_abbrev
PARAMS ((unsigned int));
561 static char *read_partial_die
PARAMS ((struct partial_die_info
*,
562 bfd
*, char *, int *));
564 static char *read_full_die
PARAMS ((struct die_info
**, bfd
*, char *));
566 static char *read_attribute
PARAMS ((struct attribute
*, struct attr_abbrev
*,
569 static unsigned int read_1_byte
PARAMS ((bfd
*, char *));
571 static int read_1_signed_byte
PARAMS ((bfd
*, char *));
573 static unsigned int read_2_bytes
PARAMS ((bfd
*, char *));
575 static unsigned int read_4_bytes
PARAMS ((bfd
*, char *));
577 static unsigned int read_8_bytes
PARAMS ((bfd
*, char *));
579 static CORE_ADDR read_address
PARAMS ((bfd
*, char *));
581 static char *read_n_bytes
PARAMS ((bfd
*, char *, unsigned int));
583 static char *read_string
PARAMS ((bfd
*, char *, unsigned int *));
585 static unsigned int read_unsigned_leb128
PARAMS ((bfd
*, char *,
588 static int read_signed_leb128
PARAMS ((bfd
*, char *, unsigned int *));
590 static void set_cu_language
PARAMS ((unsigned int));
592 static struct attribute
*dwarf_attr
PARAMS ((struct die_info
*,
595 static void dwarf_decode_lines
PARAMS ((unsigned int, char *, bfd
*));
597 static void dwarf2_start_subfile
PARAMS ((char *, char *));
599 static struct symbol
*new_symbol
PARAMS ((struct die_info
*, struct type
*,
602 static void dwarf2_const_value
PARAMS ((struct attribute
*, struct symbol
*,
605 static struct type
*die_type
PARAMS ((struct die_info
*, struct objfile
*));
607 static struct type
*die_containing_type
PARAMS ((struct die_info
*,
611 static struct type
*type_at_offset
PARAMS ((unsigned int, struct objfile
*));
614 static struct type
*tag_type_to_type
PARAMS ((struct die_info
*,
617 static void read_type_die
PARAMS ((struct die_info
*, struct objfile
*));
619 static void read_typedef
PARAMS ((struct die_info
*, struct objfile
*));
621 static void read_base_type
PARAMS ((struct die_info
*, struct objfile
*));
623 static void read_file_scope
PARAMS ((struct die_info
*, struct objfile
*));
625 static void read_func_scope
PARAMS ((struct die_info
*, struct objfile
*));
627 static void read_lexical_block_scope
PARAMS ((struct die_info
*,
630 static int dwarf2_get_pc_bounds
PARAMS ((struct die_info
*,
631 CORE_ADDR
*, CORE_ADDR
*,
634 static void dwarf2_add_field
PARAMS ((struct field_info
*, struct die_info
*,
637 static void dwarf2_attach_fields_to_type
PARAMS ((struct field_info
*,
641 static char *skip_member_fn_name
PARAMS ((char *));
643 static void dwarf2_add_member_fn
PARAMS ((struct field_info
*,
644 struct die_info
*, struct type
*,
645 struct objfile
*objfile
));
647 static void dwarf2_attach_fn_fields_to_type
PARAMS ((struct field_info
*,
651 static void read_structure_scope
PARAMS ((struct die_info
*, struct objfile
*));
653 static void read_common_block
PARAMS ((struct die_info
*, struct objfile
*));
655 static void read_enumeration
PARAMS ((struct die_info
*, struct objfile
*));
657 static struct type
*dwarf_base_type
PARAMS ((int, int, struct objfile
*));
659 static CORE_ADDR decode_locdesc
PARAMS ((struct dwarf_block
*,
662 static void read_array_type
PARAMS ((struct die_info
*, struct objfile
*));
664 static void read_tag_pointer_type
PARAMS ((struct die_info
*,
667 static void read_tag_ptr_to_member_type
PARAMS ((struct die_info
*,
670 static void read_tag_reference_type
PARAMS ((struct die_info
*,
673 static void read_tag_const_type
PARAMS ((struct die_info
*, struct objfile
*));
675 static void read_tag_volatile_type
PARAMS ((struct die_info
*,
678 static void read_tag_string_type
PARAMS ((struct die_info
*,
681 static void read_subroutine_type
PARAMS ((struct die_info
*,
684 struct die_info
*read_comp_unit
PARAMS ((char *, bfd
*));
686 static void free_die_list
PARAMS ((struct die_info
*));
688 static void process_die
PARAMS ((struct die_info
*, struct objfile
*));
690 static char *dwarf_tag_name
PARAMS ((unsigned int));
692 static char *dwarf_attr_name
PARAMS ((unsigned int));
694 static char *dwarf_form_name
PARAMS ((unsigned int));
696 static char *dwarf_stack_op_name
PARAMS ((unsigned int));
698 static char *dwarf_bool_name
PARAMS ((unsigned int));
700 static char *dwarf_type_encoding_name
PARAMS ((unsigned int));
703 static char *dwarf_cfi_name
PARAMS ((unsigned int));
705 struct die_info
*copy_die
PARAMS ((struct die_info
*));
708 struct die_info
*sibling_die
PARAMS ((struct die_info
*));
710 void dump_die
PARAMS ((struct die_info
*));
712 void dump_die_list
PARAMS ((struct die_info
*));
714 void store_in_ref_table
PARAMS ((unsigned int, struct die_info
*));
716 static void dwarf2_empty_die_ref_table
PARAMS ((void));
718 static unsigned int dwarf2_get_ref_die_offset
PARAMS ((struct attribute
*));
720 struct die_info
*follow_die_ref
PARAMS ((unsigned int));
722 static struct type
*dwarf2_fundamental_type
PARAMS ((struct objfile
*, int));
724 /* memory allocation interface */
726 static void dwarf2_free_tmp_obstack
PARAMS ((PTR
));
728 static struct dwarf_block
*dwarf_alloc_block
PARAMS ((void));
730 static struct abbrev_info
*dwarf_alloc_abbrev
PARAMS ((void));
732 static struct die_info
*dwarf_alloc_die
PARAMS ((void));
734 /* Try to locate the sections we need for DWARF 2 debugging
735 information and return true if we have enough to do something. */
738 dwarf2_has_info (abfd
)
741 dwarf_info_offset
= dwarf_abbrev_offset
= dwarf_line_offset
= 0;
742 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
743 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
753 /* This function is mapped across the sections and remembers the
754 offset and size of each of the debugging sections we are interested
758 dwarf2_locate_sections (ignore_abfd
, sectp
, ignore_ptr
)
763 if (STREQ (sectp
->name
, INFO_SECTION
))
765 dwarf_info_offset
= sectp
->filepos
;
766 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
768 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
770 dwarf_abbrev_offset
= sectp
->filepos
;
771 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
773 else if (STREQ (sectp
->name
, LINE_SECTION
))
775 dwarf_line_offset
= sectp
->filepos
;
776 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
778 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
780 dwarf_pubnames_offset
= sectp
->filepos
;
781 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
783 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
785 dwarf_aranges_offset
= sectp
->filepos
;
786 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
788 else if (STREQ (sectp
->name
, LOC_SECTION
))
790 dwarf_loc_offset
= sectp
->filepos
;
791 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
793 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
795 dwarf_macinfo_offset
= sectp
->filepos
;
796 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
798 else if (STREQ (sectp
->name
, STR_SECTION
))
800 dwarf_str_offset
= sectp
->filepos
;
801 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
805 /* Build a partial symbol table. */
808 dwarf2_build_psymtabs (objfile
, section_offsets
, mainline
)
809 struct objfile
*objfile
;
810 struct section_offsets
*section_offsets
;
814 /* We definitely need the .debug_info and .debug_abbrev sections */
816 dwarf_info_buffer
= dwarf2_read_section (objfile
,
819 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
822 dwarf_line_buffer
= dwarf2_read_section (objfile
,
826 if (mainline
|| objfile
->global_psymbols
.size
== 0 ||
827 objfile
->static_psymbols
.size
== 0)
829 init_psymbol_list (objfile
, 1024);
833 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
835 /* Things are significanlty easier if we have .debug_aranges and
836 .debug_pubnames sections */
838 dwarf2_build_psymtabs_easy (objfile
, section_offsets
, mainline
);
842 /* only test this case for now */
844 /* In this case we have to work a bit harder */
845 dwarf2_build_psymtabs_hard (objfile
, section_offsets
, mainline
);
850 /* Build the partial symbol table from the information in the
851 .debug_pubnames and .debug_aranges sections. */
854 dwarf2_build_psymtabs_easy (objfile
, section_offsets
, mainline
)
855 struct objfile
*objfile
;
856 struct section_offsets
*section_offsets
;
859 bfd
*abfd
= objfile
->obfd
;
860 char *aranges_buffer
, *pubnames_buffer
;
861 char *aranges_ptr
, *pubnames_ptr
;
862 unsigned int entry_length
, version
, info_offset
, info_size
;
864 pubnames_buffer
= dwarf2_read_section (objfile
,
865 dwarf_pubnames_offset
,
866 dwarf_pubnames_size
);
867 pubnames_ptr
= pubnames_buffer
;
868 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
870 entry_length
= read_4_bytes (abfd
, pubnames_ptr
);
872 version
= read_1_byte (abfd
, pubnames_ptr
);
874 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
876 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
880 aranges_buffer
= dwarf2_read_section (objfile
,
881 dwarf_aranges_offset
,
887 /* Build the partial symbol table by doing a quick pass through the
888 .debug_info and .debug_abbrev sections. */
891 dwarf2_build_psymtabs_hard (objfile
, section_offsets
, mainline
)
892 struct objfile
*objfile
;
893 struct section_offsets
*section_offsets
;
896 /* Instead of reading this into a big buffer, we should probably use
897 mmap() on architectures that support it. (FIXME) */
898 bfd
*abfd
= objfile
->obfd
;
899 char *info_ptr
, *abbrev_ptr
;
900 char *beg_of_comp_unit
;
901 struct comp_unit_head cu_header
;
902 struct partial_die_info comp_unit_die
;
903 struct partial_symtab
*pst
;
904 struct cleanup
*back_to
;
905 int comp_unit_has_pc_info
;
906 CORE_ADDR lowpc
, highpc
;
908 info_ptr
= dwarf_info_buffer
;
909 abbrev_ptr
= dwarf_abbrev_buffer
;
911 obstack_init (&dwarf2_tmp_obstack
);
912 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
914 while ((unsigned int) (info_ptr
- dwarf_info_buffer
)
915 + ((info_ptr
- dwarf_info_buffer
) % 4) < dwarf_info_size
)
917 beg_of_comp_unit
= info_ptr
;
918 cu_header
.length
= read_4_bytes (abfd
, info_ptr
);
920 cu_header
.version
= read_2_bytes (abfd
, info_ptr
);
922 cu_header
.abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
924 cu_header
.addr_size
= read_1_byte (abfd
, info_ptr
);
926 address_size
= cu_header
.addr_size
;
928 if (cu_header
.version
!= 2)
930 error ("Dwarf Error: wrong version in compilation unit header.");
934 /* Read the abbrevs for this compilation unit into a table */
935 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
936 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
938 /* Read the compilation unit die */
939 info_ptr
= read_partial_die (&comp_unit_die
, abfd
,
940 info_ptr
, &comp_unit_has_pc_info
);
942 /* Set the language we're debugging */
943 set_cu_language (comp_unit_die
.language
);
945 /* Allocate a new partial symbol table structure */
946 pst
= start_psymtab_common (objfile
, section_offsets
,
947 comp_unit_die
.name
? comp_unit_die
.name
: "",
949 objfile
->global_psymbols
.next
,
950 objfile
->static_psymbols
.next
);
952 pst
->read_symtab_private
= (char *)
953 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
954 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
955 DWARF_INFO_BUFFER(pst
) = dwarf_info_buffer
;
956 DWARF_INFO_OFFSET(pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
957 DWARF_ABBREV_BUFFER(pst
) = dwarf_abbrev_buffer
;
958 DWARF_ABBREV_SIZE(pst
) = dwarf_abbrev_size
;
959 DWARF_LINE_BUFFER(pst
) = dwarf_line_buffer
;
960 baseaddr
= ANOFFSET (section_offsets
, 0);
962 /* Store the function that reads in the rest of the symbol table */
963 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
965 /* Read the rest of the partial symbols from this comp unit */
966 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
);
968 /* If the compilation unit didn't have an explicit address range,
969 then use the information extracted from its child dies. */
970 if (!comp_unit_has_pc_info
)
972 comp_unit_die
.lowpc
= lowpc
;
973 comp_unit_die
.highpc
= highpc
;
975 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
976 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
978 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
979 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
980 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
981 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
982 sort_pst_symbols (pst
);
984 /* If there is already a psymtab or symtab for a file of this
985 name, remove it. (If there is a symtab, more drastic things
986 also happen.) This happens in VxWorks. */
987 free_named_symtabs (pst
->filename
);
989 info_ptr
= beg_of_comp_unit
+ cu_header
.length
+ 4;
991 do_cleanups (back_to
);
994 /* Read in all interesting dies to the end of the compilation unit. */
997 scan_partial_symbols (info_ptr
, objfile
, lowpc
, highpc
)
999 struct objfile
*objfile
;
1003 bfd
*abfd
= objfile
->obfd
;
1004 struct partial_die_info pdi
;
1005 int nesting_level
= 1; /* we've already read in comp_unit_die */
1008 *lowpc
= ((CORE_ADDR
) -1);
1009 *highpc
= ((CORE_ADDR
) 0);
1011 while (nesting_level
)
1013 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, &has_pc_info
);
1019 case DW_TAG_subprogram
:
1022 if (pdi
.lowpc
< *lowpc
)
1026 if (pdi
.highpc
> *highpc
)
1028 *highpc
= pdi
.highpc
;
1030 if ((pdi
.is_external
|| nesting_level
== 1)
1031 && !pdi
.is_declaration
)
1033 add_partial_symbol (&pdi
, objfile
);
1037 case DW_TAG_variable
:
1038 case DW_TAG_typedef
:
1039 case DW_TAG_class_type
:
1040 case DW_TAG_structure_type
:
1041 case DW_TAG_union_type
:
1042 case DW_TAG_enumeration_type
:
1043 if ((pdi
.is_external
|| nesting_level
== 1)
1044 && !pdi
.is_declaration
)
1046 add_partial_symbol (&pdi
, objfile
);
1049 case DW_TAG_enumerator
:
1050 /* File scope enumerators are added to the partial symbol
1052 if (nesting_level
== 2)
1053 add_partial_symbol (&pdi
, objfile
);
1055 case DW_TAG_base_type
:
1056 /* File scope base type definitions are added to the partial
1058 if (nesting_level
== 1)
1059 add_partial_symbol (&pdi
, objfile
);
1066 /* If the die has a sibling, skip to the sibling.
1067 Do not skip enumeration types, we want to record their
1069 if (pdi
.sibling
&& pdi
.tag
!= DW_TAG_enumeration_type
)
1071 info_ptr
= pdi
.sibling
;
1073 else if (pdi
.has_children
)
1075 /* Die has children, but the optional DW_AT_sibling attribute
1086 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1087 from `maint check'. */
1088 if (*lowpc
== ((CORE_ADDR
) -1))
1094 add_partial_symbol (pdi
, objfile
)
1095 struct partial_die_info
*pdi
;
1096 struct objfile
*objfile
;
1102 case DW_TAG_subprogram
:
1103 if (pdi
->is_external
)
1105 prim_record_minimal_symbol (pdi
->name
, pdi
->lowpc
+ baseaddr
,
1107 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1108 VAR_NAMESPACE
, LOC_BLOCK
,
1109 &objfile
->global_psymbols
,
1110 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1114 prim_record_minimal_symbol (pdi
->name
, pdi
->lowpc
+ baseaddr
,
1115 mst_file_text
, objfile
);
1116 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1117 VAR_NAMESPACE
, LOC_BLOCK
,
1118 &objfile
->static_psymbols
,
1119 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1122 case DW_TAG_variable
:
1123 if (pdi
->is_external
)
1126 Don't enter into the minimal symbol tables as there is
1127 a minimal symbol table entry from the ELF symbols already.
1128 Enter into partial symbol table if it has a location
1129 descriptor or a type.
1130 If the location descriptor is missing, new_symbol will create
1131 a LOC_UNRESOLVED symbol, the address of the variable will then
1132 be determined from the minimal symbol table whenever the variable
1134 The address for the partial symbol table entry is not
1135 used by GDB, but it comes in handy for debugging partial symbol
1139 addr
= decode_locdesc (pdi
->locdesc
, objfile
);
1140 if (pdi
->locdesc
|| pdi
->has_type
)
1141 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1142 VAR_NAMESPACE
, LOC_STATIC
,
1143 &objfile
->global_psymbols
,
1144 0, addr
+ baseaddr
, cu_language
, objfile
);
1148 /* Static Variable. Skip symbols without location descriptors. */
1149 if (pdi
->locdesc
== NULL
)
1151 addr
= decode_locdesc (pdi
->locdesc
, objfile
);
1152 prim_record_minimal_symbol (pdi
->name
, addr
+ baseaddr
,
1153 mst_file_data
, objfile
);
1154 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1155 VAR_NAMESPACE
, LOC_STATIC
,
1156 &objfile
->static_psymbols
,
1157 0, addr
+ baseaddr
, cu_language
, objfile
);
1160 case DW_TAG_typedef
:
1161 case DW_TAG_base_type
:
1162 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1163 VAR_NAMESPACE
, LOC_TYPEDEF
,
1164 &objfile
->static_psymbols
,
1165 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1167 case DW_TAG_class_type
:
1168 case DW_TAG_structure_type
:
1169 case DW_TAG_union_type
:
1170 case DW_TAG_enumeration_type
:
1171 /* Skip aggregate types without children, these are external
1173 if (pdi
->has_children
== 0)
1175 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1176 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1177 &objfile
->static_psymbols
,
1178 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1180 if (cu_language
== language_cplus
)
1182 /* For C++, these implicitly act as typedefs as well. */
1183 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1184 VAR_NAMESPACE
, LOC_TYPEDEF
,
1185 &objfile
->static_psymbols
,
1186 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1189 case DW_TAG_enumerator
:
1190 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1191 VAR_NAMESPACE
, LOC_CONST
,
1192 &objfile
->static_psymbols
,
1193 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1200 /* Expand this partial symbol table into a full symbol table. */
1203 dwarf2_psymtab_to_symtab (pst
)
1204 struct partial_symtab
*pst
;
1206 /* FIXME: This is barely more than a stub. */
1211 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1217 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1218 gdb_flush (gdb_stdout
);
1221 psymtab_to_symtab_1 (pst
);
1223 /* Finish up the debug error message. */
1225 printf_filtered ("done.\n");
1231 psymtab_to_symtab_1 (pst
)
1232 struct partial_symtab
*pst
;
1234 struct objfile
*objfile
= pst
->objfile
;
1235 bfd
*abfd
= objfile
->obfd
;
1236 struct comp_unit_head cu_header
;
1237 struct die_info
*dies
;
1238 unsigned long offset
;
1239 CORE_ADDR lowpc
, highpc
;
1240 struct die_info
*child_die
;
1242 struct symtab
*symtab
;
1243 struct cleanup
*back_to
;
1245 /* Set local variables from the partial symbol table info. */
1246 offset
= DWARF_INFO_OFFSET(pst
);
1247 dwarf_info_buffer
= DWARF_INFO_BUFFER(pst
);
1248 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER(pst
);
1249 dwarf_abbrev_size
= DWARF_ABBREV_SIZE(pst
);
1250 dwarf_line_buffer
= DWARF_LINE_BUFFER(pst
);
1251 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
1252 cu_header_offset
= offset
;
1253 info_ptr
= dwarf_info_buffer
+ offset
;
1255 obstack_init (&dwarf2_tmp_obstack
);
1256 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1259 make_cleanup (really_free_pendings
, NULL
);
1261 /* read in the comp_unit header */
1262 cu_header
.length
= read_4_bytes (abfd
, info_ptr
);
1264 cu_header
.version
= read_2_bytes (abfd
, info_ptr
);
1266 cu_header
.abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
1268 cu_header
.addr_size
= read_1_byte (abfd
, info_ptr
);
1271 /* Read the abbrevs for this compilation unit */
1272 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1273 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1275 dies
= read_comp_unit (info_ptr
, abfd
);
1277 make_cleanup (free_die_list
, dies
);
1279 /* Do line number decoding in read_file_scope () */
1280 process_die (dies
, objfile
);
1282 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1284 /* Some compilers don't define a DW_AT_high_pc attribute for
1285 the compilation unit. If the DW_AT_high_pc is missing,
1286 synthesize it, by scanning the DIE's below the compilation unit. */
1288 if (dies
->has_children
)
1290 child_die
= dies
->next
;
1291 while (child_die
&& child_die
->tag
)
1293 if (child_die
->tag
== DW_TAG_subprogram
)
1295 CORE_ADDR low
, high
;
1297 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1299 highpc
= max (highpc
, high
);
1302 child_die
= sibling_die (child_die
);
1306 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, 0);
1308 /* Set symtab language to language from DW_AT_language.
1309 If the compilation is from a C file generated by language preprocessors,
1310 do not set the language if it was already deduced by start_subfile. */
1312 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1314 symtab
->language
= cu_language
;
1316 pst
->symtab
= symtab
;
1318 sort_symtab_syms (pst
->symtab
);
1320 do_cleanups (back_to
);
1323 /* Process a die and its children. */
1326 process_die (die
, objfile
)
1327 struct die_info
*die
;
1328 struct objfile
*objfile
;
1332 case DW_TAG_padding
:
1334 case DW_TAG_compile_unit
:
1335 read_file_scope (die
, objfile
);
1337 case DW_TAG_subprogram
:
1338 read_subroutine_type (die
, objfile
);
1339 read_func_scope (die
, objfile
);
1341 case DW_TAG_inlined_subroutine
:
1342 /* FIXME: These are ignored for now.
1343 They could be used to set breakpoints on all inlined instances
1344 of a function and make GDB `next' properly over inlined functions. */
1346 case DW_TAG_lexical_block
:
1347 read_lexical_block_scope (die
, objfile
);
1349 case DW_TAG_class_type
:
1350 case DW_TAG_structure_type
:
1351 case DW_TAG_union_type
:
1352 read_structure_scope (die
, objfile
);
1354 case DW_TAG_enumeration_type
:
1355 read_enumeration (die
, objfile
);
1357 case DW_TAG_subroutine_type
:
1358 read_subroutine_type (die
, objfile
);
1360 case DW_TAG_array_type
:
1361 read_array_type (die
, objfile
);
1363 case DW_TAG_pointer_type
:
1364 read_tag_pointer_type (die
, objfile
);
1366 case DW_TAG_ptr_to_member_type
:
1367 read_tag_ptr_to_member_type (die
, objfile
);
1369 case DW_TAG_reference_type
:
1370 read_tag_reference_type (die
, objfile
);
1372 case DW_TAG_string_type
:
1373 read_tag_string_type (die
, objfile
);
1375 case DW_TAG_base_type
:
1376 read_base_type (die
, objfile
);
1377 if (dwarf_attr (die
, DW_AT_name
))
1379 /* Add a typedef symbol for the base type definition. */
1380 new_symbol (die
, die
->type
, objfile
);
1383 case DW_TAG_common_block
:
1384 read_common_block (die
, objfile
);
1386 case DW_TAG_common_inclusion
:
1389 new_symbol (die
, NULL
, objfile
);
1395 read_file_scope (die
, objfile
)
1396 struct die_info
*die
;
1397 struct objfile
*objfile
;
1399 unsigned int line_offset
= 0;
1400 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1401 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1402 struct attribute
*attr
;
1403 char *name
= "<unknown>";
1404 char *comp_dir
= NULL
;
1405 struct die_info
*child_die
;
1406 bfd
*abfd
= objfile
->obfd
;
1408 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1410 if (die
->has_children
)
1412 child_die
= die
->next
;
1413 while (child_die
&& child_die
->tag
)
1415 if (child_die
->tag
== DW_TAG_subprogram
)
1417 CORE_ADDR low
, high
;
1419 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1421 lowpc
= min (lowpc
, low
);
1422 highpc
= max (highpc
, high
);
1425 child_die
= sibling_die (child_die
);
1430 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1431 from finish_block. */
1432 if (lowpc
== ((CORE_ADDR
) -1))
1437 attr
= dwarf_attr (die
, DW_AT_name
);
1440 name
= DW_STRING (attr
);
1442 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1445 comp_dir
= DW_STRING (attr
);
1448 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1449 directory, get rid of it. */
1450 char *cp
= strchr (comp_dir
, ':');
1452 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1457 if (objfile
->ei
.entry_point
>= lowpc
&&
1458 objfile
->ei
.entry_point
< highpc
)
1460 objfile
->ei
.entry_file_lowpc
= lowpc
;
1461 objfile
->ei
.entry_file_highpc
= highpc
;
1464 attr
= dwarf_attr (die
, DW_AT_language
);
1467 set_cu_language (DW_UNSND (attr
));
1471 /* FIXME:Do something here. */
1472 if (dip
->at_producer
!= NULL
)
1474 handle_producer (dip
->at_producer
);
1478 /* The compilation unit may be in a different language or objfile,
1479 zero out all remembered fundamental types. */
1480 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1482 start_symtab (name
, comp_dir
, lowpc
);
1484 /* Decode line number information if present. */
1485 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1488 line_offset
= DW_UNSND (attr
);
1489 dwarf_decode_lines (line_offset
, comp_dir
, abfd
);
1492 /* Process all dies in compilation unit. */
1493 if (die
->has_children
)
1495 child_die
= die
->next
;
1496 while (child_die
&& child_die
->tag
)
1498 process_die (child_die
, objfile
);
1499 child_die
= sibling_die (child_die
);
1505 read_func_scope (die
, objfile
)
1506 struct die_info
*die
;
1507 struct objfile
*objfile
;
1509 register struct context_stack
*new;
1512 struct die_info
*child_die
;
1513 struct attribute
*attr
;
1516 attr
= dwarf_attr (die
, DW_AT_name
);
1519 name
= DW_STRING (attr
);
1522 /* Ignore functions with missing or empty names and functions with
1523 missing or invalid low and high pc attributes. */
1524 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1530 if (objfile
->ei
.entry_point
>= lowpc
&&
1531 objfile
->ei
.entry_point
< highpc
)
1533 objfile
->ei
.entry_func_lowpc
= lowpc
;
1534 objfile
->ei
.entry_func_highpc
= highpc
;
1537 if (STREQ (name
, "main")) /* FIXME: hardwired name */
1539 objfile
->ei
.main_func_lowpc
= lowpc
;
1540 objfile
->ei
.main_func_highpc
= highpc
;
1543 /* Decode DW_AT_frame_base location descriptor if present, keep result
1544 for DW_OP_fbreg operands in decode_locdesc. */
1545 frame_base_reg
= -1;
1546 frame_base_offset
= 0;
1547 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1550 CORE_ADDR addr
= decode_locdesc (DW_BLOCK (attr
), objfile
);
1552 frame_base_reg
= addr
;
1555 frame_base_reg
= basereg
;
1556 frame_base_offset
= addr
;
1559 complain (&dwarf2_unsupported_at_frame_base
, name
);
1562 new = push_context (0, lowpc
);
1563 new->name
= new_symbol (die
, die
->type
, objfile
);
1564 list_in_scope
= &local_symbols
;
1566 if (die
->has_children
)
1568 child_die
= die
->next
;
1569 while (child_die
&& child_die
->tag
)
1571 process_die (child_die
, objfile
);
1572 child_die
= sibling_die (child_die
);
1576 new = pop_context ();
1577 /* Make a block for the local symbols within. */
1578 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1579 lowpc
, highpc
, objfile
);
1580 list_in_scope
= &file_symbols
;
1583 /* Process all the DIES contained within a lexical block scope. Start
1584 a new scope, process the dies, and then close the scope. */
1587 read_lexical_block_scope (die
, objfile
)
1588 struct die_info
*die
;
1589 struct objfile
*objfile
;
1591 register struct context_stack
*new;
1592 CORE_ADDR lowpc
, highpc
;
1593 struct die_info
*child_die
;
1595 /* Ignore blocks with missing or invalid low and high pc attributes. */
1596 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1601 push_context (0, lowpc
);
1602 if (die
->has_children
)
1604 child_die
= die
->next
;
1605 while (child_die
&& child_die
->tag
)
1607 process_die (child_die
, objfile
);
1608 child_die
= sibling_die (child_die
);
1611 new = pop_context ();
1613 if (local_symbols
!= NULL
)
1615 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
1618 local_symbols
= new->locals
;
1621 /* Get low and high pc attributes from a die.
1622 Return 1 if the attributes are present and valid, otherwise, return 0. */
1625 dwarf2_get_pc_bounds (die
, lowpc
, highpc
, objfile
)
1626 struct die_info
*die
;
1629 struct objfile
*objfile
;
1631 struct attribute
*attr
;
1635 attr
= dwarf_attr (die
, DW_AT_low_pc
);
1637 low
= DW_ADDR (attr
);
1640 attr
= dwarf_attr (die
, DW_AT_high_pc
);
1642 high
= DW_ADDR (attr
);
1649 /* When using the GNU linker, .gnu.linkonce. sections are used to
1650 eliminate duplicate copies of functions and vtables and such.
1651 The linker will arbitrarily choose one and discard the others.
1652 The AT_*_pc values for such functions refer to local labels in
1653 these sections. If the section from that file was discarded, the
1654 labels are not in the output, so the relocs get a value of 0.
1655 If this is a discarded function, mark the pc bounds as invalid,
1656 so that GDB will ignore it. */
1657 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
1665 /* Add an aggregate field to the field list. */
1668 dwarf2_add_field (fip
, die
, objfile
)
1669 struct field_info
*fip
;
1670 struct die_info
*die
;
1671 struct objfile
*objfile
;
1673 struct nextfield
*new_field
;
1674 struct attribute
*attr
;
1676 char *fieldname
= "";
1678 /* Allocate a new field list entry and link it in. */
1679 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
1680 make_cleanup (free
, new_field
);
1681 memset (new_field
, 0, sizeof (struct nextfield
));
1682 new_field
->next
= fip
->fields
;
1683 fip
->fields
= new_field
;
1686 /* Handle accessibility and virtuality of field.
1687 The default accessibility for members is public, the default
1688 accessibility for inheritance is private. */
1689 if (die
->tag
!= DW_TAG_inheritance
)
1690 new_field
->accessibility
= DW_ACCESS_public
;
1692 new_field
->accessibility
= DW_ACCESS_private
;
1693 new_field
->virtuality
= DW_VIRTUALITY_none
;
1695 attr
= dwarf_attr (die
, DW_AT_accessibility
);
1697 new_field
->accessibility
= DW_UNSND (attr
);
1698 if (new_field
->accessibility
!= DW_ACCESS_public
)
1699 fip
->non_public_fields
= 1;
1700 attr
= dwarf_attr (die
, DW_AT_virtuality
);
1702 new_field
->virtuality
= DW_UNSND (attr
);
1704 fp
= &new_field
->field
;
1705 if (die
->tag
== DW_TAG_member
)
1707 /* Get type of field. */
1708 fp
->type
= die_type (die
, objfile
);
1710 /* Get bit size of field (zero if none). */
1711 attr
= dwarf_attr (die
, DW_AT_bit_size
);
1714 fp
->bitsize
= DW_UNSND (attr
);
1721 /* Get bit offset of field. */
1722 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
1726 decode_locdesc (DW_BLOCK (attr
), objfile
) * bits_per_byte
;
1730 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
1733 if (BITS_BIG_ENDIAN
)
1735 /* For big endian bits, the DW_AT_bit_offset gives the
1736 additional bit offset from the MSB of the containing
1737 anonymous object to the MSB of the field. We don't
1738 have to do anything special since we don't need to
1739 know the size of the anonymous object. */
1740 fp
->bitpos
+= DW_UNSND (attr
);
1744 /* For little endian bits, compute the bit offset to the
1745 MSB of the anonymous object, subtract off the number of
1746 bits from the MSB of the field to the MSB of the
1747 object, and then subtract off the number of bits of
1748 the field itself. The result is the bit offset of
1749 the LSB of the field. */
1751 int bit_offset
= DW_UNSND (attr
);
1753 attr
= dwarf_attr (die
, DW_AT_byte_size
);
1756 /* The size of the anonymous object containing
1757 the bit field is explicit, so use the
1758 indicated size (in bytes). */
1759 anonymous_size
= DW_UNSND (attr
);
1763 /* The size of the anonymous object containing
1764 the bit field must be inferred from the type
1765 attribute of the data member containing the
1767 anonymous_size
= TYPE_LENGTH (fp
->type
);
1770 anonymous_size
* bits_per_byte
- bit_offset
- fp
->bitsize
;
1774 /* Get name of field. */
1775 attr
= dwarf_attr (die
, DW_AT_name
);
1776 if (attr
&& DW_STRING (attr
))
1777 fieldname
= DW_STRING (attr
);
1778 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
1779 &objfile
->type_obstack
);
1781 /* Change accessibility for artificial fields (e.g. virtual table
1782 pointer or virtual base class pointer) to private. */
1783 if (dwarf_attr (die
, DW_AT_artificial
))
1785 new_field
->accessibility
= DW_ACCESS_private
;
1786 fip
->non_public_fields
= 1;
1789 else if (die
->tag
== DW_TAG_variable
)
1791 char *physname
= "";
1793 /* C++ static member.
1794 Get physical name, extract field name from physical name. */
1795 attr
= dwarf_attr (die
, DW_AT_name
);
1796 if (attr
&& DW_STRING (attr
))
1800 physname
= DW_STRING (attr
);
1803 while (*cp
&& !is_cplus_marker (*cp
))
1808 if (*physname
== '\0' || *fieldname
== '\0')
1810 complain (&dwarf2_bad_static_member_name
, physname
);
1814 fp
->bitsize
= (long) obsavestring (physname
, strlen (physname
),
1815 &objfile
->type_obstack
);
1816 fp
->type
= die_type (die
, objfile
);
1817 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
1818 &objfile
->type_obstack
);
1820 else if (die
->tag
== DW_TAG_inheritance
)
1822 /* C++ base class field. */
1823 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
1825 fp
->bitpos
= decode_locdesc (DW_BLOCK (attr
), objfile
) * bits_per_byte
;
1827 fp
->type
= die_type (die
, objfile
);
1828 fp
->name
= type_name_no_tag (fp
->type
);
1829 fip
->nbaseclasses
++;
1833 /* Create the vector of fields, and attach it to the type. */
1836 dwarf2_attach_fields_to_type (fip
, type
, objfile
)
1837 struct field_info
*fip
;
1839 struct objfile
*objfile
;
1841 int nfields
= fip
->nfields
;
1843 /* Record the field count, allocate space for the array of fields,
1844 and create blank accessibility bitfields if necessary. */
1845 TYPE_NFIELDS (type
) = nfields
;
1846 TYPE_FIELDS (type
) = (struct field
*)
1847 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1848 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
1850 if (fip
->non_public_fields
)
1852 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1854 TYPE_FIELD_PRIVATE_BITS (type
) =
1855 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1856 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
1858 TYPE_FIELD_PROTECTED_BITS (type
) =
1859 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1860 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
1862 TYPE_FIELD_IGNORE_BITS (type
) =
1863 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1864 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
1867 /* If the type has baseclasses, allocate and clear a bit vector for
1868 TYPE_FIELD_VIRTUAL_BITS. */
1869 if (fip
->nbaseclasses
)
1871 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
1874 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1875 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
1876 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
1877 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
1878 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
1881 /* Copy the saved-up fields into the field vector. Start from the head
1882 of the list, adding to the tail of the field array, so that they end
1883 up in the same order in the array in which they were added to the list. */
1884 while (nfields
-- > 0)
1886 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
1887 switch (fip
->fields
->accessibility
)
1889 case DW_ACCESS_private
:
1890 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
1893 case DW_ACCESS_protected
:
1894 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
1897 case DW_ACCESS_public
:
1901 /* Unknown accessibility. Complain and treat it as public. */
1903 complain (&dwarf2_unsupported_accessibility
,
1904 fip
->fields
->accessibility
);
1908 if (nfields
< fip
->nbaseclasses
)
1910 switch (fip
->fields
->virtuality
)
1912 case DW_VIRTUALITY_virtual
:
1913 case DW_VIRTUALITY_pure_virtual
:
1914 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
1918 fip
->fields
= fip
->fields
->next
;
1922 /* Skip to the end of a member function name in a mangled name. */
1925 skip_member_fn_name (physname
)
1928 char *endname
= physname
;
1930 /* Skip over leading underscores. */
1931 while (*endname
== '_')
1934 /* Find two succesive underscores. */
1936 endname
= strchr (endname
, '_');
1937 while (endname
!= NULL
&& *++endname
!= '_');
1939 if (endname
== NULL
)
1941 complain (&dwarf2_bad_member_name_complaint
, physname
);
1946 /* Take care of trailing underscores. */
1947 if (endname
[1] != '_')
1953 /* Add a member function to the proper fieldlist. */
1956 dwarf2_add_member_fn (fip
, die
, type
, objfile
)
1957 struct field_info
*fip
;
1958 struct die_info
*die
;
1960 struct objfile
*objfile
;
1962 struct attribute
*attr
;
1963 struct fnfieldlist
*flp
;
1965 struct fn_field
*fnp
;
1967 char *physname
= "";
1968 struct nextfnfield
*new_fnfield
;
1970 /* Extract member function name from mangled name. */
1971 attr
= dwarf_attr (die
, DW_AT_name
);
1972 if (attr
&& DW_STRING (attr
))
1974 physname
= DW_STRING (attr
);
1976 if ((physname
[0] == '_' && physname
[1] == '_'
1977 && strchr ("0123456789Qt", physname
[2]))
1978 || DESTRUCTOR_PREFIX_P (physname
))
1980 /* Constructor and destructor field names are set to the name
1981 of the class, but without template parameter lists.
1982 The name might be missing for anonymous aggregates. */
1983 if (TYPE_TAG_NAME (type
))
1985 char *p
= strchr (TYPE_TAG_NAME (type
), '<');
1988 fieldname
= TYPE_TAG_NAME (type
);
1990 fieldname
= obsavestring (TYPE_TAG_NAME (type
),
1991 p
- TYPE_TAG_NAME (type
),
1992 &objfile
->type_obstack
);
1996 char *anon_name
= "";
1997 fieldname
= obsavestring (anon_name
, strlen (anon_name
),
1998 &objfile
->type_obstack
);
2003 char *endname
= skip_member_fn_name (physname
);
2005 /* Ignore member function if we were unable not extract the member
2007 if (endname
== physname
)
2009 fieldname
= obsavestring (physname
, endname
- physname
,
2010 &objfile
->type_obstack
);
2013 /* Look up member function name in fieldlist. */
2014 for (i
= 0; i
< fip
->nfnfields
; i
++)
2016 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2020 /* Create new list element if necessary. */
2021 if (i
< fip
->nfnfields
)
2022 flp
= &fip
->fnfieldlists
[i
];
2025 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2027 fip
->fnfieldlists
= (struct fnfieldlist
*)
2028 xrealloc (fip
->fnfieldlists
,
2029 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2030 * sizeof (struct fnfieldlist
));
2031 if (fip
->nfnfields
== 0)
2032 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2034 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2035 flp
->name
= fieldname
;
2041 /* Create a new member function field and chain it to the field list
2043 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2044 make_cleanup (free
, new_fnfield
);
2045 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2046 new_fnfield
->next
= flp
->head
;
2047 flp
->head
= new_fnfield
;
2050 /* Fill in the member function field info. */
2051 fnp
= &new_fnfield
->fnfield
;
2052 fnp
->physname
= physname
;
2053 fnp
->type
= alloc_type (objfile
);
2054 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2056 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2057 struct type
**arg_types
;
2058 int nparams
= TYPE_NFIELDS (die
->type
);
2061 /* Copy argument types from the subroutine type. */
2062 arg_types
= (struct type
**)
2063 TYPE_ALLOC (fnp
->type
, (nparams
+ 1) * sizeof (struct type
*));
2064 for (iparams
= 0; iparams
< nparams
; iparams
++)
2065 arg_types
[iparams
] = TYPE_FIELD_TYPE (die
->type
, iparams
);
2067 /* Set last entry in argument type vector. */
2068 if (TYPE_FLAGS (die
->type
) & TYPE_FLAG_VARARGS
)
2069 arg_types
[nparams
] = NULL
;
2071 arg_types
[nparams
] = dwarf2_fundamental_type (objfile
, FT_VOID
);
2073 smash_to_method_type (fnp
->type
, type
, return_type
, arg_types
);
2075 /* Handle static member functions.
2076 Dwarf2 has no clean way to discern C++ static and non-static
2077 member functions. G++ helps GDB by marking the first
2078 parameter for non-static member functions (which is the
2079 this pointer) as artificial. We obtain this information
2080 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2081 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2082 fnp
->voffset
= VOFFSET_STATIC
;
2085 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2087 /* Get fcontext from DW_AT_containing_type if present. */
2088 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2089 fnp
->fcontext
= die_containing_type (die
, objfile
);
2091 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2092 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2094 /* Get accessibility. */
2095 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2098 switch (DW_UNSND (attr
))
2100 case DW_ACCESS_private
:
2101 fnp
->is_private
= 1;
2103 case DW_ACCESS_protected
:
2104 fnp
->is_protected
= 1;
2109 /* Get index in virtual function table if it is a virtual member function. */
2110 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2112 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
) + 2;
2115 /* Create the vector of member function fields, and attach it to the type. */
2118 dwarf2_attach_fn_fields_to_type (fip
, type
, objfile
)
2119 struct field_info
*fip
;
2121 struct objfile
*objfile
;
2123 struct fnfieldlist
*flp
;
2124 int total_length
= 0;
2127 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2128 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2129 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2131 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2133 struct nextfnfield
*nfp
= flp
->head
;
2134 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2137 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2138 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2139 fn_flp
->fn_fields
= (struct fn_field
*)
2140 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2141 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2142 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2144 total_length
+= flp
->length
;
2147 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2148 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2151 /* Called when we find the DIE that starts a structure or union scope
2152 (definition) to process all dies that define the members of the
2155 NOTE: we need to call struct_type regardless of whether or not the
2156 DIE has an at_name attribute, since it might be an anonymous
2157 structure or union. This gets the type entered into our set of
2160 However, if the structure is incomplete (an opaque struct/union)
2161 then suppress creating a symbol table entry for it since gdb only
2162 wants to find the one with the complete definition. Note that if
2163 it is complete, we just call new_symbol, which does it's own
2164 checking about whether the struct/union is anonymous or not (and
2165 suppresses creating a symbol table entry itself). */
2168 read_structure_scope (die
, objfile
)
2169 struct die_info
*die
;
2170 struct objfile
*objfile
;
2173 struct attribute
*attr
;
2175 type
= alloc_type (objfile
);
2177 INIT_CPLUS_SPECIFIC (type
);
2178 attr
= dwarf_attr (die
, DW_AT_name
);
2179 if (attr
&& DW_STRING (attr
))
2181 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2182 strlen (DW_STRING (attr
)),
2183 &objfile
->type_obstack
);
2186 if (die
->tag
== DW_TAG_structure_type
)
2188 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2190 else if (die
->tag
== DW_TAG_union_type
)
2192 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2196 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2198 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2201 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2204 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2208 TYPE_LENGTH (type
) = 0;
2211 /* We need to add the type field to the die immediately so we don't
2212 infinitely recurse when dealing with pointers to the structure
2213 type within the structure itself. */
2216 if (die
->has_children
)
2218 struct field_info fi
;
2219 struct die_info
*child_die
;
2220 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2222 memset (&fi
, 0, sizeof (struct field_info
));
2224 child_die
= die
->next
;
2226 while (child_die
&& child_die
->tag
)
2228 if (child_die
->tag
== DW_TAG_member
)
2230 dwarf2_add_field (&fi
, child_die
, objfile
);
2232 else if (child_die
->tag
== DW_TAG_variable
)
2234 /* C++ static member. */
2235 dwarf2_add_field (&fi
, child_die
, objfile
);
2237 else if (child_die
->tag
== DW_TAG_subprogram
)
2239 /* C++ member function. */
2240 process_die (child_die
, objfile
);
2241 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
);
2243 else if (child_die
->tag
== DW_TAG_inheritance
)
2245 /* C++ base class field. */
2246 dwarf2_add_field (&fi
, child_die
, objfile
);
2250 process_die (child_die
, objfile
);
2252 child_die
= sibling_die (child_die
);
2255 /* Attach fields and member functions to the type. */
2257 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2260 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2262 /* Get the type which refers to the base class (possibly this
2263 class itself) which contains the vtable pointer for the current
2264 class from the DW_AT_containing_type attribute. */
2266 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2268 struct type
*t
= die_containing_type (die
, objfile
);
2270 TYPE_VPTR_BASETYPE (type
) = t
;
2273 static const char vptr_name
[] = { '_','v','p','t','r','\0' };
2276 /* Our own class provides vtbl ptr. */
2277 for (i
= TYPE_NFIELDS (t
) - 1;
2278 i
>= TYPE_N_BASECLASSES (t
);
2281 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2283 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2284 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2286 TYPE_VPTR_FIELDNO (type
) = i
;
2291 /* Complain if virtual function table field not found. */
2292 if (i
< TYPE_N_BASECLASSES (t
))
2293 complain (&dwarf2_vtbl_not_found_complaint
,
2294 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2298 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2303 new_symbol (die
, type
, objfile
);
2305 do_cleanups (back_to
);
2309 /* No children, must be stub. */
2310 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2316 /* Given a pointer to a die which begins an enumeration, process all
2317 the dies that define the members of the enumeration.
2319 This will be much nicer in draft 6 of the DWARF spec when our
2320 members will be dies instead squished into the DW_AT_element_list
2323 NOTE: We reverse the order of the element list. */
2326 read_enumeration (die
, objfile
)
2327 struct die_info
*die
;
2328 struct objfile
*objfile
;
2330 struct die_info
*child_die
;
2332 struct field
*fields
;
2333 struct attribute
*attr
;
2336 int unsigned_enum
= 1;
2338 type
= alloc_type (objfile
);
2340 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2341 attr
= dwarf_attr (die
, DW_AT_name
);
2342 if (attr
&& DW_STRING (attr
))
2344 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2345 strlen (DW_STRING (attr
)),
2346 &objfile
->type_obstack
);
2349 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2352 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2356 TYPE_LENGTH (type
) = 0;
2361 if (die
->has_children
)
2363 child_die
= die
->next
;
2364 while (child_die
&& child_die
->tag
)
2366 if (child_die
->tag
!= DW_TAG_enumerator
)
2368 process_die (child_die
, objfile
);
2372 attr
= dwarf_attr (child_die
, DW_AT_name
);
2375 sym
= new_symbol (child_die
, type
, objfile
);
2376 if (SYMBOL_VALUE (sym
) < 0)
2379 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2381 fields
= (struct field
*)
2383 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2384 * sizeof (struct field
));
2387 fields
[num_fields
].name
= SYMBOL_NAME (sym
);
2388 fields
[num_fields
].type
= NULL
;
2389 fields
[num_fields
].bitpos
= SYMBOL_VALUE (sym
);
2390 fields
[num_fields
].bitsize
= 0;
2396 child_die
= sibling_die (child_die
);
2401 TYPE_NFIELDS (type
) = num_fields
;
2402 TYPE_FIELDS (type
) = (struct field
*)
2403 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2404 memcpy (TYPE_FIELDS (type
), fields
,
2405 sizeof (struct field
) * num_fields
);
2409 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2412 new_symbol (die
, type
, objfile
);
2415 /* Extract all information from a DW_TAG_array_type DIE and put it in
2416 the DIE's type field. For now, this only handles one dimensional
2420 read_array_type (die
, objfile
)
2421 struct die_info
*die
;
2422 struct objfile
*objfile
;
2424 struct die_info
*child_die
;
2425 struct type
*type
= NULL
;
2426 struct type
*element_type
, *range_type
, *index_type
;
2427 struct type
**range_types
= NULL
;
2428 struct attribute
*attr
;
2430 struct cleanup
*back_to
;
2432 /* Return if we've already decoded this type. */
2438 element_type
= die_type (die
, objfile
);
2440 /* Irix 6.2 native cc creates array types without children for
2441 arrays with unspecified length. */
2442 if (die
->has_children
== 0)
2444 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2445 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2446 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2450 back_to
= make_cleanup (null_cleanup
, NULL
);
2451 child_die
= die
->next
;
2452 while (child_die
&& child_die
->tag
)
2454 if (child_die
->tag
== DW_TAG_subrange_type
)
2456 unsigned int low
, high
;
2458 /* Default bounds to an array with unspecified length. */
2461 if (cu_language
== DW_LANG_Fortran77
2462 || cu_language
== DW_LANG_Fortran90
)
2464 /* FORTRAN implies a lower bound of 1, if not given. */
2468 index_type
= die_type (child_die
, objfile
);
2469 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2472 if (attr
->form
== DW_FORM_sdata
)
2474 low
= DW_SND (attr
);
2476 else if (attr
->form
== DW_FORM_udata
2477 || attr
->form
== DW_FORM_data1
2478 || attr
->form
== DW_FORM_data2
2479 || attr
->form
== DW_FORM_data4
)
2481 low
= DW_UNSND (attr
);
2485 complain (&dwarf2_non_const_array_bound_ignored
,
2486 dwarf_form_name (attr
->form
));
2488 die
->type
= lookup_pointer_type (element_type
);
2495 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2498 if (attr
->form
== DW_FORM_sdata
)
2500 high
= DW_SND (attr
);
2502 else if (attr
->form
== DW_FORM_udata
2503 || attr
->form
== DW_FORM_data1
2504 || attr
->form
== DW_FORM_data2
2505 || attr
->form
== DW_FORM_data4
)
2507 high
= DW_UNSND (attr
);
2509 else if (attr
->form
== DW_FORM_block1
)
2511 /* GCC encodes arrays with unspecified or dynamic length
2512 with a DW_FORM_block1 attribute.
2513 FIXME: GDB does not yet know how to handle dynamic
2514 arrays properly, treat them as arrays with unspecified
2520 complain (&dwarf2_non_const_array_bound_ignored
,
2521 dwarf_form_name (attr
->form
));
2523 die
->type
= lookup_pointer_type (element_type
);
2531 /* Create a range type and save it for array type creation. */
2532 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2534 range_types
= (struct type
**)
2535 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2536 * sizeof (struct type
*));
2538 make_cleanup (free_current_contents
, &range_types
);
2540 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2542 child_die
= sibling_die (child_die
);
2545 /* Dwarf2 dimensions are output from left to right, create the
2546 necessary array types in backwards order. */
2547 type
= element_type
;
2549 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2551 do_cleanups (back_to
);
2553 /* Install the type in the die. */
2557 /* First cut: install each common block member as a global variable. */
2560 read_common_block (die
, objfile
)
2561 struct die_info
*die
;
2562 struct objfile
*objfile
;
2564 struct die_info
*child_die
;
2565 struct attribute
*attr
;
2567 CORE_ADDR base
= (CORE_ADDR
) 0;
2569 attr
= dwarf_attr (die
, DW_AT_location
);
2572 base
= decode_locdesc (DW_BLOCK (attr
), objfile
);
2574 if (die
->has_children
)
2576 child_die
= die
->next
;
2577 while (child_die
&& child_die
->tag
)
2579 sym
= new_symbol (child_die
, NULL
, objfile
);
2580 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2583 SYMBOL_VALUE_ADDRESS (sym
) =
2584 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
);
2585 add_symbol_to_list (sym
, &global_symbols
);
2587 child_die
= sibling_die (child_die
);
2592 /* Extract all information from a DW_TAG_pointer_type DIE and add to
2593 the user defined type vector. */
2596 read_tag_pointer_type (die
, objfile
)
2597 struct die_info
*die
;
2598 struct objfile
*objfile
;
2601 struct attribute
*attr
;
2608 type
= lookup_pointer_type (die_type (die
, objfile
));
2609 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2612 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2616 TYPE_LENGTH (type
) = address_size
;
2621 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
2622 the user defined type vector. */
2625 read_tag_ptr_to_member_type (die
, objfile
)
2626 struct die_info
*die
;
2627 struct objfile
*objfile
;
2630 struct type
*to_type
;
2631 struct type
*domain
;
2638 type
= alloc_type (objfile
);
2639 to_type
= die_type (die
, objfile
);
2640 domain
= die_containing_type (die
, objfile
);
2641 smash_to_member_type (type
, domain
, to_type
);
2646 /* Extract all information from a DW_TAG_reference_type DIE and add to
2647 the user defined type vector. */
2650 read_tag_reference_type (die
, objfile
)
2651 struct die_info
*die
;
2652 struct objfile
*objfile
;
2655 struct attribute
*attr
;
2662 type
= lookup_reference_type (die_type (die
, objfile
));
2663 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2666 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2670 TYPE_LENGTH (type
) = address_size
;
2676 read_tag_const_type (die
, objfile
)
2677 struct die_info
*die
;
2678 struct objfile
*objfile
;
2685 complain (&dwarf2_const_ignored
);
2686 die
->type
= die_type (die
, objfile
);
2690 read_tag_volatile_type (die
, objfile
)
2691 struct die_info
*die
;
2692 struct objfile
*objfile
;
2699 complain (&dwarf2_volatile_ignored
);
2700 die
->type
= die_type (die
, objfile
);
2703 /* Extract all information from a DW_TAG_string_type DIE and add to
2704 the user defined type vector. It isn't really a user defined type,
2705 but it behaves like one, with other DIE's using an AT_user_def_type
2706 attribute to reference it. */
2709 read_tag_string_type (die
, objfile
)
2710 struct die_info
*die
;
2711 struct objfile
*objfile
;
2713 struct type
*type
, *range_type
, *index_type
, *char_type
;
2714 struct attribute
*attr
;
2715 unsigned int length
;
2722 attr
= dwarf_attr (die
, DW_AT_string_length
);
2725 length
= DW_UNSND (attr
);
2731 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2732 range_type
= create_range_type (NULL
, index_type
, 1, length
);
2733 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
2734 type
= create_string_type (char_type
, range_type
);
2738 /* Handle DIES due to C code like:
2742 int (*funcp)(int a, long l);
2746 ('funcp' generates a DW_TAG_subroutine_type DIE)
2750 read_subroutine_type (die
, objfile
)
2751 struct die_info
*die
;
2752 struct objfile
*objfile
;
2754 struct type
*type
; /* Type that this function returns */
2755 struct type
*ftype
; /* Function that returns above type */
2756 struct attribute
*attr
;
2758 /* Decode the type that this subroutine returns */
2763 type
= die_type (die
, objfile
);
2764 ftype
= lookup_function_type (type
);
2765 attr
= dwarf_attr (die
, DW_AT_prototyped
);
2766 if (attr
&& (DW_UNSND (attr
) != 0))
2767 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
2769 if (die
->has_children
)
2771 struct die_info
*child_die
;
2775 /* Count the number of parameters.
2776 FIXME: GDB currently ignores vararg functions, but knows about
2777 vararg member functions. */
2778 child_die
= die
->next
;
2779 while (child_die
&& child_die
->tag
)
2781 if (child_die
->tag
== DW_TAG_formal_parameter
)
2783 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
2784 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
2785 child_die
= sibling_die (child_die
);
2788 /* Allocate storage for parameters and fill them in. */
2789 TYPE_NFIELDS (ftype
) = nparams
;
2790 TYPE_FIELDS (ftype
) = (struct field
*)
2791 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
2793 child_die
= die
->next
;
2794 while (child_die
&& child_die
->tag
)
2796 if (child_die
->tag
== DW_TAG_formal_parameter
)
2798 /* Dwarf2 has no clean way to discern C++ static and non-static
2799 member functions. G++ helps GDB by marking the first
2800 parameter for non-static member functions (which is the
2801 this pointer) as artificial. We pass this information
2802 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
2803 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
2805 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
2807 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
2808 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
);
2811 child_die
= sibling_die (child_die
);
2819 read_typedef (die
, objfile
)
2820 struct die_info
*die
;
2821 struct objfile
*objfile
;
2827 struct attribute
*attr
;
2830 xtype
= die_type (die
, objfile
);
2832 type
= alloc_type (objfile
);
2833 TYPE_CODE (type
) = TYPE_CODE_TYPEDEF
;
2834 TYPE_FLAGS (type
) |= TYPE_FLAG_TARGET_STUB
;
2835 TYPE_TARGET_TYPE (type
) = xtype
;
2836 attr
= dwarf_attr (die
, DW_AT_name
);
2837 if (attr
&& DW_STRING (attr
))
2838 TYPE_NAME (type
) = obsavestring (DW_STRING (attr
),
2839 strlen (DW_STRING (attr
)),
2840 &objfile
->type_obstack
);
2846 /* Find a representation of a given base type and install
2847 it in the TYPE field of the die. */
2850 read_base_type (die
, objfile
)
2851 struct die_info
*die
;
2852 struct objfile
*objfile
;
2855 struct attribute
*attr
;
2856 int encoding
= 0, size
= 0;
2858 /* If we've already decoded this die, this is a no-op. */
2864 attr
= dwarf_attr (die
, DW_AT_encoding
);
2867 encoding
= DW_UNSND (attr
);
2869 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2872 size
= DW_UNSND (attr
);
2874 attr
= dwarf_attr (die
, DW_AT_name
);
2875 if (attr
&& DW_STRING (attr
))
2877 enum type_code code
= TYPE_CODE_INT
;
2878 int is_unsigned
= 0;
2882 case DW_ATE_address
:
2883 /* Turn DW_ATE_address into a void * pointer. */
2884 code
= TYPE_CODE_PTR
;
2887 case DW_ATE_boolean
:
2888 code
= TYPE_CODE_BOOL
;
2891 case DW_ATE_complex_float
:
2892 code
= TYPE_CODE_COMPLEX
;
2895 code
= TYPE_CODE_FLT
;
2898 case DW_ATE_signed_char
:
2900 case DW_ATE_unsigned
:
2901 case DW_ATE_unsigned_char
:
2905 complain (&dwarf2_unsupported_at_encoding
,
2906 dwarf_type_encoding_name (encoding
));
2909 type
= init_type (code
, size
, is_unsigned
, DW_STRING (attr
), objfile
);
2910 if (encoding
== DW_ATE_address
)
2911 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
2915 type
= dwarf_base_type (encoding
, size
, objfile
);
2920 /* Read a whole compilation unit into a linked list of dies. */
2923 read_comp_unit (info_ptr
, abfd
)
2927 struct die_info
*first_die
, *last_die
, *die
;
2931 /* Reset die reference table, we are building a new one now. */
2932 dwarf2_empty_die_ref_table ();
2936 first_die
= last_die
= NULL
;
2939 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
);
2940 if (die
->has_children
)
2951 /* Enter die in reference hash table */
2952 store_in_ref_table (die
->offset
, die
);
2956 first_die
= last_die
= die
;
2960 last_die
->next
= die
;
2964 while (nesting_level
> 0);
2968 /* Free a linked list of dies. */
2971 free_die_list (dies
)
2972 struct die_info
*dies
;
2974 struct die_info
*die
, *next
;
2986 /* Read the contents of the section at OFFSET and of size SIZE from the
2987 object file specified by OBJFILE into the psymbol_obstack and return it. */
2990 dwarf2_read_section (objfile
, offset
, size
)
2991 struct objfile
*objfile
;
2995 bfd
*abfd
= objfile
->obfd
;
3001 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3002 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3003 (bfd_read (buf
, size
, 1, abfd
) != size
))
3006 error ("Dwarf Error: Can't read DWARF data from '%s'",
3007 bfd_get_filename (abfd
));
3012 /* In DWARF version 2, the description of the debugging information is
3013 stored in a separate .debug_abbrev section. Before we read any
3014 dies from a section we read in all abbreviations and install them
3018 dwarf2_read_abbrevs (abfd
, offset
)
3020 unsigned int offset
;
3023 struct abbrev_info
*cur_abbrev
;
3024 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3025 unsigned int abbrev_form
, hash_number
;
3027 /* empty the table */
3028 dwarf2_empty_abbrev_table (NULL
);
3030 abbrev_ptr
= dwarf_abbrev_buffer
+ offset
;
3031 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3032 abbrev_ptr
+= bytes_read
;
3034 /* loop until we reach an abbrev number of 0 */
3035 while (abbrev_number
)
3037 cur_abbrev
= dwarf_alloc_abbrev ();
3039 /* read in abbrev header */
3040 cur_abbrev
->number
= abbrev_number
;
3041 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3042 abbrev_ptr
+= bytes_read
;
3043 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3046 /* now read in declarations */
3047 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3048 abbrev_ptr
+= bytes_read
;
3049 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3050 abbrev_ptr
+= bytes_read
;
3053 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3055 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3056 xrealloc (cur_abbrev
->attrs
,
3057 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3058 * sizeof (struct attr_abbrev
));
3060 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3061 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3062 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3063 abbrev_ptr
+= bytes_read
;
3064 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3065 abbrev_ptr
+= bytes_read
;
3068 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3069 cur_abbrev
->next
= dwarf2_abbrevs
[hash_number
];
3070 dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3072 /* Get next abbreviation.
3073 Under Irix6 the abbreviations for a compilation unit are not
3074 always properly terminated with an abbrev number of 0.
3075 Exit loop if we encounter an abbreviation which we have
3076 already read (which means we are about to read the abbreviations
3077 for the next compile unit) or if the end of the abbreviation
3078 table is reached. */
3079 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3080 >= dwarf_abbrev_size
)
3082 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3083 abbrev_ptr
+= bytes_read
;
3084 if (dwarf2_lookup_abbrev (abbrev_number
) != NULL
)
3089 /* Empty the abbrev table for a new compilation unit. */
3093 dwarf2_empty_abbrev_table (ignore
)
3097 struct abbrev_info
*abbrev
, *next
;
3099 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3102 abbrev
= dwarf2_abbrevs
[i
];
3105 next
= abbrev
->next
;
3106 free (abbrev
->attrs
);
3110 dwarf2_abbrevs
[i
] = NULL
;
3114 /* Lookup an abbrev_info structure in the abbrev hash table. */
3116 static struct abbrev_info
*
3117 dwarf2_lookup_abbrev (number
)
3118 unsigned int number
;
3120 unsigned int hash_number
;
3121 struct abbrev_info
*abbrev
;
3123 hash_number
= number
% ABBREV_HASH_SIZE
;
3124 abbrev
= dwarf2_abbrevs
[hash_number
];
3128 if (abbrev
->number
== number
)
3131 abbrev
= abbrev
->next
;
3136 /* Read a minimal amount of information into the minimal die structure. */
3139 read_partial_die (part_die
, abfd
, info_ptr
, has_pc_info
)
3140 struct partial_die_info
*part_die
;
3145 unsigned int abbrev_number
, bytes_read
, i
;
3146 struct abbrev_info
*abbrev
;
3147 struct attribute attr
;
3148 struct attribute spec_attr
;
3149 int found_spec_attr
= 0;
3150 int has_low_pc_attr
= 0;
3151 int has_high_pc_attr
= 0;
3153 *part_die
= zeroed_partial_die
;
3155 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3156 info_ptr
+= bytes_read
;
3160 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3163 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3165 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3166 part_die
->tag
= abbrev
->tag
;
3167 part_die
->has_children
= abbrev
->has_children
;
3168 part_die
->abbrev
= abbrev_number
;
3170 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3172 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
);
3174 /* Store the data if it is of an attribute we want to keep in a
3175 partial symbol table. */
3179 part_die
->name
= DW_STRING (&attr
);
3182 has_low_pc_attr
= 1;
3183 part_die
->lowpc
= DW_ADDR (&attr
);
3186 has_high_pc_attr
= 1;
3187 part_die
->highpc
= DW_ADDR (&attr
);
3189 case DW_AT_location
:
3190 part_die
->locdesc
= DW_BLOCK (&attr
);
3192 case DW_AT_language
:
3193 part_die
->language
= DW_UNSND (&attr
);
3195 case DW_AT_external
:
3196 part_die
->is_external
= DW_UNSND (&attr
);
3198 case DW_AT_declaration
:
3199 part_die
->is_declaration
= DW_UNSND (&attr
);
3202 part_die
->has_type
= 1;
3204 case DW_AT_abstract_origin
:
3205 case DW_AT_specification
:
3206 found_spec_attr
= 1;
3210 /* Ignore absolute siblings, they might point outside of
3211 the current compile unit. */
3212 if (attr
.form
== DW_FORM_ref_addr
)
3213 complain(&dwarf2_absolute_sibling_complaint
);
3216 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3223 /* If we found a reference attribute and the die has no name, try
3224 to find a name in the referred to die. */
3226 if (found_spec_attr
&& part_die
->name
== NULL
)
3228 struct partial_die_info spec_die
;
3232 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3233 read_partial_die (&spec_die
, abfd
, spec_ptr
, &dummy
);
3236 part_die
->name
= spec_die
.name
;
3238 /* Copy DW_AT_external attribute if it is set. */
3239 if (spec_die
.is_external
)
3240 part_die
->is_external
= spec_die
.is_external
;
3244 /* When using the GNU linker, .gnu.linkonce. sections are used to
3245 eliminate duplicate copies of functions and vtables and such.
3246 The linker will arbitrarily choose one and discard the others.
3247 The AT_*_pc values for such functions refer to local labels in
3248 these sections. If the section from that file was discarded, the
3249 labels are not in the output, so the relocs get a value of 0.
3250 If this is a discarded function, mark the pc bounds as invalid,
3251 so that GDB will ignore it. */
3252 if (has_low_pc_attr
&& has_high_pc_attr
3253 && part_die
->lowpc
< part_die
->highpc
3254 && (part_die
->lowpc
!= 0
3255 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3260 /* Read the die from the .debug_info section buffer. And set diep to
3261 point to a newly allocated die with its information. */
3264 read_full_die (diep
, abfd
, info_ptr
)
3265 struct die_info
**diep
;
3269 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3270 struct abbrev_info
*abbrev
;
3271 struct die_info
*die
;
3273 offset
= info_ptr
- dwarf_info_buffer
;
3274 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3275 info_ptr
+= bytes_read
;
3278 die
= dwarf_alloc_die ();
3280 die
->abbrev
= abbrev_number
;
3286 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3289 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3291 die
= dwarf_alloc_die ();
3292 die
->offset
= offset
;
3293 die
->tag
= abbrev
->tag
;
3294 die
->has_children
= abbrev
->has_children
;
3295 die
->abbrev
= abbrev_number
;
3298 die
->num_attrs
= abbrev
->num_attrs
;
3299 die
->attrs
= (struct attribute
*)
3300 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3302 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3304 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3312 /* Read an attribute described by an abbreviated attribute. */
3315 read_attribute (attr
, abbrev
, abfd
, info_ptr
)
3316 struct attribute
*attr
;
3317 struct attr_abbrev
*abbrev
;
3321 unsigned int bytes_read
;
3322 struct dwarf_block
*blk
;
3324 attr
->name
= abbrev
->name
;
3325 attr
->form
= abbrev
->form
;
3326 switch (abbrev
->form
)
3329 case DW_FORM_ref_addr
:
3330 DW_ADDR (attr
) = read_address (abfd
, info_ptr
);
3331 info_ptr
+= address_size
;
3333 case DW_FORM_block2
:
3334 blk
= dwarf_alloc_block ();
3335 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3337 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3338 info_ptr
+= blk
->size
;
3339 DW_BLOCK (attr
) = blk
;
3341 case DW_FORM_block4
:
3342 blk
= dwarf_alloc_block ();
3343 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3345 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3346 info_ptr
+= blk
->size
;
3347 DW_BLOCK (attr
) = blk
;
3350 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3354 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3358 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3361 case DW_FORM_string
:
3362 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3363 info_ptr
+= bytes_read
;
3366 blk
= dwarf_alloc_block ();
3367 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3368 info_ptr
+= bytes_read
;
3369 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3370 info_ptr
+= blk
->size
;
3371 DW_BLOCK (attr
) = blk
;
3373 case DW_FORM_block1
:
3374 blk
= dwarf_alloc_block ();
3375 blk
->size
= read_1_byte (abfd
, info_ptr
);
3377 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3378 info_ptr
+= blk
->size
;
3379 DW_BLOCK (attr
) = blk
;
3382 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3386 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3390 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3391 info_ptr
+= bytes_read
;
3394 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3395 info_ptr
+= bytes_read
;
3398 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3402 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3406 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3409 case DW_FORM_ref_udata
:
3410 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3411 info_ptr
+= bytes_read
;
3414 case DW_FORM_indirect
:
3416 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3417 dwarf_form_name (abbrev
->form
));
3422 /* read dwarf information from a buffer */
3425 read_1_byte (abfd
, buf
)
3429 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3433 read_1_signed_byte (abfd
, buf
)
3437 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3441 read_2_bytes (abfd
, buf
)
3445 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3449 read_2_signed_bytes (abfd
, buf
)
3453 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3457 read_4_bytes (abfd
, buf
)
3461 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3465 read_4_signed_bytes (abfd
, buf
)
3469 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3473 read_8_bytes (abfd
, buf
)
3477 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3481 read_address (abfd
, buf
)
3485 CORE_ADDR retval
= 0;
3487 if (address_size
== 4)
3489 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3490 } else { /* *THE* alternative is 8, right? */
3491 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3497 read_n_bytes (abfd
, buf
, size
)
3502 /* If the size of a host char is 8 bits, we can return a pointer
3503 to the buffer, otherwise we have to copy the data to a buffer
3504 allocated on the temporary obstack. */
3505 #if HOST_CHAR_BIT == 8
3511 ret
= obstack_alloc (&dwarf2_tmp_obstack
, size
);
3512 for (i
= 0; i
< size
; ++i
)
3514 ret
[i
] = bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3522 read_string (abfd
, buf
, bytes_read_ptr
)
3525 unsigned int *bytes_read_ptr
;
3527 /* If the size of a host char is 8 bits, we can return a pointer
3528 to the string, otherwise we have to copy the string to a buffer
3529 allocated on the temporary obstack. */
3530 #if HOST_CHAR_BIT == 8
3533 *bytes_read_ptr
= 1;
3536 *bytes_read_ptr
= strlen (buf
) + 1;
3542 while ((byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
)) != 0)
3544 obstack_1grow (&dwarf2_tmp_obstack
, byte
);
3550 *bytes_read_ptr
= 1;
3553 obstack_1grow (&dwarf2_tmp_obstack
, '\0');
3554 *bytes_read_ptr
= i
+ 1;
3555 return obstack_finish (&dwarf2_tmp_obstack
);
3560 read_unsigned_leb128 (abfd
, buf
, bytes_read_ptr
)
3563 unsigned int *bytes_read_ptr
;
3565 unsigned int result
, num_read
;
3575 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3578 result
|= ((byte
& 127) << shift
);
3579 if ((byte
& 128) == 0)
3585 *bytes_read_ptr
= num_read
;
3590 read_signed_leb128 (abfd
, buf
, bytes_read_ptr
)
3593 unsigned int *bytes_read_ptr
;
3596 int i
, shift
, size
, num_read
;
3606 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3609 result
|= ((byte
& 127) << shift
);
3611 if ((byte
& 128) == 0)
3616 if ((shift
< size
) && (byte
& 0x40))
3618 result
|= -(1 << shift
);
3620 *bytes_read_ptr
= num_read
;
3625 set_cu_language (lang
)
3632 case DW_LANG_Fortran77
:
3633 cu_language
= language_c
;
3635 case DW_LANG_C_plus_plus
:
3636 cu_language
= language_cplus
;
3638 case DW_LANG_Mips_Assembler
:
3639 cu_language
= language_asm
;
3642 case DW_LANG_Cobol74
:
3643 case DW_LANG_Cobol85
:
3645 case DW_LANG_Fortran77
: /* moved up top for now */
3647 case DW_LANG_Fortran90
:
3648 case DW_LANG_Pascal83
:
3649 case DW_LANG_Modula2
:
3651 cu_language
= language_unknown
;
3654 cu_language_defn
= language_def (cu_language
);
3657 /* Return the named attribute or NULL if not there. */
3659 static struct attribute
*
3660 dwarf_attr (die
, name
)
3661 struct die_info
*die
;
3665 struct attribute
*spec
= NULL
;
3667 for (i
= 0; i
< die
->num_attrs
; ++i
)
3669 if (die
->attrs
[i
].name
== name
)
3671 return &die
->attrs
[i
];
3673 if (die
->attrs
[i
].name
== DW_AT_specification
3674 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
3675 spec
= &die
->attrs
[i
];
3679 struct die_info
*ref_die
=
3680 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
3683 return dwarf_attr (ref_die
, name
);
3689 /* Decode the line number information for the compilation unit whose
3690 line number info is at OFFSET in the .debug_line section.
3691 The compilation directory of the file is passed in COMP_DIR. */
3695 unsigned int num_files
;
3708 unsigned int num_dirs
;
3713 dwarf_decode_lines (offset
, comp_dir
, abfd
)
3714 unsigned int offset
;
3720 struct line_head lh
;
3721 struct cleanup
*back_to
;
3722 unsigned int i
, bytes_read
;
3723 char *cur_file
, *cur_dir
;
3724 unsigned char op_code
, extended_op
, adj_opcode
;
3726 #define FILE_ALLOC_CHUNK 5
3727 #define DIR_ALLOC_CHUNK 5
3729 struct filenames files
;
3730 struct directories dirs
;
3732 if (dwarf_line_buffer
== NULL
)
3734 complain (&dwarf2_missing_line_number_section
);
3738 files
.num_files
= 0;
3744 line_ptr
= dwarf_line_buffer
+ offset
;
3746 /* read in the prologue */
3747 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
3749 line_end
= line_ptr
+ lh
.total_length
;
3750 lh
.version
= read_2_bytes (abfd
, line_ptr
);
3752 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
);
3754 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
3756 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
3758 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
3760 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
3762 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
3764 lh
.standard_opcode_lengths
= (unsigned char *)
3765 xmalloc (lh
.opcode_base
* sizeof (unsigned char));
3766 back_to
= make_cleanup (free_current_contents
, &lh
.standard_opcode_lengths
);
3768 lh
.standard_opcode_lengths
[0] = 1;
3769 for (i
= 1; i
< lh
.opcode_base
; ++i
)
3771 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
3775 /* Read directory table */
3776 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
3778 line_ptr
+= bytes_read
;
3779 if ((dirs
.num_dirs
% DIR_ALLOC_CHUNK
) == 0)
3781 dirs
.dirs
= (char **)
3782 xrealloc (dirs
.dirs
,
3783 (dirs
.num_dirs
+ DIR_ALLOC_CHUNK
) * sizeof (char *));
3784 if (dirs
.num_dirs
== 0)
3785 make_cleanup (free_current_contents
, &dirs
.dirs
);
3787 dirs
.dirs
[dirs
.num_dirs
++] = cur_dir
;
3789 line_ptr
+= bytes_read
;
3791 /* Read file name table */
3792 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
3794 line_ptr
+= bytes_read
;
3795 if ((files
.num_files
% FILE_ALLOC_CHUNK
) == 0)
3797 files
.files
= (struct fileinfo
*)
3798 xrealloc (files
.files
,
3799 (files
.num_files
+ FILE_ALLOC_CHUNK
)
3800 * sizeof (struct fileinfo
));
3801 if (files
.num_files
== 0)
3802 make_cleanup (free_current_contents
, &files
.files
);
3804 files
.files
[files
.num_files
].name
= cur_file
;
3805 files
.files
[files
.num_files
].dir
=
3806 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3807 line_ptr
+= bytes_read
;
3808 files
.files
[files
.num_files
].time
=
3809 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3810 line_ptr
+= bytes_read
;
3811 files
.files
[files
.num_files
].size
=
3812 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3813 line_ptr
+= bytes_read
;
3816 line_ptr
+= bytes_read
;
3818 /* Read the statement sequences until there's nothing left. */
3819 while (line_ptr
< line_end
)
3821 /* state machine registers */
3822 unsigned int address
= 0;
3823 unsigned int file
= 1;
3824 unsigned int line
= 1;
3825 unsigned int column
= 0;
3826 int is_stmt
= lh
.default_is_stmt
;
3827 int basic_block
= 0;
3828 int end_sequence
= 0;
3830 /* Start a subfile for the current file of the state machine. */
3831 if (files
.num_files
>= file
)
3833 /* The file and directory tables are 0 based, the references
3835 dwarf2_start_subfile (files
.files
[file
- 1].name
,
3836 (files
.files
[file
- 1].dir
3837 ? dirs
.dirs
[files
.files
[file
- 1].dir
- 1]
3841 /* Decode the table. */
3842 while (! end_sequence
)
3844 op_code
= read_1_byte (abfd
, line_ptr
);
3848 case DW_LNS_extended_op
:
3849 line_ptr
+= 1; /* ignore length */
3850 extended_op
= read_1_byte (abfd
, line_ptr
);
3852 switch (extended_op
)
3854 case DW_LNE_end_sequence
:
3856 record_line (current_subfile
, line
, address
);
3858 case DW_LNE_set_address
:
3859 address
= read_address (abfd
, line_ptr
) + baseaddr
;
3860 line_ptr
+= address_size
;
3862 case DW_LNE_define_file
:
3863 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
3864 line_ptr
+= bytes_read
;
3865 if ((files
.num_files
% FILE_ALLOC_CHUNK
) == 0)
3867 files
.files
= (struct fileinfo
*)
3868 xrealloc (files
.files
,
3869 (files
.num_files
+ FILE_ALLOC_CHUNK
)
3870 * sizeof (struct fileinfo
));
3871 if (files
.num_files
== 0)
3872 make_cleanup (free_current_contents
, &files
.files
);
3874 files
.files
[files
.num_files
].name
= cur_file
;
3875 files
.files
[files
.num_files
].dir
=
3876 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3877 line_ptr
+= bytes_read
;
3878 files
.files
[files
.num_files
].time
=
3879 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3880 line_ptr
+= bytes_read
;
3881 files
.files
[files
.num_files
].size
=
3882 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3883 line_ptr
+= bytes_read
;
3887 complain (&dwarf2_mangled_line_number_section
);
3892 record_line (current_subfile
, line
, address
);
3895 case DW_LNS_advance_pc
:
3896 address
+= lh
.minimum_instruction_length
3897 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3898 line_ptr
+= bytes_read
;
3900 case DW_LNS_advance_line
:
3901 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
3902 line_ptr
+= bytes_read
;
3904 case DW_LNS_set_file
:
3905 /* The file and directory tables are 0 based, the references
3907 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3908 line_ptr
+= bytes_read
;
3909 dwarf2_start_subfile
3910 (files
.files
[file
- 1].name
,
3911 (files
.files
[file
- 1].dir
3912 ? dirs
.dirs
[files
.files
[file
- 1].dir
- 1]
3915 case DW_LNS_set_column
:
3916 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3917 line_ptr
+= bytes_read
;
3919 case DW_LNS_negate_stmt
:
3920 is_stmt
= (!is_stmt
);
3922 case DW_LNS_set_basic_block
:
3925 case DW_LNS_const_add_pc
:
3926 address
+= (255 - lh
.opcode_base
) / lh
.line_range
;
3928 case DW_LNS_fixed_advance_pc
:
3929 address
+= read_2_bytes (abfd
, line_ptr
);
3932 default: /* special operand */
3933 adj_opcode
= op_code
- lh
.opcode_base
;
3934 address
+= (adj_opcode
/ lh
.line_range
)
3935 * lh
.minimum_instruction_length
;
3936 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
3937 /* append row to matrix using current values */
3938 record_line (current_subfile
, line
, address
);
3944 do_cleanups (back_to
);
3947 /* Start a subfile for DWARF. FILENAME is the name of the file and
3948 DIRNAME the name of the source directory which contains FILENAME
3949 or NULL if not known.
3950 This routine tries to keep line numbers from identical absolute and
3951 relative file names in a common subfile.
3953 Using the `list' example from the GDB testsuite, which resides in
3954 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
3955 of /srcdir/list0.c yields the following debugging information for list0.c:
3957 DW_AT_name: /srcdir/list0.c
3958 DW_AT_comp_dir: /compdir
3959 files.files[0].name: list0.h
3960 files.files[0].dir: /srcdir
3961 files.files[1].name: list0.c
3962 files.files[1].dir: /srcdir
3964 The line number information for list0.c has to end up in a single
3965 subfile, so that `break /srcdir/list0.c:1' works as expected. */
3968 dwarf2_start_subfile (filename
, dirname
)
3972 /* If the filename isn't absolute, try to match an existing subfile
3973 with the full pathname. */
3975 if (*filename
!= '/' && dirname
!= NULL
)
3977 struct subfile
*subfile
;
3978 char *fullname
= concat (dirname
, "/", filename
, NULL
);
3980 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
3982 if (STREQ (subfile
->name
, fullname
))
3984 current_subfile
= subfile
;
3991 start_subfile (filename
, dirname
);
3994 /* Given a pointer to a DWARF information entry, figure out if we need
3995 to make a symbol table entry for it, and if so, create a new entry
3996 and return a pointer to it.
3997 If TYPE is NULL, determine symbol type from the die, otherwise
3998 used the passed type.
4001 static struct symbol
*
4002 new_symbol (die
, type
, objfile
)
4003 struct die_info
*die
;
4005 struct objfile
*objfile
;
4007 struct symbol
*sym
= NULL
;
4008 struct attribute
*attr
= NULL
;
4009 struct attribute
*attr2
= NULL
;
4012 attr
= dwarf_attr (die
, DW_AT_name
);
4013 if (attr
&& DW_STRING (attr
))
4015 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4016 sizeof (struct symbol
));
4017 OBJSTAT (objfile
, n_syms
++);
4018 memset (sym
, 0, sizeof (struct symbol
));
4019 SYMBOL_NAME (sym
) = obsavestring (DW_STRING (attr
),
4020 strlen (DW_STRING (attr
)),
4021 &objfile
->symbol_obstack
);
4023 /* Default assumptions.
4024 Use the passed type or decode it from the die. */
4025 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4026 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4028 SYMBOL_TYPE (sym
) = type
;
4030 SYMBOL_TYPE (sym
) = die_type (die
, objfile
);
4031 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4034 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4037 /* If this symbol is from a C++ compilation, then attempt to
4038 cache the demangled form for future reference. This is a
4039 typical time versus space tradeoff, that was decided in favor
4040 of time because it sped up C++ symbol lookups by a factor of
4043 SYMBOL_LANGUAGE (sym
) = cu_language
;
4044 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4048 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4051 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4053 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4055 case DW_TAG_subprogram
:
4056 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4058 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4059 attr2
= dwarf_attr (die
, DW_AT_external
);
4060 if (attr2
&& (DW_UNSND (attr2
) != 0))
4062 add_symbol_to_list (sym
, &global_symbols
);
4066 add_symbol_to_list (sym
, list_in_scope
);
4069 case DW_TAG_variable
:
4070 /* Compilation with minimal debug info may result in variables
4071 with missing type entries. Change the misleading `void' type
4072 to something sensible. */
4073 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4074 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4075 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4076 "<variable, no debug info>",
4078 attr
= dwarf_attr (die
, DW_AT_const_value
);
4081 dwarf2_const_value (attr
, sym
, objfile
);
4082 attr2
= dwarf_attr (die
, DW_AT_external
);
4083 if (attr2
&& (DW_UNSND (attr2
) != 0))
4084 add_symbol_to_list (sym
, &global_symbols
);
4086 add_symbol_to_list (sym
, list_in_scope
);
4089 attr
= dwarf_attr (die
, DW_AT_location
);
4092 attr2
= dwarf_attr (die
, DW_AT_external
);
4093 if (attr2
&& (DW_UNSND (attr2
) != 0))
4095 SYMBOL_VALUE_ADDRESS (sym
) =
4096 decode_locdesc (DW_BLOCK (attr
), objfile
);
4097 add_symbol_to_list (sym
, &global_symbols
);
4099 /* In shared libraries the address of the variable
4100 in the location descriptor might still be relocatable,
4101 so its value could be zero.
4102 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4103 value is zero, the address of the variable will then
4104 be determined from the minimal symbol table whenever
4105 the variable is referenced. */
4106 if (SYMBOL_VALUE_ADDRESS (sym
))
4108 SYMBOL_VALUE_ADDRESS (sym
) += baseaddr
;
4109 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4112 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4116 SYMBOL_VALUE (sym
) = addr
=
4117 decode_locdesc (DW_BLOCK (attr
), objfile
);
4118 add_symbol_to_list (sym
, list_in_scope
);
4121 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4125 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4129 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4130 SYMBOL_BASEREG (sym
) = basereg
;
4134 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4138 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4139 SYMBOL_VALUE_ADDRESS (sym
) = addr
+ baseaddr
;
4145 /* We do not know the address of this symbol.
4146 If it is an external symbol and we have type information
4147 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4148 The address of the variable will then be determined from
4149 the minimal symbol table whenever the variable is
4151 attr2
= dwarf_attr (die
, DW_AT_external
);
4152 if (attr2
&& (DW_UNSND (attr2
) != 0)
4153 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4155 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4156 add_symbol_to_list (sym
, &global_symbols
);
4160 case DW_TAG_formal_parameter
:
4161 attr
= dwarf_attr (die
, DW_AT_location
);
4164 SYMBOL_VALUE (sym
) = decode_locdesc (DW_BLOCK (attr
), objfile
);
4167 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4171 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4172 SYMBOL_BASEREG (sym
) = basereg
;
4176 SYMBOL_CLASS (sym
) = LOC_ARG
;
4179 attr
= dwarf_attr (die
, DW_AT_const_value
);
4182 dwarf2_const_value (attr
, sym
, objfile
);
4184 add_symbol_to_list (sym
, list_in_scope
);
4186 case DW_TAG_unspecified_parameters
:
4187 /* From varargs functions; gdb doesn't seem to have any
4188 interest in this information, so just ignore it for now.
4191 case DW_TAG_class_type
:
4192 case DW_TAG_structure_type
:
4193 case DW_TAG_union_type
:
4194 case DW_TAG_enumeration_type
:
4195 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4196 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
4197 add_symbol_to_list (sym
, list_in_scope
);
4199 /* The semantics of C++ state that "struct foo { ... }" also
4200 defines a typedef for "foo". Synthesize a typedef symbol so
4201 that "ptype foo" works as expected. */
4202 if (cu_language
== language_cplus
)
4204 struct symbol
*typedef_sym
= (struct symbol
*)
4205 obstack_alloc (&objfile
->symbol_obstack
,
4206 sizeof (struct symbol
));
4207 *typedef_sym
= *sym
;
4208 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
4209 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
4210 TYPE_NAME (SYMBOL_TYPE (sym
)) =
4211 obsavestring (SYMBOL_NAME (sym
),
4212 strlen (SYMBOL_NAME (sym
)),
4213 &objfile
->type_obstack
);
4214 add_symbol_to_list (typedef_sym
, list_in_scope
);
4217 case DW_TAG_typedef
:
4218 case DW_TAG_base_type
:
4219 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4220 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4221 add_symbol_to_list (sym
, list_in_scope
);
4223 case DW_TAG_enumerator
:
4224 attr
= dwarf_attr (die
, DW_AT_const_value
);
4227 dwarf2_const_value (attr
, sym
, objfile
);
4229 add_symbol_to_list (sym
, list_in_scope
);
4232 /* Not a tag we recognize. Hopefully we aren't processing
4233 trash data, but since we must specifically ignore things
4234 we don't recognize, there is nothing else we should do at
4236 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
4243 /* Copy constant value from an attribute to a symbol. */
4246 dwarf2_const_value (attr
, sym
, objfile
)
4247 struct attribute
*attr
;
4249 struct objfile
*objfile
;
4251 struct dwarf_block
*blk
;
4256 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != (unsigned int) address_size
)
4257 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4258 address_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4259 SYMBOL_VALUE_BYTES (sym
) = (char *)
4260 obstack_alloc (&objfile
->symbol_obstack
, address_size
);
4261 store_address (SYMBOL_VALUE_BYTES (sym
), address_size
, DW_ADDR (attr
));
4262 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4264 case DW_FORM_block1
:
4265 case DW_FORM_block2
:
4266 case DW_FORM_block4
:
4268 blk
= DW_BLOCK (attr
);
4269 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
4270 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4271 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4272 SYMBOL_VALUE_BYTES (sym
) = (char *)
4273 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
4274 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
4275 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4283 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
4284 SYMBOL_CLASS (sym
) = LOC_CONST
;
4287 complain (&dwarf2_unsupported_const_value_attr
,
4288 dwarf_form_name (attr
->form
));
4289 SYMBOL_VALUE (sym
) = 0;
4290 SYMBOL_CLASS (sym
) = LOC_CONST
;
4295 /* Return the type of the die in question using its DW_AT_type attribute. */
4297 static struct type
*
4298 die_type (die
, objfile
)
4299 struct die_info
*die
;
4300 struct objfile
*objfile
;
4303 struct attribute
*type_attr
;
4304 struct die_info
*type_die
;
4307 type_attr
= dwarf_attr (die
, DW_AT_type
);
4310 /* A missing DW_AT_type represents a void type. */
4311 return dwarf2_fundamental_type (objfile
, FT_VOID
);
4315 ref
= dwarf2_get_ref_die_offset (type_attr
);
4316 type_die
= follow_die_ref (ref
);
4319 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4323 type
= tag_type_to_type (type_die
, objfile
);
4326 dump_die (type_die
);
4327 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
4332 /* Return the containing type of the die in question using its
4333 DW_AT_containing_type attribute. */
4335 static struct type
*
4336 die_containing_type (die
, objfile
)
4337 struct die_info
*die
;
4338 struct objfile
*objfile
;
4340 struct type
*type
= NULL
;
4341 struct attribute
*type_attr
;
4342 struct die_info
*type_die
= NULL
;
4345 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
4348 ref
= dwarf2_get_ref_die_offset (type_attr
);
4349 type_die
= follow_die_ref (ref
);
4352 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4355 type
= tag_type_to_type (type_die
, objfile
);
4360 dump_die (type_die
);
4361 error ("Dwarf Error: Problem turning containing type into gdb type.");
4367 static struct type
*
4368 type_at_offset (offset
, objfile
)
4369 unsigned int offset
;
4370 struct objfile
*objfile
;
4372 struct die_info
*die
;
4375 die
= follow_die_ref (offset
);
4378 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
4381 type
= tag_type_to_type (die
, objfile
);
4386 static struct type
*
4387 tag_type_to_type (die
, objfile
)
4388 struct die_info
*die
;
4389 struct objfile
*objfile
;
4397 read_type_die (die
, objfile
);
4401 error ("Dwarf Error: Cannot find type of die.");
4408 read_type_die (die
, objfile
)
4409 struct die_info
*die
;
4410 struct objfile
*objfile
;
4414 case DW_TAG_class_type
:
4415 case DW_TAG_structure_type
:
4416 case DW_TAG_union_type
:
4417 read_structure_scope (die
, objfile
);
4419 case DW_TAG_enumeration_type
:
4420 read_enumeration (die
, objfile
);
4422 case DW_TAG_subprogram
:
4423 case DW_TAG_subroutine_type
:
4424 read_subroutine_type (die
, objfile
);
4426 case DW_TAG_array_type
:
4427 read_array_type (die
, objfile
);
4429 case DW_TAG_pointer_type
:
4430 read_tag_pointer_type (die
, objfile
);
4432 case DW_TAG_ptr_to_member_type
:
4433 read_tag_ptr_to_member_type (die
, objfile
);
4435 case DW_TAG_reference_type
:
4436 read_tag_reference_type (die
, objfile
);
4438 case DW_TAG_const_type
:
4439 read_tag_const_type (die
, objfile
);
4441 case DW_TAG_volatile_type
:
4442 read_tag_volatile_type (die
, objfile
);
4444 case DW_TAG_string_type
:
4445 read_tag_string_type (die
, objfile
);
4447 case DW_TAG_typedef
:
4448 read_typedef (die
, objfile
);
4450 case DW_TAG_base_type
:
4451 read_base_type (die
, objfile
);
4454 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
4459 static struct type
*
4460 dwarf_base_type (encoding
, size
, objfile
)
4463 struct objfile
*objfile
;
4465 /* FIXME - this should not produce a new (struct type *)
4466 every time. It should cache base types. */
4470 case DW_ATE_address
:
4471 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
4473 case DW_ATE_boolean
:
4474 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
4476 case DW_ATE_complex_float
:
4479 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
4483 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
4489 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
4493 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
4500 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
4503 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
4507 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
4511 case DW_ATE_signed_char
:
4512 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
4514 case DW_ATE_unsigned
:
4518 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
4521 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
4525 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
4529 case DW_ATE_unsigned_char
:
4530 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
4533 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
4541 struct die_info
*old_die
;
4543 struct die_info
*new_die
;
4546 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
4547 memset (new_die
, 0, sizeof (struct die_info
));
4549 new_die
->tag
= old_die
->tag
;
4550 new_die
->has_children
= old_die
->has_children
;
4551 new_die
->abbrev
= old_die
->abbrev
;
4552 new_die
->offset
= old_die
->offset
;
4553 new_die
->type
= NULL
;
4555 num_attrs
= old_die
->num_attrs
;
4556 new_die
->num_attrs
= num_attrs
;
4557 new_die
->attrs
= (struct attribute
*)
4558 xmalloc (num_attrs
* sizeof (struct attribute
));
4560 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
4562 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
4563 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
4564 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
4567 new_die
->next
= NULL
;
4572 /* Return sibling of die, NULL if no sibling. */
4576 struct die_info
*die
;
4578 int nesting_level
= 0;
4580 if (!die
->has_children
)
4582 if (die
->next
&& (die
->next
->tag
== 0))
4595 if (die
->has_children
)
4605 while (nesting_level
);
4606 if (die
&& (die
->tag
== 0))
4617 /* Convert a DIE tag into its string name. */
4620 dwarf_tag_name (tag
)
4621 register unsigned tag
;
4625 case DW_TAG_padding
:
4626 return "DW_TAG_padding";
4627 case DW_TAG_array_type
:
4628 return "DW_TAG_array_type";
4629 case DW_TAG_class_type
:
4630 return "DW_TAG_class_type";
4631 case DW_TAG_entry_point
:
4632 return "DW_TAG_entry_point";
4633 case DW_TAG_enumeration_type
:
4634 return "DW_TAG_enumeration_type";
4635 case DW_TAG_formal_parameter
:
4636 return "DW_TAG_formal_parameter";
4637 case DW_TAG_imported_declaration
:
4638 return "DW_TAG_imported_declaration";
4640 return "DW_TAG_label";
4641 case DW_TAG_lexical_block
:
4642 return "DW_TAG_lexical_block";
4644 return "DW_TAG_member";
4645 case DW_TAG_pointer_type
:
4646 return "DW_TAG_pointer_type";
4647 case DW_TAG_reference_type
:
4648 return "DW_TAG_reference_type";
4649 case DW_TAG_compile_unit
:
4650 return "DW_TAG_compile_unit";
4651 case DW_TAG_string_type
:
4652 return "DW_TAG_string_type";
4653 case DW_TAG_structure_type
:
4654 return "DW_TAG_structure_type";
4655 case DW_TAG_subroutine_type
:
4656 return "DW_TAG_subroutine_type";
4657 case DW_TAG_typedef
:
4658 return "DW_TAG_typedef";
4659 case DW_TAG_union_type
:
4660 return "DW_TAG_union_type";
4661 case DW_TAG_unspecified_parameters
:
4662 return "DW_TAG_unspecified_parameters";
4663 case DW_TAG_variant
:
4664 return "DW_TAG_variant";
4665 case DW_TAG_common_block
:
4666 return "DW_TAG_common_block";
4667 case DW_TAG_common_inclusion
:
4668 return "DW_TAG_common_inclusion";
4669 case DW_TAG_inheritance
:
4670 return "DW_TAG_inheritance";
4671 case DW_TAG_inlined_subroutine
:
4672 return "DW_TAG_inlined_subroutine";
4674 return "DW_TAG_module";
4675 case DW_TAG_ptr_to_member_type
:
4676 return "DW_TAG_ptr_to_member_type";
4677 case DW_TAG_set_type
:
4678 return "DW_TAG_set_type";
4679 case DW_TAG_subrange_type
:
4680 return "DW_TAG_subrange_type";
4681 case DW_TAG_with_stmt
:
4682 return "DW_TAG_with_stmt";
4683 case DW_TAG_access_declaration
:
4684 return "DW_TAG_access_declaration";
4685 case DW_TAG_base_type
:
4686 return "DW_TAG_base_type";
4687 case DW_TAG_catch_block
:
4688 return "DW_TAG_catch_block";
4689 case DW_TAG_const_type
:
4690 return "DW_TAG_const_type";
4691 case DW_TAG_constant
:
4692 return "DW_TAG_constant";
4693 case DW_TAG_enumerator
:
4694 return "DW_TAG_enumerator";
4695 case DW_TAG_file_type
:
4696 return "DW_TAG_file_type";
4698 return "DW_TAG_friend";
4699 case DW_TAG_namelist
:
4700 return "DW_TAG_namelist";
4701 case DW_TAG_namelist_item
:
4702 return "DW_TAG_namelist_item";
4703 case DW_TAG_packed_type
:
4704 return "DW_TAG_packed_type";
4705 case DW_TAG_subprogram
:
4706 return "DW_TAG_subprogram";
4707 case DW_TAG_template_type_param
:
4708 return "DW_TAG_template_type_param";
4709 case DW_TAG_template_value_param
:
4710 return "DW_TAG_template_value_param";
4711 case DW_TAG_thrown_type
:
4712 return "DW_TAG_thrown_type";
4713 case DW_TAG_try_block
:
4714 return "DW_TAG_try_block";
4715 case DW_TAG_variant_part
:
4716 return "DW_TAG_variant_part";
4717 case DW_TAG_variable
:
4718 return "DW_TAG_variable";
4719 case DW_TAG_volatile_type
:
4720 return "DW_TAG_volatile_type";
4721 case DW_TAG_MIPS_loop
:
4722 return "DW_TAG_MIPS_loop";
4723 case DW_TAG_format_label
:
4724 return "DW_TAG_format_label";
4725 case DW_TAG_function_template
:
4726 return "DW_TAG_function_template";
4727 case DW_TAG_class_template
:
4728 return "DW_TAG_class_template";
4730 return "DW_TAG_<unknown>";
4734 /* Convert a DWARF attribute code into its string name. */
4737 dwarf_attr_name (attr
)
4738 register unsigned attr
;
4743 return "DW_AT_sibling";
4744 case DW_AT_location
:
4745 return "DW_AT_location";
4747 return "DW_AT_name";
4748 case DW_AT_ordering
:
4749 return "DW_AT_ordering";
4750 case DW_AT_subscr_data
:
4751 return "DW_AT_subscr_data";
4752 case DW_AT_byte_size
:
4753 return "DW_AT_byte_size";
4754 case DW_AT_bit_offset
:
4755 return "DW_AT_bit_offset";
4756 case DW_AT_bit_size
:
4757 return "DW_AT_bit_size";
4758 case DW_AT_element_list
:
4759 return "DW_AT_element_list";
4760 case DW_AT_stmt_list
:
4761 return "DW_AT_stmt_list";
4763 return "DW_AT_low_pc";
4765 return "DW_AT_high_pc";
4766 case DW_AT_language
:
4767 return "DW_AT_language";
4769 return "DW_AT_member";
4771 return "DW_AT_discr";
4772 case DW_AT_discr_value
:
4773 return "DW_AT_discr_value";
4774 case DW_AT_visibility
:
4775 return "DW_AT_visibility";
4777 return "DW_AT_import";
4778 case DW_AT_string_length
:
4779 return "DW_AT_string_length";
4780 case DW_AT_common_reference
:
4781 return "DW_AT_common_reference";
4782 case DW_AT_comp_dir
:
4783 return "DW_AT_comp_dir";
4784 case DW_AT_const_value
:
4785 return "DW_AT_const_value";
4786 case DW_AT_containing_type
:
4787 return "DW_AT_containing_type";
4788 case DW_AT_default_value
:
4789 return "DW_AT_default_value";
4791 return "DW_AT_inline";
4792 case DW_AT_is_optional
:
4793 return "DW_AT_is_optional";
4794 case DW_AT_lower_bound
:
4795 return "DW_AT_lower_bound";
4796 case DW_AT_producer
:
4797 return "DW_AT_producer";
4798 case DW_AT_prototyped
:
4799 return "DW_AT_prototyped";
4800 case DW_AT_return_addr
:
4801 return "DW_AT_return_addr";
4802 case DW_AT_start_scope
:
4803 return "DW_AT_start_scope";
4804 case DW_AT_stride_size
:
4805 return "DW_AT_stride_size";
4806 case DW_AT_upper_bound
:
4807 return "DW_AT_upper_bound";
4808 case DW_AT_abstract_origin
:
4809 return "DW_AT_abstract_origin";
4810 case DW_AT_accessibility
:
4811 return "DW_AT_accessibility";
4812 case DW_AT_address_class
:
4813 return "DW_AT_address_class";
4814 case DW_AT_artificial
:
4815 return "DW_AT_artificial";
4816 case DW_AT_base_types
:
4817 return "DW_AT_base_types";
4818 case DW_AT_calling_convention
:
4819 return "DW_AT_calling_convention";
4821 return "DW_AT_count";
4822 case DW_AT_data_member_location
:
4823 return "DW_AT_data_member_location";
4824 case DW_AT_decl_column
:
4825 return "DW_AT_decl_column";
4826 case DW_AT_decl_file
:
4827 return "DW_AT_decl_file";
4828 case DW_AT_decl_line
:
4829 return "DW_AT_decl_line";
4830 case DW_AT_declaration
:
4831 return "DW_AT_declaration";
4832 case DW_AT_discr_list
:
4833 return "DW_AT_discr_list";
4834 case DW_AT_encoding
:
4835 return "DW_AT_encoding";
4836 case DW_AT_external
:
4837 return "DW_AT_external";
4838 case DW_AT_frame_base
:
4839 return "DW_AT_frame_base";
4841 return "DW_AT_friend";
4842 case DW_AT_identifier_case
:
4843 return "DW_AT_identifier_case";
4844 case DW_AT_macro_info
:
4845 return "DW_AT_macro_info";
4846 case DW_AT_namelist_items
:
4847 return "DW_AT_namelist_items";
4848 case DW_AT_priority
:
4849 return "DW_AT_priority";
4851 return "DW_AT_segment";
4852 case DW_AT_specification
:
4853 return "DW_AT_specification";
4854 case DW_AT_static_link
:
4855 return "DW_AT_static_link";
4857 return "DW_AT_type";
4858 case DW_AT_use_location
:
4859 return "DW_AT_use_location";
4860 case DW_AT_variable_parameter
:
4861 return "DW_AT_variable_parameter";
4862 case DW_AT_virtuality
:
4863 return "DW_AT_virtuality";
4864 case DW_AT_vtable_elem_location
:
4865 return "DW_AT_vtable_elem_location";
4868 case DW_AT_MIPS_fde
:
4869 return "DW_AT_MIPS_fde";
4870 case DW_AT_MIPS_loop_begin
:
4871 return "DW_AT_MIPS_loop_begin";
4872 case DW_AT_MIPS_tail_loop_begin
:
4873 return "DW_AT_MIPS_tail_loop_begin";
4874 case DW_AT_MIPS_epilog_begin
:
4875 return "DW_AT_MIPS_epilog_begin";
4876 case DW_AT_MIPS_loop_unroll_factor
:
4877 return "DW_AT_MIPS_loop_unroll_factor";
4878 case DW_AT_MIPS_software_pipeline_depth
:
4879 return "DW_AT_MIPS_software_pipeline_depth";
4880 case DW_AT_MIPS_linkage_name
:
4881 return "DW_AT_MIPS_linkage_name";
4884 case DW_AT_sf_names
:
4885 return "DW_AT_sf_names";
4886 case DW_AT_src_info
:
4887 return "DW_AT_src_info";
4888 case DW_AT_mac_info
:
4889 return "DW_AT_mac_info";
4890 case DW_AT_src_coords
:
4891 return "DW_AT_src_coords";
4892 case DW_AT_body_begin
:
4893 return "DW_AT_body_begin";
4894 case DW_AT_body_end
:
4895 return "DW_AT_body_end";
4897 return "DW_AT_<unknown>";
4901 /* Convert a DWARF value form code into its string name. */
4904 dwarf_form_name (form
)
4905 register unsigned form
;
4910 return "DW_FORM_addr";
4911 case DW_FORM_block2
:
4912 return "DW_FORM_block2";
4913 case DW_FORM_block4
:
4914 return "DW_FORM_block4";
4916 return "DW_FORM_data2";
4918 return "DW_FORM_data4";
4920 return "DW_FORM_data8";
4921 case DW_FORM_string
:
4922 return "DW_FORM_string";
4924 return "DW_FORM_block";
4925 case DW_FORM_block1
:
4926 return "DW_FORM_block1";
4928 return "DW_FORM_data1";
4930 return "DW_FORM_flag";
4932 return "DW_FORM_sdata";
4934 return "DW_FORM_strp";
4936 return "DW_FORM_udata";
4937 case DW_FORM_ref_addr
:
4938 return "DW_FORM_ref_addr";
4940 return "DW_FORM_ref1";
4942 return "DW_FORM_ref2";
4944 return "DW_FORM_ref4";
4946 return "DW_FORM_ref8";
4947 case DW_FORM_ref_udata
:
4948 return "DW_FORM_ref_udata";
4949 case DW_FORM_indirect
:
4950 return "DW_FORM_indirect";
4952 return "DW_FORM_<unknown>";
4956 /* Convert a DWARF stack opcode into its string name. */
4959 dwarf_stack_op_name (op
)
4960 register unsigned op
;
4965 return "DW_OP_addr";
4967 return "DW_OP_deref";
4969 return "DW_OP_const1u";
4971 return "DW_OP_const1s";
4973 return "DW_OP_const2u";
4975 return "DW_OP_const2s";
4977 return "DW_OP_const4u";
4979 return "DW_OP_const4s";
4981 return "DW_OP_const8u";
4983 return "DW_OP_const8s";
4985 return "DW_OP_constu";
4987 return "DW_OP_consts";
4991 return "DW_OP_drop";
4993 return "DW_OP_over";
4995 return "DW_OP_pick";
4997 return "DW_OP_swap";
5001 return "DW_OP_xderef";
5009 return "DW_OP_minus";
5021 return "DW_OP_plus";
5022 case DW_OP_plus_uconst
:
5023 return "DW_OP_plus_uconst";
5029 return "DW_OP_shra";
5047 return "DW_OP_skip";
5049 return "DW_OP_lit0";
5051 return "DW_OP_lit1";
5053 return "DW_OP_lit2";
5055 return "DW_OP_lit3";
5057 return "DW_OP_lit4";
5059 return "DW_OP_lit5";
5061 return "DW_OP_lit6";
5063 return "DW_OP_lit7";
5065 return "DW_OP_lit8";
5067 return "DW_OP_lit9";
5069 return "DW_OP_lit10";
5071 return "DW_OP_lit11";
5073 return "DW_OP_lit12";
5075 return "DW_OP_lit13";
5077 return "DW_OP_lit14";
5079 return "DW_OP_lit15";
5081 return "DW_OP_lit16";
5083 return "DW_OP_lit17";
5085 return "DW_OP_lit18";
5087 return "DW_OP_lit19";
5089 return "DW_OP_lit20";
5091 return "DW_OP_lit21";
5093 return "DW_OP_lit22";
5095 return "DW_OP_lit23";
5097 return "DW_OP_lit24";
5099 return "DW_OP_lit25";
5101 return "DW_OP_lit26";
5103 return "DW_OP_lit27";
5105 return "DW_OP_lit28";
5107 return "DW_OP_lit29";
5109 return "DW_OP_lit30";
5111 return "DW_OP_lit31";
5113 return "DW_OP_reg0";
5115 return "DW_OP_reg1";
5117 return "DW_OP_reg2";
5119 return "DW_OP_reg3";
5121 return "DW_OP_reg4";
5123 return "DW_OP_reg5";
5125 return "DW_OP_reg6";
5127 return "DW_OP_reg7";
5129 return "DW_OP_reg8";
5131 return "DW_OP_reg9";
5133 return "DW_OP_reg10";
5135 return "DW_OP_reg11";
5137 return "DW_OP_reg12";
5139 return "DW_OP_reg13";
5141 return "DW_OP_reg14";
5143 return "DW_OP_reg15";
5145 return "DW_OP_reg16";
5147 return "DW_OP_reg17";
5149 return "DW_OP_reg18";
5151 return "DW_OP_reg19";
5153 return "DW_OP_reg20";
5155 return "DW_OP_reg21";
5157 return "DW_OP_reg22";
5159 return "DW_OP_reg23";
5161 return "DW_OP_reg24";
5163 return "DW_OP_reg25";
5165 return "DW_OP_reg26";
5167 return "DW_OP_reg27";
5169 return "DW_OP_reg28";
5171 return "DW_OP_reg29";
5173 return "DW_OP_reg30";
5175 return "DW_OP_reg31";
5177 return "DW_OP_breg0";
5179 return "DW_OP_breg1";
5181 return "DW_OP_breg2";
5183 return "DW_OP_breg3";
5185 return "DW_OP_breg4";
5187 return "DW_OP_breg5";
5189 return "DW_OP_breg6";
5191 return "DW_OP_breg7";
5193 return "DW_OP_breg8";
5195 return "DW_OP_breg9";
5197 return "DW_OP_breg10";
5199 return "DW_OP_breg11";
5201 return "DW_OP_breg12";
5203 return "DW_OP_breg13";
5205 return "DW_OP_breg14";
5207 return "DW_OP_breg15";
5209 return "DW_OP_breg16";
5211 return "DW_OP_breg17";
5213 return "DW_OP_breg18";
5215 return "DW_OP_breg19";
5217 return "DW_OP_breg20";
5219 return "DW_OP_breg21";
5221 return "DW_OP_breg22";
5223 return "DW_OP_breg23";
5225 return "DW_OP_breg24";
5227 return "DW_OP_breg25";
5229 return "DW_OP_breg26";
5231 return "DW_OP_breg27";
5233 return "DW_OP_breg28";
5235 return "DW_OP_breg29";
5237 return "DW_OP_breg30";
5239 return "DW_OP_breg31";
5241 return "DW_OP_regx";
5243 return "DW_OP_fbreg";
5245 return "DW_OP_bregx";
5247 return "DW_OP_piece";
5248 case DW_OP_deref_size
:
5249 return "DW_OP_deref_size";
5250 case DW_OP_xderef_size
:
5251 return "DW_OP_xderef_size";
5255 return "OP_<unknown>";
5260 dwarf_bool_name (bool)
5269 /* Convert a DWARF type code into its string name. */
5272 dwarf_type_encoding_name (enc
)
5273 register unsigned enc
;
5277 case DW_ATE_address
:
5278 return "DW_ATE_address";
5279 case DW_ATE_boolean
:
5280 return "DW_ATE_boolean";
5281 case DW_ATE_complex_float
:
5282 return "DW_ATE_complex_float";
5284 return "DW_ATE_float";
5286 return "DW_ATE_signed";
5287 case DW_ATE_signed_char
:
5288 return "DW_ATE_signed_char";
5289 case DW_ATE_unsigned
:
5290 return "DW_ATE_unsigned";
5291 case DW_ATE_unsigned_char
:
5292 return "DW_ATE_unsigned_char";
5294 return "DW_ATE_<unknown>";
5298 /* Convert a DWARF call frame info operation to its string name. */
5302 dwarf_cfi_name (cfi_opc
)
5303 register unsigned cfi_opc
;
5307 case DW_CFA_advance_loc
:
5308 return "DW_CFA_advance_loc";
5310 return "DW_CFA_offset";
5311 case DW_CFA_restore
:
5312 return "DW_CFA_restore";
5314 return "DW_CFA_nop";
5315 case DW_CFA_set_loc
:
5316 return "DW_CFA_set_loc";
5317 case DW_CFA_advance_loc1
:
5318 return "DW_CFA_advance_loc1";
5319 case DW_CFA_advance_loc2
:
5320 return "DW_CFA_advance_loc2";
5321 case DW_CFA_advance_loc4
:
5322 return "DW_CFA_advance_loc4";
5323 case DW_CFA_offset_extended
:
5324 return "DW_CFA_offset_extended";
5325 case DW_CFA_restore_extended
:
5326 return "DW_CFA_restore_extended";
5327 case DW_CFA_undefined
:
5328 return "DW_CFA_undefined";
5329 case DW_CFA_same_value
:
5330 return "DW_CFA_same_value";
5331 case DW_CFA_register
:
5332 return "DW_CFA_register";
5333 case DW_CFA_remember_state
:
5334 return "DW_CFA_remember_state";
5335 case DW_CFA_restore_state
:
5336 return "DW_CFA_restore_state";
5337 case DW_CFA_def_cfa
:
5338 return "DW_CFA_def_cfa";
5339 case DW_CFA_def_cfa_register
:
5340 return "DW_CFA_def_cfa_register";
5341 case DW_CFA_def_cfa_offset
:
5342 return "DW_CFA_def_cfa_offset";
5343 /* SGI/MIPS specific */
5344 case DW_CFA_MIPS_advance_loc8
:
5345 return "DW_CFA_MIPS_advance_loc8";
5347 return "DW_CFA_<unknown>";
5354 struct die_info
*die
;
5358 fprintf (stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
5359 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
5360 fprintf (stderr
, "\thas children: %s\n",
5361 dwarf_bool_name (die
->has_children
));
5363 fprintf (stderr
, "\tattributes:\n");
5364 for (i
= 0; i
< die
->num_attrs
; ++i
)
5366 fprintf (stderr
, "\t\t%s (%s) ",
5367 dwarf_attr_name (die
->attrs
[i
].name
),
5368 dwarf_form_name (die
->attrs
[i
].form
));
5369 switch (die
->attrs
[i
].form
)
5371 case DW_FORM_ref_addr
:
5373 fprintf (stderr
, "address: ");
5374 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, stderr
);
5376 case DW_FORM_block2
:
5377 case DW_FORM_block4
:
5379 case DW_FORM_block1
:
5380 fprintf (stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
5390 fprintf (stderr
, "constant: %d", DW_UNSND (&die
->attrs
[i
]));
5392 case DW_FORM_string
:
5393 fprintf (stderr
, "string: \"%s\"",
5394 DW_STRING (&die
->attrs
[i
])
5395 ? DW_STRING (&die
->attrs
[i
]) : "");
5398 if (DW_UNSND (&die
->attrs
[i
]))
5399 fprintf (stderr
, "flag: TRUE");
5401 fprintf (stderr
, "flag: FALSE");
5403 case DW_FORM_strp
: /* we do not support separate string
5405 case DW_FORM_indirect
: /* we do not handle indirect yet */
5406 case DW_FORM_data8
: /* we do not have 64 bit quantities */
5408 fprintf (stderr
, "unsupported attribute form: %d.",
5409 die
->attrs
[i
].form
);
5411 fprintf (stderr
, "\n");
5417 struct die_info
*die
;
5427 store_in_ref_table (offset
, die
)
5428 unsigned int offset
;
5429 struct die_info
*die
;
5432 struct die_info
*old
;
5434 h
= (offset
% REF_HASH_SIZE
);
5435 old
= die_ref_table
[h
];
5436 die
->next_ref
= old
;
5437 die_ref_table
[h
] = die
;
5442 dwarf2_empty_die_ref_table ()
5444 memset (die_ref_table
, 0, sizeof (die_ref_table
));
5448 dwarf2_get_ref_die_offset (attr
)
5449 struct attribute
*attr
;
5451 unsigned int result
= 0;
5455 case DW_FORM_ref_addr
:
5456 result
= DW_ADDR (attr
);
5461 case DW_FORM_ref_udata
:
5462 result
= cu_header_offset
+ DW_UNSND (attr
);
5465 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
5471 follow_die_ref (offset
)
5472 unsigned int offset
;
5474 struct die_info
*die
;
5477 h
= (offset
% REF_HASH_SIZE
);
5478 die
= die_ref_table
[h
];
5481 if (die
->offset
== offset
)
5485 die
= die
->next_ref
;
5490 static struct type
*
5491 dwarf2_fundamental_type (objfile
, typeid)
5492 struct objfile
*objfile
;
5495 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
5497 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
5501 /* Look for this particular type in the fundamental type vector. If
5502 one is not found, create and install one appropriate for the
5503 current language and the current target machine. */
5505 if (ftypes
[typeid] == NULL
)
5507 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
5510 return (ftypes
[typeid]);
5513 /* Decode simple location descriptions.
5514 Given a pointer to a dwarf block that defines a location, compute
5515 the location and return the value.
5517 FIXME: This is a kludge until we figure out a better
5518 way to handle the location descriptions.
5519 Gdb's design does not mesh well with the DWARF2 notion of a location
5520 computing interpreter, which is a shame because the flexibility goes unused.
5521 FIXME: Implement more operations as necessary.
5523 A location description containing no operations indicates that the
5524 object is optimized out. The global optimized_out flag is set for
5525 those, the return value is meaningless.
5527 When the result is a register number, the global isreg flag is set,
5528 otherwise it is cleared.
5530 When the result is a base register offset, the global offreg flag is set
5531 and the register number is returned in basereg, otherwise it is cleared.
5533 When the DW_OP_fbreg operation is encountered without a corresponding
5534 DW_AT_frame_base attribute, the global islocal flag is set.
5535 Hopefully the machine dependent code knows how to set up a virtual
5536 frame pointer for the local references.
5538 Note that stack[0] is unused except as a default error return.
5539 Note that stack overflow is not yet handled. */
5542 decode_locdesc (blk
, objfile
)
5543 struct dwarf_block
*blk
;
5544 struct objfile
*objfile
;
5547 int size
= blk
->size
;
5548 char *data
= blk
->data
;
5549 CORE_ADDR stack
[64];
5551 unsigned int bytes_read
, unsnd
;
5601 stack
[++stacki
] = op
- DW_OP_reg0
;
5606 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
5608 #if defined(HARRIS_TARGET) && defined(_M88K)
5609 /* The Harris 88110 gdb ports have long kept their special reg
5610 numbers between their gp-regs and their x-regs. This is
5611 not how our dwarf is generated. Punt. */
5614 stack
[++stacki
] = unsnd
;
5650 basereg
= op
- DW_OP_breg0
;
5651 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5656 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5658 if (frame_base_reg
>= 0)
5661 basereg
= frame_base_reg
;
5662 stack
[stacki
] += frame_base_offset
;
5666 complain (&dwarf2_missing_at_frame_base
);
5672 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
]);
5677 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
5682 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
5687 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
5692 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
5697 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
5702 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
5707 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
5713 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5718 stack
[stacki
- 1] += stack
[stacki
];
5722 case DW_OP_plus_uconst
:
5723 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
5728 stack
[stacki
- 1] = stack
[stacki
] - stack
[stacki
- 1];
5733 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name(op
));
5734 return (stack
[stacki
]);
5737 return (stack
[stacki
]);
5740 /* memory allocation interface */
5744 dwarf2_free_tmp_obstack (ignore
)
5747 obstack_free (&dwarf2_tmp_obstack
, NULL
);
5750 static struct dwarf_block
*
5751 dwarf_alloc_block ()
5753 struct dwarf_block
*blk
;
5755 blk
= (struct dwarf_block
*)
5756 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
5760 static struct abbrev_info
*
5761 dwarf_alloc_abbrev ()
5763 struct abbrev_info
*abbrev
;
5765 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
5766 memset (abbrev
, 0, sizeof (struct abbrev_info
));
5770 static struct die_info
*
5773 struct die_info
*die
;
5775 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5776 memset (die
, 0, sizeof (struct die_info
));