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
152 unsigned int abbrev_offset
;
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 *dwarf2_linkage_name
PARAMS ((struct die_info
*));
692 static char *dwarf_tag_name
PARAMS ((unsigned int));
694 static char *dwarf_attr_name
PARAMS ((unsigned int));
696 static char *dwarf_form_name
PARAMS ((unsigned int));
698 static char *dwarf_stack_op_name
PARAMS ((unsigned int));
700 static char *dwarf_bool_name
PARAMS ((unsigned int));
702 static char *dwarf_type_encoding_name
PARAMS ((unsigned int));
705 static char *dwarf_cfi_name
PARAMS ((unsigned int));
707 struct die_info
*copy_die
PARAMS ((struct die_info
*));
710 struct die_info
*sibling_die
PARAMS ((struct die_info
*));
712 void dump_die
PARAMS ((struct die_info
*));
714 void dump_die_list
PARAMS ((struct die_info
*));
716 void store_in_ref_table
PARAMS ((unsigned int, struct die_info
*));
718 static void dwarf2_empty_die_ref_table
PARAMS ((void));
720 static unsigned int dwarf2_get_ref_die_offset
PARAMS ((struct attribute
*));
722 struct die_info
*follow_die_ref
PARAMS ((unsigned int));
724 static struct type
*dwarf2_fundamental_type
PARAMS ((struct objfile
*, int));
726 /* memory allocation interface */
728 static void dwarf2_free_tmp_obstack
PARAMS ((PTR
));
730 static struct dwarf_block
*dwarf_alloc_block
PARAMS ((void));
732 static struct abbrev_info
*dwarf_alloc_abbrev
PARAMS ((void));
734 static struct die_info
*dwarf_alloc_die
PARAMS ((void));
736 /* Try to locate the sections we need for DWARF 2 debugging
737 information and return true if we have enough to do something. */
740 dwarf2_has_info (abfd
)
743 dwarf_info_offset
= dwarf_abbrev_offset
= dwarf_line_offset
= 0;
744 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
745 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
755 /* This function is mapped across the sections and remembers the
756 offset and size of each of the debugging sections we are interested
760 dwarf2_locate_sections (ignore_abfd
, sectp
, ignore_ptr
)
765 if (STREQ (sectp
->name
, INFO_SECTION
))
767 dwarf_info_offset
= sectp
->filepos
;
768 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
770 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
772 dwarf_abbrev_offset
= sectp
->filepos
;
773 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
775 else if (STREQ (sectp
->name
, LINE_SECTION
))
777 dwarf_line_offset
= sectp
->filepos
;
778 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
780 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
782 dwarf_pubnames_offset
= sectp
->filepos
;
783 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
785 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
787 dwarf_aranges_offset
= sectp
->filepos
;
788 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
790 else if (STREQ (sectp
->name
, LOC_SECTION
))
792 dwarf_loc_offset
= sectp
->filepos
;
793 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
795 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
797 dwarf_macinfo_offset
= sectp
->filepos
;
798 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
800 else if (STREQ (sectp
->name
, STR_SECTION
))
802 dwarf_str_offset
= sectp
->filepos
;
803 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
807 /* Build a partial symbol table. */
810 dwarf2_build_psymtabs (objfile
, section_offsets
, mainline
)
811 struct objfile
*objfile
;
812 struct section_offsets
*section_offsets
;
816 /* We definitely need the .debug_info and .debug_abbrev sections */
818 dwarf_info_buffer
= dwarf2_read_section (objfile
,
821 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
824 dwarf_line_buffer
= dwarf2_read_section (objfile
,
828 if (mainline
|| objfile
->global_psymbols
.size
== 0 ||
829 objfile
->static_psymbols
.size
== 0)
831 init_psymbol_list (objfile
, 1024);
835 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
837 /* Things are significanlty easier if we have .debug_aranges and
838 .debug_pubnames sections */
840 dwarf2_build_psymtabs_easy (objfile
, section_offsets
, mainline
);
844 /* only test this case for now */
846 /* In this case we have to work a bit harder */
847 dwarf2_build_psymtabs_hard (objfile
, section_offsets
, mainline
);
852 /* Build the partial symbol table from the information in the
853 .debug_pubnames and .debug_aranges sections. */
856 dwarf2_build_psymtabs_easy (objfile
, section_offsets
, mainline
)
857 struct objfile
*objfile
;
858 struct section_offsets
*section_offsets
;
861 bfd
*abfd
= objfile
->obfd
;
862 char *aranges_buffer
, *pubnames_buffer
;
863 char *aranges_ptr
, *pubnames_ptr
;
864 unsigned int entry_length
, version
, info_offset
, info_size
;
866 pubnames_buffer
= dwarf2_read_section (objfile
,
867 dwarf_pubnames_offset
,
868 dwarf_pubnames_size
);
869 pubnames_ptr
= pubnames_buffer
;
870 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
872 entry_length
= read_4_bytes (abfd
, pubnames_ptr
);
874 version
= read_1_byte (abfd
, pubnames_ptr
);
876 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
878 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
882 aranges_buffer
= dwarf2_read_section (objfile
,
883 dwarf_aranges_offset
,
889 /* Build the partial symbol table by doing a quick pass through the
890 .debug_info and .debug_abbrev sections. */
893 dwarf2_build_psymtabs_hard (objfile
, section_offsets
, mainline
)
894 struct objfile
*objfile
;
895 struct section_offsets
*section_offsets
;
898 /* Instead of reading this into a big buffer, we should probably use
899 mmap() on architectures that support it. (FIXME) */
900 bfd
*abfd
= objfile
->obfd
;
901 char *info_ptr
, *abbrev_ptr
;
902 char *beg_of_comp_unit
;
903 struct comp_unit_head cu_header
;
904 struct partial_die_info comp_unit_die
;
905 struct partial_symtab
*pst
;
906 struct cleanup
*back_to
;
907 int comp_unit_has_pc_info
;
908 CORE_ADDR lowpc
, highpc
;
910 info_ptr
= dwarf_info_buffer
;
911 abbrev_ptr
= dwarf_abbrev_buffer
;
913 obstack_init (&dwarf2_tmp_obstack
);
914 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
916 while ((unsigned int) (info_ptr
- dwarf_info_buffer
)
917 + ((info_ptr
- dwarf_info_buffer
) % 4) < dwarf_info_size
)
919 beg_of_comp_unit
= info_ptr
;
920 cu_header
.length
= read_4_bytes (abfd
, info_ptr
);
922 cu_header
.version
= read_2_bytes (abfd
, info_ptr
);
924 cu_header
.abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
926 cu_header
.addr_size
= read_1_byte (abfd
, info_ptr
);
928 address_size
= cu_header
.addr_size
;
930 if (cu_header
.version
!= 2)
932 error ("Dwarf Error: wrong version in compilation unit header.");
935 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
937 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (at 0x%lx + 6).",
938 (long) cu_header
.abbrev_offset
,
939 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
942 if (beg_of_comp_unit
+ cu_header
.length
+ 4
943 > dwarf_info_buffer
+ dwarf_info_size
)
945 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (0x%lx + 0).",
946 (long) cu_header
.length
,
947 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
951 /* Read the abbrevs for this compilation unit into a table */
952 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
953 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
955 /* Read the compilation unit die */
956 info_ptr
= read_partial_die (&comp_unit_die
, abfd
,
957 info_ptr
, &comp_unit_has_pc_info
);
959 /* Set the language we're debugging */
960 set_cu_language (comp_unit_die
.language
);
962 /* Allocate a new partial symbol table structure */
963 pst
= start_psymtab_common (objfile
, section_offsets
,
964 comp_unit_die
.name
? comp_unit_die
.name
: "",
966 objfile
->global_psymbols
.next
,
967 objfile
->static_psymbols
.next
);
969 pst
->read_symtab_private
= (char *)
970 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
971 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
972 DWARF_INFO_BUFFER(pst
) = dwarf_info_buffer
;
973 DWARF_INFO_OFFSET(pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
974 DWARF_ABBREV_BUFFER(pst
) = dwarf_abbrev_buffer
;
975 DWARF_ABBREV_SIZE(pst
) = dwarf_abbrev_size
;
976 DWARF_LINE_BUFFER(pst
) = dwarf_line_buffer
;
977 baseaddr
= ANOFFSET (section_offsets
, 0);
979 /* Store the function that reads in the rest of the symbol table */
980 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
982 /* Check if comp unit has_children.
983 If so, read the rest of the partial symbols from this comp unit.
984 If not, there's no more debug_info for this comp unit. */
985 if (comp_unit_die
.has_children
)
986 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
);
988 /* If the compilation unit didn't have an explicit address range,
989 then use the information extracted from its child dies. */
990 if (!comp_unit_has_pc_info
)
992 comp_unit_die
.lowpc
= lowpc
;
993 comp_unit_die
.highpc
= highpc
;
995 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
996 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
998 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
999 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1000 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1001 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1002 sort_pst_symbols (pst
);
1004 /* If there is already a psymtab or symtab for a file of this
1005 name, remove it. (If there is a symtab, more drastic things
1006 also happen.) This happens in VxWorks. */
1007 free_named_symtabs (pst
->filename
);
1009 info_ptr
= beg_of_comp_unit
+ cu_header
.length
+ 4;
1011 do_cleanups (back_to
);
1014 /* Read in all interesting dies to the end of the compilation unit. */
1017 scan_partial_symbols (info_ptr
, objfile
, lowpc
, highpc
)
1019 struct objfile
*objfile
;
1023 bfd
*abfd
= objfile
->obfd
;
1024 struct partial_die_info pdi
;
1026 /* This function is called after we've read in the comp_unit_die in
1027 order to read its children. We start the nesting level at 1 since
1028 we have pushed 1 level down in order to read the comp unit's children.
1029 The comp unit itself is at level 0, so we stop reading when we pop
1030 back to that level. */
1032 int nesting_level
= 1;
1035 *lowpc
= ((CORE_ADDR
) -1);
1036 *highpc
= ((CORE_ADDR
) 0);
1038 while (nesting_level
)
1040 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, &has_pc_info
);
1046 case DW_TAG_subprogram
:
1049 if (pdi
.lowpc
< *lowpc
)
1053 if (pdi
.highpc
> *highpc
)
1055 *highpc
= pdi
.highpc
;
1057 if ((pdi
.is_external
|| nesting_level
== 1)
1058 && !pdi
.is_declaration
)
1060 add_partial_symbol (&pdi
, objfile
);
1064 case DW_TAG_variable
:
1065 case DW_TAG_typedef
:
1066 case DW_TAG_class_type
:
1067 case DW_TAG_structure_type
:
1068 case DW_TAG_union_type
:
1069 case DW_TAG_enumeration_type
:
1070 if ((pdi
.is_external
|| nesting_level
== 1)
1071 && !pdi
.is_declaration
)
1073 add_partial_symbol (&pdi
, objfile
);
1076 case DW_TAG_enumerator
:
1077 /* File scope enumerators are added to the partial symbol
1079 if (nesting_level
== 2)
1080 add_partial_symbol (&pdi
, objfile
);
1082 case DW_TAG_base_type
:
1083 /* File scope base type definitions are added to the partial
1085 if (nesting_level
== 1)
1086 add_partial_symbol (&pdi
, objfile
);
1093 /* If the die has a sibling, skip to the sibling.
1094 Do not skip enumeration types, we want to record their
1096 if (pdi
.sibling
&& pdi
.tag
!= DW_TAG_enumeration_type
)
1098 info_ptr
= pdi
.sibling
;
1100 else if (pdi
.has_children
)
1102 /* Die has children, but the optional DW_AT_sibling attribute
1113 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1114 from `maint check'. */
1115 if (*lowpc
== ((CORE_ADDR
) -1))
1121 add_partial_symbol (pdi
, objfile
)
1122 struct partial_die_info
*pdi
;
1123 struct objfile
*objfile
;
1129 case DW_TAG_subprogram
:
1130 if (pdi
->is_external
)
1132 prim_record_minimal_symbol (pdi
->name
, pdi
->lowpc
+ baseaddr
,
1134 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1135 VAR_NAMESPACE
, LOC_BLOCK
,
1136 &objfile
->global_psymbols
,
1137 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1141 prim_record_minimal_symbol (pdi
->name
, pdi
->lowpc
+ baseaddr
,
1142 mst_file_text
, objfile
);
1143 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1144 VAR_NAMESPACE
, LOC_BLOCK
,
1145 &objfile
->static_psymbols
,
1146 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1149 case DW_TAG_variable
:
1150 if (pdi
->is_external
)
1153 Don't enter into the minimal symbol tables as there is
1154 a minimal symbol table entry from the ELF symbols already.
1155 Enter into partial symbol table if it has a location
1156 descriptor or a type.
1157 If the location descriptor is missing, new_symbol will create
1158 a LOC_UNRESOLVED symbol, the address of the variable will then
1159 be determined from the minimal symbol table whenever the variable
1161 The address for the partial symbol table entry is not
1162 used by GDB, but it comes in handy for debugging partial symbol
1166 addr
= decode_locdesc (pdi
->locdesc
, objfile
);
1167 if (pdi
->locdesc
|| pdi
->has_type
)
1168 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1169 VAR_NAMESPACE
, LOC_STATIC
,
1170 &objfile
->global_psymbols
,
1171 0, addr
+ baseaddr
, cu_language
, objfile
);
1175 /* Static Variable. Skip symbols without location descriptors. */
1176 if (pdi
->locdesc
== NULL
)
1178 addr
= decode_locdesc (pdi
->locdesc
, objfile
);
1179 prim_record_minimal_symbol (pdi
->name
, addr
+ baseaddr
,
1180 mst_file_data
, objfile
);
1181 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1182 VAR_NAMESPACE
, LOC_STATIC
,
1183 &objfile
->static_psymbols
,
1184 0, addr
+ baseaddr
, cu_language
, objfile
);
1187 case DW_TAG_typedef
:
1188 case DW_TAG_base_type
:
1189 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1190 VAR_NAMESPACE
, LOC_TYPEDEF
,
1191 &objfile
->static_psymbols
,
1192 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1194 case DW_TAG_class_type
:
1195 case DW_TAG_structure_type
:
1196 case DW_TAG_union_type
:
1197 case DW_TAG_enumeration_type
:
1198 /* Skip aggregate types without children, these are external
1200 if (pdi
->has_children
== 0)
1202 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1203 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1204 &objfile
->static_psymbols
,
1205 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1207 if (cu_language
== language_cplus
)
1209 /* For C++, these implicitly act as typedefs as well. */
1210 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1211 VAR_NAMESPACE
, LOC_TYPEDEF
,
1212 &objfile
->static_psymbols
,
1213 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1216 case DW_TAG_enumerator
:
1217 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1218 VAR_NAMESPACE
, LOC_CONST
,
1219 &objfile
->static_psymbols
,
1220 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1227 /* Expand this partial symbol table into a full symbol table. */
1230 dwarf2_psymtab_to_symtab (pst
)
1231 struct partial_symtab
*pst
;
1233 /* FIXME: This is barely more than a stub. */
1238 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1244 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1245 gdb_flush (gdb_stdout
);
1248 psymtab_to_symtab_1 (pst
);
1250 /* Finish up the debug error message. */
1252 printf_filtered ("done.\n");
1258 psymtab_to_symtab_1 (pst
)
1259 struct partial_symtab
*pst
;
1261 struct objfile
*objfile
= pst
->objfile
;
1262 bfd
*abfd
= objfile
->obfd
;
1263 struct comp_unit_head cu_header
;
1264 struct die_info
*dies
;
1265 unsigned long offset
;
1266 CORE_ADDR lowpc
, highpc
;
1267 struct die_info
*child_die
;
1269 struct symtab
*symtab
;
1270 struct cleanup
*back_to
;
1272 /* Set local variables from the partial symbol table info. */
1273 offset
= DWARF_INFO_OFFSET(pst
);
1274 dwarf_info_buffer
= DWARF_INFO_BUFFER(pst
);
1275 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER(pst
);
1276 dwarf_abbrev_size
= DWARF_ABBREV_SIZE(pst
);
1277 dwarf_line_buffer
= DWARF_LINE_BUFFER(pst
);
1278 baseaddr
= ANOFFSET (pst
->section_offsets
, 0);
1279 cu_header_offset
= offset
;
1280 info_ptr
= dwarf_info_buffer
+ offset
;
1282 obstack_init (&dwarf2_tmp_obstack
);
1283 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1286 make_cleanup (really_free_pendings
, NULL
);
1288 /* read in the comp_unit header */
1289 cu_header
.length
= read_4_bytes (abfd
, info_ptr
);
1291 cu_header
.version
= read_2_bytes (abfd
, info_ptr
);
1293 cu_header
.abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
1295 cu_header
.addr_size
= read_1_byte (abfd
, info_ptr
);
1298 /* Read the abbrevs for this compilation unit */
1299 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1300 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1302 dies
= read_comp_unit (info_ptr
, abfd
);
1304 make_cleanup (free_die_list
, dies
);
1306 /* Do line number decoding in read_file_scope () */
1307 process_die (dies
, objfile
);
1309 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1311 /* Some compilers don't define a DW_AT_high_pc attribute for
1312 the compilation unit. If the DW_AT_high_pc is missing,
1313 synthesize it, by scanning the DIE's below the compilation unit. */
1315 if (dies
->has_children
)
1317 child_die
= dies
->next
;
1318 while (child_die
&& child_die
->tag
)
1320 if (child_die
->tag
== DW_TAG_subprogram
)
1322 CORE_ADDR low
, high
;
1324 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1326 highpc
= max (highpc
, high
);
1329 child_die
= sibling_die (child_die
);
1333 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, 0);
1335 /* Set symtab language to language from DW_AT_language.
1336 If the compilation is from a C file generated by language preprocessors,
1337 do not set the language if it was already deduced by start_subfile. */
1339 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1341 symtab
->language
= cu_language
;
1343 pst
->symtab
= symtab
;
1345 sort_symtab_syms (pst
->symtab
);
1347 do_cleanups (back_to
);
1350 /* Process a die and its children. */
1353 process_die (die
, objfile
)
1354 struct die_info
*die
;
1355 struct objfile
*objfile
;
1359 case DW_TAG_padding
:
1361 case DW_TAG_compile_unit
:
1362 read_file_scope (die
, objfile
);
1364 case DW_TAG_subprogram
:
1365 read_subroutine_type (die
, objfile
);
1366 read_func_scope (die
, objfile
);
1368 case DW_TAG_inlined_subroutine
:
1369 /* FIXME: These are ignored for now.
1370 They could be used to set breakpoints on all inlined instances
1371 of a function and make GDB `next' properly over inlined functions. */
1373 case DW_TAG_lexical_block
:
1374 read_lexical_block_scope (die
, objfile
);
1376 case DW_TAG_class_type
:
1377 case DW_TAG_structure_type
:
1378 case DW_TAG_union_type
:
1379 read_structure_scope (die
, objfile
);
1381 case DW_TAG_enumeration_type
:
1382 read_enumeration (die
, objfile
);
1384 case DW_TAG_subroutine_type
:
1385 read_subroutine_type (die
, objfile
);
1387 case DW_TAG_array_type
:
1388 read_array_type (die
, objfile
);
1390 case DW_TAG_pointer_type
:
1391 read_tag_pointer_type (die
, objfile
);
1393 case DW_TAG_ptr_to_member_type
:
1394 read_tag_ptr_to_member_type (die
, objfile
);
1396 case DW_TAG_reference_type
:
1397 read_tag_reference_type (die
, objfile
);
1399 case DW_TAG_string_type
:
1400 read_tag_string_type (die
, objfile
);
1402 case DW_TAG_base_type
:
1403 read_base_type (die
, objfile
);
1404 if (dwarf_attr (die
, DW_AT_name
))
1406 /* Add a typedef symbol for the base type definition. */
1407 new_symbol (die
, die
->type
, objfile
);
1410 case DW_TAG_common_block
:
1411 read_common_block (die
, objfile
);
1413 case DW_TAG_common_inclusion
:
1416 new_symbol (die
, NULL
, objfile
);
1422 read_file_scope (die
, objfile
)
1423 struct die_info
*die
;
1424 struct objfile
*objfile
;
1426 unsigned int line_offset
= 0;
1427 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1428 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1429 struct attribute
*attr
;
1430 char *name
= "<unknown>";
1431 char *comp_dir
= NULL
;
1432 struct die_info
*child_die
;
1433 bfd
*abfd
= objfile
->obfd
;
1435 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1437 if (die
->has_children
)
1439 child_die
= die
->next
;
1440 while (child_die
&& child_die
->tag
)
1442 if (child_die
->tag
== DW_TAG_subprogram
)
1444 CORE_ADDR low
, high
;
1446 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1448 lowpc
= min (lowpc
, low
);
1449 highpc
= max (highpc
, high
);
1452 child_die
= sibling_die (child_die
);
1457 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1458 from finish_block. */
1459 if (lowpc
== ((CORE_ADDR
) -1))
1464 attr
= dwarf_attr (die
, DW_AT_name
);
1467 name
= DW_STRING (attr
);
1469 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1472 comp_dir
= DW_STRING (attr
);
1475 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1476 directory, get rid of it. */
1477 char *cp
= strchr (comp_dir
, ':');
1479 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1484 if (objfile
->ei
.entry_point
>= lowpc
&&
1485 objfile
->ei
.entry_point
< highpc
)
1487 objfile
->ei
.entry_file_lowpc
= lowpc
;
1488 objfile
->ei
.entry_file_highpc
= highpc
;
1491 attr
= dwarf_attr (die
, DW_AT_language
);
1494 set_cu_language (DW_UNSND (attr
));
1498 /* FIXME:Do something here. */
1499 if (dip
->at_producer
!= NULL
)
1501 handle_producer (dip
->at_producer
);
1505 /* The compilation unit may be in a different language or objfile,
1506 zero out all remembered fundamental types. */
1507 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1509 start_symtab (name
, comp_dir
, lowpc
);
1510 record_debugformat ("DWARF 2");
1512 /* Decode line number information if present. */
1513 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1516 line_offset
= DW_UNSND (attr
);
1517 dwarf_decode_lines (line_offset
, comp_dir
, abfd
);
1520 /* Process all dies in compilation unit. */
1521 if (die
->has_children
)
1523 child_die
= die
->next
;
1524 while (child_die
&& child_die
->tag
)
1526 process_die (child_die
, objfile
);
1527 child_die
= sibling_die (child_die
);
1533 read_func_scope (die
, objfile
)
1534 struct die_info
*die
;
1535 struct objfile
*objfile
;
1537 register struct context_stack
*new;
1540 struct die_info
*child_die
;
1541 struct attribute
*attr
;
1544 name
= dwarf2_linkage_name (die
);
1546 /* Ignore functions with missing or empty names and functions with
1547 missing or invalid low and high pc attributes. */
1548 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1554 if (objfile
->ei
.entry_point
>= lowpc
&&
1555 objfile
->ei
.entry_point
< highpc
)
1557 objfile
->ei
.entry_func_lowpc
= lowpc
;
1558 objfile
->ei
.entry_func_highpc
= highpc
;
1561 if (STREQ (name
, "main")) /* FIXME: hardwired name */
1563 objfile
->ei
.main_func_lowpc
= lowpc
;
1564 objfile
->ei
.main_func_highpc
= highpc
;
1567 /* Decode DW_AT_frame_base location descriptor if present, keep result
1568 for DW_OP_fbreg operands in decode_locdesc. */
1569 frame_base_reg
= -1;
1570 frame_base_offset
= 0;
1571 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1574 CORE_ADDR addr
= decode_locdesc (DW_BLOCK (attr
), objfile
);
1576 frame_base_reg
= addr
;
1579 frame_base_reg
= basereg
;
1580 frame_base_offset
= addr
;
1583 complain (&dwarf2_unsupported_at_frame_base
, name
);
1586 new = push_context (0, lowpc
);
1587 new->name
= new_symbol (die
, die
->type
, objfile
);
1588 list_in_scope
= &local_symbols
;
1590 if (die
->has_children
)
1592 child_die
= die
->next
;
1593 while (child_die
&& child_die
->tag
)
1595 process_die (child_die
, objfile
);
1596 child_die
= sibling_die (child_die
);
1600 new = pop_context ();
1601 /* Make a block for the local symbols within. */
1602 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1603 lowpc
, highpc
, objfile
);
1604 list_in_scope
= &file_symbols
;
1607 /* Process all the DIES contained within a lexical block scope. Start
1608 a new scope, process the dies, and then close the scope. */
1611 read_lexical_block_scope (die
, objfile
)
1612 struct die_info
*die
;
1613 struct objfile
*objfile
;
1615 register struct context_stack
*new;
1616 CORE_ADDR lowpc
, highpc
;
1617 struct die_info
*child_die
;
1619 /* Ignore blocks with missing or invalid low and high pc attributes. */
1620 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1625 push_context (0, lowpc
);
1626 if (die
->has_children
)
1628 child_die
= die
->next
;
1629 while (child_die
&& child_die
->tag
)
1631 process_die (child_die
, objfile
);
1632 child_die
= sibling_die (child_die
);
1635 new = pop_context ();
1637 if (local_symbols
!= NULL
)
1639 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
1642 local_symbols
= new->locals
;
1645 /* Get low and high pc attributes from a die.
1646 Return 1 if the attributes are present and valid, otherwise, return 0. */
1649 dwarf2_get_pc_bounds (die
, lowpc
, highpc
, objfile
)
1650 struct die_info
*die
;
1653 struct objfile
*objfile
;
1655 struct attribute
*attr
;
1659 attr
= dwarf_attr (die
, DW_AT_low_pc
);
1661 low
= DW_ADDR (attr
);
1664 attr
= dwarf_attr (die
, DW_AT_high_pc
);
1666 high
= DW_ADDR (attr
);
1673 /* When using the GNU linker, .gnu.linkonce. sections are used to
1674 eliminate duplicate copies of functions and vtables and such.
1675 The linker will arbitrarily choose one and discard the others.
1676 The AT_*_pc values for such functions refer to local labels in
1677 these sections. If the section from that file was discarded, the
1678 labels are not in the output, so the relocs get a value of 0.
1679 If this is a discarded function, mark the pc bounds as invalid,
1680 so that GDB will ignore it. */
1681 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
1689 /* Add an aggregate field to the field list. */
1692 dwarf2_add_field (fip
, die
, objfile
)
1693 struct field_info
*fip
;
1694 struct die_info
*die
;
1695 struct objfile
*objfile
;
1697 struct nextfield
*new_field
;
1698 struct attribute
*attr
;
1700 char *fieldname
= "";
1702 /* Allocate a new field list entry and link it in. */
1703 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
1704 make_cleanup (free
, new_field
);
1705 memset (new_field
, 0, sizeof (struct nextfield
));
1706 new_field
->next
= fip
->fields
;
1707 fip
->fields
= new_field
;
1710 /* Handle accessibility and virtuality of field.
1711 The default accessibility for members is public, the default
1712 accessibility for inheritance is private. */
1713 if (die
->tag
!= DW_TAG_inheritance
)
1714 new_field
->accessibility
= DW_ACCESS_public
;
1716 new_field
->accessibility
= DW_ACCESS_private
;
1717 new_field
->virtuality
= DW_VIRTUALITY_none
;
1719 attr
= dwarf_attr (die
, DW_AT_accessibility
);
1721 new_field
->accessibility
= DW_UNSND (attr
);
1722 if (new_field
->accessibility
!= DW_ACCESS_public
)
1723 fip
->non_public_fields
= 1;
1724 attr
= dwarf_attr (die
, DW_AT_virtuality
);
1726 new_field
->virtuality
= DW_UNSND (attr
);
1728 fp
= &new_field
->field
;
1729 if (die
->tag
== DW_TAG_member
)
1731 /* Get type of field. */
1732 fp
->type
= die_type (die
, objfile
);
1734 /* Get bit size of field (zero if none). */
1735 attr
= dwarf_attr (die
, DW_AT_bit_size
);
1738 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
1742 FIELD_BITSIZE (*fp
) = 0;
1745 /* Get bit offset of field. */
1746 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
1749 FIELD_BITPOS (*fp
) =
1750 decode_locdesc (DW_BLOCK (attr
), objfile
) * bits_per_byte
;
1753 FIELD_BITPOS (*fp
) = 0;
1754 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
1757 if (BITS_BIG_ENDIAN
)
1759 /* For big endian bits, the DW_AT_bit_offset gives the
1760 additional bit offset from the MSB of the containing
1761 anonymous object to the MSB of the field. We don't
1762 have to do anything special since we don't need to
1763 know the size of the anonymous object. */
1764 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
1768 /* For little endian bits, compute the bit offset to the
1769 MSB of the anonymous object, subtract off the number of
1770 bits from the MSB of the field to the MSB of the
1771 object, and then subtract off the number of bits of
1772 the field itself. The result is the bit offset of
1773 the LSB of the field. */
1775 int bit_offset
= DW_UNSND (attr
);
1777 attr
= dwarf_attr (die
, DW_AT_byte_size
);
1780 /* The size of the anonymous object containing
1781 the bit field is explicit, so use the
1782 indicated size (in bytes). */
1783 anonymous_size
= DW_UNSND (attr
);
1787 /* The size of the anonymous object containing
1788 the bit field must be inferred from the type
1789 attribute of the data member containing the
1791 anonymous_size
= TYPE_LENGTH (fp
->type
);
1793 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
1794 - bit_offset
- FIELD_BITSIZE (*fp
);
1798 /* Get name of field. */
1799 attr
= dwarf_attr (die
, DW_AT_name
);
1800 if (attr
&& DW_STRING (attr
))
1801 fieldname
= DW_STRING (attr
);
1802 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
1803 &objfile
->type_obstack
);
1805 /* Change accessibility for artificial fields (e.g. virtual table
1806 pointer or virtual base class pointer) to private. */
1807 if (dwarf_attr (die
, DW_AT_artificial
))
1809 new_field
->accessibility
= DW_ACCESS_private
;
1810 fip
->non_public_fields
= 1;
1813 else if (die
->tag
== DW_TAG_variable
)
1818 /* C++ static member.
1819 Get physical name, extract field name from physical name. */
1820 physname
= dwarf2_linkage_name (die
);
1821 if (physname
== NULL
)
1825 while (*cp
&& !is_cplus_marker (*cp
))
1829 if (*fieldname
== '\0')
1831 complain (&dwarf2_bad_static_member_name
, physname
);
1834 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
1835 &objfile
->type_obstack
));
1836 FIELD_TYPE (*fp
) = die_type (die
, objfile
);
1837 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
1838 &objfile
->type_obstack
);
1840 else if (die
->tag
== DW_TAG_inheritance
)
1842 /* C++ base class field. */
1843 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
1845 FIELD_BITPOS (*fp
) = decode_locdesc (DW_BLOCK (attr
), objfile
) * bits_per_byte
;
1846 FIELD_BITSIZE (*fp
) = 0;
1847 FIELD_TYPE (*fp
) = die_type (die
, objfile
);
1848 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
1849 fip
->nbaseclasses
++;
1853 /* Create the vector of fields, and attach it to the type. */
1856 dwarf2_attach_fields_to_type (fip
, type
, objfile
)
1857 struct field_info
*fip
;
1859 struct objfile
*objfile
;
1861 int nfields
= fip
->nfields
;
1863 /* Record the field count, allocate space for the array of fields,
1864 and create blank accessibility bitfields if necessary. */
1865 TYPE_NFIELDS (type
) = nfields
;
1866 TYPE_FIELDS (type
) = (struct field
*)
1867 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1868 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
1870 if (fip
->non_public_fields
)
1872 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1874 TYPE_FIELD_PRIVATE_BITS (type
) =
1875 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1876 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
1878 TYPE_FIELD_PROTECTED_BITS (type
) =
1879 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1880 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
1882 TYPE_FIELD_IGNORE_BITS (type
) =
1883 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1884 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
1887 /* If the type has baseclasses, allocate and clear a bit vector for
1888 TYPE_FIELD_VIRTUAL_BITS. */
1889 if (fip
->nbaseclasses
)
1891 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
1894 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1895 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
1896 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
1897 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
1898 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
1901 /* Copy the saved-up fields into the field vector. Start from the head
1902 of the list, adding to the tail of the field array, so that they end
1903 up in the same order in the array in which they were added to the list. */
1904 while (nfields
-- > 0)
1906 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
1907 switch (fip
->fields
->accessibility
)
1909 case DW_ACCESS_private
:
1910 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
1913 case DW_ACCESS_protected
:
1914 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
1917 case DW_ACCESS_public
:
1921 /* Unknown accessibility. Complain and treat it as public. */
1923 complain (&dwarf2_unsupported_accessibility
,
1924 fip
->fields
->accessibility
);
1928 if (nfields
< fip
->nbaseclasses
)
1930 switch (fip
->fields
->virtuality
)
1932 case DW_VIRTUALITY_virtual
:
1933 case DW_VIRTUALITY_pure_virtual
:
1934 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
1938 fip
->fields
= fip
->fields
->next
;
1942 /* Skip to the end of a member function name in a mangled name. */
1945 skip_member_fn_name (physname
)
1948 char *endname
= physname
;
1950 /* Skip over leading underscores. */
1951 while (*endname
== '_')
1954 /* Find two succesive underscores. */
1956 endname
= strchr (endname
, '_');
1957 while (endname
!= NULL
&& *++endname
!= '_');
1959 if (endname
== NULL
)
1961 complain (&dwarf2_bad_member_name_complaint
, physname
);
1966 /* Take care of trailing underscores. */
1967 if (endname
[1] != '_')
1973 /* Add a member function to the proper fieldlist. */
1976 dwarf2_add_member_fn (fip
, die
, type
, objfile
)
1977 struct field_info
*fip
;
1978 struct die_info
*die
;
1980 struct objfile
*objfile
;
1982 struct attribute
*attr
;
1983 struct fnfieldlist
*flp
;
1985 struct fn_field
*fnp
;
1988 struct nextfnfield
*new_fnfield
;
1990 /* Extract member function name from mangled name. */
1991 physname
= dwarf2_linkage_name (die
);
1992 if (physname
== NULL
)
1994 if ((physname
[0] == '_' && physname
[1] == '_'
1995 && strchr ("0123456789Qt", physname
[2]))
1996 || DESTRUCTOR_PREFIX_P (physname
))
1998 /* Constructor and destructor field names are set to the name
1999 of the class, but without template parameter lists.
2000 The name might be missing for anonymous aggregates. */
2001 if (TYPE_TAG_NAME (type
))
2003 char *p
= strchr (TYPE_TAG_NAME (type
), '<');
2006 fieldname
= TYPE_TAG_NAME (type
);
2008 fieldname
= obsavestring (TYPE_TAG_NAME (type
),
2009 p
- TYPE_TAG_NAME (type
),
2010 &objfile
->type_obstack
);
2014 char *anon_name
= "";
2015 fieldname
= obsavestring (anon_name
, strlen (anon_name
),
2016 &objfile
->type_obstack
);
2021 char *endname
= skip_member_fn_name (physname
);
2023 /* Ignore member function if we were unable not extract the member
2025 if (endname
== physname
)
2027 fieldname
= obsavestring (physname
, endname
- physname
,
2028 &objfile
->type_obstack
);
2031 /* Look up member function name in fieldlist. */
2032 for (i
= 0; i
< fip
->nfnfields
; i
++)
2034 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2038 /* Create new list element if necessary. */
2039 if (i
< fip
->nfnfields
)
2040 flp
= &fip
->fnfieldlists
[i
];
2043 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2045 fip
->fnfieldlists
= (struct fnfieldlist
*)
2046 xrealloc (fip
->fnfieldlists
,
2047 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2048 * sizeof (struct fnfieldlist
));
2049 if (fip
->nfnfields
== 0)
2050 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2052 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2053 flp
->name
= fieldname
;
2059 /* Create a new member function field and chain it to the field list
2061 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2062 make_cleanup (free
, new_fnfield
);
2063 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2064 new_fnfield
->next
= flp
->head
;
2065 flp
->head
= new_fnfield
;
2068 /* Fill in the member function field info. */
2069 fnp
= &new_fnfield
->fnfield
;
2070 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2071 &objfile
->type_obstack
);
2072 fnp
->type
= alloc_type (objfile
);
2073 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2075 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2076 struct type
**arg_types
;
2077 int nparams
= TYPE_NFIELDS (die
->type
);
2080 /* Copy argument types from the subroutine type. */
2081 arg_types
= (struct type
**)
2082 TYPE_ALLOC (fnp
->type
, (nparams
+ 1) * sizeof (struct type
*));
2083 for (iparams
= 0; iparams
< nparams
; iparams
++)
2084 arg_types
[iparams
] = TYPE_FIELD_TYPE (die
->type
, iparams
);
2086 /* Set last entry in argument type vector. */
2087 if (TYPE_FLAGS (die
->type
) & TYPE_FLAG_VARARGS
)
2088 arg_types
[nparams
] = NULL
;
2090 arg_types
[nparams
] = dwarf2_fundamental_type (objfile
, FT_VOID
);
2092 smash_to_method_type (fnp
->type
, type
, return_type
, arg_types
);
2094 /* Handle static member functions.
2095 Dwarf2 has no clean way to discern C++ static and non-static
2096 member functions. G++ helps GDB by marking the first
2097 parameter for non-static member functions (which is the
2098 this pointer) as artificial. We obtain this information
2099 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2100 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2101 fnp
->voffset
= VOFFSET_STATIC
;
2104 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2106 /* Get fcontext from DW_AT_containing_type if present. */
2107 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2108 fnp
->fcontext
= die_containing_type (die
, objfile
);
2110 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2111 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2113 /* Get accessibility. */
2114 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2117 switch (DW_UNSND (attr
))
2119 case DW_ACCESS_private
:
2120 fnp
->is_private
= 1;
2122 case DW_ACCESS_protected
:
2123 fnp
->is_protected
= 1;
2128 /* Get index in virtual function table if it is a virtual member function. */
2129 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2131 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
) + 2;
2134 /* Create the vector of member function fields, and attach it to the type. */
2137 dwarf2_attach_fn_fields_to_type (fip
, type
, objfile
)
2138 struct field_info
*fip
;
2140 struct objfile
*objfile
;
2142 struct fnfieldlist
*flp
;
2143 int total_length
= 0;
2146 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2147 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2148 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2150 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2152 struct nextfnfield
*nfp
= flp
->head
;
2153 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2156 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2157 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2158 fn_flp
->fn_fields
= (struct fn_field
*)
2159 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2160 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2161 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2163 total_length
+= flp
->length
;
2166 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2167 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2170 /* Called when we find the DIE that starts a structure or union scope
2171 (definition) to process all dies that define the members of the
2174 NOTE: we need to call struct_type regardless of whether or not the
2175 DIE has an at_name attribute, since it might be an anonymous
2176 structure or union. This gets the type entered into our set of
2179 However, if the structure is incomplete (an opaque struct/union)
2180 then suppress creating a symbol table entry for it since gdb only
2181 wants to find the one with the complete definition. Note that if
2182 it is complete, we just call new_symbol, which does it's own
2183 checking about whether the struct/union is anonymous or not (and
2184 suppresses creating a symbol table entry itself). */
2187 read_structure_scope (die
, objfile
)
2188 struct die_info
*die
;
2189 struct objfile
*objfile
;
2192 struct attribute
*attr
;
2194 type
= alloc_type (objfile
);
2196 INIT_CPLUS_SPECIFIC (type
);
2197 attr
= dwarf_attr (die
, DW_AT_name
);
2198 if (attr
&& DW_STRING (attr
))
2200 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2201 strlen (DW_STRING (attr
)),
2202 &objfile
->type_obstack
);
2205 if (die
->tag
== DW_TAG_structure_type
)
2207 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2209 else if (die
->tag
== DW_TAG_union_type
)
2211 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2215 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2217 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2220 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2223 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2227 TYPE_LENGTH (type
) = 0;
2230 /* We need to add the type field to the die immediately so we don't
2231 infinitely recurse when dealing with pointers to the structure
2232 type within the structure itself. */
2235 if (die
->has_children
)
2237 struct field_info fi
;
2238 struct die_info
*child_die
;
2239 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2241 memset (&fi
, 0, sizeof (struct field_info
));
2243 child_die
= die
->next
;
2245 while (child_die
&& child_die
->tag
)
2247 if (child_die
->tag
== DW_TAG_member
)
2249 dwarf2_add_field (&fi
, child_die
, objfile
);
2251 else if (child_die
->tag
== DW_TAG_variable
)
2253 /* C++ static member. */
2254 dwarf2_add_field (&fi
, child_die
, objfile
);
2256 else if (child_die
->tag
== DW_TAG_subprogram
)
2258 /* C++ member function. */
2259 process_die (child_die
, objfile
);
2260 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
);
2262 else if (child_die
->tag
== DW_TAG_inheritance
)
2264 /* C++ base class field. */
2265 dwarf2_add_field (&fi
, child_die
, objfile
);
2269 process_die (child_die
, objfile
);
2271 child_die
= sibling_die (child_die
);
2274 /* Attach fields and member functions to the type. */
2276 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2279 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2281 /* Get the type which refers to the base class (possibly this
2282 class itself) which contains the vtable pointer for the current
2283 class from the DW_AT_containing_type attribute. */
2285 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2287 struct type
*t
= die_containing_type (die
, objfile
);
2289 TYPE_VPTR_BASETYPE (type
) = t
;
2292 static const char vptr_name
[] = { '_','v','p','t','r','\0' };
2295 /* Our own class provides vtbl ptr. */
2296 for (i
= TYPE_NFIELDS (t
) - 1;
2297 i
>= TYPE_N_BASECLASSES (t
);
2300 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2302 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2303 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2305 TYPE_VPTR_FIELDNO (type
) = i
;
2310 /* Complain if virtual function table field not found. */
2311 if (i
< TYPE_N_BASECLASSES (t
))
2312 complain (&dwarf2_vtbl_not_found_complaint
,
2313 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2317 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2322 new_symbol (die
, type
, objfile
);
2324 do_cleanups (back_to
);
2328 /* No children, must be stub. */
2329 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2335 /* Given a pointer to a die which begins an enumeration, process all
2336 the dies that define the members of the enumeration.
2338 This will be much nicer in draft 6 of the DWARF spec when our
2339 members will be dies instead squished into the DW_AT_element_list
2342 NOTE: We reverse the order of the element list. */
2345 read_enumeration (die
, objfile
)
2346 struct die_info
*die
;
2347 struct objfile
*objfile
;
2349 struct die_info
*child_die
;
2351 struct field
*fields
;
2352 struct attribute
*attr
;
2355 int unsigned_enum
= 1;
2357 type
= alloc_type (objfile
);
2359 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2360 attr
= dwarf_attr (die
, DW_AT_name
);
2361 if (attr
&& DW_STRING (attr
))
2363 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2364 strlen (DW_STRING (attr
)),
2365 &objfile
->type_obstack
);
2368 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2371 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2375 TYPE_LENGTH (type
) = 0;
2380 if (die
->has_children
)
2382 child_die
= die
->next
;
2383 while (child_die
&& child_die
->tag
)
2385 if (child_die
->tag
!= DW_TAG_enumerator
)
2387 process_die (child_die
, objfile
);
2391 attr
= dwarf_attr (child_die
, DW_AT_name
);
2394 sym
= new_symbol (child_die
, type
, objfile
);
2395 if (SYMBOL_VALUE (sym
) < 0)
2398 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2400 fields
= (struct field
*)
2402 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2403 * sizeof (struct field
));
2406 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2407 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2408 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2409 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2415 child_die
= sibling_die (child_die
);
2420 TYPE_NFIELDS (type
) = num_fields
;
2421 TYPE_FIELDS (type
) = (struct field
*)
2422 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2423 memcpy (TYPE_FIELDS (type
), fields
,
2424 sizeof (struct field
) * num_fields
);
2428 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2431 new_symbol (die
, type
, objfile
);
2434 /* Extract all information from a DW_TAG_array_type DIE and put it in
2435 the DIE's type field. For now, this only handles one dimensional
2439 read_array_type (die
, objfile
)
2440 struct die_info
*die
;
2441 struct objfile
*objfile
;
2443 struct die_info
*child_die
;
2444 struct type
*type
= NULL
;
2445 struct type
*element_type
, *range_type
, *index_type
;
2446 struct type
**range_types
= NULL
;
2447 struct attribute
*attr
;
2449 struct cleanup
*back_to
;
2451 /* Return if we've already decoded this type. */
2457 element_type
= die_type (die
, objfile
);
2459 /* Irix 6.2 native cc creates array types without children for
2460 arrays with unspecified length. */
2461 if (die
->has_children
== 0)
2463 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2464 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2465 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2469 back_to
= make_cleanup (null_cleanup
, NULL
);
2470 child_die
= die
->next
;
2471 while (child_die
&& child_die
->tag
)
2473 if (child_die
->tag
== DW_TAG_subrange_type
)
2475 unsigned int low
, high
;
2477 /* Default bounds to an array with unspecified length. */
2480 if (cu_language
== DW_LANG_Fortran77
2481 || cu_language
== DW_LANG_Fortran90
)
2483 /* FORTRAN implies a lower bound of 1, if not given. */
2487 index_type
= die_type (child_die
, objfile
);
2488 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2491 if (attr
->form
== DW_FORM_sdata
)
2493 low
= DW_SND (attr
);
2495 else if (attr
->form
== DW_FORM_udata
2496 || attr
->form
== DW_FORM_data1
2497 || attr
->form
== DW_FORM_data2
2498 || attr
->form
== DW_FORM_data4
)
2500 low
= DW_UNSND (attr
);
2504 complain (&dwarf2_non_const_array_bound_ignored
,
2505 dwarf_form_name (attr
->form
));
2507 die
->type
= lookup_pointer_type (element_type
);
2514 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2517 if (attr
->form
== DW_FORM_sdata
)
2519 high
= DW_SND (attr
);
2521 else if (attr
->form
== DW_FORM_udata
2522 || attr
->form
== DW_FORM_data1
2523 || attr
->form
== DW_FORM_data2
2524 || attr
->form
== DW_FORM_data4
)
2526 high
= DW_UNSND (attr
);
2528 else if (attr
->form
== DW_FORM_block1
)
2530 /* GCC encodes arrays with unspecified or dynamic length
2531 with a DW_FORM_block1 attribute.
2532 FIXME: GDB does not yet know how to handle dynamic
2533 arrays properly, treat them as arrays with unspecified
2539 complain (&dwarf2_non_const_array_bound_ignored
,
2540 dwarf_form_name (attr
->form
));
2542 die
->type
= lookup_pointer_type (element_type
);
2550 /* Create a range type and save it for array type creation. */
2551 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2553 range_types
= (struct type
**)
2554 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2555 * sizeof (struct type
*));
2557 make_cleanup (free_current_contents
, &range_types
);
2559 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2561 child_die
= sibling_die (child_die
);
2564 /* Dwarf2 dimensions are output from left to right, create the
2565 necessary array types in backwards order. */
2566 type
= element_type
;
2568 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2570 do_cleanups (back_to
);
2572 /* Install the type in the die. */
2576 /* First cut: install each common block member as a global variable. */
2579 read_common_block (die
, objfile
)
2580 struct die_info
*die
;
2581 struct objfile
*objfile
;
2583 struct die_info
*child_die
;
2584 struct attribute
*attr
;
2586 CORE_ADDR base
= (CORE_ADDR
) 0;
2588 attr
= dwarf_attr (die
, DW_AT_location
);
2591 base
= decode_locdesc (DW_BLOCK (attr
), objfile
);
2593 if (die
->has_children
)
2595 child_die
= die
->next
;
2596 while (child_die
&& child_die
->tag
)
2598 sym
= new_symbol (child_die
, NULL
, objfile
);
2599 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2602 SYMBOL_VALUE_ADDRESS (sym
) =
2603 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
);
2604 add_symbol_to_list (sym
, &global_symbols
);
2606 child_die
= sibling_die (child_die
);
2611 /* Extract all information from a DW_TAG_pointer_type DIE and add to
2612 the user defined type vector. */
2615 read_tag_pointer_type (die
, objfile
)
2616 struct die_info
*die
;
2617 struct objfile
*objfile
;
2620 struct attribute
*attr
;
2627 type
= lookup_pointer_type (die_type (die
, objfile
));
2628 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2631 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2635 TYPE_LENGTH (type
) = address_size
;
2640 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
2641 the user defined type vector. */
2644 read_tag_ptr_to_member_type (die
, objfile
)
2645 struct die_info
*die
;
2646 struct objfile
*objfile
;
2649 struct type
*to_type
;
2650 struct type
*domain
;
2657 type
= alloc_type (objfile
);
2658 to_type
= die_type (die
, objfile
);
2659 domain
= die_containing_type (die
, objfile
);
2660 smash_to_member_type (type
, domain
, to_type
);
2665 /* Extract all information from a DW_TAG_reference_type DIE and add to
2666 the user defined type vector. */
2669 read_tag_reference_type (die
, objfile
)
2670 struct die_info
*die
;
2671 struct objfile
*objfile
;
2674 struct attribute
*attr
;
2681 type
= lookup_reference_type (die_type (die
, objfile
));
2682 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2685 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2689 TYPE_LENGTH (type
) = address_size
;
2695 read_tag_const_type (die
, objfile
)
2696 struct die_info
*die
;
2697 struct objfile
*objfile
;
2704 complain (&dwarf2_const_ignored
);
2705 die
->type
= die_type (die
, objfile
);
2709 read_tag_volatile_type (die
, objfile
)
2710 struct die_info
*die
;
2711 struct objfile
*objfile
;
2718 complain (&dwarf2_volatile_ignored
);
2719 die
->type
= die_type (die
, objfile
);
2722 /* Extract all information from a DW_TAG_string_type DIE and add to
2723 the user defined type vector. It isn't really a user defined type,
2724 but it behaves like one, with other DIE's using an AT_user_def_type
2725 attribute to reference it. */
2728 read_tag_string_type (die
, objfile
)
2729 struct die_info
*die
;
2730 struct objfile
*objfile
;
2732 struct type
*type
, *range_type
, *index_type
, *char_type
;
2733 struct attribute
*attr
;
2734 unsigned int length
;
2741 attr
= dwarf_attr (die
, DW_AT_string_length
);
2744 length
= DW_UNSND (attr
);
2750 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2751 range_type
= create_range_type (NULL
, index_type
, 1, length
);
2752 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
2753 type
= create_string_type (char_type
, range_type
);
2757 /* Handle DIES due to C code like:
2761 int (*funcp)(int a, long l);
2765 ('funcp' generates a DW_TAG_subroutine_type DIE)
2769 read_subroutine_type (die
, objfile
)
2770 struct die_info
*die
;
2771 struct objfile
*objfile
;
2773 struct type
*type
; /* Type that this function returns */
2774 struct type
*ftype
; /* Function that returns above type */
2775 struct attribute
*attr
;
2777 /* Decode the type that this subroutine returns */
2782 type
= die_type (die
, objfile
);
2783 ftype
= lookup_function_type (type
);
2784 attr
= dwarf_attr (die
, DW_AT_prototyped
);
2785 if (attr
&& (DW_UNSND (attr
) != 0))
2786 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
2788 if (die
->has_children
)
2790 struct die_info
*child_die
;
2794 /* Count the number of parameters.
2795 FIXME: GDB currently ignores vararg functions, but knows about
2796 vararg member functions. */
2797 child_die
= die
->next
;
2798 while (child_die
&& child_die
->tag
)
2800 if (child_die
->tag
== DW_TAG_formal_parameter
)
2802 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
2803 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
2804 child_die
= sibling_die (child_die
);
2807 /* Allocate storage for parameters and fill them in. */
2808 TYPE_NFIELDS (ftype
) = nparams
;
2809 TYPE_FIELDS (ftype
) = (struct field
*)
2810 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
2812 child_die
= die
->next
;
2813 while (child_die
&& child_die
->tag
)
2815 if (child_die
->tag
== DW_TAG_formal_parameter
)
2817 /* Dwarf2 has no clean way to discern C++ static and non-static
2818 member functions. G++ helps GDB by marking the first
2819 parameter for non-static member functions (which is the
2820 this pointer) as artificial. We pass this information
2821 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
2822 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
2824 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
2826 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
2827 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
);
2830 child_die
= sibling_die (child_die
);
2838 read_typedef (die
, objfile
)
2839 struct die_info
*die
;
2840 struct objfile
*objfile
;
2846 struct attribute
*attr
;
2849 xtype
= die_type (die
, objfile
);
2851 type
= alloc_type (objfile
);
2852 TYPE_CODE (type
) = TYPE_CODE_TYPEDEF
;
2853 TYPE_FLAGS (type
) |= TYPE_FLAG_TARGET_STUB
;
2854 TYPE_TARGET_TYPE (type
) = xtype
;
2855 attr
= dwarf_attr (die
, DW_AT_name
);
2856 if (attr
&& DW_STRING (attr
))
2857 TYPE_NAME (type
) = obsavestring (DW_STRING (attr
),
2858 strlen (DW_STRING (attr
)),
2859 &objfile
->type_obstack
);
2865 /* Find a representation of a given base type and install
2866 it in the TYPE field of the die. */
2869 read_base_type (die
, objfile
)
2870 struct die_info
*die
;
2871 struct objfile
*objfile
;
2874 struct attribute
*attr
;
2875 int encoding
= 0, size
= 0;
2877 /* If we've already decoded this die, this is a no-op. */
2883 attr
= dwarf_attr (die
, DW_AT_encoding
);
2886 encoding
= DW_UNSND (attr
);
2888 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2891 size
= DW_UNSND (attr
);
2893 attr
= dwarf_attr (die
, DW_AT_name
);
2894 if (attr
&& DW_STRING (attr
))
2896 enum type_code code
= TYPE_CODE_INT
;
2897 int is_unsigned
= 0;
2901 case DW_ATE_address
:
2902 /* Turn DW_ATE_address into a void * pointer. */
2903 code
= TYPE_CODE_PTR
;
2906 case DW_ATE_boolean
:
2907 code
= TYPE_CODE_BOOL
;
2910 case DW_ATE_complex_float
:
2911 code
= TYPE_CODE_COMPLEX
;
2914 code
= TYPE_CODE_FLT
;
2917 case DW_ATE_signed_char
:
2919 case DW_ATE_unsigned
:
2920 case DW_ATE_unsigned_char
:
2924 complain (&dwarf2_unsupported_at_encoding
,
2925 dwarf_type_encoding_name (encoding
));
2928 type
= init_type (code
, size
, is_unsigned
, DW_STRING (attr
), objfile
);
2929 if (encoding
== DW_ATE_address
)
2930 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
2934 type
= dwarf_base_type (encoding
, size
, objfile
);
2939 /* Read a whole compilation unit into a linked list of dies. */
2942 read_comp_unit (info_ptr
, abfd
)
2946 struct die_info
*first_die
, *last_die
, *die
;
2950 /* Reset die reference table, we are building a new one now. */
2951 dwarf2_empty_die_ref_table ();
2955 first_die
= last_die
= NULL
;
2958 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
);
2959 if (die
->has_children
)
2970 /* Enter die in reference hash table */
2971 store_in_ref_table (die
->offset
, die
);
2975 first_die
= last_die
= die
;
2979 last_die
->next
= die
;
2983 while (nesting_level
> 0);
2987 /* Free a linked list of dies. */
2990 free_die_list (dies
)
2991 struct die_info
*dies
;
2993 struct die_info
*die
, *next
;
3005 /* Read the contents of the section at OFFSET and of size SIZE from the
3006 object file specified by OBJFILE into the psymbol_obstack and return it. */
3009 dwarf2_read_section (objfile
, offset
, size
)
3010 struct objfile
*objfile
;
3014 bfd
*abfd
= objfile
->obfd
;
3020 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3021 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3022 (bfd_read (buf
, size
, 1, abfd
) != size
))
3025 error ("Dwarf Error: Can't read DWARF data from '%s'",
3026 bfd_get_filename (abfd
));
3031 /* In DWARF version 2, the description of the debugging information is
3032 stored in a separate .debug_abbrev section. Before we read any
3033 dies from a section we read in all abbreviations and install them
3037 dwarf2_read_abbrevs (abfd
, offset
)
3039 unsigned int offset
;
3042 struct abbrev_info
*cur_abbrev
;
3043 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3044 unsigned int abbrev_form
, hash_number
;
3046 /* empty the table */
3047 dwarf2_empty_abbrev_table (NULL
);
3049 abbrev_ptr
= dwarf_abbrev_buffer
+ offset
;
3050 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3051 abbrev_ptr
+= bytes_read
;
3053 /* loop until we reach an abbrev number of 0 */
3054 while (abbrev_number
)
3056 cur_abbrev
= dwarf_alloc_abbrev ();
3058 /* read in abbrev header */
3059 cur_abbrev
->number
= abbrev_number
;
3060 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3061 abbrev_ptr
+= bytes_read
;
3062 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3065 /* now read in declarations */
3066 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3067 abbrev_ptr
+= bytes_read
;
3068 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3069 abbrev_ptr
+= bytes_read
;
3072 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3074 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3075 xrealloc (cur_abbrev
->attrs
,
3076 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3077 * sizeof (struct attr_abbrev
));
3079 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3080 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3081 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3082 abbrev_ptr
+= bytes_read
;
3083 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3084 abbrev_ptr
+= bytes_read
;
3087 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3088 cur_abbrev
->next
= dwarf2_abbrevs
[hash_number
];
3089 dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3091 /* Get next abbreviation.
3092 Under Irix6 the abbreviations for a compilation unit are not
3093 always properly terminated with an abbrev number of 0.
3094 Exit loop if we encounter an abbreviation which we have
3095 already read (which means we are about to read the abbreviations
3096 for the next compile unit) or if the end of the abbreviation
3097 table is reached. */
3098 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3099 >= dwarf_abbrev_size
)
3101 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3102 abbrev_ptr
+= bytes_read
;
3103 if (dwarf2_lookup_abbrev (abbrev_number
) != NULL
)
3108 /* Empty the abbrev table for a new compilation unit. */
3112 dwarf2_empty_abbrev_table (ignore
)
3116 struct abbrev_info
*abbrev
, *next
;
3118 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3121 abbrev
= dwarf2_abbrevs
[i
];
3124 next
= abbrev
->next
;
3125 free (abbrev
->attrs
);
3129 dwarf2_abbrevs
[i
] = NULL
;
3133 /* Lookup an abbrev_info structure in the abbrev hash table. */
3135 static struct abbrev_info
*
3136 dwarf2_lookup_abbrev (number
)
3137 unsigned int number
;
3139 unsigned int hash_number
;
3140 struct abbrev_info
*abbrev
;
3142 hash_number
= number
% ABBREV_HASH_SIZE
;
3143 abbrev
= dwarf2_abbrevs
[hash_number
];
3147 if (abbrev
->number
== number
)
3150 abbrev
= abbrev
->next
;
3155 /* Read a minimal amount of information into the minimal die structure. */
3158 read_partial_die (part_die
, abfd
, info_ptr
, has_pc_info
)
3159 struct partial_die_info
*part_die
;
3164 unsigned int abbrev_number
, bytes_read
, i
;
3165 struct abbrev_info
*abbrev
;
3166 struct attribute attr
;
3167 struct attribute spec_attr
;
3168 int found_spec_attr
= 0;
3169 int has_low_pc_attr
= 0;
3170 int has_high_pc_attr
= 0;
3172 *part_die
= zeroed_partial_die
;
3174 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3175 info_ptr
+= bytes_read
;
3179 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3182 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3184 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3185 part_die
->tag
= abbrev
->tag
;
3186 part_die
->has_children
= abbrev
->has_children
;
3187 part_die
->abbrev
= abbrev_number
;
3189 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3191 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
);
3193 /* Store the data if it is of an attribute we want to keep in a
3194 partial symbol table. */
3199 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3200 if (part_die
->name
== NULL
)
3201 part_die
->name
= DW_STRING (&attr
);
3203 case DW_AT_MIPS_linkage_name
:
3204 part_die
->name
= DW_STRING (&attr
);
3207 has_low_pc_attr
= 1;
3208 part_die
->lowpc
= DW_ADDR (&attr
);
3211 has_high_pc_attr
= 1;
3212 part_die
->highpc
= DW_ADDR (&attr
);
3214 case DW_AT_location
:
3215 part_die
->locdesc
= DW_BLOCK (&attr
);
3217 case DW_AT_language
:
3218 part_die
->language
= DW_UNSND (&attr
);
3220 case DW_AT_external
:
3221 part_die
->is_external
= DW_UNSND (&attr
);
3223 case DW_AT_declaration
:
3224 part_die
->is_declaration
= DW_UNSND (&attr
);
3227 part_die
->has_type
= 1;
3229 case DW_AT_abstract_origin
:
3230 case DW_AT_specification
:
3231 found_spec_attr
= 1;
3235 /* Ignore absolute siblings, they might point outside of
3236 the current compile unit. */
3237 if (attr
.form
== DW_FORM_ref_addr
)
3238 complain(&dwarf2_absolute_sibling_complaint
);
3241 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3248 /* If we found a reference attribute and the die has no name, try
3249 to find a name in the referred to die. */
3251 if (found_spec_attr
&& part_die
->name
== NULL
)
3253 struct partial_die_info spec_die
;
3257 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3258 read_partial_die (&spec_die
, abfd
, spec_ptr
, &dummy
);
3261 part_die
->name
= spec_die
.name
;
3263 /* Copy DW_AT_external attribute if it is set. */
3264 if (spec_die
.is_external
)
3265 part_die
->is_external
= spec_die
.is_external
;
3269 /* When using the GNU linker, .gnu.linkonce. sections are used to
3270 eliminate duplicate copies of functions and vtables and such.
3271 The linker will arbitrarily choose one and discard the others.
3272 The AT_*_pc values for such functions refer to local labels in
3273 these sections. If the section from that file was discarded, the
3274 labels are not in the output, so the relocs get a value of 0.
3275 If this is a discarded function, mark the pc bounds as invalid,
3276 so that GDB will ignore it. */
3277 if (has_low_pc_attr
&& has_high_pc_attr
3278 && part_die
->lowpc
< part_die
->highpc
3279 && (part_die
->lowpc
!= 0
3280 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3285 /* Read the die from the .debug_info section buffer. And set diep to
3286 point to a newly allocated die with its information. */
3289 read_full_die (diep
, abfd
, info_ptr
)
3290 struct die_info
**diep
;
3294 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3295 struct abbrev_info
*abbrev
;
3296 struct die_info
*die
;
3298 offset
= info_ptr
- dwarf_info_buffer
;
3299 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3300 info_ptr
+= bytes_read
;
3303 die
= dwarf_alloc_die ();
3305 die
->abbrev
= abbrev_number
;
3311 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3314 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3316 die
= dwarf_alloc_die ();
3317 die
->offset
= offset
;
3318 die
->tag
= abbrev
->tag
;
3319 die
->has_children
= abbrev
->has_children
;
3320 die
->abbrev
= abbrev_number
;
3323 die
->num_attrs
= abbrev
->num_attrs
;
3324 die
->attrs
= (struct attribute
*)
3325 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3327 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3329 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3337 /* Read an attribute described by an abbreviated attribute. */
3340 read_attribute (attr
, abbrev
, abfd
, info_ptr
)
3341 struct attribute
*attr
;
3342 struct attr_abbrev
*abbrev
;
3346 unsigned int bytes_read
;
3347 struct dwarf_block
*blk
;
3349 attr
->name
= abbrev
->name
;
3350 attr
->form
= abbrev
->form
;
3351 switch (abbrev
->form
)
3354 case DW_FORM_ref_addr
:
3355 DW_ADDR (attr
) = read_address (abfd
, info_ptr
);
3356 info_ptr
+= address_size
;
3358 case DW_FORM_block2
:
3359 blk
= dwarf_alloc_block ();
3360 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3362 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3363 info_ptr
+= blk
->size
;
3364 DW_BLOCK (attr
) = blk
;
3366 case DW_FORM_block4
:
3367 blk
= dwarf_alloc_block ();
3368 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3370 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3371 info_ptr
+= blk
->size
;
3372 DW_BLOCK (attr
) = blk
;
3375 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3379 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3383 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3386 case DW_FORM_string
:
3387 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3388 info_ptr
+= bytes_read
;
3391 blk
= dwarf_alloc_block ();
3392 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3393 info_ptr
+= bytes_read
;
3394 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3395 info_ptr
+= blk
->size
;
3396 DW_BLOCK (attr
) = blk
;
3398 case DW_FORM_block1
:
3399 blk
= dwarf_alloc_block ();
3400 blk
->size
= read_1_byte (abfd
, info_ptr
);
3402 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3403 info_ptr
+= blk
->size
;
3404 DW_BLOCK (attr
) = blk
;
3407 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3411 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3415 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3416 info_ptr
+= bytes_read
;
3419 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3420 info_ptr
+= bytes_read
;
3423 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3427 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3431 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3434 case DW_FORM_ref_udata
:
3435 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3436 info_ptr
+= bytes_read
;
3439 case DW_FORM_indirect
:
3441 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3442 dwarf_form_name (abbrev
->form
));
3447 /* read dwarf information from a buffer */
3450 read_1_byte (abfd
, buf
)
3454 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3458 read_1_signed_byte (abfd
, buf
)
3462 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3466 read_2_bytes (abfd
, buf
)
3470 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3474 read_2_signed_bytes (abfd
, buf
)
3478 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3482 read_4_bytes (abfd
, buf
)
3486 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3490 read_4_signed_bytes (abfd
, buf
)
3494 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3498 read_8_bytes (abfd
, buf
)
3502 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3506 read_address (abfd
, buf
)
3510 CORE_ADDR retval
= 0;
3512 if (address_size
== 4)
3514 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3515 } else { /* *THE* alternative is 8, right? */
3516 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3522 read_n_bytes (abfd
, buf
, size
)
3527 /* If the size of a host char is 8 bits, we can return a pointer
3528 to the buffer, otherwise we have to copy the data to a buffer
3529 allocated on the temporary obstack. */
3530 #if HOST_CHAR_BIT == 8
3536 ret
= obstack_alloc (&dwarf2_tmp_obstack
, size
);
3537 for (i
= 0; i
< size
; ++i
)
3539 ret
[i
] = bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3547 read_string (abfd
, buf
, bytes_read_ptr
)
3550 unsigned int *bytes_read_ptr
;
3552 /* If the size of a host char is 8 bits, we can return a pointer
3553 to the string, otherwise we have to copy the string to a buffer
3554 allocated on the temporary obstack. */
3555 #if HOST_CHAR_BIT == 8
3558 *bytes_read_ptr
= 1;
3561 *bytes_read_ptr
= strlen (buf
) + 1;
3567 while ((byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
)) != 0)
3569 obstack_1grow (&dwarf2_tmp_obstack
, byte
);
3575 *bytes_read_ptr
= 1;
3578 obstack_1grow (&dwarf2_tmp_obstack
, '\0');
3579 *bytes_read_ptr
= i
+ 1;
3580 return obstack_finish (&dwarf2_tmp_obstack
);
3585 read_unsigned_leb128 (abfd
, buf
, bytes_read_ptr
)
3588 unsigned int *bytes_read_ptr
;
3590 unsigned int result
, num_read
;
3600 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3603 result
|= ((byte
& 127) << shift
);
3604 if ((byte
& 128) == 0)
3610 *bytes_read_ptr
= num_read
;
3615 read_signed_leb128 (abfd
, buf
, bytes_read_ptr
)
3618 unsigned int *bytes_read_ptr
;
3621 int i
, shift
, size
, num_read
;
3631 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3634 result
|= ((byte
& 127) << shift
);
3636 if ((byte
& 128) == 0)
3641 if ((shift
< size
) && (byte
& 0x40))
3643 result
|= -(1 << shift
);
3645 *bytes_read_ptr
= num_read
;
3650 set_cu_language (lang
)
3657 case DW_LANG_Fortran77
:
3658 cu_language
= language_c
;
3660 case DW_LANG_C_plus_plus
:
3661 cu_language
= language_cplus
;
3663 case DW_LANG_Mips_Assembler
:
3664 cu_language
= language_asm
;
3667 case DW_LANG_Cobol74
:
3668 case DW_LANG_Cobol85
:
3670 case DW_LANG_Fortran77
: /* moved up top for now */
3672 case DW_LANG_Fortran90
:
3673 case DW_LANG_Pascal83
:
3674 case DW_LANG_Modula2
:
3676 cu_language
= language_unknown
;
3679 cu_language_defn
= language_def (cu_language
);
3682 /* Return the named attribute or NULL if not there. */
3684 static struct attribute
*
3685 dwarf_attr (die
, name
)
3686 struct die_info
*die
;
3690 struct attribute
*spec
= NULL
;
3692 for (i
= 0; i
< die
->num_attrs
; ++i
)
3694 if (die
->attrs
[i
].name
== name
)
3696 return &die
->attrs
[i
];
3698 if (die
->attrs
[i
].name
== DW_AT_specification
3699 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
3700 spec
= &die
->attrs
[i
];
3704 struct die_info
*ref_die
=
3705 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
3708 return dwarf_attr (ref_die
, name
);
3714 /* Decode the line number information for the compilation unit whose
3715 line number info is at OFFSET in the .debug_line section.
3716 The compilation directory of the file is passed in COMP_DIR. */
3720 unsigned int num_files
;
3733 unsigned int num_dirs
;
3738 dwarf_decode_lines (offset
, comp_dir
, abfd
)
3739 unsigned int offset
;
3745 struct line_head lh
;
3746 struct cleanup
*back_to
;
3747 unsigned int i
, bytes_read
;
3748 char *cur_file
, *cur_dir
;
3749 unsigned char op_code
, extended_op
, adj_opcode
;
3751 #define FILE_ALLOC_CHUNK 5
3752 #define DIR_ALLOC_CHUNK 5
3754 struct filenames files
;
3755 struct directories dirs
;
3757 if (dwarf_line_buffer
== NULL
)
3759 complain (&dwarf2_missing_line_number_section
);
3763 files
.num_files
= 0;
3769 line_ptr
= dwarf_line_buffer
+ offset
;
3771 /* read in the prologue */
3772 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
3774 line_end
= line_ptr
+ lh
.total_length
;
3775 lh
.version
= read_2_bytes (abfd
, line_ptr
);
3777 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
);
3779 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
3781 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
3783 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
3785 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
3787 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
3789 lh
.standard_opcode_lengths
= (unsigned char *)
3790 xmalloc (lh
.opcode_base
* sizeof (unsigned char));
3791 back_to
= make_cleanup (free_current_contents
, &lh
.standard_opcode_lengths
);
3793 lh
.standard_opcode_lengths
[0] = 1;
3794 for (i
= 1; i
< lh
.opcode_base
; ++i
)
3796 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
3800 /* Read directory table */
3801 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
3803 line_ptr
+= bytes_read
;
3804 if ((dirs
.num_dirs
% DIR_ALLOC_CHUNK
) == 0)
3806 dirs
.dirs
= (char **)
3807 xrealloc (dirs
.dirs
,
3808 (dirs
.num_dirs
+ DIR_ALLOC_CHUNK
) * sizeof (char *));
3809 if (dirs
.num_dirs
== 0)
3810 make_cleanup (free_current_contents
, &dirs
.dirs
);
3812 dirs
.dirs
[dirs
.num_dirs
++] = cur_dir
;
3814 line_ptr
+= bytes_read
;
3816 /* Read file name table */
3817 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
3819 line_ptr
+= bytes_read
;
3820 if ((files
.num_files
% FILE_ALLOC_CHUNK
) == 0)
3822 files
.files
= (struct fileinfo
*)
3823 xrealloc (files
.files
,
3824 (files
.num_files
+ FILE_ALLOC_CHUNK
)
3825 * sizeof (struct fileinfo
));
3826 if (files
.num_files
== 0)
3827 make_cleanup (free_current_contents
, &files
.files
);
3829 files
.files
[files
.num_files
].name
= cur_file
;
3830 files
.files
[files
.num_files
].dir
=
3831 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3832 line_ptr
+= bytes_read
;
3833 files
.files
[files
.num_files
].time
=
3834 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3835 line_ptr
+= bytes_read
;
3836 files
.files
[files
.num_files
].size
=
3837 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3838 line_ptr
+= bytes_read
;
3841 line_ptr
+= bytes_read
;
3843 /* Read the statement sequences until there's nothing left. */
3844 while (line_ptr
< line_end
)
3846 /* state machine registers */
3847 unsigned int address
= 0;
3848 unsigned int file
= 1;
3849 unsigned int line
= 1;
3850 unsigned int column
= 0;
3851 int is_stmt
= lh
.default_is_stmt
;
3852 int basic_block
= 0;
3853 int end_sequence
= 0;
3855 /* Start a subfile for the current file of the state machine. */
3856 if (files
.num_files
>= file
)
3858 /* The file and directory tables are 0 based, the references
3860 dwarf2_start_subfile (files
.files
[file
- 1].name
,
3861 (files
.files
[file
- 1].dir
3862 ? dirs
.dirs
[files
.files
[file
- 1].dir
- 1]
3866 /* Decode the table. */
3867 while (! end_sequence
)
3869 op_code
= read_1_byte (abfd
, line_ptr
);
3873 case DW_LNS_extended_op
:
3874 line_ptr
+= 1; /* ignore length */
3875 extended_op
= read_1_byte (abfd
, line_ptr
);
3877 switch (extended_op
)
3879 case DW_LNE_end_sequence
:
3881 record_line (current_subfile
, line
, address
);
3883 case DW_LNE_set_address
:
3884 address
= read_address (abfd
, line_ptr
) + baseaddr
;
3885 line_ptr
+= address_size
;
3887 case DW_LNE_define_file
:
3888 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
3889 line_ptr
+= bytes_read
;
3890 if ((files
.num_files
% FILE_ALLOC_CHUNK
) == 0)
3892 files
.files
= (struct fileinfo
*)
3893 xrealloc (files
.files
,
3894 (files
.num_files
+ FILE_ALLOC_CHUNK
)
3895 * sizeof (struct fileinfo
));
3896 if (files
.num_files
== 0)
3897 make_cleanup (free_current_contents
, &files
.files
);
3899 files
.files
[files
.num_files
].name
= cur_file
;
3900 files
.files
[files
.num_files
].dir
=
3901 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3902 line_ptr
+= bytes_read
;
3903 files
.files
[files
.num_files
].time
=
3904 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3905 line_ptr
+= bytes_read
;
3906 files
.files
[files
.num_files
].size
=
3907 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3908 line_ptr
+= bytes_read
;
3912 complain (&dwarf2_mangled_line_number_section
);
3917 record_line (current_subfile
, line
, address
);
3920 case DW_LNS_advance_pc
:
3921 address
+= lh
.minimum_instruction_length
3922 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3923 line_ptr
+= bytes_read
;
3925 case DW_LNS_advance_line
:
3926 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
3927 line_ptr
+= bytes_read
;
3929 case DW_LNS_set_file
:
3930 /* The file and directory tables are 0 based, the references
3932 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3933 line_ptr
+= bytes_read
;
3934 dwarf2_start_subfile
3935 (files
.files
[file
- 1].name
,
3936 (files
.files
[file
- 1].dir
3937 ? dirs
.dirs
[files
.files
[file
- 1].dir
- 1]
3940 case DW_LNS_set_column
:
3941 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3942 line_ptr
+= bytes_read
;
3944 case DW_LNS_negate_stmt
:
3945 is_stmt
= (!is_stmt
);
3947 case DW_LNS_set_basic_block
:
3950 case DW_LNS_const_add_pc
:
3951 address
+= (255 - lh
.opcode_base
) / lh
.line_range
;
3953 case DW_LNS_fixed_advance_pc
:
3954 address
+= read_2_bytes (abfd
, line_ptr
);
3957 default: /* special operand */
3958 adj_opcode
= op_code
- lh
.opcode_base
;
3959 address
+= (adj_opcode
/ lh
.line_range
)
3960 * lh
.minimum_instruction_length
;
3961 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
3962 /* append row to matrix using current values */
3963 record_line (current_subfile
, line
, address
);
3969 do_cleanups (back_to
);
3972 /* Start a subfile for DWARF. FILENAME is the name of the file and
3973 DIRNAME the name of the source directory which contains FILENAME
3974 or NULL if not known.
3975 This routine tries to keep line numbers from identical absolute and
3976 relative file names in a common subfile.
3978 Using the `list' example from the GDB testsuite, which resides in
3979 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
3980 of /srcdir/list0.c yields the following debugging information for list0.c:
3982 DW_AT_name: /srcdir/list0.c
3983 DW_AT_comp_dir: /compdir
3984 files.files[0].name: list0.h
3985 files.files[0].dir: /srcdir
3986 files.files[1].name: list0.c
3987 files.files[1].dir: /srcdir
3989 The line number information for list0.c has to end up in a single
3990 subfile, so that `break /srcdir/list0.c:1' works as expected. */
3993 dwarf2_start_subfile (filename
, dirname
)
3997 /* If the filename isn't absolute, try to match an existing subfile
3998 with the full pathname. */
4000 if (*filename
!= '/' && dirname
!= NULL
)
4002 struct subfile
*subfile
;
4003 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4005 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4007 if (STREQ (subfile
->name
, fullname
))
4009 current_subfile
= subfile
;
4016 start_subfile (filename
, dirname
);
4019 /* Given a pointer to a DWARF information entry, figure out if we need
4020 to make a symbol table entry for it, and if so, create a new entry
4021 and return a pointer to it.
4022 If TYPE is NULL, determine symbol type from the die, otherwise
4023 used the passed type.
4026 static struct symbol
*
4027 new_symbol (die
, type
, objfile
)
4028 struct die_info
*die
;
4030 struct objfile
*objfile
;
4032 struct symbol
*sym
= NULL
;
4034 struct attribute
*attr
= NULL
;
4035 struct attribute
*attr2
= NULL
;
4038 name
= dwarf2_linkage_name (die
);
4041 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4042 sizeof (struct symbol
));
4043 OBJSTAT (objfile
, n_syms
++);
4044 memset (sym
, 0, sizeof (struct symbol
));
4045 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4046 &objfile
->symbol_obstack
);
4048 /* Default assumptions.
4049 Use the passed type or decode it from the die. */
4050 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4051 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4053 SYMBOL_TYPE (sym
) = type
;
4055 SYMBOL_TYPE (sym
) = die_type (die
, objfile
);
4056 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4059 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4062 /* If this symbol is from a C++ compilation, then attempt to
4063 cache the demangled form for future reference. This is a
4064 typical time versus space tradeoff, that was decided in favor
4065 of time because it sped up C++ symbol lookups by a factor of
4068 SYMBOL_LANGUAGE (sym
) = cu_language
;
4069 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4073 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4076 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4078 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4080 case DW_TAG_subprogram
:
4081 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4083 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4084 attr2
= dwarf_attr (die
, DW_AT_external
);
4085 if (attr2
&& (DW_UNSND (attr2
) != 0))
4087 add_symbol_to_list (sym
, &global_symbols
);
4091 add_symbol_to_list (sym
, list_in_scope
);
4094 case DW_TAG_variable
:
4095 /* Compilation with minimal debug info may result in variables
4096 with missing type entries. Change the misleading `void' type
4097 to something sensible. */
4098 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4099 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4100 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4101 "<variable, no debug info>",
4103 attr
= dwarf_attr (die
, DW_AT_const_value
);
4106 dwarf2_const_value (attr
, sym
, objfile
);
4107 attr2
= dwarf_attr (die
, DW_AT_external
);
4108 if (attr2
&& (DW_UNSND (attr2
) != 0))
4109 add_symbol_to_list (sym
, &global_symbols
);
4111 add_symbol_to_list (sym
, list_in_scope
);
4114 attr
= dwarf_attr (die
, DW_AT_location
);
4117 attr2
= dwarf_attr (die
, DW_AT_external
);
4118 if (attr2
&& (DW_UNSND (attr2
) != 0))
4120 SYMBOL_VALUE_ADDRESS (sym
) =
4121 decode_locdesc (DW_BLOCK (attr
), objfile
);
4122 add_symbol_to_list (sym
, &global_symbols
);
4124 /* In shared libraries the address of the variable
4125 in the location descriptor might still be relocatable,
4126 so its value could be zero.
4127 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4128 value is zero, the address of the variable will then
4129 be determined from the minimal symbol table whenever
4130 the variable is referenced. */
4131 if (SYMBOL_VALUE_ADDRESS (sym
))
4133 SYMBOL_VALUE_ADDRESS (sym
) += baseaddr
;
4134 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4137 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4141 SYMBOL_VALUE (sym
) = addr
=
4142 decode_locdesc (DW_BLOCK (attr
), objfile
);
4143 add_symbol_to_list (sym
, list_in_scope
);
4146 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4150 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4154 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4155 SYMBOL_BASEREG (sym
) = basereg
;
4159 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4163 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4164 SYMBOL_VALUE_ADDRESS (sym
) = addr
+ baseaddr
;
4170 /* We do not know the address of this symbol.
4171 If it is an external symbol and we have type information
4172 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4173 The address of the variable will then be determined from
4174 the minimal symbol table whenever the variable is
4176 attr2
= dwarf_attr (die
, DW_AT_external
);
4177 if (attr2
&& (DW_UNSND (attr2
) != 0)
4178 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4180 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4181 add_symbol_to_list (sym
, &global_symbols
);
4185 case DW_TAG_formal_parameter
:
4186 attr
= dwarf_attr (die
, DW_AT_location
);
4189 SYMBOL_VALUE (sym
) = decode_locdesc (DW_BLOCK (attr
), objfile
);
4192 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4196 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4197 SYMBOL_BASEREG (sym
) = basereg
;
4201 SYMBOL_CLASS (sym
) = LOC_ARG
;
4204 attr
= dwarf_attr (die
, DW_AT_const_value
);
4207 dwarf2_const_value (attr
, sym
, objfile
);
4209 add_symbol_to_list (sym
, list_in_scope
);
4211 case DW_TAG_unspecified_parameters
:
4212 /* From varargs functions; gdb doesn't seem to have any
4213 interest in this information, so just ignore it for now.
4216 case DW_TAG_class_type
:
4217 case DW_TAG_structure_type
:
4218 case DW_TAG_union_type
:
4219 case DW_TAG_enumeration_type
:
4220 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4221 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
4222 add_symbol_to_list (sym
, list_in_scope
);
4224 /* The semantics of C++ state that "struct foo { ... }" also
4225 defines a typedef for "foo". Synthesize a typedef symbol so
4226 that "ptype foo" works as expected. */
4227 if (cu_language
== language_cplus
)
4229 struct symbol
*typedef_sym
= (struct symbol
*)
4230 obstack_alloc (&objfile
->symbol_obstack
,
4231 sizeof (struct symbol
));
4232 *typedef_sym
= *sym
;
4233 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
4234 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
4235 TYPE_NAME (SYMBOL_TYPE (sym
)) =
4236 obsavestring (SYMBOL_NAME (sym
),
4237 strlen (SYMBOL_NAME (sym
)),
4238 &objfile
->type_obstack
);
4239 add_symbol_to_list (typedef_sym
, list_in_scope
);
4242 case DW_TAG_typedef
:
4243 case DW_TAG_base_type
:
4244 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4245 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4246 add_symbol_to_list (sym
, list_in_scope
);
4248 case DW_TAG_enumerator
:
4249 attr
= dwarf_attr (die
, DW_AT_const_value
);
4252 dwarf2_const_value (attr
, sym
, objfile
);
4254 add_symbol_to_list (sym
, list_in_scope
);
4257 /* Not a tag we recognize. Hopefully we aren't processing
4258 trash data, but since we must specifically ignore things
4259 we don't recognize, there is nothing else we should do at
4261 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
4268 /* Copy constant value from an attribute to a symbol. */
4271 dwarf2_const_value (attr
, sym
, objfile
)
4272 struct attribute
*attr
;
4274 struct objfile
*objfile
;
4276 struct dwarf_block
*blk
;
4281 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != (unsigned int) address_size
)
4282 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4283 address_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4284 SYMBOL_VALUE_BYTES (sym
) = (char *)
4285 obstack_alloc (&objfile
->symbol_obstack
, address_size
);
4286 store_address (SYMBOL_VALUE_BYTES (sym
), address_size
, DW_ADDR (attr
));
4287 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4289 case DW_FORM_block1
:
4290 case DW_FORM_block2
:
4291 case DW_FORM_block4
:
4293 blk
= DW_BLOCK (attr
);
4294 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
4295 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4296 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4297 SYMBOL_VALUE_BYTES (sym
) = (char *)
4298 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
4299 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
4300 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4308 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
4309 SYMBOL_CLASS (sym
) = LOC_CONST
;
4312 complain (&dwarf2_unsupported_const_value_attr
,
4313 dwarf_form_name (attr
->form
));
4314 SYMBOL_VALUE (sym
) = 0;
4315 SYMBOL_CLASS (sym
) = LOC_CONST
;
4320 /* Return the type of the die in question using its DW_AT_type attribute. */
4322 static struct type
*
4323 die_type (die
, objfile
)
4324 struct die_info
*die
;
4325 struct objfile
*objfile
;
4328 struct attribute
*type_attr
;
4329 struct die_info
*type_die
;
4332 type_attr
= dwarf_attr (die
, DW_AT_type
);
4335 /* A missing DW_AT_type represents a void type. */
4336 return dwarf2_fundamental_type (objfile
, FT_VOID
);
4340 ref
= dwarf2_get_ref_die_offset (type_attr
);
4341 type_die
= follow_die_ref (ref
);
4344 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4348 type
= tag_type_to_type (type_die
, objfile
);
4351 dump_die (type_die
);
4352 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
4357 /* Return the containing type of the die in question using its
4358 DW_AT_containing_type attribute. */
4360 static struct type
*
4361 die_containing_type (die
, objfile
)
4362 struct die_info
*die
;
4363 struct objfile
*objfile
;
4365 struct type
*type
= NULL
;
4366 struct attribute
*type_attr
;
4367 struct die_info
*type_die
= NULL
;
4370 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
4373 ref
= dwarf2_get_ref_die_offset (type_attr
);
4374 type_die
= follow_die_ref (ref
);
4377 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4380 type
= tag_type_to_type (type_die
, objfile
);
4385 dump_die (type_die
);
4386 error ("Dwarf Error: Problem turning containing type into gdb type.");
4392 static struct type
*
4393 type_at_offset (offset
, objfile
)
4394 unsigned int offset
;
4395 struct objfile
*objfile
;
4397 struct die_info
*die
;
4400 die
= follow_die_ref (offset
);
4403 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
4406 type
= tag_type_to_type (die
, objfile
);
4411 static struct type
*
4412 tag_type_to_type (die
, objfile
)
4413 struct die_info
*die
;
4414 struct objfile
*objfile
;
4422 read_type_die (die
, objfile
);
4426 error ("Dwarf Error: Cannot find type of die.");
4433 read_type_die (die
, objfile
)
4434 struct die_info
*die
;
4435 struct objfile
*objfile
;
4439 case DW_TAG_class_type
:
4440 case DW_TAG_structure_type
:
4441 case DW_TAG_union_type
:
4442 read_structure_scope (die
, objfile
);
4444 case DW_TAG_enumeration_type
:
4445 read_enumeration (die
, objfile
);
4447 case DW_TAG_subprogram
:
4448 case DW_TAG_subroutine_type
:
4449 read_subroutine_type (die
, objfile
);
4451 case DW_TAG_array_type
:
4452 read_array_type (die
, objfile
);
4454 case DW_TAG_pointer_type
:
4455 read_tag_pointer_type (die
, objfile
);
4457 case DW_TAG_ptr_to_member_type
:
4458 read_tag_ptr_to_member_type (die
, objfile
);
4460 case DW_TAG_reference_type
:
4461 read_tag_reference_type (die
, objfile
);
4463 case DW_TAG_const_type
:
4464 read_tag_const_type (die
, objfile
);
4466 case DW_TAG_volatile_type
:
4467 read_tag_volatile_type (die
, objfile
);
4469 case DW_TAG_string_type
:
4470 read_tag_string_type (die
, objfile
);
4472 case DW_TAG_typedef
:
4473 read_typedef (die
, objfile
);
4475 case DW_TAG_base_type
:
4476 read_base_type (die
, objfile
);
4479 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
4484 static struct type
*
4485 dwarf_base_type (encoding
, size
, objfile
)
4488 struct objfile
*objfile
;
4490 /* FIXME - this should not produce a new (struct type *)
4491 every time. It should cache base types. */
4495 case DW_ATE_address
:
4496 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
4498 case DW_ATE_boolean
:
4499 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
4501 case DW_ATE_complex_float
:
4504 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
4508 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
4514 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
4518 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
4525 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
4528 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
4532 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
4536 case DW_ATE_signed_char
:
4537 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
4539 case DW_ATE_unsigned
:
4543 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
4546 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
4550 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
4554 case DW_ATE_unsigned_char
:
4555 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
4558 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
4566 struct die_info
*old_die
;
4568 struct die_info
*new_die
;
4571 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
4572 memset (new_die
, 0, sizeof (struct die_info
));
4574 new_die
->tag
= old_die
->tag
;
4575 new_die
->has_children
= old_die
->has_children
;
4576 new_die
->abbrev
= old_die
->abbrev
;
4577 new_die
->offset
= old_die
->offset
;
4578 new_die
->type
= NULL
;
4580 num_attrs
= old_die
->num_attrs
;
4581 new_die
->num_attrs
= num_attrs
;
4582 new_die
->attrs
= (struct attribute
*)
4583 xmalloc (num_attrs
* sizeof (struct attribute
));
4585 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
4587 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
4588 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
4589 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
4592 new_die
->next
= NULL
;
4597 /* Return sibling of die, NULL if no sibling. */
4601 struct die_info
*die
;
4603 int nesting_level
= 0;
4605 if (!die
->has_children
)
4607 if (die
->next
&& (die
->next
->tag
== 0))
4620 if (die
->has_children
)
4630 while (nesting_level
);
4631 if (die
&& (die
->tag
== 0))
4642 /* Get linkage name of a die, return NULL if not found. */
4645 dwarf2_linkage_name (die
)
4646 struct die_info
*die
;
4648 struct attribute
*attr
;
4650 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
4651 if (attr
&& DW_STRING (attr
))
4652 return DW_STRING (attr
);
4653 attr
= dwarf_attr (die
, DW_AT_name
);
4654 if (attr
&& DW_STRING (attr
))
4655 return DW_STRING (attr
);
4659 /* Convert a DIE tag into its string name. */
4662 dwarf_tag_name (tag
)
4663 register unsigned tag
;
4667 case DW_TAG_padding
:
4668 return "DW_TAG_padding";
4669 case DW_TAG_array_type
:
4670 return "DW_TAG_array_type";
4671 case DW_TAG_class_type
:
4672 return "DW_TAG_class_type";
4673 case DW_TAG_entry_point
:
4674 return "DW_TAG_entry_point";
4675 case DW_TAG_enumeration_type
:
4676 return "DW_TAG_enumeration_type";
4677 case DW_TAG_formal_parameter
:
4678 return "DW_TAG_formal_parameter";
4679 case DW_TAG_imported_declaration
:
4680 return "DW_TAG_imported_declaration";
4682 return "DW_TAG_label";
4683 case DW_TAG_lexical_block
:
4684 return "DW_TAG_lexical_block";
4686 return "DW_TAG_member";
4687 case DW_TAG_pointer_type
:
4688 return "DW_TAG_pointer_type";
4689 case DW_TAG_reference_type
:
4690 return "DW_TAG_reference_type";
4691 case DW_TAG_compile_unit
:
4692 return "DW_TAG_compile_unit";
4693 case DW_TAG_string_type
:
4694 return "DW_TAG_string_type";
4695 case DW_TAG_structure_type
:
4696 return "DW_TAG_structure_type";
4697 case DW_TAG_subroutine_type
:
4698 return "DW_TAG_subroutine_type";
4699 case DW_TAG_typedef
:
4700 return "DW_TAG_typedef";
4701 case DW_TAG_union_type
:
4702 return "DW_TAG_union_type";
4703 case DW_TAG_unspecified_parameters
:
4704 return "DW_TAG_unspecified_parameters";
4705 case DW_TAG_variant
:
4706 return "DW_TAG_variant";
4707 case DW_TAG_common_block
:
4708 return "DW_TAG_common_block";
4709 case DW_TAG_common_inclusion
:
4710 return "DW_TAG_common_inclusion";
4711 case DW_TAG_inheritance
:
4712 return "DW_TAG_inheritance";
4713 case DW_TAG_inlined_subroutine
:
4714 return "DW_TAG_inlined_subroutine";
4716 return "DW_TAG_module";
4717 case DW_TAG_ptr_to_member_type
:
4718 return "DW_TAG_ptr_to_member_type";
4719 case DW_TAG_set_type
:
4720 return "DW_TAG_set_type";
4721 case DW_TAG_subrange_type
:
4722 return "DW_TAG_subrange_type";
4723 case DW_TAG_with_stmt
:
4724 return "DW_TAG_with_stmt";
4725 case DW_TAG_access_declaration
:
4726 return "DW_TAG_access_declaration";
4727 case DW_TAG_base_type
:
4728 return "DW_TAG_base_type";
4729 case DW_TAG_catch_block
:
4730 return "DW_TAG_catch_block";
4731 case DW_TAG_const_type
:
4732 return "DW_TAG_const_type";
4733 case DW_TAG_constant
:
4734 return "DW_TAG_constant";
4735 case DW_TAG_enumerator
:
4736 return "DW_TAG_enumerator";
4737 case DW_TAG_file_type
:
4738 return "DW_TAG_file_type";
4740 return "DW_TAG_friend";
4741 case DW_TAG_namelist
:
4742 return "DW_TAG_namelist";
4743 case DW_TAG_namelist_item
:
4744 return "DW_TAG_namelist_item";
4745 case DW_TAG_packed_type
:
4746 return "DW_TAG_packed_type";
4747 case DW_TAG_subprogram
:
4748 return "DW_TAG_subprogram";
4749 case DW_TAG_template_type_param
:
4750 return "DW_TAG_template_type_param";
4751 case DW_TAG_template_value_param
:
4752 return "DW_TAG_template_value_param";
4753 case DW_TAG_thrown_type
:
4754 return "DW_TAG_thrown_type";
4755 case DW_TAG_try_block
:
4756 return "DW_TAG_try_block";
4757 case DW_TAG_variant_part
:
4758 return "DW_TAG_variant_part";
4759 case DW_TAG_variable
:
4760 return "DW_TAG_variable";
4761 case DW_TAG_volatile_type
:
4762 return "DW_TAG_volatile_type";
4763 case DW_TAG_MIPS_loop
:
4764 return "DW_TAG_MIPS_loop";
4765 case DW_TAG_format_label
:
4766 return "DW_TAG_format_label";
4767 case DW_TAG_function_template
:
4768 return "DW_TAG_function_template";
4769 case DW_TAG_class_template
:
4770 return "DW_TAG_class_template";
4772 return "DW_TAG_<unknown>";
4776 /* Convert a DWARF attribute code into its string name. */
4779 dwarf_attr_name (attr
)
4780 register unsigned attr
;
4785 return "DW_AT_sibling";
4786 case DW_AT_location
:
4787 return "DW_AT_location";
4789 return "DW_AT_name";
4790 case DW_AT_ordering
:
4791 return "DW_AT_ordering";
4792 case DW_AT_subscr_data
:
4793 return "DW_AT_subscr_data";
4794 case DW_AT_byte_size
:
4795 return "DW_AT_byte_size";
4796 case DW_AT_bit_offset
:
4797 return "DW_AT_bit_offset";
4798 case DW_AT_bit_size
:
4799 return "DW_AT_bit_size";
4800 case DW_AT_element_list
:
4801 return "DW_AT_element_list";
4802 case DW_AT_stmt_list
:
4803 return "DW_AT_stmt_list";
4805 return "DW_AT_low_pc";
4807 return "DW_AT_high_pc";
4808 case DW_AT_language
:
4809 return "DW_AT_language";
4811 return "DW_AT_member";
4813 return "DW_AT_discr";
4814 case DW_AT_discr_value
:
4815 return "DW_AT_discr_value";
4816 case DW_AT_visibility
:
4817 return "DW_AT_visibility";
4819 return "DW_AT_import";
4820 case DW_AT_string_length
:
4821 return "DW_AT_string_length";
4822 case DW_AT_common_reference
:
4823 return "DW_AT_common_reference";
4824 case DW_AT_comp_dir
:
4825 return "DW_AT_comp_dir";
4826 case DW_AT_const_value
:
4827 return "DW_AT_const_value";
4828 case DW_AT_containing_type
:
4829 return "DW_AT_containing_type";
4830 case DW_AT_default_value
:
4831 return "DW_AT_default_value";
4833 return "DW_AT_inline";
4834 case DW_AT_is_optional
:
4835 return "DW_AT_is_optional";
4836 case DW_AT_lower_bound
:
4837 return "DW_AT_lower_bound";
4838 case DW_AT_producer
:
4839 return "DW_AT_producer";
4840 case DW_AT_prototyped
:
4841 return "DW_AT_prototyped";
4842 case DW_AT_return_addr
:
4843 return "DW_AT_return_addr";
4844 case DW_AT_start_scope
:
4845 return "DW_AT_start_scope";
4846 case DW_AT_stride_size
:
4847 return "DW_AT_stride_size";
4848 case DW_AT_upper_bound
:
4849 return "DW_AT_upper_bound";
4850 case DW_AT_abstract_origin
:
4851 return "DW_AT_abstract_origin";
4852 case DW_AT_accessibility
:
4853 return "DW_AT_accessibility";
4854 case DW_AT_address_class
:
4855 return "DW_AT_address_class";
4856 case DW_AT_artificial
:
4857 return "DW_AT_artificial";
4858 case DW_AT_base_types
:
4859 return "DW_AT_base_types";
4860 case DW_AT_calling_convention
:
4861 return "DW_AT_calling_convention";
4863 return "DW_AT_count";
4864 case DW_AT_data_member_location
:
4865 return "DW_AT_data_member_location";
4866 case DW_AT_decl_column
:
4867 return "DW_AT_decl_column";
4868 case DW_AT_decl_file
:
4869 return "DW_AT_decl_file";
4870 case DW_AT_decl_line
:
4871 return "DW_AT_decl_line";
4872 case DW_AT_declaration
:
4873 return "DW_AT_declaration";
4874 case DW_AT_discr_list
:
4875 return "DW_AT_discr_list";
4876 case DW_AT_encoding
:
4877 return "DW_AT_encoding";
4878 case DW_AT_external
:
4879 return "DW_AT_external";
4880 case DW_AT_frame_base
:
4881 return "DW_AT_frame_base";
4883 return "DW_AT_friend";
4884 case DW_AT_identifier_case
:
4885 return "DW_AT_identifier_case";
4886 case DW_AT_macro_info
:
4887 return "DW_AT_macro_info";
4888 case DW_AT_namelist_items
:
4889 return "DW_AT_namelist_items";
4890 case DW_AT_priority
:
4891 return "DW_AT_priority";
4893 return "DW_AT_segment";
4894 case DW_AT_specification
:
4895 return "DW_AT_specification";
4896 case DW_AT_static_link
:
4897 return "DW_AT_static_link";
4899 return "DW_AT_type";
4900 case DW_AT_use_location
:
4901 return "DW_AT_use_location";
4902 case DW_AT_variable_parameter
:
4903 return "DW_AT_variable_parameter";
4904 case DW_AT_virtuality
:
4905 return "DW_AT_virtuality";
4906 case DW_AT_vtable_elem_location
:
4907 return "DW_AT_vtable_elem_location";
4910 case DW_AT_MIPS_fde
:
4911 return "DW_AT_MIPS_fde";
4912 case DW_AT_MIPS_loop_begin
:
4913 return "DW_AT_MIPS_loop_begin";
4914 case DW_AT_MIPS_tail_loop_begin
:
4915 return "DW_AT_MIPS_tail_loop_begin";
4916 case DW_AT_MIPS_epilog_begin
:
4917 return "DW_AT_MIPS_epilog_begin";
4918 case DW_AT_MIPS_loop_unroll_factor
:
4919 return "DW_AT_MIPS_loop_unroll_factor";
4920 case DW_AT_MIPS_software_pipeline_depth
:
4921 return "DW_AT_MIPS_software_pipeline_depth";
4922 case DW_AT_MIPS_linkage_name
:
4923 return "DW_AT_MIPS_linkage_name";
4926 case DW_AT_sf_names
:
4927 return "DW_AT_sf_names";
4928 case DW_AT_src_info
:
4929 return "DW_AT_src_info";
4930 case DW_AT_mac_info
:
4931 return "DW_AT_mac_info";
4932 case DW_AT_src_coords
:
4933 return "DW_AT_src_coords";
4934 case DW_AT_body_begin
:
4935 return "DW_AT_body_begin";
4936 case DW_AT_body_end
:
4937 return "DW_AT_body_end";
4939 return "DW_AT_<unknown>";
4943 /* Convert a DWARF value form code into its string name. */
4946 dwarf_form_name (form
)
4947 register unsigned form
;
4952 return "DW_FORM_addr";
4953 case DW_FORM_block2
:
4954 return "DW_FORM_block2";
4955 case DW_FORM_block4
:
4956 return "DW_FORM_block4";
4958 return "DW_FORM_data2";
4960 return "DW_FORM_data4";
4962 return "DW_FORM_data8";
4963 case DW_FORM_string
:
4964 return "DW_FORM_string";
4966 return "DW_FORM_block";
4967 case DW_FORM_block1
:
4968 return "DW_FORM_block1";
4970 return "DW_FORM_data1";
4972 return "DW_FORM_flag";
4974 return "DW_FORM_sdata";
4976 return "DW_FORM_strp";
4978 return "DW_FORM_udata";
4979 case DW_FORM_ref_addr
:
4980 return "DW_FORM_ref_addr";
4982 return "DW_FORM_ref1";
4984 return "DW_FORM_ref2";
4986 return "DW_FORM_ref4";
4988 return "DW_FORM_ref8";
4989 case DW_FORM_ref_udata
:
4990 return "DW_FORM_ref_udata";
4991 case DW_FORM_indirect
:
4992 return "DW_FORM_indirect";
4994 return "DW_FORM_<unknown>";
4998 /* Convert a DWARF stack opcode into its string name. */
5001 dwarf_stack_op_name (op
)
5002 register unsigned op
;
5007 return "DW_OP_addr";
5009 return "DW_OP_deref";
5011 return "DW_OP_const1u";
5013 return "DW_OP_const1s";
5015 return "DW_OP_const2u";
5017 return "DW_OP_const2s";
5019 return "DW_OP_const4u";
5021 return "DW_OP_const4s";
5023 return "DW_OP_const8u";
5025 return "DW_OP_const8s";
5027 return "DW_OP_constu";
5029 return "DW_OP_consts";
5033 return "DW_OP_drop";
5035 return "DW_OP_over";
5037 return "DW_OP_pick";
5039 return "DW_OP_swap";
5043 return "DW_OP_xderef";
5051 return "DW_OP_minus";
5063 return "DW_OP_plus";
5064 case DW_OP_plus_uconst
:
5065 return "DW_OP_plus_uconst";
5071 return "DW_OP_shra";
5089 return "DW_OP_skip";
5091 return "DW_OP_lit0";
5093 return "DW_OP_lit1";
5095 return "DW_OP_lit2";
5097 return "DW_OP_lit3";
5099 return "DW_OP_lit4";
5101 return "DW_OP_lit5";
5103 return "DW_OP_lit6";
5105 return "DW_OP_lit7";
5107 return "DW_OP_lit8";
5109 return "DW_OP_lit9";
5111 return "DW_OP_lit10";
5113 return "DW_OP_lit11";
5115 return "DW_OP_lit12";
5117 return "DW_OP_lit13";
5119 return "DW_OP_lit14";
5121 return "DW_OP_lit15";
5123 return "DW_OP_lit16";
5125 return "DW_OP_lit17";
5127 return "DW_OP_lit18";
5129 return "DW_OP_lit19";
5131 return "DW_OP_lit20";
5133 return "DW_OP_lit21";
5135 return "DW_OP_lit22";
5137 return "DW_OP_lit23";
5139 return "DW_OP_lit24";
5141 return "DW_OP_lit25";
5143 return "DW_OP_lit26";
5145 return "DW_OP_lit27";
5147 return "DW_OP_lit28";
5149 return "DW_OP_lit29";
5151 return "DW_OP_lit30";
5153 return "DW_OP_lit31";
5155 return "DW_OP_reg0";
5157 return "DW_OP_reg1";
5159 return "DW_OP_reg2";
5161 return "DW_OP_reg3";
5163 return "DW_OP_reg4";
5165 return "DW_OP_reg5";
5167 return "DW_OP_reg6";
5169 return "DW_OP_reg7";
5171 return "DW_OP_reg8";
5173 return "DW_OP_reg9";
5175 return "DW_OP_reg10";
5177 return "DW_OP_reg11";
5179 return "DW_OP_reg12";
5181 return "DW_OP_reg13";
5183 return "DW_OP_reg14";
5185 return "DW_OP_reg15";
5187 return "DW_OP_reg16";
5189 return "DW_OP_reg17";
5191 return "DW_OP_reg18";
5193 return "DW_OP_reg19";
5195 return "DW_OP_reg20";
5197 return "DW_OP_reg21";
5199 return "DW_OP_reg22";
5201 return "DW_OP_reg23";
5203 return "DW_OP_reg24";
5205 return "DW_OP_reg25";
5207 return "DW_OP_reg26";
5209 return "DW_OP_reg27";
5211 return "DW_OP_reg28";
5213 return "DW_OP_reg29";
5215 return "DW_OP_reg30";
5217 return "DW_OP_reg31";
5219 return "DW_OP_breg0";
5221 return "DW_OP_breg1";
5223 return "DW_OP_breg2";
5225 return "DW_OP_breg3";
5227 return "DW_OP_breg4";
5229 return "DW_OP_breg5";
5231 return "DW_OP_breg6";
5233 return "DW_OP_breg7";
5235 return "DW_OP_breg8";
5237 return "DW_OP_breg9";
5239 return "DW_OP_breg10";
5241 return "DW_OP_breg11";
5243 return "DW_OP_breg12";
5245 return "DW_OP_breg13";
5247 return "DW_OP_breg14";
5249 return "DW_OP_breg15";
5251 return "DW_OP_breg16";
5253 return "DW_OP_breg17";
5255 return "DW_OP_breg18";
5257 return "DW_OP_breg19";
5259 return "DW_OP_breg20";
5261 return "DW_OP_breg21";
5263 return "DW_OP_breg22";
5265 return "DW_OP_breg23";
5267 return "DW_OP_breg24";
5269 return "DW_OP_breg25";
5271 return "DW_OP_breg26";
5273 return "DW_OP_breg27";
5275 return "DW_OP_breg28";
5277 return "DW_OP_breg29";
5279 return "DW_OP_breg30";
5281 return "DW_OP_breg31";
5283 return "DW_OP_regx";
5285 return "DW_OP_fbreg";
5287 return "DW_OP_bregx";
5289 return "DW_OP_piece";
5290 case DW_OP_deref_size
:
5291 return "DW_OP_deref_size";
5292 case DW_OP_xderef_size
:
5293 return "DW_OP_xderef_size";
5297 return "OP_<unknown>";
5302 dwarf_bool_name (bool)
5311 /* Convert a DWARF type code into its string name. */
5314 dwarf_type_encoding_name (enc
)
5315 register unsigned enc
;
5319 case DW_ATE_address
:
5320 return "DW_ATE_address";
5321 case DW_ATE_boolean
:
5322 return "DW_ATE_boolean";
5323 case DW_ATE_complex_float
:
5324 return "DW_ATE_complex_float";
5326 return "DW_ATE_float";
5328 return "DW_ATE_signed";
5329 case DW_ATE_signed_char
:
5330 return "DW_ATE_signed_char";
5331 case DW_ATE_unsigned
:
5332 return "DW_ATE_unsigned";
5333 case DW_ATE_unsigned_char
:
5334 return "DW_ATE_unsigned_char";
5336 return "DW_ATE_<unknown>";
5340 /* Convert a DWARF call frame info operation to its string name. */
5344 dwarf_cfi_name (cfi_opc
)
5345 register unsigned cfi_opc
;
5349 case DW_CFA_advance_loc
:
5350 return "DW_CFA_advance_loc";
5352 return "DW_CFA_offset";
5353 case DW_CFA_restore
:
5354 return "DW_CFA_restore";
5356 return "DW_CFA_nop";
5357 case DW_CFA_set_loc
:
5358 return "DW_CFA_set_loc";
5359 case DW_CFA_advance_loc1
:
5360 return "DW_CFA_advance_loc1";
5361 case DW_CFA_advance_loc2
:
5362 return "DW_CFA_advance_loc2";
5363 case DW_CFA_advance_loc4
:
5364 return "DW_CFA_advance_loc4";
5365 case DW_CFA_offset_extended
:
5366 return "DW_CFA_offset_extended";
5367 case DW_CFA_restore_extended
:
5368 return "DW_CFA_restore_extended";
5369 case DW_CFA_undefined
:
5370 return "DW_CFA_undefined";
5371 case DW_CFA_same_value
:
5372 return "DW_CFA_same_value";
5373 case DW_CFA_register
:
5374 return "DW_CFA_register";
5375 case DW_CFA_remember_state
:
5376 return "DW_CFA_remember_state";
5377 case DW_CFA_restore_state
:
5378 return "DW_CFA_restore_state";
5379 case DW_CFA_def_cfa
:
5380 return "DW_CFA_def_cfa";
5381 case DW_CFA_def_cfa_register
:
5382 return "DW_CFA_def_cfa_register";
5383 case DW_CFA_def_cfa_offset
:
5384 return "DW_CFA_def_cfa_offset";
5385 /* SGI/MIPS specific */
5386 case DW_CFA_MIPS_advance_loc8
:
5387 return "DW_CFA_MIPS_advance_loc8";
5389 return "DW_CFA_<unknown>";
5396 struct die_info
*die
;
5400 fprintf (stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
5401 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
5402 fprintf (stderr
, "\thas children: %s\n",
5403 dwarf_bool_name (die
->has_children
));
5405 fprintf (stderr
, "\tattributes:\n");
5406 for (i
= 0; i
< die
->num_attrs
; ++i
)
5408 fprintf (stderr
, "\t\t%s (%s) ",
5409 dwarf_attr_name (die
->attrs
[i
].name
),
5410 dwarf_form_name (die
->attrs
[i
].form
));
5411 switch (die
->attrs
[i
].form
)
5413 case DW_FORM_ref_addr
:
5415 fprintf (stderr
, "address: ");
5416 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, stderr
);
5418 case DW_FORM_block2
:
5419 case DW_FORM_block4
:
5421 case DW_FORM_block1
:
5422 fprintf (stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
5432 fprintf (stderr
, "constant: %d", DW_UNSND (&die
->attrs
[i
]));
5434 case DW_FORM_string
:
5435 fprintf (stderr
, "string: \"%s\"",
5436 DW_STRING (&die
->attrs
[i
])
5437 ? DW_STRING (&die
->attrs
[i
]) : "");
5440 if (DW_UNSND (&die
->attrs
[i
]))
5441 fprintf (stderr
, "flag: TRUE");
5443 fprintf (stderr
, "flag: FALSE");
5445 case DW_FORM_strp
: /* we do not support separate string
5447 case DW_FORM_indirect
: /* we do not handle indirect yet */
5448 case DW_FORM_data8
: /* we do not have 64 bit quantities */
5450 fprintf (stderr
, "unsupported attribute form: %d.",
5451 die
->attrs
[i
].form
);
5453 fprintf (stderr
, "\n");
5459 struct die_info
*die
;
5469 store_in_ref_table (offset
, die
)
5470 unsigned int offset
;
5471 struct die_info
*die
;
5474 struct die_info
*old
;
5476 h
= (offset
% REF_HASH_SIZE
);
5477 old
= die_ref_table
[h
];
5478 die
->next_ref
= old
;
5479 die_ref_table
[h
] = die
;
5484 dwarf2_empty_die_ref_table ()
5486 memset (die_ref_table
, 0, sizeof (die_ref_table
));
5490 dwarf2_get_ref_die_offset (attr
)
5491 struct attribute
*attr
;
5493 unsigned int result
= 0;
5497 case DW_FORM_ref_addr
:
5498 result
= DW_ADDR (attr
);
5503 case DW_FORM_ref_udata
:
5504 result
= cu_header_offset
+ DW_UNSND (attr
);
5507 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
5513 follow_die_ref (offset
)
5514 unsigned int offset
;
5516 struct die_info
*die
;
5519 h
= (offset
% REF_HASH_SIZE
);
5520 die
= die_ref_table
[h
];
5523 if (die
->offset
== offset
)
5527 die
= die
->next_ref
;
5532 static struct type
*
5533 dwarf2_fundamental_type (objfile
, typeid)
5534 struct objfile
*objfile
;
5537 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
5539 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
5543 /* Look for this particular type in the fundamental type vector. If
5544 one is not found, create and install one appropriate for the
5545 current language and the current target machine. */
5547 if (ftypes
[typeid] == NULL
)
5549 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
5552 return (ftypes
[typeid]);
5555 /* Decode simple location descriptions.
5556 Given a pointer to a dwarf block that defines a location, compute
5557 the location and return the value.
5559 FIXME: This is a kludge until we figure out a better
5560 way to handle the location descriptions.
5561 Gdb's design does not mesh well with the DWARF2 notion of a location
5562 computing interpreter, which is a shame because the flexibility goes unused.
5563 FIXME: Implement more operations as necessary.
5565 A location description containing no operations indicates that the
5566 object is optimized out. The global optimized_out flag is set for
5567 those, the return value is meaningless.
5569 When the result is a register number, the global isreg flag is set,
5570 otherwise it is cleared.
5572 When the result is a base register offset, the global offreg flag is set
5573 and the register number is returned in basereg, otherwise it is cleared.
5575 When the DW_OP_fbreg operation is encountered without a corresponding
5576 DW_AT_frame_base attribute, the global islocal flag is set.
5577 Hopefully the machine dependent code knows how to set up a virtual
5578 frame pointer for the local references.
5580 Note that stack[0] is unused except as a default error return.
5581 Note that stack overflow is not yet handled. */
5584 decode_locdesc (blk
, objfile
)
5585 struct dwarf_block
*blk
;
5586 struct objfile
*objfile
;
5589 int size
= blk
->size
;
5590 char *data
= blk
->data
;
5591 CORE_ADDR stack
[64];
5593 unsigned int bytes_read
, unsnd
;
5643 stack
[++stacki
] = op
- DW_OP_reg0
;
5648 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
5650 #if defined(HARRIS_TARGET) && defined(_M88K)
5651 /* The Harris 88110 gdb ports have long kept their special reg
5652 numbers between their gp-regs and their x-regs. This is
5653 not how our dwarf is generated. Punt. */
5656 stack
[++stacki
] = unsnd
;
5692 basereg
= op
- DW_OP_breg0
;
5693 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5698 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5700 if (frame_base_reg
>= 0)
5703 basereg
= frame_base_reg
;
5704 stack
[stacki
] += frame_base_offset
;
5708 complain (&dwarf2_missing_at_frame_base
);
5714 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
]);
5719 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
5724 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
5729 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
5734 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
5739 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
5744 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
5749 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
5755 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5760 stack
[stacki
- 1] += stack
[stacki
];
5764 case DW_OP_plus_uconst
:
5765 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
5770 stack
[stacki
- 1] = stack
[stacki
] - stack
[stacki
- 1];
5775 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name(op
));
5776 return (stack
[stacki
]);
5779 return (stack
[stacki
]);
5782 /* memory allocation interface */
5786 dwarf2_free_tmp_obstack (ignore
)
5789 obstack_free (&dwarf2_tmp_obstack
, NULL
);
5792 static struct dwarf_block
*
5793 dwarf_alloc_block ()
5795 struct dwarf_block
*blk
;
5797 blk
= (struct dwarf_block
*)
5798 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
5802 static struct abbrev_info
*
5803 dwarf_alloc_abbrev ()
5805 struct abbrev_info
*abbrev
;
5807 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
5808 memset (abbrev
, 0, sizeof (struct abbrev_info
));
5812 static struct die_info
*
5815 struct die_info
*die
;
5817 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5818 memset (die
, 0, sizeof (struct die_info
));