1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
10 support in dwarfread.c
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or (at
17 your option) any later version.
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330,
27 Boston, MA 02111-1307, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
42 #include "complaints.h"
45 #include "gdb_string.h"
46 #include "gdb_assert.h"
47 #include <sys/types.h>
49 #ifndef DWARF2_REG_TO_REGNUM
50 #define DWARF2_REG_TO_REGNUM(REG) (REG)
54 /* .debug_info header for a compilation unit
55 Because of alignment constraints, this structure has padding and cannot
56 be mapped directly onto the beginning of the .debug_info section. */
57 typedef struct comp_unit_header
59 unsigned int length
; /* length of the .debug_info
61 unsigned short version
; /* version number -- 2 for DWARF
63 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
64 unsigned char addr_size
; /* byte size of an address -- 4 */
67 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
70 /* .debug_pubnames header
71 Because of alignment constraints, this structure has padding and cannot
72 be mapped directly onto the beginning of the .debug_info section. */
73 typedef struct pubnames_header
75 unsigned int length
; /* length of the .debug_pubnames
77 unsigned char version
; /* version number -- 2 for DWARF
79 unsigned int info_offset
; /* offset into .debug_info section */
80 unsigned int info_size
; /* byte size of .debug_info section
84 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
86 /* .debug_pubnames header
87 Because of alignment constraints, this structure has padding and cannot
88 be mapped directly onto the beginning of the .debug_info section. */
89 typedef struct aranges_header
91 unsigned int length
; /* byte len of the .debug_aranges
93 unsigned short version
; /* version number -- 2 for DWARF
95 unsigned int info_offset
; /* offset into .debug_info section */
96 unsigned char addr_size
; /* byte size of an address */
97 unsigned char seg_size
; /* byte size of segment descriptor */
100 #define _ACTUAL_ARANGES_HEADER_SIZE 12
102 /* .debug_line statement program prologue
103 Because of alignment constraints, this structure has padding and cannot
104 be mapped directly onto the beginning of the .debug_info section. */
105 typedef struct statement_prologue
107 unsigned int total_length
; /* byte length of the statement
109 unsigned short version
; /* version number -- 2 for DWARF
111 unsigned int prologue_length
; /* # bytes between prologue &
113 unsigned char minimum_instruction_length
; /* byte size of
115 unsigned char default_is_stmt
; /* initial value of is_stmt
118 unsigned char line_range
;
119 unsigned char opcode_base
; /* number assigned to first special
121 unsigned char *standard_opcode_lengths
;
125 /* offsets and sizes of debugging sections */
127 static file_ptr dwarf_info_offset
;
128 static file_ptr dwarf_abbrev_offset
;
129 static file_ptr dwarf_line_offset
;
130 static file_ptr dwarf_pubnames_offset
;
131 static file_ptr dwarf_aranges_offset
;
132 static file_ptr dwarf_loc_offset
;
133 static file_ptr dwarf_macinfo_offset
;
134 static file_ptr dwarf_str_offset
;
135 file_ptr dwarf_frame_offset
;
136 file_ptr dwarf_eh_frame_offset
;
138 static unsigned int dwarf_info_size
;
139 static unsigned int dwarf_abbrev_size
;
140 static unsigned int dwarf_line_size
;
141 static unsigned int dwarf_pubnames_size
;
142 static unsigned int dwarf_aranges_size
;
143 static unsigned int dwarf_loc_size
;
144 static unsigned int dwarf_macinfo_size
;
145 static unsigned int dwarf_str_size
;
146 unsigned int dwarf_frame_size
;
147 unsigned int dwarf_eh_frame_size
;
149 /* names of the debugging sections */
151 #define INFO_SECTION ".debug_info"
152 #define ABBREV_SECTION ".debug_abbrev"
153 #define LINE_SECTION ".debug_line"
154 #define PUBNAMES_SECTION ".debug_pubnames"
155 #define ARANGES_SECTION ".debug_aranges"
156 #define LOC_SECTION ".debug_loc"
157 #define MACINFO_SECTION ".debug_macinfo"
158 #define STR_SECTION ".debug_str"
159 #define FRAME_SECTION ".debug_frame"
160 #define EH_FRAME_SECTION ".eh_frame"
162 /* local data types */
164 /* The data in a compilation unit header, after target2host
165 translation, looks like this. */
166 struct comp_unit_head
168 unsigned long length
;
170 unsigned int abbrev_offset
;
171 unsigned char addr_size
;
172 unsigned char signed_addr_p
;
173 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
174 unsigned int initial_length_size
; /* size of the length field; either
178 /* The data in the .debug_line statement prologue looks like this. */
181 unsigned int total_length
;
182 unsigned short version
;
183 unsigned int prologue_length
;
184 unsigned char minimum_instruction_length
;
185 unsigned char default_is_stmt
;
187 unsigned char line_range
;
188 unsigned char opcode_base
;
189 unsigned char *standard_opcode_lengths
;
192 /* When we construct a partial symbol table entry we only
193 need this much information. */
194 struct partial_die_info
197 unsigned char has_children
;
198 unsigned char is_external
;
199 unsigned char is_declaration
;
200 unsigned char has_type
;
207 struct dwarf_block
*locdesc
;
208 unsigned int language
;
212 /* This data structure holds the information of an abbrev. */
215 unsigned int number
; /* number identifying abbrev */
216 enum dwarf_tag tag
; /* dwarf tag */
217 int has_children
; /* boolean */
218 unsigned int num_attrs
; /* number of attributes */
219 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
220 struct abbrev_info
*next
; /* next in chain */
225 enum dwarf_attribute name
;
226 enum dwarf_form form
;
229 /* This data structure holds a complete die structure. */
232 enum dwarf_tag tag
; /* Tag indicating type of die */
233 unsigned short has_children
; /* Does the die have children */
234 unsigned int abbrev
; /* Abbrev number */
235 unsigned int offset
; /* Offset in .debug_info section */
236 unsigned int num_attrs
; /* Number of attributes */
237 struct attribute
*attrs
; /* An array of attributes */
238 struct die_info
*next_ref
; /* Next die in ref hash table */
239 struct die_info
*next
; /* Next die in linked list */
240 struct type
*type
; /* Cached type information */
243 /* Attributes have a name and a value */
246 enum dwarf_attribute name
;
247 enum dwarf_form form
;
251 struct dwarf_block
*blk
;
259 /* Get at parts of an attribute structure */
261 #define DW_STRING(attr) ((attr)->u.str)
262 #define DW_UNSND(attr) ((attr)->u.unsnd)
263 #define DW_BLOCK(attr) ((attr)->u.blk)
264 #define DW_SND(attr) ((attr)->u.snd)
265 #define DW_ADDR(attr) ((attr)->u.addr)
267 /* Blocks are a bunch of untyped bytes. */
274 /* We only hold one compilation unit's abbrevs in
275 memory at any one time. */
276 #ifndef ABBREV_HASH_SIZE
277 #define ABBREV_HASH_SIZE 121
279 #ifndef ATTR_ALLOC_CHUNK
280 #define ATTR_ALLOC_CHUNK 4
283 static struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
285 /* A hash table of die offsets for following references. */
286 #ifndef REF_HASH_SIZE
287 #define REF_HASH_SIZE 1021
290 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
292 /* Obstack for allocating temporary storage used during symbol reading. */
293 static struct obstack dwarf2_tmp_obstack
;
295 /* Offset to the first byte of the current compilation unit header,
296 for resolving relative reference dies. */
297 static unsigned int cu_header_offset
;
299 /* Allocate fields for structs, unions and enums in this size. */
300 #ifndef DW_FIELD_ALLOC_CHUNK
301 #define DW_FIELD_ALLOC_CHUNK 4
304 /* The language we are debugging. */
305 static enum language cu_language
;
306 static const struct language_defn
*cu_language_defn
;
308 /* Actually data from the sections. */
309 static char *dwarf_info_buffer
;
310 static char *dwarf_abbrev_buffer
;
311 static char *dwarf_line_buffer
;
312 static char *dwarf_str_buffer
;
314 /* A zeroed version of a partial die for initialization purposes. */
315 static struct partial_die_info zeroed_partial_die
;
317 /* The generic symbol table building routines have separate lists for
318 file scope symbols and all all other scopes (local scopes). So
319 we need to select the right one to pass to add_symbol_to_list().
320 We do it by keeping a pointer to the correct list in list_in_scope.
322 FIXME: The original dwarf code just treated the file scope as the first
323 local scope, and all other local scopes as nested local scopes, and worked
324 fine. Check to see if we really need to distinguish these
326 static struct pending
**list_in_scope
= &file_symbols
;
328 /* FIXME: decode_locdesc sets these variables to describe the location
329 to the caller. These ought to be a structure or something. If
330 none of the flags are set, the object lives at the address returned
331 by decode_locdesc. */
333 static int optimized_out
; /* No ops in location in expression,
334 so object was optimized out. */
335 static int isreg
; /* Object lives in register.
336 decode_locdesc's return value is
337 the register number. */
338 static int offreg
; /* Object's address is the sum of the
339 register specified by basereg, plus
340 the offset returned. */
341 static int basereg
; /* See `offreg'. */
342 static int isderef
; /* Value described by flags above is
343 the address of a pointer to the object. */
344 static int islocal
; /* Variable is at the returned offset
345 from the frame start, but there's
346 no identified frame pointer for
347 this function, so we can't say
348 which register it's relative to;
351 /* DW_AT_frame_base values for the current function.
352 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
353 contains the register number for the frame register.
354 frame_base_offset is the offset from the frame register to the
355 virtual stack frame. */
356 static int frame_base_reg
;
357 static CORE_ADDR frame_base_offset
;
359 /* This value is added to each symbol value. FIXME: Generalize to
360 the section_offsets structure used by dbxread (once this is done,
361 pass the appropriate section number to end_symtab). */
362 static CORE_ADDR baseaddr
; /* Add to each symbol value */
364 /* We put a pointer to this structure in the read_symtab_private field
366 The complete dwarf information for an objfile is kept in the
367 psymbol_obstack, so that absolute die references can be handled.
368 Most of the information in this structure is related to an entire
369 object file and could be passed via the sym_private field of the objfile.
370 It is however conceivable that dwarf2 might not be the only type
371 of symbols read from an object file. */
375 /* Pointer to start of dwarf info buffer for the objfile. */
377 char *dwarf_info_buffer
;
379 /* Offset in dwarf_info_buffer for this compilation unit. */
381 unsigned long dwarf_info_offset
;
383 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
385 char *dwarf_abbrev_buffer
;
387 /* Size of dwarf abbreviation section for the objfile. */
389 unsigned int dwarf_abbrev_size
;
391 /* Pointer to start of dwarf line buffer for the objfile. */
393 char *dwarf_line_buffer
;
395 /* Pointer to start of dwarf string buffer for the objfile. */
397 char *dwarf_str_buffer
;
399 /* Size of dwarf string section for the objfile. */
401 unsigned int dwarf_str_size
;
404 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
405 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
406 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
407 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
408 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
409 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
410 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
411 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
413 /* Maintain an array of referenced fundamental types for the current
414 compilation unit being read. For DWARF version 1, we have to construct
415 the fundamental types on the fly, since no information about the
416 fundamental types is supplied. Each such fundamental type is created by
417 calling a language dependent routine to create the type, and then a
418 pointer to that type is then placed in the array at the index specified
419 by it's FT_<TYPENAME> value. The array has a fixed size set by the
420 FT_NUM_MEMBERS compile time constant, which is the number of predefined
421 fundamental types gdb knows how to construct. */
422 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
424 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
425 but this would require a corresponding change in unpack_field_as_long
427 static int bits_per_byte
= 8;
429 /* The routines that read and process dies for a C struct or C++ class
430 pass lists of data member fields and lists of member function fields
431 in an instance of a field_info structure, as defined below. */
434 /* List of data member and baseclasses fields. */
437 struct nextfield
*next
;
444 /* Number of fields. */
447 /* Number of baseclasses. */
450 /* Set if the accesibility of one of the fields is not public. */
451 int non_public_fields
;
453 /* Member function fields array, entries are allocated in the order they
454 are encountered in the object file. */
457 struct nextfnfield
*next
;
458 struct fn_field fnfield
;
462 /* Member function fieldlist array, contains name of possibly overloaded
463 member function, number of overloaded member functions and a pointer
464 to the head of the member function field chain. */
469 struct nextfnfield
*head
;
473 /* Number of entries in the fnfieldlists array. */
477 /* Various complaints about symbol reading that don't abort the process */
479 static struct complaint dwarf2_const_ignored
=
481 "type qualifier 'const' ignored", 0, 0
483 static struct complaint dwarf2_volatile_ignored
=
485 "type qualifier 'volatile' ignored", 0, 0
487 static struct complaint dwarf2_non_const_array_bound_ignored
=
489 "non-constant array bounds form '%s' ignored", 0, 0
491 static struct complaint dwarf2_missing_line_number_section
=
493 "missing .debug_line section", 0, 0
495 static struct complaint dwarf2_mangled_line_number_section
=
497 "mangled .debug_line section", 0, 0
499 static struct complaint dwarf2_unsupported_die_ref_attr
=
501 "unsupported die ref attribute form: '%s'", 0, 0
503 static struct complaint dwarf2_unsupported_stack_op
=
505 "unsupported stack op: '%s'", 0, 0
507 static struct complaint dwarf2_complex_location_expr
=
509 "location expression too complex", 0, 0
511 static struct complaint dwarf2_unsupported_tag
=
513 "unsupported tag: '%s'", 0, 0
515 static struct complaint dwarf2_unsupported_at_encoding
=
517 "unsupported DW_AT_encoding: '%s'", 0, 0
519 static struct complaint dwarf2_unsupported_at_frame_base
=
521 "unsupported DW_AT_frame_base for function '%s'", 0, 0
523 static struct complaint dwarf2_unexpected_tag
=
525 "unexepected tag in read_type_die: '%s'", 0, 0
527 static struct complaint dwarf2_missing_at_frame_base
=
529 "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
531 static struct complaint dwarf2_bad_static_member_name
=
533 "unrecognized static data member name '%s'", 0, 0
535 static struct complaint dwarf2_unsupported_accessibility
=
537 "unsupported accessibility %d", 0, 0
539 static struct complaint dwarf2_bad_member_name_complaint
=
541 "cannot extract member name from '%s'", 0, 0
543 static struct complaint dwarf2_missing_member_fn_type_complaint
=
545 "member function type missing for '%s'", 0, 0
547 static struct complaint dwarf2_vtbl_not_found_complaint
=
549 "virtual function table pointer not found when defining class '%s'", 0, 0
551 static struct complaint dwarf2_absolute_sibling_complaint
=
553 "ignoring absolute DW_AT_sibling", 0, 0
555 static struct complaint dwarf2_const_value_length_mismatch
=
557 "const value length mismatch for '%s', got %d, expected %d", 0, 0
559 static struct complaint dwarf2_unsupported_const_value_attr
=
561 "unsupported const value attribute form: '%s'", 0, 0
564 /* local function prototypes */
566 static void dwarf2_locate_sections (bfd
*, asection
*, PTR
);
569 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
572 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
574 static char *scan_partial_symbols (char *, struct objfile
*,
575 CORE_ADDR
*, CORE_ADDR
*,
576 const struct comp_unit_head
*);
578 static void add_partial_symbol (struct partial_die_info
*, struct objfile
*,
579 const struct comp_unit_head
*);
581 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
583 static void psymtab_to_symtab_1 (struct partial_symtab
*);
585 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int);
587 static void dwarf2_read_abbrevs (bfd
*, unsigned int);
589 static void dwarf2_empty_abbrev_table (PTR
);
591 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int);
593 static char *read_partial_die (struct partial_die_info
*,
595 const struct comp_unit_head
*);
597 static char *read_full_die (struct die_info
**, bfd
*, char *,
598 const struct comp_unit_head
*);
600 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
601 bfd
*, char *, const struct comp_unit_head
*);
603 static char *read_attribute_value (struct attribute
*, unsigned,
604 bfd
*, char *, const struct comp_unit_head
*);
606 static unsigned int read_1_byte (bfd
*, char *);
608 static int read_1_signed_byte (bfd
*, char *);
610 static unsigned int read_2_bytes (bfd
*, char *);
612 static unsigned int read_4_bytes (bfd
*, char *);
614 static unsigned long read_8_bytes (bfd
*, char *);
616 static CORE_ADDR
read_address (bfd
*, char *ptr
, const struct comp_unit_head
*,
619 static LONGEST
read_initial_length (bfd
*, char *,
620 struct comp_unit_head
*, int *bytes_read
);
622 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
625 static char *read_n_bytes (bfd
*, char *, unsigned int);
627 static char *read_string (bfd
*, char *, unsigned int *);
629 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
632 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
634 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
636 static void set_cu_language (unsigned int);
638 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
640 static int die_is_declaration (struct die_info
*);
642 static void dwarf_decode_lines (unsigned int, char *, bfd
*,
643 const struct comp_unit_head
*);
645 static void dwarf2_start_subfile (char *, char *);
647 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
648 struct objfile
*, const struct comp_unit_head
*);
650 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
651 struct objfile
*, const struct comp_unit_head
*);
653 static void dwarf2_const_value_data (struct attribute
*attr
,
657 static struct type
*die_type (struct die_info
*, struct objfile
*,
658 const struct comp_unit_head
*);
660 static struct type
*die_containing_type (struct die_info
*, struct objfile
*,
661 const struct comp_unit_head
*);
664 static struct type
*type_at_offset (unsigned int, struct objfile
*);
667 static struct type
*tag_type_to_type (struct die_info
*, struct objfile
*,
668 const struct comp_unit_head
*);
670 static void read_type_die (struct die_info
*, struct objfile
*,
671 const struct comp_unit_head
*);
673 static void read_typedef (struct die_info
*, struct objfile
*,
674 const struct comp_unit_head
*);
676 static void read_base_type (struct die_info
*, struct objfile
*);
678 static void read_file_scope (struct die_info
*, struct objfile
*,
679 const struct comp_unit_head
*);
681 static void read_func_scope (struct die_info
*, struct objfile
*,
682 const struct comp_unit_head
*);
684 static void read_lexical_block_scope (struct die_info
*, struct objfile
*,
685 const struct comp_unit_head
*);
687 static int dwarf2_get_pc_bounds (struct die_info
*,
688 CORE_ADDR
*, CORE_ADDR
*, struct objfile
*);
690 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
691 struct objfile
*, const struct comp_unit_head
*);
693 static void dwarf2_attach_fields_to_type (struct field_info
*,
694 struct type
*, struct objfile
*);
696 static void dwarf2_add_member_fn (struct field_info
*,
697 struct die_info
*, struct type
*,
698 struct objfile
*objfile
,
699 const struct comp_unit_head
*);
701 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
702 struct type
*, struct objfile
*);
704 static void read_structure_scope (struct die_info
*, struct objfile
*,
705 const struct comp_unit_head
*);
707 static void read_common_block (struct die_info
*, struct objfile
*,
708 const struct comp_unit_head
*);
710 static void read_enumeration (struct die_info
*, struct objfile
*,
711 const struct comp_unit_head
*);
713 static struct type
*dwarf_base_type (int, int, struct objfile
*);
715 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct objfile
*,
716 const struct comp_unit_head
*);
718 static void read_array_type (struct die_info
*, struct objfile
*,
719 const struct comp_unit_head
*);
721 static void read_tag_pointer_type (struct die_info
*, struct objfile
*,
722 const struct comp_unit_head
*);
724 static void read_tag_ptr_to_member_type (struct die_info
*, struct objfile
*,
725 const struct comp_unit_head
*);
727 static void read_tag_reference_type (struct die_info
*, struct objfile
*,
728 const struct comp_unit_head
*);
730 static void read_tag_const_type (struct die_info
*, struct objfile
*,
731 const struct comp_unit_head
*);
733 static void read_tag_volatile_type (struct die_info
*, struct objfile
*,
734 const struct comp_unit_head
*);
736 static void read_tag_string_type (struct die_info
*, struct objfile
*);
738 static void read_subroutine_type (struct die_info
*, struct objfile
*,
739 const struct comp_unit_head
*);
741 static struct die_info
*read_comp_unit (char *, bfd
*,
742 const struct comp_unit_head
*);
744 static void free_die_list (struct die_info
*);
746 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
748 static void process_die (struct die_info
*, struct objfile
*,
749 const struct comp_unit_head
*);
751 static char *dwarf2_linkage_name (struct die_info
*);
753 static char *dwarf_tag_name (unsigned int);
755 static char *dwarf_attr_name (unsigned int);
757 static char *dwarf_form_name (unsigned int);
759 static char *dwarf_stack_op_name (unsigned int);
761 static char *dwarf_bool_name (unsigned int);
763 static char *dwarf_type_encoding_name (unsigned int);
766 static char *dwarf_cfi_name (unsigned int);
768 struct die_info
*copy_die (struct die_info
*);
771 static struct die_info
*sibling_die (struct die_info
*);
773 static void dump_die (struct die_info
*);
775 static void dump_die_list (struct die_info
*);
777 static void store_in_ref_table (unsigned int, struct die_info
*);
779 static void dwarf2_empty_hash_tables (void);
781 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
783 static struct die_info
*follow_die_ref (unsigned int);
785 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
787 /* memory allocation interface */
789 static void dwarf2_free_tmp_obstack (PTR
);
791 static struct dwarf_block
*dwarf_alloc_block (void);
793 static struct abbrev_info
*dwarf_alloc_abbrev (void);
795 static struct die_info
*dwarf_alloc_die (void);
797 /* Try to locate the sections we need for DWARF 2 debugging
798 information and return true if we have enough to do something. */
801 dwarf2_has_info (bfd
*abfd
)
803 dwarf_info_offset
= dwarf_abbrev_offset
= dwarf_line_offset
= 0;
804 dwarf_str_offset
= 0;
805 dwarf_frame_offset
= dwarf_eh_frame_offset
= 0;
806 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
807 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
817 /* This function is mapped across the sections and remembers the
818 offset and size of each of the debugging sections we are interested
822 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, PTR ignore_ptr
)
824 if (STREQ (sectp
->name
, INFO_SECTION
))
826 dwarf_info_offset
= sectp
->filepos
;
827 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
829 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
831 dwarf_abbrev_offset
= sectp
->filepos
;
832 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
834 else if (STREQ (sectp
->name
, LINE_SECTION
))
836 dwarf_line_offset
= sectp
->filepos
;
837 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
839 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
841 dwarf_pubnames_offset
= sectp
->filepos
;
842 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
844 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
846 dwarf_aranges_offset
= sectp
->filepos
;
847 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
849 else if (STREQ (sectp
->name
, LOC_SECTION
))
851 dwarf_loc_offset
= sectp
->filepos
;
852 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
854 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
856 dwarf_macinfo_offset
= sectp
->filepos
;
857 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
859 else if (STREQ (sectp
->name
, STR_SECTION
))
861 dwarf_str_offset
= sectp
->filepos
;
862 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
864 else if (STREQ (sectp
->name
, FRAME_SECTION
))
866 dwarf_frame_offset
= sectp
->filepos
;
867 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
869 else if (STREQ (sectp
->name
, EH_FRAME_SECTION
))
871 dwarf_eh_frame_offset
= sectp
->filepos
;
872 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
876 /* Build a partial symbol table. */
879 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
882 /* We definitely need the .debug_info and .debug_abbrev sections */
884 dwarf_info_buffer
= dwarf2_read_section (objfile
,
887 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
890 dwarf_line_buffer
= dwarf2_read_section (objfile
,
894 if (dwarf_str_offset
)
895 dwarf_str_buffer
= dwarf2_read_section (objfile
,
899 dwarf_str_buffer
= NULL
;
902 || (objfile
->global_psymbols
.size
== 0
903 && objfile
->static_psymbols
.size
== 0))
905 init_psymbol_list (objfile
, 1024);
909 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
911 /* Things are significantly easier if we have .debug_aranges and
912 .debug_pubnames sections */
914 dwarf2_build_psymtabs_easy (objfile
, mainline
);
918 /* only test this case for now */
920 /* In this case we have to work a bit harder */
921 dwarf2_build_psymtabs_hard (objfile
, mainline
);
926 /* Build the partial symbol table from the information in the
927 .debug_pubnames and .debug_aranges sections. */
930 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
932 bfd
*abfd
= objfile
->obfd
;
933 char *aranges_buffer
, *pubnames_buffer
;
934 char *aranges_ptr
, *pubnames_ptr
;
935 unsigned int entry_length
, version
, info_offset
, info_size
;
937 pubnames_buffer
= dwarf2_read_section (objfile
,
938 dwarf_pubnames_offset
,
939 dwarf_pubnames_size
);
940 pubnames_ptr
= pubnames_buffer
;
941 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
943 struct comp_unit_head cu_header
;
946 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
948 pubnames_ptr
+= bytes_read
;
949 version
= read_1_byte (abfd
, pubnames_ptr
);
951 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
953 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
957 aranges_buffer
= dwarf2_read_section (objfile
,
958 dwarf_aranges_offset
,
964 /* Read in the comp unit header information from the debug_info at
968 read_comp_unit_head (struct comp_unit_head
*cu_header
,
969 char *info_ptr
, bfd
*abfd
)
973 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
975 info_ptr
+= bytes_read
;
976 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
978 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
980 info_ptr
+= bytes_read
;
981 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
983 signed_addr
= bfd_get_sign_extend_vma (abfd
);
985 internal_error (__FILE__
, __LINE__
,
986 "read_comp_unit_head: dwarf from non elf file");
987 cu_header
->signed_addr_p
= signed_addr
;
991 /* Build the partial symbol table by doing a quick pass through the
992 .debug_info and .debug_abbrev sections. */
995 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
997 /* Instead of reading this into a big buffer, we should probably use
998 mmap() on architectures that support it. (FIXME) */
999 bfd
*abfd
= objfile
->obfd
;
1000 char *info_ptr
, *abbrev_ptr
;
1001 char *beg_of_comp_unit
;
1002 struct partial_die_info comp_unit_die
;
1003 struct partial_symtab
*pst
;
1004 struct cleanup
*back_to
;
1005 CORE_ADDR lowpc
, highpc
;
1007 info_ptr
= dwarf_info_buffer
;
1008 abbrev_ptr
= dwarf_abbrev_buffer
;
1010 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1011 the partial symbol scan, like attribute values.
1013 We could reduce our peak memory consumption during partial symbol
1014 table construction by freeing stuff from this obstack more often
1015 --- say, after processing each compilation unit, or each die ---
1016 but it turns out that this saves almost nothing. For an
1017 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1018 on dwarf2_tmp_obstack. Some investigation showed:
1020 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1021 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1022 all fixed-length values not requiring dynamic allocation.
1024 2) 30% of the attributes used the form DW_FORM_string. For
1025 DW_FORM_string, read_attribute simply hands back a pointer to
1026 the null-terminated string in dwarf_info_buffer, so no dynamic
1027 allocation is needed there either.
1029 3) The remaining 1% of the attributes all used DW_FORM_block1.
1030 75% of those were DW_AT_frame_base location lists for
1031 functions; the rest were DW_AT_location attributes, probably
1032 for the global variables.
1034 Anyway, what this all means is that the memory the dwarf2
1035 reader uses as temporary space reading partial symbols is about
1036 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1038 obstack_init (&dwarf2_tmp_obstack
);
1039 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1041 /* Since the objects we're extracting from dwarf_info_buffer vary in
1042 length, only the individual functions to extract them (like
1043 read_comp_unit_head and read_partial_die) can really know whether
1044 the buffer is large enough to hold another complete object.
1046 At the moment, they don't actually check that. If
1047 dwarf_info_buffer holds just one extra byte after the last
1048 compilation unit's dies, then read_comp_unit_head will happily
1049 read off the end of the buffer. read_partial_die is similarly
1050 casual. Those functions should be fixed.
1052 For this loop condition, simply checking whether there's any data
1053 left at all should be sufficient. */
1054 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1056 struct comp_unit_head cu_header
;
1057 beg_of_comp_unit
= info_ptr
;
1058 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1060 if (cu_header
.version
!= 2)
1062 error ("Dwarf Error: wrong version in compilation unit header.");
1065 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
1067 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6).",
1068 (long) cu_header
.abbrev_offset
,
1069 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1072 if (beg_of_comp_unit
+ cu_header
.length
+ cu_header
.initial_length_size
1073 > dwarf_info_buffer
+ dwarf_info_size
)
1075 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0).",
1076 (long) cu_header
.length
,
1077 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1080 /* Read the abbrevs for this compilation unit into a table */
1081 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1082 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1084 /* Read the compilation unit die */
1085 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1088 /* Set the language we're debugging */
1089 set_cu_language (comp_unit_die
.language
);
1091 /* Allocate a new partial symbol table structure */
1092 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1093 comp_unit_die
.name
? comp_unit_die
.name
: "",
1094 comp_unit_die
.lowpc
,
1095 objfile
->global_psymbols
.next
,
1096 objfile
->static_psymbols
.next
);
1098 pst
->read_symtab_private
= (char *)
1099 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1100 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1101 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1102 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1103 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1104 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1105 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1106 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1107 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1108 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1110 /* Store the function that reads in the rest of the symbol table */
1111 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1113 /* Check if comp unit has_children.
1114 If so, read the rest of the partial symbols from this comp unit.
1115 If not, there's no more debug_info for this comp unit. */
1116 if (comp_unit_die
.has_children
)
1118 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
,
1121 /* If the compilation unit didn't have an explicit address range,
1122 then use the information extracted from its child dies. */
1123 if (! comp_unit_die
.has_pc_info
)
1125 comp_unit_die
.lowpc
= lowpc
;
1126 comp_unit_die
.highpc
= highpc
;
1129 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1130 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1132 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1133 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1134 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1135 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1136 sort_pst_symbols (pst
);
1138 /* If there is already a psymtab or symtab for a file of this
1139 name, remove it. (If there is a symtab, more drastic things
1140 also happen.) This happens in VxWorks. */
1141 free_named_symtabs (pst
->filename
);
1143 info_ptr
= beg_of_comp_unit
+ cu_header
.length
1144 + cu_header
.initial_length_size
;
1146 do_cleanups (back_to
);
1149 /* Read in all interesting dies to the end of the compilation unit. */
1152 scan_partial_symbols (char *info_ptr
, struct objfile
*objfile
,
1153 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1154 const struct comp_unit_head
*cu_header
)
1156 bfd
*abfd
= objfile
->obfd
;
1157 struct partial_die_info pdi
;
1159 /* This function is called after we've read in the comp_unit_die in
1160 order to read its children. We start the nesting level at 1 since
1161 we have pushed 1 level down in order to read the comp unit's children.
1162 The comp unit itself is at level 0, so we stop reading when we pop
1163 back to that level. */
1165 int nesting_level
= 1;
1167 *lowpc
= ((CORE_ADDR
) -1);
1168 *highpc
= ((CORE_ADDR
) 0);
1170 while (nesting_level
)
1172 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1178 case DW_TAG_subprogram
:
1179 if (pdi
.has_pc_info
)
1181 if (pdi
.lowpc
< *lowpc
)
1185 if (pdi
.highpc
> *highpc
)
1187 *highpc
= pdi
.highpc
;
1189 if ((pdi
.is_external
|| nesting_level
== 1)
1190 && !pdi
.is_declaration
)
1192 add_partial_symbol (&pdi
, objfile
, cu_header
);
1196 case DW_TAG_variable
:
1197 case DW_TAG_typedef
:
1198 case DW_TAG_class_type
:
1199 case DW_TAG_structure_type
:
1200 case DW_TAG_union_type
:
1201 case DW_TAG_enumeration_type
:
1202 if ((pdi
.is_external
|| nesting_level
== 1)
1203 && !pdi
.is_declaration
)
1205 add_partial_symbol (&pdi
, objfile
, cu_header
);
1208 case DW_TAG_enumerator
:
1209 /* File scope enumerators are added to the partial symbol
1211 if (nesting_level
== 2)
1212 add_partial_symbol (&pdi
, objfile
, cu_header
);
1214 case DW_TAG_base_type
:
1215 /* File scope base type definitions are added to the partial
1217 if (nesting_level
== 1)
1218 add_partial_symbol (&pdi
, objfile
, cu_header
);
1225 /* If the die has a sibling, skip to the sibling.
1226 Do not skip enumeration types, we want to record their
1228 if (pdi
.sibling
&& pdi
.tag
!= DW_TAG_enumeration_type
)
1230 info_ptr
= pdi
.sibling
;
1232 else if (pdi
.has_children
)
1234 /* Die has children, but the optional DW_AT_sibling attribute
1245 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1246 from `maint check'. */
1247 if (*lowpc
== ((CORE_ADDR
) -1))
1253 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1254 const struct comp_unit_head
*cu_header
)
1260 case DW_TAG_subprogram
:
1261 if (pdi
->is_external
)
1263 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1264 mst_text, objfile); */
1265 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1266 VAR_NAMESPACE
, LOC_BLOCK
,
1267 &objfile
->global_psymbols
,
1268 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1272 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1273 mst_file_text, objfile); */
1274 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1275 VAR_NAMESPACE
, LOC_BLOCK
,
1276 &objfile
->static_psymbols
,
1277 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1280 case DW_TAG_variable
:
1281 if (pdi
->is_external
)
1284 Don't enter into the minimal symbol tables as there is
1285 a minimal symbol table entry from the ELF symbols already.
1286 Enter into partial symbol table if it has a location
1287 descriptor or a type.
1288 If the location descriptor is missing, new_symbol will create
1289 a LOC_UNRESOLVED symbol, the address of the variable will then
1290 be determined from the minimal symbol table whenever the variable
1292 The address for the partial symbol table entry is not
1293 used by GDB, but it comes in handy for debugging partial symbol
1297 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1298 if (pdi
->locdesc
|| pdi
->has_type
)
1299 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1300 VAR_NAMESPACE
, LOC_STATIC
,
1301 &objfile
->global_psymbols
,
1302 0, addr
+ baseaddr
, cu_language
, objfile
);
1306 /* Static Variable. Skip symbols without location descriptors. */
1307 if (pdi
->locdesc
== NULL
)
1309 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1310 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1311 mst_file_data, objfile); */
1312 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1313 VAR_NAMESPACE
, LOC_STATIC
,
1314 &objfile
->static_psymbols
,
1315 0, addr
+ baseaddr
, cu_language
, objfile
);
1318 case DW_TAG_typedef
:
1319 case DW_TAG_base_type
:
1320 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1321 VAR_NAMESPACE
, LOC_TYPEDEF
,
1322 &objfile
->static_psymbols
,
1323 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1325 case DW_TAG_class_type
:
1326 case DW_TAG_structure_type
:
1327 case DW_TAG_union_type
:
1328 case DW_TAG_enumeration_type
:
1329 /* Skip aggregate types without children, these are external
1331 if (pdi
->has_children
== 0)
1333 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1334 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1335 &objfile
->static_psymbols
,
1336 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1338 if (cu_language
== language_cplus
)
1340 /* For C++, these implicitly act as typedefs as well. */
1341 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1342 VAR_NAMESPACE
, LOC_TYPEDEF
,
1343 &objfile
->static_psymbols
,
1344 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1347 case DW_TAG_enumerator
:
1348 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1349 VAR_NAMESPACE
, LOC_CONST
,
1350 &objfile
->static_psymbols
,
1351 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1358 /* Expand this partial symbol table into a full symbol table. */
1361 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1363 /* FIXME: This is barely more than a stub. */
1368 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1374 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1375 gdb_flush (gdb_stdout
);
1378 psymtab_to_symtab_1 (pst
);
1380 /* Finish up the debug error message. */
1382 printf_filtered ("done.\n");
1388 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1390 struct objfile
*objfile
= pst
->objfile
;
1391 bfd
*abfd
= objfile
->obfd
;
1392 struct comp_unit_head cu_header
;
1393 struct die_info
*dies
;
1394 unsigned long offset
;
1395 CORE_ADDR lowpc
, highpc
;
1396 struct die_info
*child_die
;
1398 struct symtab
*symtab
;
1399 struct cleanup
*back_to
;
1401 /* Set local variables from the partial symbol table info. */
1402 offset
= DWARF_INFO_OFFSET (pst
);
1403 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1404 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1405 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1406 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1407 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1408 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1409 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1410 cu_header_offset
= offset
;
1411 info_ptr
= dwarf_info_buffer
+ offset
;
1413 obstack_init (&dwarf2_tmp_obstack
);
1414 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1417 make_cleanup (really_free_pendings
, NULL
);
1419 /* read in the comp_unit header */
1420 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1422 /* Read the abbrevs for this compilation unit */
1423 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1424 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1426 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
1428 make_cleanup_free_die_list (dies
);
1430 /* Do line number decoding in read_file_scope () */
1431 process_die (dies
, objfile
, &cu_header
);
1433 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1435 /* Some compilers don't define a DW_AT_high_pc attribute for
1436 the compilation unit. If the DW_AT_high_pc is missing,
1437 synthesize it, by scanning the DIE's below the compilation unit. */
1439 if (dies
->has_children
)
1441 child_die
= dies
->next
;
1442 while (child_die
&& child_die
->tag
)
1444 if (child_die
->tag
== DW_TAG_subprogram
)
1446 CORE_ADDR low
, high
;
1448 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1450 highpc
= max (highpc
, high
);
1453 child_die
= sibling_die (child_die
);
1457 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1459 /* Set symtab language to language from DW_AT_language.
1460 If the compilation is from a C file generated by language preprocessors,
1461 do not set the language if it was already deduced by start_subfile. */
1463 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1465 symtab
->language
= cu_language
;
1467 pst
->symtab
= symtab
;
1469 sort_symtab_syms (pst
->symtab
);
1471 do_cleanups (back_to
);
1474 /* Process a die and its children. */
1477 process_die (struct die_info
*die
, struct objfile
*objfile
,
1478 const struct comp_unit_head
*cu_header
)
1482 case DW_TAG_padding
:
1484 case DW_TAG_compile_unit
:
1485 read_file_scope (die
, objfile
, cu_header
);
1487 case DW_TAG_subprogram
:
1488 read_subroutine_type (die
, objfile
, cu_header
);
1489 read_func_scope (die
, objfile
, cu_header
);
1491 case DW_TAG_inlined_subroutine
:
1492 /* FIXME: These are ignored for now.
1493 They could be used to set breakpoints on all inlined instances
1494 of a function and make GDB `next' properly over inlined functions. */
1496 case DW_TAG_lexical_block
:
1497 read_lexical_block_scope (die
, objfile
, cu_header
);
1499 case DW_TAG_class_type
:
1500 case DW_TAG_structure_type
:
1501 case DW_TAG_union_type
:
1502 read_structure_scope (die
, objfile
, cu_header
);
1504 case DW_TAG_enumeration_type
:
1505 read_enumeration (die
, objfile
, cu_header
);
1507 case DW_TAG_subroutine_type
:
1508 read_subroutine_type (die
, objfile
, cu_header
);
1510 case DW_TAG_array_type
:
1511 read_array_type (die
, objfile
, cu_header
);
1513 case DW_TAG_pointer_type
:
1514 read_tag_pointer_type (die
, objfile
, cu_header
);
1516 case DW_TAG_ptr_to_member_type
:
1517 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1519 case DW_TAG_reference_type
:
1520 read_tag_reference_type (die
, objfile
, cu_header
);
1522 case DW_TAG_string_type
:
1523 read_tag_string_type (die
, objfile
);
1525 case DW_TAG_base_type
:
1526 read_base_type (die
, objfile
);
1527 if (dwarf_attr (die
, DW_AT_name
))
1529 /* Add a typedef symbol for the base type definition. */
1530 new_symbol (die
, die
->type
, objfile
, cu_header
);
1533 case DW_TAG_common_block
:
1534 read_common_block (die
, objfile
, cu_header
);
1536 case DW_TAG_common_inclusion
:
1539 new_symbol (die
, NULL
, objfile
, cu_header
);
1545 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1546 const struct comp_unit_head
*cu_header
)
1548 unsigned int line_offset
= 0;
1549 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1550 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1551 struct attribute
*attr
;
1552 char *name
= "<unknown>";
1553 char *comp_dir
= NULL
;
1554 struct die_info
*child_die
;
1555 bfd
*abfd
= objfile
->obfd
;
1557 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1559 if (die
->has_children
)
1561 child_die
= die
->next
;
1562 while (child_die
&& child_die
->tag
)
1564 if (child_die
->tag
== DW_TAG_subprogram
)
1566 CORE_ADDR low
, high
;
1568 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1570 lowpc
= min (lowpc
, low
);
1571 highpc
= max (highpc
, high
);
1574 child_die
= sibling_die (child_die
);
1579 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1580 from finish_block. */
1581 if (lowpc
== ((CORE_ADDR
) -1))
1586 attr
= dwarf_attr (die
, DW_AT_name
);
1589 name
= DW_STRING (attr
);
1591 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1594 comp_dir
= DW_STRING (attr
);
1597 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1598 directory, get rid of it. */
1599 char *cp
= strchr (comp_dir
, ':');
1601 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1606 if (objfile
->ei
.entry_point
>= lowpc
&&
1607 objfile
->ei
.entry_point
< highpc
)
1609 objfile
->ei
.entry_file_lowpc
= lowpc
;
1610 objfile
->ei
.entry_file_highpc
= highpc
;
1613 attr
= dwarf_attr (die
, DW_AT_language
);
1616 set_cu_language (DW_UNSND (attr
));
1619 /* We assume that we're processing GCC output. */
1620 processing_gcc_compilation
= 2;
1622 /* FIXME:Do something here. */
1623 if (dip
->at_producer
!= NULL
)
1625 handle_producer (dip
->at_producer
);
1629 /* The compilation unit may be in a different language or objfile,
1630 zero out all remembered fundamental types. */
1631 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1633 start_symtab (name
, comp_dir
, lowpc
);
1634 record_debugformat ("DWARF 2");
1636 /* Decode line number information if present. */
1637 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1640 line_offset
= DW_UNSND (attr
);
1641 dwarf_decode_lines (line_offset
, comp_dir
, abfd
, cu_header
);
1644 /* Process all dies in compilation unit. */
1645 if (die
->has_children
)
1647 child_die
= die
->next
;
1648 while (child_die
&& child_die
->tag
)
1650 process_die (child_die
, objfile
, cu_header
);
1651 child_die
= sibling_die (child_die
);
1657 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
1658 const struct comp_unit_head
*cu_header
)
1660 register struct context_stack
*new;
1663 struct die_info
*child_die
;
1664 struct attribute
*attr
;
1667 name
= dwarf2_linkage_name (die
);
1669 /* Ignore functions with missing or empty names and functions with
1670 missing or invalid low and high pc attributes. */
1671 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1677 if (objfile
->ei
.entry_point
>= lowpc
&&
1678 objfile
->ei
.entry_point
< highpc
)
1680 objfile
->ei
.entry_func_lowpc
= lowpc
;
1681 objfile
->ei
.entry_func_highpc
= highpc
;
1684 /* Decode DW_AT_frame_base location descriptor if present, keep result
1685 for DW_OP_fbreg operands in decode_locdesc. */
1686 frame_base_reg
= -1;
1687 frame_base_offset
= 0;
1688 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1691 CORE_ADDR addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
1693 complain (&dwarf2_unsupported_at_frame_base
, name
);
1695 frame_base_reg
= addr
;
1698 frame_base_reg
= basereg
;
1699 frame_base_offset
= addr
;
1702 complain (&dwarf2_unsupported_at_frame_base
, name
);
1705 new = push_context (0, lowpc
);
1706 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
1707 list_in_scope
= &local_symbols
;
1709 if (die
->has_children
)
1711 child_die
= die
->next
;
1712 while (child_die
&& child_die
->tag
)
1714 process_die (child_die
, objfile
, cu_header
);
1715 child_die
= sibling_die (child_die
);
1719 new = pop_context ();
1720 /* Make a block for the local symbols within. */
1721 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1722 lowpc
, highpc
, objfile
);
1723 list_in_scope
= &file_symbols
;
1726 /* Process all the DIES contained within a lexical block scope. Start
1727 a new scope, process the dies, and then close the scope. */
1730 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
1731 const struct comp_unit_head
*cu_header
)
1733 register struct context_stack
*new;
1734 CORE_ADDR lowpc
, highpc
;
1735 struct die_info
*child_die
;
1737 /* Ignore blocks with missing or invalid low and high pc attributes. */
1738 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1743 push_context (0, lowpc
);
1744 if (die
->has_children
)
1746 child_die
= die
->next
;
1747 while (child_die
&& child_die
->tag
)
1749 process_die (child_die
, objfile
, cu_header
);
1750 child_die
= sibling_die (child_die
);
1753 new = pop_context ();
1755 if (local_symbols
!= NULL
)
1757 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
1760 local_symbols
= new->locals
;
1763 /* Get low and high pc attributes from a die.
1764 Return 1 if the attributes are present and valid, otherwise, return 0. */
1767 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1768 struct objfile
*objfile
)
1770 struct attribute
*attr
;
1774 attr
= dwarf_attr (die
, DW_AT_low_pc
);
1776 low
= DW_ADDR (attr
);
1779 attr
= dwarf_attr (die
, DW_AT_high_pc
);
1781 high
= DW_ADDR (attr
);
1788 /* When using the GNU linker, .gnu.linkonce. sections are used to
1789 eliminate duplicate copies of functions and vtables and such.
1790 The linker will arbitrarily choose one and discard the others.
1791 The AT_*_pc values for such functions refer to local labels in
1792 these sections. If the section from that file was discarded, the
1793 labels are not in the output, so the relocs get a value of 0.
1794 If this is a discarded function, mark the pc bounds as invalid,
1795 so that GDB will ignore it. */
1796 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
1804 /* Add an aggregate field to the field list. */
1807 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
1808 struct objfile
*objfile
,
1809 const struct comp_unit_head
*cu_header
)
1811 struct nextfield
*new_field
;
1812 struct attribute
*attr
;
1814 char *fieldname
= "";
1816 /* Allocate a new field list entry and link it in. */
1817 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
1818 make_cleanup (xfree
, new_field
);
1819 memset (new_field
, 0, sizeof (struct nextfield
));
1820 new_field
->next
= fip
->fields
;
1821 fip
->fields
= new_field
;
1824 /* Handle accessibility and virtuality of field.
1825 The default accessibility for members is public, the default
1826 accessibility for inheritance is private. */
1827 if (die
->tag
!= DW_TAG_inheritance
)
1828 new_field
->accessibility
= DW_ACCESS_public
;
1830 new_field
->accessibility
= DW_ACCESS_private
;
1831 new_field
->virtuality
= DW_VIRTUALITY_none
;
1833 attr
= dwarf_attr (die
, DW_AT_accessibility
);
1835 new_field
->accessibility
= DW_UNSND (attr
);
1836 if (new_field
->accessibility
!= DW_ACCESS_public
)
1837 fip
->non_public_fields
= 1;
1838 attr
= dwarf_attr (die
, DW_AT_virtuality
);
1840 new_field
->virtuality
= DW_UNSND (attr
);
1842 fp
= &new_field
->field
;
1843 if (die
->tag
== DW_TAG_member
)
1845 /* Get type of field. */
1846 fp
->type
= die_type (die
, objfile
, cu_header
);
1848 /* Get bit size of field (zero if none). */
1849 attr
= dwarf_attr (die
, DW_AT_bit_size
);
1852 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
1856 FIELD_BITSIZE (*fp
) = 0;
1859 /* Get bit offset of field. */
1860 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
1863 FIELD_BITPOS (*fp
) =
1864 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
1867 FIELD_BITPOS (*fp
) = 0;
1868 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
1871 if (BITS_BIG_ENDIAN
)
1873 /* For big endian bits, the DW_AT_bit_offset gives the
1874 additional bit offset from the MSB of the containing
1875 anonymous object to the MSB of the field. We don't
1876 have to do anything special since we don't need to
1877 know the size of the anonymous object. */
1878 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
1882 /* For little endian bits, compute the bit offset to the
1883 MSB of the anonymous object, subtract off the number of
1884 bits from the MSB of the field to the MSB of the
1885 object, and then subtract off the number of bits of
1886 the field itself. The result is the bit offset of
1887 the LSB of the field. */
1889 int bit_offset
= DW_UNSND (attr
);
1891 attr
= dwarf_attr (die
, DW_AT_byte_size
);
1894 /* The size of the anonymous object containing
1895 the bit field is explicit, so use the
1896 indicated size (in bytes). */
1897 anonymous_size
= DW_UNSND (attr
);
1901 /* The size of the anonymous object containing
1902 the bit field must be inferred from the type
1903 attribute of the data member containing the
1905 anonymous_size
= TYPE_LENGTH (fp
->type
);
1907 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
1908 - bit_offset
- FIELD_BITSIZE (*fp
);
1912 /* Get name of field. */
1913 attr
= dwarf_attr (die
, DW_AT_name
);
1914 if (attr
&& DW_STRING (attr
))
1915 fieldname
= DW_STRING (attr
);
1916 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
1917 &objfile
->type_obstack
);
1919 /* Change accessibility for artificial fields (e.g. virtual table
1920 pointer or virtual base class pointer) to private. */
1921 if (dwarf_attr (die
, DW_AT_artificial
))
1923 new_field
->accessibility
= DW_ACCESS_private
;
1924 fip
->non_public_fields
= 1;
1927 else if (die
->tag
== DW_TAG_variable
)
1931 /* C++ static member.
1932 Get name of field. */
1933 attr
= dwarf_attr (die
, DW_AT_name
);
1934 if (attr
&& DW_STRING (attr
))
1935 fieldname
= DW_STRING (attr
);
1939 /* Get physical name. */
1940 physname
= dwarf2_linkage_name (die
);
1942 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
1943 &objfile
->type_obstack
));
1944 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
1945 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
1946 &objfile
->type_obstack
);
1948 else if (die
->tag
== DW_TAG_inheritance
)
1950 /* C++ base class field. */
1951 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
1953 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
1955 FIELD_BITSIZE (*fp
) = 0;
1956 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
1957 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
1958 fip
->nbaseclasses
++;
1962 /* Create the vector of fields, and attach it to the type. */
1965 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
1966 struct objfile
*objfile
)
1968 int nfields
= fip
->nfields
;
1970 /* Record the field count, allocate space for the array of fields,
1971 and create blank accessibility bitfields if necessary. */
1972 TYPE_NFIELDS (type
) = nfields
;
1973 TYPE_FIELDS (type
) = (struct field
*)
1974 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1975 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
1977 if (fip
->non_public_fields
)
1979 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1981 TYPE_FIELD_PRIVATE_BITS (type
) =
1982 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1983 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
1985 TYPE_FIELD_PROTECTED_BITS (type
) =
1986 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1987 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
1989 TYPE_FIELD_IGNORE_BITS (type
) =
1990 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1991 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
1994 /* If the type has baseclasses, allocate and clear a bit vector for
1995 TYPE_FIELD_VIRTUAL_BITS. */
1996 if (fip
->nbaseclasses
)
1998 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2001 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2002 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2003 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2004 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2005 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2008 /* Copy the saved-up fields into the field vector. Start from the head
2009 of the list, adding to the tail of the field array, so that they end
2010 up in the same order in the array in which they were added to the list. */
2011 while (nfields
-- > 0)
2013 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2014 switch (fip
->fields
->accessibility
)
2016 case DW_ACCESS_private
:
2017 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2020 case DW_ACCESS_protected
:
2021 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2024 case DW_ACCESS_public
:
2028 /* Unknown accessibility. Complain and treat it as public. */
2030 complain (&dwarf2_unsupported_accessibility
,
2031 fip
->fields
->accessibility
);
2035 if (nfields
< fip
->nbaseclasses
)
2037 switch (fip
->fields
->virtuality
)
2039 case DW_VIRTUALITY_virtual
:
2040 case DW_VIRTUALITY_pure_virtual
:
2041 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2045 fip
->fields
= fip
->fields
->next
;
2049 /* Add a member function to the proper fieldlist. */
2052 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2053 struct type
*type
, struct objfile
*objfile
,
2054 const struct comp_unit_head
*cu_header
)
2056 struct attribute
*attr
;
2057 struct fnfieldlist
*flp
;
2059 struct fn_field
*fnp
;
2062 struct nextfnfield
*new_fnfield
;
2064 /* Get name of member function. */
2065 attr
= dwarf_attr (die
, DW_AT_name
);
2066 if (attr
&& DW_STRING (attr
))
2067 fieldname
= DW_STRING (attr
);
2071 /* Get the mangled name. */
2072 physname
= dwarf2_linkage_name (die
);
2074 /* Look up member function name in fieldlist. */
2075 for (i
= 0; i
< fip
->nfnfields
; i
++)
2077 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2081 /* Create new list element if necessary. */
2082 if (i
< fip
->nfnfields
)
2083 flp
= &fip
->fnfieldlists
[i
];
2086 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2088 fip
->fnfieldlists
= (struct fnfieldlist
*)
2089 xrealloc (fip
->fnfieldlists
,
2090 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2091 * sizeof (struct fnfieldlist
));
2092 if (fip
->nfnfields
== 0)
2093 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2095 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2096 flp
->name
= fieldname
;
2102 /* Create a new member function field and chain it to the field list
2104 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2105 make_cleanup (xfree
, new_fnfield
);
2106 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2107 new_fnfield
->next
= flp
->head
;
2108 flp
->head
= new_fnfield
;
2111 /* Fill in the member function field info. */
2112 fnp
= &new_fnfield
->fnfield
;
2113 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2114 &objfile
->type_obstack
);
2115 fnp
->type
= alloc_type (objfile
);
2116 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2118 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2119 struct type
**arg_types
;
2120 int nparams
= TYPE_NFIELDS (die
->type
);
2123 /* Copy argument types from the subroutine type. */
2124 arg_types
= (struct type
**)
2125 TYPE_ALLOC (fnp
->type
, (nparams
+ 1) * sizeof (struct type
*));
2126 for (iparams
= 0; iparams
< nparams
; iparams
++)
2127 arg_types
[iparams
] = TYPE_FIELD_TYPE (die
->type
, iparams
);
2129 /* Set last entry in argument type vector. */
2130 if (TYPE_VARARGS (die
->type
))
2131 arg_types
[nparams
] = NULL
;
2133 arg_types
[nparams
] = dwarf2_fundamental_type (objfile
, FT_VOID
);
2135 smash_to_method_type (fnp
->type
, type
, return_type
, arg_types
);
2137 /* Handle static member functions.
2138 Dwarf2 has no clean way to discern C++ static and non-static
2139 member functions. G++ helps GDB by marking the first
2140 parameter for non-static member functions (which is the
2141 this pointer) as artificial. We obtain this information
2142 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2143 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2144 fnp
->voffset
= VOFFSET_STATIC
;
2147 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2149 /* Get fcontext from DW_AT_containing_type if present. */
2150 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2151 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2153 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2154 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2156 /* Get accessibility. */
2157 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2160 switch (DW_UNSND (attr
))
2162 case DW_ACCESS_private
:
2163 fnp
->is_private
= 1;
2165 case DW_ACCESS_protected
:
2166 fnp
->is_protected
= 1;
2171 /* Check for artificial methods. */
2172 attr
= dwarf_attr (die
, DW_AT_artificial
);
2173 if (attr
&& DW_UNSND (attr
) != 0)
2174 fnp
->is_artificial
= 1;
2176 /* Get index in virtual function table if it is a virtual member function. */
2177 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2179 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2182 /* Create the vector of member function fields, and attach it to the type. */
2185 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2186 struct objfile
*objfile
)
2188 struct fnfieldlist
*flp
;
2189 int total_length
= 0;
2192 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2193 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2194 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2196 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2198 struct nextfnfield
*nfp
= flp
->head
;
2199 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2202 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2203 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2204 fn_flp
->fn_fields
= (struct fn_field
*)
2205 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2206 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2207 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2209 total_length
+= flp
->length
;
2212 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2213 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2216 /* Called when we find the DIE that starts a structure or union scope
2217 (definition) to process all dies that define the members of the
2220 NOTE: we need to call struct_type regardless of whether or not the
2221 DIE has an at_name attribute, since it might be an anonymous
2222 structure or union. This gets the type entered into our set of
2225 However, if the structure is incomplete (an opaque struct/union)
2226 then suppress creating a symbol table entry for it since gdb only
2227 wants to find the one with the complete definition. Note that if
2228 it is complete, we just call new_symbol, which does it's own
2229 checking about whether the struct/union is anonymous or not (and
2230 suppresses creating a symbol table entry itself). */
2233 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2234 const struct comp_unit_head
*cu_header
)
2237 struct attribute
*attr
;
2239 type
= alloc_type (objfile
);
2241 INIT_CPLUS_SPECIFIC (type
);
2242 attr
= dwarf_attr (die
, DW_AT_name
);
2243 if (attr
&& DW_STRING (attr
))
2245 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2246 strlen (DW_STRING (attr
)),
2247 &objfile
->type_obstack
);
2250 if (die
->tag
== DW_TAG_structure_type
)
2252 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2254 else if (die
->tag
== DW_TAG_union_type
)
2256 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2260 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2262 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2265 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2268 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2272 TYPE_LENGTH (type
) = 0;
2275 /* We need to add the type field to the die immediately so we don't
2276 infinitely recurse when dealing with pointers to the structure
2277 type within the structure itself. */
2280 if (die
->has_children
&& ! die_is_declaration (die
))
2282 struct field_info fi
;
2283 struct die_info
*child_die
;
2284 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2286 memset (&fi
, 0, sizeof (struct field_info
));
2288 child_die
= die
->next
;
2290 while (child_die
&& child_die
->tag
)
2292 if (child_die
->tag
== DW_TAG_member
)
2294 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2296 else if (child_die
->tag
== DW_TAG_variable
)
2298 /* C++ static member. */
2299 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2301 else if (child_die
->tag
== DW_TAG_subprogram
)
2303 /* C++ member function. */
2304 process_die (child_die
, objfile
, cu_header
);
2305 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2307 else if (child_die
->tag
== DW_TAG_inheritance
)
2309 /* C++ base class field. */
2310 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2314 process_die (child_die
, objfile
, cu_header
);
2316 child_die
= sibling_die (child_die
);
2319 /* Attach fields and member functions to the type. */
2321 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2324 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2326 /* Get the type which refers to the base class (possibly this
2327 class itself) which contains the vtable pointer for the current
2328 class from the DW_AT_containing_type attribute. */
2330 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2332 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2334 TYPE_VPTR_BASETYPE (type
) = t
;
2337 static const char vptr_name
[] =
2338 {'_', 'v', 'p', 't', 'r', '\0'};
2341 /* Our own class provides vtbl ptr. */
2342 for (i
= TYPE_NFIELDS (t
) - 1;
2343 i
>= TYPE_N_BASECLASSES (t
);
2346 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2348 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2349 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2351 TYPE_VPTR_FIELDNO (type
) = i
;
2356 /* Complain if virtual function table field not found. */
2357 if (i
< TYPE_N_BASECLASSES (t
))
2358 complain (&dwarf2_vtbl_not_found_complaint
,
2359 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2363 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2368 new_symbol (die
, type
, objfile
, cu_header
);
2370 do_cleanups (back_to
);
2374 /* No children, must be stub. */
2375 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2378 finish_cv_type (die
->type
);
2381 /* Given a pointer to a die which begins an enumeration, process all
2382 the dies that define the members of the enumeration.
2384 This will be much nicer in draft 6 of the DWARF spec when our
2385 members will be dies instead squished into the DW_AT_element_list
2388 NOTE: We reverse the order of the element list. */
2391 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2392 const struct comp_unit_head
*cu_header
)
2394 struct die_info
*child_die
;
2396 struct field
*fields
;
2397 struct attribute
*attr
;
2400 int unsigned_enum
= 1;
2402 type
= alloc_type (objfile
);
2404 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2405 attr
= dwarf_attr (die
, DW_AT_name
);
2406 if (attr
&& DW_STRING (attr
))
2408 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2409 strlen (DW_STRING (attr
)),
2410 &objfile
->type_obstack
);
2413 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2416 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2420 TYPE_LENGTH (type
) = 0;
2425 if (die
->has_children
)
2427 child_die
= die
->next
;
2428 while (child_die
&& child_die
->tag
)
2430 if (child_die
->tag
!= DW_TAG_enumerator
)
2432 process_die (child_die
, objfile
, cu_header
);
2436 attr
= dwarf_attr (child_die
, DW_AT_name
);
2439 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2440 if (SYMBOL_VALUE (sym
) < 0)
2443 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2445 fields
= (struct field
*)
2447 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2448 * sizeof (struct field
));
2451 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2452 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2453 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2454 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2460 child_die
= sibling_die (child_die
);
2465 TYPE_NFIELDS (type
) = num_fields
;
2466 TYPE_FIELDS (type
) = (struct field
*)
2467 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2468 memcpy (TYPE_FIELDS (type
), fields
,
2469 sizeof (struct field
) * num_fields
);
2473 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2476 new_symbol (die
, type
, objfile
, cu_header
);
2479 /* Extract all information from a DW_TAG_array_type DIE and put it in
2480 the DIE's type field. For now, this only handles one dimensional
2484 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2485 const struct comp_unit_head
*cu_header
)
2487 struct die_info
*child_die
;
2488 struct type
*type
= NULL
;
2489 struct type
*element_type
, *range_type
, *index_type
;
2490 struct type
**range_types
= NULL
;
2491 struct attribute
*attr
;
2493 struct cleanup
*back_to
;
2495 /* Return if we've already decoded this type. */
2501 element_type
= die_type (die
, objfile
, cu_header
);
2503 /* Irix 6.2 native cc creates array types without children for
2504 arrays with unspecified length. */
2505 if (die
->has_children
== 0)
2507 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2508 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2509 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2513 back_to
= make_cleanup (null_cleanup
, NULL
);
2514 child_die
= die
->next
;
2515 while (child_die
&& child_die
->tag
)
2517 if (child_die
->tag
== DW_TAG_subrange_type
)
2519 unsigned int low
, high
;
2521 /* Default bounds to an array with unspecified length. */
2524 if (cu_language
== language_fortran
)
2526 /* FORTRAN implies a lower bound of 1, if not given. */
2530 index_type
= die_type (child_die
, objfile
, cu_header
);
2531 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2534 if (attr
->form
== DW_FORM_sdata
)
2536 low
= DW_SND (attr
);
2538 else if (attr
->form
== DW_FORM_udata
2539 || attr
->form
== DW_FORM_data1
2540 || attr
->form
== DW_FORM_data2
2541 || attr
->form
== DW_FORM_data4
2542 || attr
->form
== DW_FORM_data8
)
2544 low
= DW_UNSND (attr
);
2548 complain (&dwarf2_non_const_array_bound_ignored
,
2549 dwarf_form_name (attr
->form
));
2551 die
->type
= lookup_pointer_type (element_type
);
2558 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2561 if (attr
->form
== DW_FORM_sdata
)
2563 high
= DW_SND (attr
);
2565 else if (attr
->form
== DW_FORM_udata
2566 || attr
->form
== DW_FORM_data1
2567 || attr
->form
== DW_FORM_data2
2568 || attr
->form
== DW_FORM_data4
2569 || attr
->form
== DW_FORM_data8
)
2571 high
= DW_UNSND (attr
);
2573 else if (attr
->form
== DW_FORM_block1
)
2575 /* GCC encodes arrays with unspecified or dynamic length
2576 with a DW_FORM_block1 attribute.
2577 FIXME: GDB does not yet know how to handle dynamic
2578 arrays properly, treat them as arrays with unspecified
2584 complain (&dwarf2_non_const_array_bound_ignored
,
2585 dwarf_form_name (attr
->form
));
2587 die
->type
= lookup_pointer_type (element_type
);
2595 /* Create a range type and save it for array type creation. */
2596 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2598 range_types
= (struct type
**)
2599 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2600 * sizeof (struct type
*));
2602 make_cleanup (free_current_contents
, &range_types
);
2604 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2606 child_die
= sibling_die (child_die
);
2609 /* Dwarf2 dimensions are output from left to right, create the
2610 necessary array types in backwards order. */
2611 type
= element_type
;
2613 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2615 do_cleanups (back_to
);
2617 /* Install the type in the die. */
2621 /* First cut: install each common block member as a global variable. */
2624 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
2625 const struct comp_unit_head
*cu_header
)
2627 struct die_info
*child_die
;
2628 struct attribute
*attr
;
2630 CORE_ADDR base
= (CORE_ADDR
) 0;
2632 attr
= dwarf_attr (die
, DW_AT_location
);
2635 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2637 if (die
->has_children
)
2639 child_die
= die
->next
;
2640 while (child_die
&& child_die
->tag
)
2642 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
2643 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2646 SYMBOL_VALUE_ADDRESS (sym
) =
2647 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2648 add_symbol_to_list (sym
, &global_symbols
);
2650 child_die
= sibling_die (child_die
);
2655 /* Extract all information from a DW_TAG_pointer_type DIE and add to
2656 the user defined type vector. */
2659 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
2660 const struct comp_unit_head
*cu_header
)
2663 struct attribute
*attr
;
2670 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
2671 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2674 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2678 TYPE_LENGTH (type
) = cu_header
->addr_size
;
2683 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
2684 the user defined type vector. */
2687 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
2688 const struct comp_unit_head
*cu_header
)
2691 struct type
*to_type
;
2692 struct type
*domain
;
2699 type
= alloc_type (objfile
);
2700 to_type
= die_type (die
, objfile
, cu_header
);
2701 domain
= die_containing_type (die
, objfile
, cu_header
);
2702 smash_to_member_type (type
, domain
, to_type
);
2707 /* Extract all information from a DW_TAG_reference_type DIE and add to
2708 the user defined type vector. */
2711 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
2712 const struct comp_unit_head
*cu_header
)
2715 struct attribute
*attr
;
2722 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
2723 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2726 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2730 TYPE_LENGTH (type
) = cu_header
->addr_size
;
2736 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
2737 const struct comp_unit_head
*cu_header
)
2739 struct type
*base_type
;
2746 base_type
= die_type (die
, objfile
, cu_header
);
2747 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
2751 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
2752 const struct comp_unit_head
*cu_header
)
2754 struct type
*base_type
;
2761 base_type
= die_type (die
, objfile
, cu_header
);
2762 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
2765 /* Extract all information from a DW_TAG_string_type DIE and add to
2766 the user defined type vector. It isn't really a user defined type,
2767 but it behaves like one, with other DIE's using an AT_user_def_type
2768 attribute to reference it. */
2771 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
2773 struct type
*type
, *range_type
, *index_type
, *char_type
;
2774 struct attribute
*attr
;
2775 unsigned int length
;
2782 attr
= dwarf_attr (die
, DW_AT_string_length
);
2785 length
= DW_UNSND (attr
);
2789 /* check for the DW_AT_byte_size attribute */
2790 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2793 length
= DW_UNSND (attr
);
2800 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2801 range_type
= create_range_type (NULL
, index_type
, 1, length
);
2802 if (cu_language
== language_fortran
)
2804 /* Need to create a unique string type for bounds
2806 type
= create_string_type (0, range_type
);
2810 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
2811 type
= create_string_type (char_type
, range_type
);
2816 /* Handle DIES due to C code like:
2820 int (*funcp)(int a, long l);
2824 ('funcp' generates a DW_TAG_subroutine_type DIE)
2828 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
2829 const struct comp_unit_head
*cu_header
)
2831 struct type
*type
; /* Type that this function returns */
2832 struct type
*ftype
; /* Function that returns above type */
2833 struct attribute
*attr
;
2835 /* Decode the type that this subroutine returns */
2840 type
= die_type (die
, objfile
, cu_header
);
2841 ftype
= lookup_function_type (type
);
2843 /* All functions in C++ have prototypes. */
2844 attr
= dwarf_attr (die
, DW_AT_prototyped
);
2845 if ((attr
&& (DW_UNSND (attr
) != 0))
2846 || cu_language
== language_cplus
)
2847 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
2849 if (die
->has_children
)
2851 struct die_info
*child_die
;
2855 /* Count the number of parameters.
2856 FIXME: GDB currently ignores vararg functions, but knows about
2857 vararg member functions. */
2858 child_die
= die
->next
;
2859 while (child_die
&& child_die
->tag
)
2861 if (child_die
->tag
== DW_TAG_formal_parameter
)
2863 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
2864 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
2865 child_die
= sibling_die (child_die
);
2868 /* Allocate storage for parameters and fill them in. */
2869 TYPE_NFIELDS (ftype
) = nparams
;
2870 TYPE_FIELDS (ftype
) = (struct field
*)
2871 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
2873 child_die
= die
->next
;
2874 while (child_die
&& child_die
->tag
)
2876 if (child_die
->tag
== DW_TAG_formal_parameter
)
2878 /* Dwarf2 has no clean way to discern C++ static and non-static
2879 member functions. G++ helps GDB by marking the first
2880 parameter for non-static member functions (which is the
2881 this pointer) as artificial. We pass this information
2882 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
2883 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
2885 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
2887 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
2888 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
2892 child_die
= sibling_die (child_die
);
2900 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
2901 const struct comp_unit_head
*cu_header
)
2903 struct attribute
*attr
;
2908 attr
= dwarf_attr (die
, DW_AT_name
);
2909 if (attr
&& DW_STRING (attr
))
2911 name
= DW_STRING (attr
);
2913 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
2914 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
2918 /* Find a representation of a given base type and install
2919 it in the TYPE field of the die. */
2922 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
2925 struct attribute
*attr
;
2926 int encoding
= 0, size
= 0;
2928 /* If we've already decoded this die, this is a no-op. */
2934 attr
= dwarf_attr (die
, DW_AT_encoding
);
2937 encoding
= DW_UNSND (attr
);
2939 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2942 size
= DW_UNSND (attr
);
2944 attr
= dwarf_attr (die
, DW_AT_name
);
2945 if (attr
&& DW_STRING (attr
))
2947 enum type_code code
= TYPE_CODE_INT
;
2952 case DW_ATE_address
:
2953 /* Turn DW_ATE_address into a void * pointer. */
2954 code
= TYPE_CODE_PTR
;
2955 type_flags
|= TYPE_FLAG_UNSIGNED
;
2957 case DW_ATE_boolean
:
2958 code
= TYPE_CODE_BOOL
;
2959 type_flags
|= TYPE_FLAG_UNSIGNED
;
2961 case DW_ATE_complex_float
:
2962 code
= TYPE_CODE_COMPLEX
;
2965 code
= TYPE_CODE_FLT
;
2968 case DW_ATE_signed_char
:
2970 case DW_ATE_unsigned
:
2971 case DW_ATE_unsigned_char
:
2972 type_flags
|= TYPE_FLAG_UNSIGNED
;
2975 complain (&dwarf2_unsupported_at_encoding
,
2976 dwarf_type_encoding_name (encoding
));
2979 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
2980 if (encoding
== DW_ATE_address
)
2981 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
2982 else if (encoding
== DW_ATE_complex_float
)
2985 TYPE_TARGET_TYPE (type
)
2986 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
2987 else if (size
== 16)
2988 TYPE_TARGET_TYPE (type
)
2989 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
2991 TYPE_TARGET_TYPE (type
)
2992 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
2997 type
= dwarf_base_type (encoding
, size
, objfile
);
3002 /* Read a whole compilation unit into a linked list of dies. */
3004 static struct die_info
*
3005 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3006 const struct comp_unit_head
*cu_header
)
3008 struct die_info
*first_die
, *last_die
, *die
;
3012 /* Reset die reference table; we are
3013 building new ones now. */
3014 dwarf2_empty_hash_tables ();
3018 first_die
= last_die
= NULL
;
3021 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3022 if (die
->has_children
)
3033 /* Enter die in reference hash table */
3034 store_in_ref_table (die
->offset
, die
);
3038 first_die
= last_die
= die
;
3042 last_die
->next
= die
;
3046 while (nesting_level
> 0);
3050 /* Free a linked list of dies. */
3053 free_die_list (struct die_info
*dies
)
3055 struct die_info
*die
, *next
;
3068 do_free_die_list_cleanup (void *dies
)
3070 free_die_list (dies
);
3073 static struct cleanup
*
3074 make_cleanup_free_die_list (struct die_info
*dies
)
3076 return make_cleanup (do_free_die_list_cleanup
, dies
);
3080 /* Read the contents of the section at OFFSET and of size SIZE from the
3081 object file specified by OBJFILE into the psymbol_obstack and return it. */
3084 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3087 bfd
*abfd
= objfile
->obfd
;
3093 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3094 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3095 (bfd_bread (buf
, size
, abfd
) != size
))
3098 error ("Dwarf Error: Can't read DWARF data from '%s'",
3099 bfd_get_filename (abfd
));
3104 /* In DWARF version 2, the description of the debugging information is
3105 stored in a separate .debug_abbrev section. Before we read any
3106 dies from a section we read in all abbreviations and install them
3110 dwarf2_read_abbrevs (bfd
*abfd
, unsigned int offset
)
3113 struct abbrev_info
*cur_abbrev
;
3114 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3115 unsigned int abbrev_form
, hash_number
;
3117 /* empty the table */
3118 dwarf2_empty_abbrev_table (NULL
);
3120 abbrev_ptr
= dwarf_abbrev_buffer
+ offset
;
3121 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3122 abbrev_ptr
+= bytes_read
;
3124 /* loop until we reach an abbrev number of 0 */
3125 while (abbrev_number
)
3127 cur_abbrev
= dwarf_alloc_abbrev ();
3129 /* read in abbrev header */
3130 cur_abbrev
->number
= abbrev_number
;
3131 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3132 abbrev_ptr
+= bytes_read
;
3133 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3136 /* now read in declarations */
3137 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3138 abbrev_ptr
+= bytes_read
;
3139 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3140 abbrev_ptr
+= bytes_read
;
3143 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3145 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3146 xrealloc (cur_abbrev
->attrs
,
3147 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3148 * sizeof (struct attr_abbrev
));
3150 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3151 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3152 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3153 abbrev_ptr
+= bytes_read
;
3154 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3155 abbrev_ptr
+= bytes_read
;
3158 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3159 cur_abbrev
->next
= dwarf2_abbrevs
[hash_number
];
3160 dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3162 /* Get next abbreviation.
3163 Under Irix6 the abbreviations for a compilation unit are not
3164 always properly terminated with an abbrev number of 0.
3165 Exit loop if we encounter an abbreviation which we have
3166 already read (which means we are about to read the abbreviations
3167 for the next compile unit) or if the end of the abbreviation
3168 table is reached. */
3169 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3170 >= dwarf_abbrev_size
)
3172 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3173 abbrev_ptr
+= bytes_read
;
3174 if (dwarf2_lookup_abbrev (abbrev_number
) != NULL
)
3179 /* Empty the abbrev table for a new compilation unit. */
3183 dwarf2_empty_abbrev_table (PTR ignore
)
3186 struct abbrev_info
*abbrev
, *next
;
3188 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3191 abbrev
= dwarf2_abbrevs
[i
];
3194 next
= abbrev
->next
;
3195 xfree (abbrev
->attrs
);
3199 dwarf2_abbrevs
[i
] = NULL
;
3203 /* Lookup an abbrev_info structure in the abbrev hash table. */
3205 static struct abbrev_info
*
3206 dwarf2_lookup_abbrev (unsigned int number
)
3208 unsigned int hash_number
;
3209 struct abbrev_info
*abbrev
;
3211 hash_number
= number
% ABBREV_HASH_SIZE
;
3212 abbrev
= dwarf2_abbrevs
[hash_number
];
3216 if (abbrev
->number
== number
)
3219 abbrev
= abbrev
->next
;
3224 /* Read a minimal amount of information into the minimal die structure. */
3227 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3228 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3230 unsigned int abbrev_number
, bytes_read
, i
;
3231 struct abbrev_info
*abbrev
;
3232 struct attribute attr
;
3233 struct attribute spec_attr
;
3234 int found_spec_attr
= 0;
3235 int has_low_pc_attr
= 0;
3236 int has_high_pc_attr
= 0;
3238 *part_die
= zeroed_partial_die
;
3239 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3240 info_ptr
+= bytes_read
;
3244 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3247 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3249 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3250 part_die
->tag
= abbrev
->tag
;
3251 part_die
->has_children
= abbrev
->has_children
;
3252 part_die
->abbrev
= abbrev_number
;
3254 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3256 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3257 info_ptr
, cu_header
);
3259 /* Store the data if it is of an attribute we want to keep in a
3260 partial symbol table. */
3265 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3266 if (part_die
->name
== NULL
)
3267 part_die
->name
= DW_STRING (&attr
);
3269 case DW_AT_MIPS_linkage_name
:
3270 part_die
->name
= DW_STRING (&attr
);
3273 has_low_pc_attr
= 1;
3274 part_die
->lowpc
= DW_ADDR (&attr
);
3277 has_high_pc_attr
= 1;
3278 part_die
->highpc
= DW_ADDR (&attr
);
3280 case DW_AT_location
:
3281 part_die
->locdesc
= DW_BLOCK (&attr
);
3283 case DW_AT_language
:
3284 part_die
->language
= DW_UNSND (&attr
);
3286 case DW_AT_external
:
3287 part_die
->is_external
= DW_UNSND (&attr
);
3289 case DW_AT_declaration
:
3290 part_die
->is_declaration
= DW_UNSND (&attr
);
3293 part_die
->has_type
= 1;
3295 case DW_AT_abstract_origin
:
3296 case DW_AT_specification
:
3297 found_spec_attr
= 1;
3301 /* Ignore absolute siblings, they might point outside of
3302 the current compile unit. */
3303 if (attr
.form
== DW_FORM_ref_addr
)
3304 complain (&dwarf2_absolute_sibling_complaint
);
3307 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3314 /* If we found a reference attribute and the die has no name, try
3315 to find a name in the referred to die. */
3317 if (found_spec_attr
&& part_die
->name
== NULL
)
3319 struct partial_die_info spec_die
;
3323 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3324 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3327 part_die
->name
= spec_die
.name
;
3329 /* Copy DW_AT_external attribute if it is set. */
3330 if (spec_die
.is_external
)
3331 part_die
->is_external
= spec_die
.is_external
;
3335 /* When using the GNU linker, .gnu.linkonce. sections are used to
3336 eliminate duplicate copies of functions and vtables and such.
3337 The linker will arbitrarily choose one and discard the others.
3338 The AT_*_pc values for such functions refer to local labels in
3339 these sections. If the section from that file was discarded, the
3340 labels are not in the output, so the relocs get a value of 0.
3341 If this is a discarded function, mark the pc bounds as invalid,
3342 so that GDB will ignore it. */
3343 if (has_low_pc_attr
&& has_high_pc_attr
3344 && part_die
->lowpc
< part_die
->highpc
3345 && (part_die
->lowpc
!= 0
3346 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3347 part_die
->has_pc_info
= 1;
3351 /* Read the die from the .debug_info section buffer. And set diep to
3352 point to a newly allocated die with its information. */
3355 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3356 const struct comp_unit_head
*cu_header
)
3358 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3359 struct abbrev_info
*abbrev
;
3360 struct die_info
*die
;
3362 offset
= info_ptr
- dwarf_info_buffer
;
3363 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3364 info_ptr
+= bytes_read
;
3367 die
= dwarf_alloc_die ();
3369 die
->abbrev
= abbrev_number
;
3375 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3378 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3380 die
= dwarf_alloc_die ();
3381 die
->offset
= offset
;
3382 die
->tag
= abbrev
->tag
;
3383 die
->has_children
= abbrev
->has_children
;
3384 die
->abbrev
= abbrev_number
;
3387 die
->num_attrs
= abbrev
->num_attrs
;
3388 die
->attrs
= (struct attribute
*)
3389 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3391 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3393 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3394 abfd
, info_ptr
, cu_header
);
3401 /* Read an attribute value described by an attribute form. */
3404 read_attribute_value (struct attribute
*attr
, unsigned form
,
3405 bfd
*abfd
, char *info_ptr
,
3406 const struct comp_unit_head
*cu_header
)
3408 unsigned int bytes_read
;
3409 struct dwarf_block
*blk
;
3415 case DW_FORM_ref_addr
:
3416 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3417 info_ptr
+= bytes_read
;
3419 case DW_FORM_block2
:
3420 blk
= dwarf_alloc_block ();
3421 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3423 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3424 info_ptr
+= blk
->size
;
3425 DW_BLOCK (attr
) = blk
;
3427 case DW_FORM_block4
:
3428 blk
= dwarf_alloc_block ();
3429 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3431 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3432 info_ptr
+= blk
->size
;
3433 DW_BLOCK (attr
) = blk
;
3436 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3440 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3444 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3447 case DW_FORM_string
:
3448 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3449 info_ptr
+= bytes_read
;
3452 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
3454 info_ptr
+= bytes_read
;
3457 blk
= dwarf_alloc_block ();
3458 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3459 info_ptr
+= bytes_read
;
3460 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3461 info_ptr
+= blk
->size
;
3462 DW_BLOCK (attr
) = blk
;
3464 case DW_FORM_block1
:
3465 blk
= dwarf_alloc_block ();
3466 blk
->size
= read_1_byte (abfd
, info_ptr
);
3468 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3469 info_ptr
+= blk
->size
;
3470 DW_BLOCK (attr
) = blk
;
3473 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3477 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3481 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3482 info_ptr
+= bytes_read
;
3485 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3486 info_ptr
+= bytes_read
;
3489 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3493 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3497 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3501 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3504 case DW_FORM_ref_udata
:
3505 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3506 info_ptr
+= bytes_read
;
3508 case DW_FORM_indirect
:
3509 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3510 info_ptr
+= bytes_read
;
3511 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
3514 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3515 dwarf_form_name (form
));
3520 /* Read an attribute described by an abbreviated attribute. */
3523 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
3524 bfd
*abfd
, char *info_ptr
,
3525 const struct comp_unit_head
*cu_header
)
3527 attr
->name
= abbrev
->name
;
3528 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
3531 /* read dwarf information from a buffer */
3534 read_1_byte (bfd
*abfd
, char *buf
)
3536 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3540 read_1_signed_byte (bfd
*abfd
, char *buf
)
3542 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3546 read_2_bytes (bfd
*abfd
, char *buf
)
3548 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3552 read_2_signed_bytes (bfd
*abfd
, char *buf
)
3554 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3558 read_4_bytes (bfd
*abfd
, char *buf
)
3560 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3564 read_4_signed_bytes (bfd
*abfd
, char *buf
)
3566 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3569 static unsigned long
3570 read_8_bytes (bfd
*abfd
, char *buf
)
3572 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3576 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3579 CORE_ADDR retval
= 0;
3581 if (cu_header
->signed_addr_p
)
3583 switch (cu_header
->addr_size
)
3586 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3589 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3592 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
3595 internal_error (__FILE__
, __LINE__
,
3596 "read_address: bad switch, signed");
3601 switch (cu_header
->addr_size
)
3604 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3607 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3610 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3613 internal_error (__FILE__
, __LINE__
,
3614 "read_address: bad switch, unsigned");
3618 *bytes_read
= cu_header
->addr_size
;
3622 /* Reads the initial length from a section. The (draft) DWARF 2.1
3623 specification allows the initial length to take up either 4 bytes
3624 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
3625 bytes describe the length and all offsets will be 8 bytes in length
3628 The value returned via bytes_read should be used to increment
3629 the relevant pointer after calling read_initial_length().
3631 As a side effect, this function sets the fields initial_length_size
3632 and offset_size in cu_header to the values appropriate for the
3633 length field. (The format of the initial length field determines
3634 the width of file offsets to be fetched later with fetch_offset().)
3636 [ Note: read_initial_length() and read_offset() are based on the
3637 document entitled "DWARF Debugging Information Format", revision
3638 2.1, draft 4, dated July 20, 2000. This document was obtained
3641 http://reality.sgi.com/dehnert_engr/dwarf/dwarf2p1-draft4-000720.pdf
3643 This document is only a draft and is subject to change. (So beware.)
3645 - Kevin, Aug 4, 2000
3649 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
3654 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3656 if (retval
== 0xffffffff)
3658 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
3660 if (cu_header
!= NULL
)
3662 cu_header
->initial_length_size
= 12;
3663 cu_header
->offset_size
= 8;
3669 if (cu_header
!= NULL
)
3671 cu_header
->initial_length_size
= 4;
3672 cu_header
->offset_size
= 4;
3679 /* Read an offset from the data stream. The size of the offset is
3680 given by cu_header->offset_size. */
3683 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3688 switch (cu_header
->offset_size
)
3691 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3695 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3699 internal_error (__FILE__
, __LINE__
,
3700 "read_offset: bad switch");
3707 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
3709 /* If the size of a host char is 8 bits, we can return a pointer
3710 to the buffer, otherwise we have to copy the data to a buffer
3711 allocated on the temporary obstack. */
3712 gdb_assert (HOST_CHAR_BIT
== 8);
3717 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3719 /* If the size of a host char is 8 bits, we can return a pointer
3720 to the string, otherwise we have to copy the string to a buffer
3721 allocated on the temporary obstack. */
3722 gdb_assert (HOST_CHAR_BIT
== 8);
3725 *bytes_read_ptr
= 1;
3728 *bytes_read_ptr
= strlen (buf
) + 1;
3733 read_indirect_string (bfd
*abfd
, char *buf
,
3734 const struct comp_unit_head
*cu_header
,
3735 unsigned int *bytes_read_ptr
)
3737 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
3738 (int *) bytes_read_ptr
);
3740 if (dwarf_str_buffer
== NULL
)
3742 error ("DW_FORM_strp used without .debug_str section");
3745 if (str_offset
>= dwarf_str_size
)
3747 error ("DW_FORM_strp pointing outside of .debug_str section");
3750 gdb_assert (HOST_CHAR_BIT
== 8);
3751 if (dwarf_str_buffer
[str_offset
] == '\0')
3753 return dwarf_str_buffer
+ str_offset
;
3756 static unsigned long
3757 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3759 unsigned long result
;
3760 unsigned int num_read
;
3770 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3773 result
|= ((unsigned long)(byte
& 127) << shift
);
3774 if ((byte
& 128) == 0)
3780 *bytes_read_ptr
= num_read
;
3785 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3788 int i
, shift
, size
, num_read
;
3798 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3801 result
|= ((long)(byte
& 127) << shift
);
3803 if ((byte
& 128) == 0)
3808 if ((shift
< size
) && (byte
& 0x40))
3810 result
|= -(1 << shift
);
3812 *bytes_read_ptr
= num_read
;
3817 set_cu_language (unsigned int lang
)
3823 cu_language
= language_c
;
3825 case DW_LANG_C_plus_plus
:
3826 cu_language
= language_cplus
;
3828 case DW_LANG_Fortran77
:
3829 case DW_LANG_Fortran90
:
3830 case DW_LANG_Fortran95
:
3831 cu_language
= language_fortran
;
3833 case DW_LANG_Mips_Assembler
:
3834 cu_language
= language_asm
;
3837 cu_language
= language_java
;
3840 case DW_LANG_Cobol74
:
3841 case DW_LANG_Cobol85
:
3842 case DW_LANG_Pascal83
:
3843 case DW_LANG_Modula2
:
3845 cu_language
= language_unknown
;
3848 cu_language_defn
= language_def (cu_language
);
3851 /* Return the named attribute or NULL if not there. */
3853 static struct attribute
*
3854 dwarf_attr (struct die_info
*die
, unsigned int name
)
3857 struct attribute
*spec
= NULL
;
3859 for (i
= 0; i
< die
->num_attrs
; ++i
)
3861 if (die
->attrs
[i
].name
== name
)
3863 return &die
->attrs
[i
];
3865 if (die
->attrs
[i
].name
== DW_AT_specification
3866 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
3867 spec
= &die
->attrs
[i
];
3871 struct die_info
*ref_die
=
3872 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
3875 return dwarf_attr (ref_die
, name
);
3882 die_is_declaration (struct die_info
*die
)
3884 return (dwarf_attr (die
, DW_AT_declaration
)
3885 && ! dwarf_attr (die
, DW_AT_specification
));
3888 /* Decode the line number information for the compilation unit whose
3889 line number info is at OFFSET in the .debug_line section.
3890 The compilation directory of the file is passed in COMP_DIR. */
3894 unsigned int num_files
;
3907 unsigned int num_dirs
;
3912 dwarf_decode_lines (unsigned int offset
, char *comp_dir
, bfd
*abfd
,
3913 const struct comp_unit_head
*cu_header
)
3917 struct line_head lh
;
3918 struct cleanup
*back_to
;
3919 unsigned int i
, bytes_read
;
3920 char *cur_file
, *cur_dir
;
3921 unsigned char op_code
, extended_op
, adj_opcode
;
3923 #define FILE_ALLOC_CHUNK 5
3924 #define DIR_ALLOC_CHUNK 5
3926 struct filenames files
;
3927 struct directories dirs
;
3929 if (dwarf_line_buffer
== NULL
)
3931 complain (&dwarf2_missing_line_number_section
);
3935 files
.num_files
= 0;
3941 line_ptr
= dwarf_line_buffer
+ offset
;
3943 /* read in the prologue */
3944 lh
.total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
3945 line_ptr
+= bytes_read
;
3946 line_end
= line_ptr
+ lh
.total_length
;
3947 lh
.version
= read_2_bytes (abfd
, line_ptr
);
3949 lh
.prologue_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
3950 line_ptr
+= bytes_read
;
3951 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
3953 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
3955 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
3957 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
3959 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
3961 lh
.standard_opcode_lengths
= (unsigned char *)
3962 xmalloc (lh
.opcode_base
* sizeof (unsigned char));
3963 back_to
= make_cleanup (free_current_contents
, &lh
.standard_opcode_lengths
);
3965 lh
.standard_opcode_lengths
[0] = 1;
3966 for (i
= 1; i
< lh
.opcode_base
; ++i
)
3968 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
3972 /* Read directory table */
3973 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
3975 line_ptr
+= bytes_read
;
3976 if ((dirs
.num_dirs
% DIR_ALLOC_CHUNK
) == 0)
3978 dirs
.dirs
= (char **)
3979 xrealloc (dirs
.dirs
,
3980 (dirs
.num_dirs
+ DIR_ALLOC_CHUNK
) * sizeof (char *));
3981 if (dirs
.num_dirs
== 0)
3982 make_cleanup (free_current_contents
, &dirs
.dirs
);
3984 dirs
.dirs
[dirs
.num_dirs
++] = cur_dir
;
3986 line_ptr
+= bytes_read
;
3988 /* Read file name table */
3989 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
3991 line_ptr
+= bytes_read
;
3992 if ((files
.num_files
% FILE_ALLOC_CHUNK
) == 0)
3994 files
.files
= (struct fileinfo
*)
3995 xrealloc (files
.files
,
3996 (files
.num_files
+ FILE_ALLOC_CHUNK
)
3997 * sizeof (struct fileinfo
));
3998 if (files
.num_files
== 0)
3999 make_cleanup (free_current_contents
, &files
.files
);
4001 files
.files
[files
.num_files
].name
= cur_file
;
4002 files
.files
[files
.num_files
].dir
=
4003 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4004 line_ptr
+= bytes_read
;
4005 files
.files
[files
.num_files
].time
=
4006 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4007 line_ptr
+= bytes_read
;
4008 files
.files
[files
.num_files
].size
=
4009 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4010 line_ptr
+= bytes_read
;
4013 line_ptr
+= bytes_read
;
4015 /* Read the statement sequences until there's nothing left. */
4016 while (line_ptr
< line_end
)
4018 /* state machine registers */
4019 CORE_ADDR address
= 0;
4020 unsigned int file
= 1;
4021 unsigned int line
= 1;
4022 unsigned int column
= 0;
4023 int is_stmt
= lh
.default_is_stmt
;
4024 int basic_block
= 0;
4025 int end_sequence
= 0;
4027 /* Start a subfile for the current file of the state machine. */
4028 if (files
.num_files
>= file
)
4030 /* The file and directory tables are 0 based, the references
4032 dwarf2_start_subfile (files
.files
[file
- 1].name
,
4033 (files
.files
[file
- 1].dir
4034 ? dirs
.dirs
[files
.files
[file
- 1].dir
- 1]
4038 /* Decode the table. */
4039 while (!end_sequence
)
4041 op_code
= read_1_byte (abfd
, line_ptr
);
4044 if (op_code
>= lh
.opcode_base
)
4045 { /* Special operand. */
4046 adj_opcode
= op_code
- lh
.opcode_base
;
4047 address
+= (adj_opcode
/ lh
.line_range
)
4048 * lh
.minimum_instruction_length
;
4049 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
4050 /* append row to matrix using current values */
4051 record_line (current_subfile
, line
, address
);
4054 else switch (op_code
)
4056 case DW_LNS_extended_op
:
4057 line_ptr
+= 1; /* ignore length */
4058 extended_op
= read_1_byte (abfd
, line_ptr
);
4060 switch (extended_op
)
4062 case DW_LNE_end_sequence
:
4064 /* Don't call record_line here. The end_sequence
4065 instruction provides the address of the first byte
4066 *after* the last line in the sequence; it's not the
4067 address of any real source line. However, the GDB
4068 linetable structure only records the starts of lines,
4069 not the ends. This is a weakness of GDB. */
4071 case DW_LNE_set_address
:
4072 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4073 line_ptr
+= bytes_read
;
4074 address
+= baseaddr
;
4076 case DW_LNE_define_file
:
4077 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
4078 line_ptr
+= bytes_read
;
4079 if ((files
.num_files
% FILE_ALLOC_CHUNK
) == 0)
4081 files
.files
= (struct fileinfo
*)
4082 xrealloc (files
.files
,
4083 (files
.num_files
+ FILE_ALLOC_CHUNK
)
4084 * sizeof (struct fileinfo
));
4085 if (files
.num_files
== 0)
4086 make_cleanup (free_current_contents
, &files
.files
);
4088 files
.files
[files
.num_files
].name
= cur_file
;
4089 files
.files
[files
.num_files
].dir
=
4090 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4091 line_ptr
+= bytes_read
;
4092 files
.files
[files
.num_files
].time
=
4093 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4094 line_ptr
+= bytes_read
;
4095 files
.files
[files
.num_files
].size
=
4096 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4097 line_ptr
+= bytes_read
;
4101 complain (&dwarf2_mangled_line_number_section
);
4106 record_line (current_subfile
, line
, address
);
4109 case DW_LNS_advance_pc
:
4110 address
+= lh
.minimum_instruction_length
4111 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4112 line_ptr
+= bytes_read
;
4114 case DW_LNS_advance_line
:
4115 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4116 line_ptr
+= bytes_read
;
4118 case DW_LNS_set_file
:
4119 /* The file and directory tables are 0 based, the references
4121 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4122 line_ptr
+= bytes_read
;
4123 dwarf2_start_subfile
4124 (files
.files
[file
- 1].name
,
4125 (files
.files
[file
- 1].dir
4126 ? dirs
.dirs
[files
.files
[file
- 1].dir
- 1]
4129 case DW_LNS_set_column
:
4130 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4131 line_ptr
+= bytes_read
;
4133 case DW_LNS_negate_stmt
:
4134 is_stmt
= (!is_stmt
);
4136 case DW_LNS_set_basic_block
:
4139 /* Add to the address register of the state machine the
4140 address increment value corresponding to special opcode
4141 255. Ie, this value is scaled by the minimum instruction
4142 length since special opcode 255 would have scaled the
4144 case DW_LNS_const_add_pc
:
4145 address
+= (lh
.minimum_instruction_length
4146 * ((255 - lh
.opcode_base
) / lh
.line_range
));
4148 case DW_LNS_fixed_advance_pc
:
4149 address
+= read_2_bytes (abfd
, line_ptr
);
4153 { /* Unknown standard opcode, ignore it. */
4155 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
4157 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4158 line_ptr
+= bytes_read
;
4165 do_cleanups (back_to
);
4168 /* Start a subfile for DWARF. FILENAME is the name of the file and
4169 DIRNAME the name of the source directory which contains FILENAME
4170 or NULL if not known.
4171 This routine tries to keep line numbers from identical absolute and
4172 relative file names in a common subfile.
4174 Using the `list' example from the GDB testsuite, which resides in
4175 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4176 of /srcdir/list0.c yields the following debugging information for list0.c:
4178 DW_AT_name: /srcdir/list0.c
4179 DW_AT_comp_dir: /compdir
4180 files.files[0].name: list0.h
4181 files.files[0].dir: /srcdir
4182 files.files[1].name: list0.c
4183 files.files[1].dir: /srcdir
4185 The line number information for list0.c has to end up in a single
4186 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4189 dwarf2_start_subfile (char *filename
, char *dirname
)
4191 /* If the filename isn't absolute, try to match an existing subfile
4192 with the full pathname. */
4194 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4196 struct subfile
*subfile
;
4197 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4199 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4201 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4203 current_subfile
= subfile
;
4210 start_subfile (filename
, dirname
);
4213 /* Given a pointer to a DWARF information entry, figure out if we need
4214 to make a symbol table entry for it, and if so, create a new entry
4215 and return a pointer to it.
4216 If TYPE is NULL, determine symbol type from the die, otherwise
4217 used the passed type. */
4219 static struct symbol
*
4220 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4221 const struct comp_unit_head
*cu_header
)
4223 struct symbol
*sym
= NULL
;
4225 struct attribute
*attr
= NULL
;
4226 struct attribute
*attr2
= NULL
;
4229 name
= dwarf2_linkage_name (die
);
4232 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4233 sizeof (struct symbol
));
4234 OBJSTAT (objfile
, n_syms
++);
4235 memset (sym
, 0, sizeof (struct symbol
));
4236 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4237 &objfile
->symbol_obstack
);
4239 /* Default assumptions.
4240 Use the passed type or decode it from the die. */
4241 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4242 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4244 SYMBOL_TYPE (sym
) = type
;
4246 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4247 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4250 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4253 /* If this symbol is from a C++ compilation, then attempt to
4254 cache the demangled form for future reference. This is a
4255 typical time versus space tradeoff, that was decided in favor
4256 of time because it sped up C++ symbol lookups by a factor of
4259 SYMBOL_LANGUAGE (sym
) = cu_language
;
4260 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4264 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4267 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4269 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4271 case DW_TAG_subprogram
:
4272 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4274 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4275 attr2
= dwarf_attr (die
, DW_AT_external
);
4276 if (attr2
&& (DW_UNSND (attr2
) != 0))
4278 add_symbol_to_list (sym
, &global_symbols
);
4282 add_symbol_to_list (sym
, list_in_scope
);
4285 case DW_TAG_variable
:
4286 /* Compilation with minimal debug info may result in variables
4287 with missing type entries. Change the misleading `void' type
4288 to something sensible. */
4289 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4290 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4291 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4292 "<variable, no debug info>",
4294 attr
= dwarf_attr (die
, DW_AT_const_value
);
4297 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4298 attr2
= dwarf_attr (die
, DW_AT_external
);
4299 if (attr2
&& (DW_UNSND (attr2
) != 0))
4300 add_symbol_to_list (sym
, &global_symbols
);
4302 add_symbol_to_list (sym
, list_in_scope
);
4305 attr
= dwarf_attr (die
, DW_AT_location
);
4308 attr2
= dwarf_attr (die
, DW_AT_external
);
4309 if (attr2
&& (DW_UNSND (attr2
) != 0))
4311 SYMBOL_VALUE_ADDRESS (sym
) =
4312 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4313 add_symbol_to_list (sym
, &global_symbols
);
4315 /* In shared libraries the address of the variable
4316 in the location descriptor might still be relocatable,
4317 so its value could be zero.
4318 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4319 value is zero, the address of the variable will then
4320 be determined from the minimal symbol table whenever
4321 the variable is referenced. */
4322 if (SYMBOL_VALUE_ADDRESS (sym
))
4324 fixup_symbol_section (sym
, objfile
);
4325 SYMBOL_VALUE_ADDRESS (sym
) +=
4326 ANOFFSET (objfile
->section_offsets
,
4327 SYMBOL_SECTION (sym
));
4328 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4331 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4335 SYMBOL_VALUE (sym
) = addr
=
4336 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4337 add_symbol_to_list (sym
, list_in_scope
);
4340 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4344 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4345 SYMBOL_VALUE (sym
) =
4346 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4350 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4351 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4355 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4359 fixup_symbol_section (sym
, objfile
);
4360 SYMBOL_VALUE_ADDRESS (sym
) =
4361 addr
+ ANOFFSET (objfile
->section_offsets
,
4362 SYMBOL_SECTION (sym
));
4363 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4369 /* We do not know the address of this symbol.
4370 If it is an external symbol and we have type information
4371 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4372 The address of the variable will then be determined from
4373 the minimal symbol table whenever the variable is
4375 attr2
= dwarf_attr (die
, DW_AT_external
);
4376 if (attr2
&& (DW_UNSND (attr2
) != 0)
4377 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4379 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4380 add_symbol_to_list (sym
, &global_symbols
);
4384 case DW_TAG_formal_parameter
:
4385 attr
= dwarf_attr (die
, DW_AT_location
);
4388 SYMBOL_VALUE (sym
) =
4389 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4392 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4393 SYMBOL_VALUE (sym
) =
4394 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4400 if (basereg
!= frame_base_reg
)
4401 complain (&dwarf2_complex_location_expr
);
4402 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
4406 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4407 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4412 SYMBOL_CLASS (sym
) = LOC_ARG
;
4415 attr
= dwarf_attr (die
, DW_AT_const_value
);
4418 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4420 add_symbol_to_list (sym
, list_in_scope
);
4422 case DW_TAG_unspecified_parameters
:
4423 /* From varargs functions; gdb doesn't seem to have any
4424 interest in this information, so just ignore it for now.
4427 case DW_TAG_class_type
:
4428 case DW_TAG_structure_type
:
4429 case DW_TAG_union_type
:
4430 case DW_TAG_enumeration_type
:
4431 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4432 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
4433 add_symbol_to_list (sym
, list_in_scope
);
4435 /* The semantics of C++ state that "struct foo { ... }" also
4436 defines a typedef for "foo". Synthesize a typedef symbol so
4437 that "ptype foo" works as expected. */
4438 if (cu_language
== language_cplus
)
4440 struct symbol
*typedef_sym
= (struct symbol
*)
4441 obstack_alloc (&objfile
->symbol_obstack
,
4442 sizeof (struct symbol
));
4443 *typedef_sym
= *sym
;
4444 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
4445 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
4446 TYPE_NAME (SYMBOL_TYPE (sym
)) =
4447 obsavestring (SYMBOL_NAME (sym
),
4448 strlen (SYMBOL_NAME (sym
)),
4449 &objfile
->type_obstack
);
4450 add_symbol_to_list (typedef_sym
, list_in_scope
);
4453 case DW_TAG_typedef
:
4454 case DW_TAG_base_type
:
4455 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4456 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4457 add_symbol_to_list (sym
, list_in_scope
);
4459 case DW_TAG_enumerator
:
4460 attr
= dwarf_attr (die
, DW_AT_const_value
);
4463 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4465 add_symbol_to_list (sym
, list_in_scope
);
4468 /* Not a tag we recognize. Hopefully we aren't processing
4469 trash data, but since we must specifically ignore things
4470 we don't recognize, there is nothing else we should do at
4472 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
4479 /* Copy constant value from an attribute to a symbol. */
4482 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
4483 struct objfile
*objfile
,
4484 const struct comp_unit_head
*cu_header
)
4486 struct dwarf_block
*blk
;
4491 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
4492 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4493 cu_header
->addr_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4494 SYMBOL_VALUE_BYTES (sym
) = (char *)
4495 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
4496 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
4498 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4500 case DW_FORM_block1
:
4501 case DW_FORM_block2
:
4502 case DW_FORM_block4
:
4504 blk
= DW_BLOCK (attr
);
4505 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
4506 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4507 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4508 SYMBOL_VALUE_BYTES (sym
) = (char *)
4509 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
4510 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
4511 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4514 /* The DW_AT_const_value attributes are supposed to carry the
4515 symbol's value "represented as it would be on the target
4516 architecture." By the time we get here, it's already been
4517 converted to host endianness, so we just need to sign- or
4518 zero-extend it as appropriate. */
4520 dwarf2_const_value_data (attr
, sym
, 8);
4523 dwarf2_const_value_data (attr
, sym
, 16);
4526 dwarf2_const_value_data (attr
, sym
, 32);
4529 dwarf2_const_value_data (attr
, sym
, 64);
4533 SYMBOL_VALUE (sym
) = DW_SND (attr
);
4534 SYMBOL_CLASS (sym
) = LOC_CONST
;
4538 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
4539 SYMBOL_CLASS (sym
) = LOC_CONST
;
4543 complain (&dwarf2_unsupported_const_value_attr
,
4544 dwarf_form_name (attr
->form
));
4545 SYMBOL_VALUE (sym
) = 0;
4546 SYMBOL_CLASS (sym
) = LOC_CONST
;
4552 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
4553 or zero-extend it as appropriate for the symbol's type. */
4555 dwarf2_const_value_data (struct attribute
*attr
,
4559 LONGEST l
= DW_UNSND (attr
);
4561 if (bits
< sizeof (l
) * 8)
4563 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
4564 l
&= ((LONGEST
) 1 << bits
) - 1;
4566 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
4569 SYMBOL_VALUE (sym
) = l
;
4570 SYMBOL_CLASS (sym
) = LOC_CONST
;
4574 /* Return the type of the die in question using its DW_AT_type attribute. */
4576 static struct type
*
4577 die_type (struct die_info
*die
, struct objfile
*objfile
,
4578 const struct comp_unit_head
*cu_header
)
4581 struct attribute
*type_attr
;
4582 struct die_info
*type_die
;
4585 type_attr
= dwarf_attr (die
, DW_AT_type
);
4588 /* A missing DW_AT_type represents a void type. */
4589 return dwarf2_fundamental_type (objfile
, FT_VOID
);
4593 ref
= dwarf2_get_ref_die_offset (type_attr
);
4594 type_die
= follow_die_ref (ref
);
4597 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4601 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
4604 dump_die (type_die
);
4605 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
4610 /* Return the containing type of the die in question using its
4611 DW_AT_containing_type attribute. */
4613 static struct type
*
4614 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
4615 const struct comp_unit_head
*cu_header
)
4617 struct type
*type
= NULL
;
4618 struct attribute
*type_attr
;
4619 struct die_info
*type_die
= NULL
;
4622 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
4625 ref
= dwarf2_get_ref_die_offset (type_attr
);
4626 type_die
= follow_die_ref (ref
);
4629 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4632 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
4637 dump_die (type_die
);
4638 error ("Dwarf Error: Problem turning containing type into gdb type.");
4644 static struct type
*
4645 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
4647 struct die_info
*die
;
4650 die
= follow_die_ref (offset
);
4653 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
4656 type
= tag_type_to_type (die
, objfile
);
4661 static struct type
*
4662 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
4663 const struct comp_unit_head
*cu_header
)
4671 read_type_die (die
, objfile
, cu_header
);
4675 error ("Dwarf Error: Cannot find type of die.");
4682 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
4683 const struct comp_unit_head
*cu_header
)
4687 case DW_TAG_class_type
:
4688 case DW_TAG_structure_type
:
4689 case DW_TAG_union_type
:
4690 read_structure_scope (die
, objfile
, cu_header
);
4692 case DW_TAG_enumeration_type
:
4693 read_enumeration (die
, objfile
, cu_header
);
4695 case DW_TAG_subprogram
:
4696 case DW_TAG_subroutine_type
:
4697 read_subroutine_type (die
, objfile
, cu_header
);
4699 case DW_TAG_array_type
:
4700 read_array_type (die
, objfile
, cu_header
);
4702 case DW_TAG_pointer_type
:
4703 read_tag_pointer_type (die
, objfile
, cu_header
);
4705 case DW_TAG_ptr_to_member_type
:
4706 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
4708 case DW_TAG_reference_type
:
4709 read_tag_reference_type (die
, objfile
, cu_header
);
4711 case DW_TAG_const_type
:
4712 read_tag_const_type (die
, objfile
, cu_header
);
4714 case DW_TAG_volatile_type
:
4715 read_tag_volatile_type (die
, objfile
, cu_header
);
4717 case DW_TAG_string_type
:
4718 read_tag_string_type (die
, objfile
);
4720 case DW_TAG_typedef
:
4721 read_typedef (die
, objfile
, cu_header
);
4723 case DW_TAG_base_type
:
4724 read_base_type (die
, objfile
);
4727 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
4732 static struct type
*
4733 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
4735 /* FIXME - this should not produce a new (struct type *)
4736 every time. It should cache base types. */
4740 case DW_ATE_address
:
4741 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
4743 case DW_ATE_boolean
:
4744 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
4746 case DW_ATE_complex_float
:
4749 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
4753 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
4759 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
4763 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
4770 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
4773 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
4777 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
4781 case DW_ATE_signed_char
:
4782 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
4784 case DW_ATE_unsigned
:
4788 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
4791 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
4795 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
4799 case DW_ATE_unsigned_char
:
4800 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
4803 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
4810 copy_die (struct die_info
*old_die
)
4812 struct die_info
*new_die
;
4815 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
4816 memset (new_die
, 0, sizeof (struct die_info
));
4818 new_die
->tag
= old_die
->tag
;
4819 new_die
->has_children
= old_die
->has_children
;
4820 new_die
->abbrev
= old_die
->abbrev
;
4821 new_die
->offset
= old_die
->offset
;
4822 new_die
->type
= NULL
;
4824 num_attrs
= old_die
->num_attrs
;
4825 new_die
->num_attrs
= num_attrs
;
4826 new_die
->attrs
= (struct attribute
*)
4827 xmalloc (num_attrs
* sizeof (struct attribute
));
4829 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
4831 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
4832 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
4833 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
4836 new_die
->next
= NULL
;
4841 /* Return sibling of die, NULL if no sibling. */
4843 static struct die_info
*
4844 sibling_die (struct die_info
*die
)
4846 int nesting_level
= 0;
4848 if (!die
->has_children
)
4850 if (die
->next
&& (die
->next
->tag
== 0))
4863 if (die
->has_children
)
4873 while (nesting_level
);
4874 if (die
&& (die
->tag
== 0))
4885 /* Get linkage name of a die, return NULL if not found. */
4888 dwarf2_linkage_name (struct die_info
*die
)
4890 struct attribute
*attr
;
4892 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
4893 if (attr
&& DW_STRING (attr
))
4894 return DW_STRING (attr
);
4895 attr
= dwarf_attr (die
, DW_AT_name
);
4896 if (attr
&& DW_STRING (attr
))
4897 return DW_STRING (attr
);
4901 /* Convert a DIE tag into its string name. */
4904 dwarf_tag_name (register unsigned tag
)
4908 case DW_TAG_padding
:
4909 return "DW_TAG_padding";
4910 case DW_TAG_array_type
:
4911 return "DW_TAG_array_type";
4912 case DW_TAG_class_type
:
4913 return "DW_TAG_class_type";
4914 case DW_TAG_entry_point
:
4915 return "DW_TAG_entry_point";
4916 case DW_TAG_enumeration_type
:
4917 return "DW_TAG_enumeration_type";
4918 case DW_TAG_formal_parameter
:
4919 return "DW_TAG_formal_parameter";
4920 case DW_TAG_imported_declaration
:
4921 return "DW_TAG_imported_declaration";
4923 return "DW_TAG_label";
4924 case DW_TAG_lexical_block
:
4925 return "DW_TAG_lexical_block";
4927 return "DW_TAG_member";
4928 case DW_TAG_pointer_type
:
4929 return "DW_TAG_pointer_type";
4930 case DW_TAG_reference_type
:
4931 return "DW_TAG_reference_type";
4932 case DW_TAG_compile_unit
:
4933 return "DW_TAG_compile_unit";
4934 case DW_TAG_string_type
:
4935 return "DW_TAG_string_type";
4936 case DW_TAG_structure_type
:
4937 return "DW_TAG_structure_type";
4938 case DW_TAG_subroutine_type
:
4939 return "DW_TAG_subroutine_type";
4940 case DW_TAG_typedef
:
4941 return "DW_TAG_typedef";
4942 case DW_TAG_union_type
:
4943 return "DW_TAG_union_type";
4944 case DW_TAG_unspecified_parameters
:
4945 return "DW_TAG_unspecified_parameters";
4946 case DW_TAG_variant
:
4947 return "DW_TAG_variant";
4948 case DW_TAG_common_block
:
4949 return "DW_TAG_common_block";
4950 case DW_TAG_common_inclusion
:
4951 return "DW_TAG_common_inclusion";
4952 case DW_TAG_inheritance
:
4953 return "DW_TAG_inheritance";
4954 case DW_TAG_inlined_subroutine
:
4955 return "DW_TAG_inlined_subroutine";
4957 return "DW_TAG_module";
4958 case DW_TAG_ptr_to_member_type
:
4959 return "DW_TAG_ptr_to_member_type";
4960 case DW_TAG_set_type
:
4961 return "DW_TAG_set_type";
4962 case DW_TAG_subrange_type
:
4963 return "DW_TAG_subrange_type";
4964 case DW_TAG_with_stmt
:
4965 return "DW_TAG_with_stmt";
4966 case DW_TAG_access_declaration
:
4967 return "DW_TAG_access_declaration";
4968 case DW_TAG_base_type
:
4969 return "DW_TAG_base_type";
4970 case DW_TAG_catch_block
:
4971 return "DW_TAG_catch_block";
4972 case DW_TAG_const_type
:
4973 return "DW_TAG_const_type";
4974 case DW_TAG_constant
:
4975 return "DW_TAG_constant";
4976 case DW_TAG_enumerator
:
4977 return "DW_TAG_enumerator";
4978 case DW_TAG_file_type
:
4979 return "DW_TAG_file_type";
4981 return "DW_TAG_friend";
4982 case DW_TAG_namelist
:
4983 return "DW_TAG_namelist";
4984 case DW_TAG_namelist_item
:
4985 return "DW_TAG_namelist_item";
4986 case DW_TAG_packed_type
:
4987 return "DW_TAG_packed_type";
4988 case DW_TAG_subprogram
:
4989 return "DW_TAG_subprogram";
4990 case DW_TAG_template_type_param
:
4991 return "DW_TAG_template_type_param";
4992 case DW_TAG_template_value_param
:
4993 return "DW_TAG_template_value_param";
4994 case DW_TAG_thrown_type
:
4995 return "DW_TAG_thrown_type";
4996 case DW_TAG_try_block
:
4997 return "DW_TAG_try_block";
4998 case DW_TAG_variant_part
:
4999 return "DW_TAG_variant_part";
5000 case DW_TAG_variable
:
5001 return "DW_TAG_variable";
5002 case DW_TAG_volatile_type
:
5003 return "DW_TAG_volatile_type";
5004 case DW_TAG_MIPS_loop
:
5005 return "DW_TAG_MIPS_loop";
5006 case DW_TAG_format_label
:
5007 return "DW_TAG_format_label";
5008 case DW_TAG_function_template
:
5009 return "DW_TAG_function_template";
5010 case DW_TAG_class_template
:
5011 return "DW_TAG_class_template";
5013 return "DW_TAG_<unknown>";
5017 /* Convert a DWARF attribute code into its string name. */
5020 dwarf_attr_name (register unsigned attr
)
5025 return "DW_AT_sibling";
5026 case DW_AT_location
:
5027 return "DW_AT_location";
5029 return "DW_AT_name";
5030 case DW_AT_ordering
:
5031 return "DW_AT_ordering";
5032 case DW_AT_subscr_data
:
5033 return "DW_AT_subscr_data";
5034 case DW_AT_byte_size
:
5035 return "DW_AT_byte_size";
5036 case DW_AT_bit_offset
:
5037 return "DW_AT_bit_offset";
5038 case DW_AT_bit_size
:
5039 return "DW_AT_bit_size";
5040 case DW_AT_element_list
:
5041 return "DW_AT_element_list";
5042 case DW_AT_stmt_list
:
5043 return "DW_AT_stmt_list";
5045 return "DW_AT_low_pc";
5047 return "DW_AT_high_pc";
5048 case DW_AT_language
:
5049 return "DW_AT_language";
5051 return "DW_AT_member";
5053 return "DW_AT_discr";
5054 case DW_AT_discr_value
:
5055 return "DW_AT_discr_value";
5056 case DW_AT_visibility
:
5057 return "DW_AT_visibility";
5059 return "DW_AT_import";
5060 case DW_AT_string_length
:
5061 return "DW_AT_string_length";
5062 case DW_AT_common_reference
:
5063 return "DW_AT_common_reference";
5064 case DW_AT_comp_dir
:
5065 return "DW_AT_comp_dir";
5066 case DW_AT_const_value
:
5067 return "DW_AT_const_value";
5068 case DW_AT_containing_type
:
5069 return "DW_AT_containing_type";
5070 case DW_AT_default_value
:
5071 return "DW_AT_default_value";
5073 return "DW_AT_inline";
5074 case DW_AT_is_optional
:
5075 return "DW_AT_is_optional";
5076 case DW_AT_lower_bound
:
5077 return "DW_AT_lower_bound";
5078 case DW_AT_producer
:
5079 return "DW_AT_producer";
5080 case DW_AT_prototyped
:
5081 return "DW_AT_prototyped";
5082 case DW_AT_return_addr
:
5083 return "DW_AT_return_addr";
5084 case DW_AT_start_scope
:
5085 return "DW_AT_start_scope";
5086 case DW_AT_stride_size
:
5087 return "DW_AT_stride_size";
5088 case DW_AT_upper_bound
:
5089 return "DW_AT_upper_bound";
5090 case DW_AT_abstract_origin
:
5091 return "DW_AT_abstract_origin";
5092 case DW_AT_accessibility
:
5093 return "DW_AT_accessibility";
5094 case DW_AT_address_class
:
5095 return "DW_AT_address_class";
5096 case DW_AT_artificial
:
5097 return "DW_AT_artificial";
5098 case DW_AT_base_types
:
5099 return "DW_AT_base_types";
5100 case DW_AT_calling_convention
:
5101 return "DW_AT_calling_convention";
5103 return "DW_AT_count";
5104 case DW_AT_data_member_location
:
5105 return "DW_AT_data_member_location";
5106 case DW_AT_decl_column
:
5107 return "DW_AT_decl_column";
5108 case DW_AT_decl_file
:
5109 return "DW_AT_decl_file";
5110 case DW_AT_decl_line
:
5111 return "DW_AT_decl_line";
5112 case DW_AT_declaration
:
5113 return "DW_AT_declaration";
5114 case DW_AT_discr_list
:
5115 return "DW_AT_discr_list";
5116 case DW_AT_encoding
:
5117 return "DW_AT_encoding";
5118 case DW_AT_external
:
5119 return "DW_AT_external";
5120 case DW_AT_frame_base
:
5121 return "DW_AT_frame_base";
5123 return "DW_AT_friend";
5124 case DW_AT_identifier_case
:
5125 return "DW_AT_identifier_case";
5126 case DW_AT_macro_info
:
5127 return "DW_AT_macro_info";
5128 case DW_AT_namelist_items
:
5129 return "DW_AT_namelist_items";
5130 case DW_AT_priority
:
5131 return "DW_AT_priority";
5133 return "DW_AT_segment";
5134 case DW_AT_specification
:
5135 return "DW_AT_specification";
5136 case DW_AT_static_link
:
5137 return "DW_AT_static_link";
5139 return "DW_AT_type";
5140 case DW_AT_use_location
:
5141 return "DW_AT_use_location";
5142 case DW_AT_variable_parameter
:
5143 return "DW_AT_variable_parameter";
5144 case DW_AT_virtuality
:
5145 return "DW_AT_virtuality";
5146 case DW_AT_vtable_elem_location
:
5147 return "DW_AT_vtable_elem_location";
5150 case DW_AT_MIPS_fde
:
5151 return "DW_AT_MIPS_fde";
5152 case DW_AT_MIPS_loop_begin
:
5153 return "DW_AT_MIPS_loop_begin";
5154 case DW_AT_MIPS_tail_loop_begin
:
5155 return "DW_AT_MIPS_tail_loop_begin";
5156 case DW_AT_MIPS_epilog_begin
:
5157 return "DW_AT_MIPS_epilog_begin";
5158 case DW_AT_MIPS_loop_unroll_factor
:
5159 return "DW_AT_MIPS_loop_unroll_factor";
5160 case DW_AT_MIPS_software_pipeline_depth
:
5161 return "DW_AT_MIPS_software_pipeline_depth";
5162 case DW_AT_MIPS_linkage_name
:
5163 return "DW_AT_MIPS_linkage_name";
5166 case DW_AT_sf_names
:
5167 return "DW_AT_sf_names";
5168 case DW_AT_src_info
:
5169 return "DW_AT_src_info";
5170 case DW_AT_mac_info
:
5171 return "DW_AT_mac_info";
5172 case DW_AT_src_coords
:
5173 return "DW_AT_src_coords";
5174 case DW_AT_body_begin
:
5175 return "DW_AT_body_begin";
5176 case DW_AT_body_end
:
5177 return "DW_AT_body_end";
5179 return "DW_AT_<unknown>";
5183 /* Convert a DWARF value form code into its string name. */
5186 dwarf_form_name (register unsigned form
)
5191 return "DW_FORM_addr";
5192 case DW_FORM_block2
:
5193 return "DW_FORM_block2";
5194 case DW_FORM_block4
:
5195 return "DW_FORM_block4";
5197 return "DW_FORM_data2";
5199 return "DW_FORM_data4";
5201 return "DW_FORM_data8";
5202 case DW_FORM_string
:
5203 return "DW_FORM_string";
5205 return "DW_FORM_block";
5206 case DW_FORM_block1
:
5207 return "DW_FORM_block1";
5209 return "DW_FORM_data1";
5211 return "DW_FORM_flag";
5213 return "DW_FORM_sdata";
5215 return "DW_FORM_strp";
5217 return "DW_FORM_udata";
5218 case DW_FORM_ref_addr
:
5219 return "DW_FORM_ref_addr";
5221 return "DW_FORM_ref1";
5223 return "DW_FORM_ref2";
5225 return "DW_FORM_ref4";
5227 return "DW_FORM_ref8";
5228 case DW_FORM_ref_udata
:
5229 return "DW_FORM_ref_udata";
5230 case DW_FORM_indirect
:
5231 return "DW_FORM_indirect";
5233 return "DW_FORM_<unknown>";
5237 /* Convert a DWARF stack opcode into its string name. */
5240 dwarf_stack_op_name (register unsigned op
)
5245 return "DW_OP_addr";
5247 return "DW_OP_deref";
5249 return "DW_OP_const1u";
5251 return "DW_OP_const1s";
5253 return "DW_OP_const2u";
5255 return "DW_OP_const2s";
5257 return "DW_OP_const4u";
5259 return "DW_OP_const4s";
5261 return "DW_OP_const8u";
5263 return "DW_OP_const8s";
5265 return "DW_OP_constu";
5267 return "DW_OP_consts";
5271 return "DW_OP_drop";
5273 return "DW_OP_over";
5275 return "DW_OP_pick";
5277 return "DW_OP_swap";
5281 return "DW_OP_xderef";
5289 return "DW_OP_minus";
5301 return "DW_OP_plus";
5302 case DW_OP_plus_uconst
:
5303 return "DW_OP_plus_uconst";
5309 return "DW_OP_shra";
5327 return "DW_OP_skip";
5329 return "DW_OP_lit0";
5331 return "DW_OP_lit1";
5333 return "DW_OP_lit2";
5335 return "DW_OP_lit3";
5337 return "DW_OP_lit4";
5339 return "DW_OP_lit5";
5341 return "DW_OP_lit6";
5343 return "DW_OP_lit7";
5345 return "DW_OP_lit8";
5347 return "DW_OP_lit9";
5349 return "DW_OP_lit10";
5351 return "DW_OP_lit11";
5353 return "DW_OP_lit12";
5355 return "DW_OP_lit13";
5357 return "DW_OP_lit14";
5359 return "DW_OP_lit15";
5361 return "DW_OP_lit16";
5363 return "DW_OP_lit17";
5365 return "DW_OP_lit18";
5367 return "DW_OP_lit19";
5369 return "DW_OP_lit20";
5371 return "DW_OP_lit21";
5373 return "DW_OP_lit22";
5375 return "DW_OP_lit23";
5377 return "DW_OP_lit24";
5379 return "DW_OP_lit25";
5381 return "DW_OP_lit26";
5383 return "DW_OP_lit27";
5385 return "DW_OP_lit28";
5387 return "DW_OP_lit29";
5389 return "DW_OP_lit30";
5391 return "DW_OP_lit31";
5393 return "DW_OP_reg0";
5395 return "DW_OP_reg1";
5397 return "DW_OP_reg2";
5399 return "DW_OP_reg3";
5401 return "DW_OP_reg4";
5403 return "DW_OP_reg5";
5405 return "DW_OP_reg6";
5407 return "DW_OP_reg7";
5409 return "DW_OP_reg8";
5411 return "DW_OP_reg9";
5413 return "DW_OP_reg10";
5415 return "DW_OP_reg11";
5417 return "DW_OP_reg12";
5419 return "DW_OP_reg13";
5421 return "DW_OP_reg14";
5423 return "DW_OP_reg15";
5425 return "DW_OP_reg16";
5427 return "DW_OP_reg17";
5429 return "DW_OP_reg18";
5431 return "DW_OP_reg19";
5433 return "DW_OP_reg20";
5435 return "DW_OP_reg21";
5437 return "DW_OP_reg22";
5439 return "DW_OP_reg23";
5441 return "DW_OP_reg24";
5443 return "DW_OP_reg25";
5445 return "DW_OP_reg26";
5447 return "DW_OP_reg27";
5449 return "DW_OP_reg28";
5451 return "DW_OP_reg29";
5453 return "DW_OP_reg30";
5455 return "DW_OP_reg31";
5457 return "DW_OP_breg0";
5459 return "DW_OP_breg1";
5461 return "DW_OP_breg2";
5463 return "DW_OP_breg3";
5465 return "DW_OP_breg4";
5467 return "DW_OP_breg5";
5469 return "DW_OP_breg6";
5471 return "DW_OP_breg7";
5473 return "DW_OP_breg8";
5475 return "DW_OP_breg9";
5477 return "DW_OP_breg10";
5479 return "DW_OP_breg11";
5481 return "DW_OP_breg12";
5483 return "DW_OP_breg13";
5485 return "DW_OP_breg14";
5487 return "DW_OP_breg15";
5489 return "DW_OP_breg16";
5491 return "DW_OP_breg17";
5493 return "DW_OP_breg18";
5495 return "DW_OP_breg19";
5497 return "DW_OP_breg20";
5499 return "DW_OP_breg21";
5501 return "DW_OP_breg22";
5503 return "DW_OP_breg23";
5505 return "DW_OP_breg24";
5507 return "DW_OP_breg25";
5509 return "DW_OP_breg26";
5511 return "DW_OP_breg27";
5513 return "DW_OP_breg28";
5515 return "DW_OP_breg29";
5517 return "DW_OP_breg30";
5519 return "DW_OP_breg31";
5521 return "DW_OP_regx";
5523 return "DW_OP_fbreg";
5525 return "DW_OP_bregx";
5527 return "DW_OP_piece";
5528 case DW_OP_deref_size
:
5529 return "DW_OP_deref_size";
5530 case DW_OP_xderef_size
:
5531 return "DW_OP_xderef_size";
5535 return "OP_<unknown>";
5540 dwarf_bool_name (unsigned mybool
)
5548 /* Convert a DWARF type code into its string name. */
5551 dwarf_type_encoding_name (register unsigned enc
)
5555 case DW_ATE_address
:
5556 return "DW_ATE_address";
5557 case DW_ATE_boolean
:
5558 return "DW_ATE_boolean";
5559 case DW_ATE_complex_float
:
5560 return "DW_ATE_complex_float";
5562 return "DW_ATE_float";
5564 return "DW_ATE_signed";
5565 case DW_ATE_signed_char
:
5566 return "DW_ATE_signed_char";
5567 case DW_ATE_unsigned
:
5568 return "DW_ATE_unsigned";
5569 case DW_ATE_unsigned_char
:
5570 return "DW_ATE_unsigned_char";
5572 return "DW_ATE_<unknown>";
5576 /* Convert a DWARF call frame info operation to its string name. */
5580 dwarf_cfi_name (register unsigned cfi_opc
)
5584 case DW_CFA_advance_loc
:
5585 return "DW_CFA_advance_loc";
5587 return "DW_CFA_offset";
5588 case DW_CFA_restore
:
5589 return "DW_CFA_restore";
5591 return "DW_CFA_nop";
5592 case DW_CFA_set_loc
:
5593 return "DW_CFA_set_loc";
5594 case DW_CFA_advance_loc1
:
5595 return "DW_CFA_advance_loc1";
5596 case DW_CFA_advance_loc2
:
5597 return "DW_CFA_advance_loc2";
5598 case DW_CFA_advance_loc4
:
5599 return "DW_CFA_advance_loc4";
5600 case DW_CFA_offset_extended
:
5601 return "DW_CFA_offset_extended";
5602 case DW_CFA_restore_extended
:
5603 return "DW_CFA_restore_extended";
5604 case DW_CFA_undefined
:
5605 return "DW_CFA_undefined";
5606 case DW_CFA_same_value
:
5607 return "DW_CFA_same_value";
5608 case DW_CFA_register
:
5609 return "DW_CFA_register";
5610 case DW_CFA_remember_state
:
5611 return "DW_CFA_remember_state";
5612 case DW_CFA_restore_state
:
5613 return "DW_CFA_restore_state";
5614 case DW_CFA_def_cfa
:
5615 return "DW_CFA_def_cfa";
5616 case DW_CFA_def_cfa_register
:
5617 return "DW_CFA_def_cfa_register";
5618 case DW_CFA_def_cfa_offset
:
5619 return "DW_CFA_def_cfa_offset";
5622 case DW_CFA_def_cfa_expression
:
5623 return "DW_CFA_def_cfa_expression";
5624 case DW_CFA_expression
:
5625 return "DW_CFA_expression";
5626 case DW_CFA_offset_extended_sf
:
5627 return "DW_CFA_offset_extended_sf";
5628 case DW_CFA_def_cfa_sf
:
5629 return "DW_CFA_def_cfa_sf";
5630 case DW_CFA_def_cfa_offset_sf
:
5631 return "DW_CFA_def_cfa_offset_sf";
5633 /* SGI/MIPS specific */
5634 case DW_CFA_MIPS_advance_loc8
:
5635 return "DW_CFA_MIPS_advance_loc8";
5637 /* GNU extensions */
5638 case DW_CFA_GNU_window_save
:
5639 return "DW_CFA_GNU_window_save";
5640 case DW_CFA_GNU_args_size
:
5641 return "DW_CFA_GNU_args_size";
5642 case DW_CFA_GNU_negative_offset_extended
:
5643 return "DW_CFA_GNU_negative_offset_extended";
5646 return "DW_CFA_<unknown>";
5652 dump_die (struct die_info
*die
)
5656 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
5657 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
5658 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
5659 dwarf_bool_name (die
->has_children
));
5661 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
5662 for (i
= 0; i
< die
->num_attrs
; ++i
)
5664 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
5665 dwarf_attr_name (die
->attrs
[i
].name
),
5666 dwarf_form_name (die
->attrs
[i
].form
));
5667 switch (die
->attrs
[i
].form
)
5669 case DW_FORM_ref_addr
:
5671 fprintf_unfiltered (gdb_stderr
, "address: ");
5672 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
5674 case DW_FORM_block2
:
5675 case DW_FORM_block4
:
5677 case DW_FORM_block1
:
5678 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
5689 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
5691 case DW_FORM_string
:
5693 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
5694 DW_STRING (&die
->attrs
[i
])
5695 ? DW_STRING (&die
->attrs
[i
]) : "");
5698 if (DW_UNSND (&die
->attrs
[i
]))
5699 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
5701 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
5703 case DW_FORM_indirect
:
5704 /* the reader will have reduced the indirect form to
5705 the "base form" so this form should not occur */
5706 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
5709 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
5710 die
->attrs
[i
].form
);
5712 fprintf_unfiltered (gdb_stderr
, "\n");
5717 dump_die_list (struct die_info
*die
)
5727 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
5730 struct die_info
*old
;
5732 h
= (offset
% REF_HASH_SIZE
);
5733 old
= die_ref_table
[h
];
5734 die
->next_ref
= old
;
5735 die_ref_table
[h
] = die
;
5740 dwarf2_empty_hash_tables (void)
5742 memset (die_ref_table
, 0, sizeof (die_ref_table
));
5746 dwarf2_get_ref_die_offset (struct attribute
*attr
)
5748 unsigned int result
= 0;
5752 case DW_FORM_ref_addr
:
5753 result
= DW_ADDR (attr
);
5759 case DW_FORM_ref_udata
:
5760 result
= cu_header_offset
+ DW_UNSND (attr
);
5763 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
5768 static struct die_info
*
5769 follow_die_ref (unsigned int offset
)
5771 struct die_info
*die
;
5774 h
= (offset
% REF_HASH_SIZE
);
5775 die
= die_ref_table
[h
];
5778 if (die
->offset
== offset
)
5782 die
= die
->next_ref
;
5787 static struct type
*
5788 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
5790 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
5792 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
5796 /* Look for this particular type in the fundamental type vector. If
5797 one is not found, create and install one appropriate for the
5798 current language and the current target machine. */
5800 if (ftypes
[typeid] == NULL
)
5802 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
5805 return (ftypes
[typeid]);
5808 /* Decode simple location descriptions.
5809 Given a pointer to a dwarf block that defines a location, compute
5810 the location and return the value.
5812 FIXME: This is a kludge until we figure out a better
5813 way to handle the location descriptions.
5814 Gdb's design does not mesh well with the DWARF2 notion of a location
5815 computing interpreter, which is a shame because the flexibility goes unused.
5816 FIXME: Implement more operations as necessary.
5818 A location description containing no operations indicates that the
5819 object is optimized out. The global optimized_out flag is set for
5820 those, the return value is meaningless.
5822 When the result is a register number, the global isreg flag is set,
5823 otherwise it is cleared.
5825 When the result is a base register offset, the global offreg flag is set
5826 and the register number is returned in basereg, otherwise it is cleared.
5828 When the DW_OP_fbreg operation is encountered without a corresponding
5829 DW_AT_frame_base attribute, the global islocal flag is set.
5830 Hopefully the machine dependent code knows how to set up a virtual
5831 frame pointer for the local references.
5833 Note that stack[0] is unused except as a default error return.
5834 Note that stack overflow is not yet handled. */
5837 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
5838 const struct comp_unit_head
*cu_header
)
5841 int size
= blk
->size
;
5842 char *data
= blk
->data
;
5843 CORE_ADDR stack
[64];
5845 unsigned int bytes_read
, unsnd
;
5895 stack
[++stacki
] = op
- DW_OP_lit0
;
5931 stack
[++stacki
] = op
- DW_OP_reg0
;
5936 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
5938 #if defined(HARRIS_TARGET) && defined(_M88K)
5939 /* The Harris 88110 gdb ports have long kept their special reg
5940 numbers between their gp-regs and their x-regs. This is
5941 not how our dwarf is generated. Punt. */
5944 stack
[++stacki
] = unsnd
;
5980 basereg
= op
- DW_OP_breg0
;
5981 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5987 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
5989 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5994 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5996 if (frame_base_reg
>= 0)
5999 basereg
= frame_base_reg
;
6000 stack
[stacki
] += frame_base_offset
;
6004 complain (&dwarf2_missing_at_frame_base
);
6010 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
6011 cu_header
, &bytes_read
);
6016 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
6021 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
6026 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
6031 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
6036 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
6041 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
6046 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
6052 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6057 stack
[stacki
+ 1] = stack
[stacki
];
6062 stack
[stacki
- 1] += stack
[stacki
];
6066 case DW_OP_plus_uconst
:
6067 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6072 stack
[stacki
- 1] -= stack
[stacki
];
6078 /* If we're not the last op, then we definitely can't encode
6079 this using GDB's address_class enum. */
6081 complain (&dwarf2_complex_location_expr
);
6085 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name (op
));
6086 return (stack
[stacki
]);
6089 return (stack
[stacki
]);
6092 /* memory allocation interface */
6096 dwarf2_free_tmp_obstack (PTR ignore
)
6098 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6101 static struct dwarf_block
*
6102 dwarf_alloc_block (void)
6104 struct dwarf_block
*blk
;
6106 blk
= (struct dwarf_block
*)
6107 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6111 static struct abbrev_info
*
6112 dwarf_alloc_abbrev (void)
6114 struct abbrev_info
*abbrev
;
6116 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6117 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6121 static struct die_info
*
6122 dwarf_alloc_die (void)
6124 struct die_info
*die
;
6126 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6127 memset (die
, 0, sizeof (struct die_info
));