1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
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 /* Dwarf2 has no clean way to discern C++ static and non-static member
478 functions. G++ helps GDB by marking the first parameter for non-static
479 member functions (which is the this pointer) as artificial.
480 We pass this information between dwarf2_add_member_fn and
481 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
482 #define TYPE_FIELD_ARTIFICIAL TYPE_FIELD_BITPOS
484 /* Various complaints about symbol reading that don't abort the process */
486 static struct complaint dwarf2_const_ignored
=
488 "type qualifier 'const' ignored", 0, 0
490 static struct complaint dwarf2_volatile_ignored
=
492 "type qualifier 'volatile' ignored", 0, 0
494 static struct complaint dwarf2_non_const_array_bound_ignored
=
496 "non-constant array bounds form '%s' ignored", 0, 0
498 static struct complaint dwarf2_missing_line_number_section
=
500 "missing .debug_line section", 0, 0
502 static struct complaint dwarf2_mangled_line_number_section
=
504 "mangled .debug_line section", 0, 0
506 static struct complaint dwarf2_unsupported_die_ref_attr
=
508 "unsupported die ref attribute form: '%s'", 0, 0
510 static struct complaint dwarf2_unsupported_stack_op
=
512 "unsupported stack op: '%s'", 0, 0
514 static struct complaint dwarf2_complex_location_expr
=
516 "location expression too complex", 0, 0
518 static struct complaint dwarf2_unsupported_tag
=
520 "unsupported tag: '%s'", 0, 0
522 static struct complaint dwarf2_unsupported_at_encoding
=
524 "unsupported DW_AT_encoding: '%s'", 0, 0
526 static struct complaint dwarf2_unsupported_at_frame_base
=
528 "unsupported DW_AT_frame_base for function '%s'", 0, 0
530 static struct complaint dwarf2_unexpected_tag
=
532 "unexepected tag in read_type_die: '%s'", 0, 0
534 static struct complaint dwarf2_missing_at_frame_base
=
536 "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
538 static struct complaint dwarf2_bad_static_member_name
=
540 "unrecognized static data member name '%s'", 0, 0
542 static struct complaint dwarf2_unsupported_accessibility
=
544 "unsupported accessibility %d", 0, 0
546 static struct complaint dwarf2_bad_member_name_complaint
=
548 "cannot extract member name from '%s'", 0, 0
550 static struct complaint dwarf2_missing_member_fn_type_complaint
=
552 "member function type missing for '%s'", 0, 0
554 static struct complaint dwarf2_vtbl_not_found_complaint
=
556 "virtual function table pointer not found when defining class '%s'", 0, 0
558 static struct complaint dwarf2_absolute_sibling_complaint
=
560 "ignoring absolute DW_AT_sibling", 0, 0
562 static struct complaint dwarf2_const_value_length_mismatch
=
564 "const value length mismatch for '%s', got %d, expected %d", 0, 0
566 static struct complaint dwarf2_unsupported_const_value_attr
=
568 "unsupported const value attribute form: '%s'", 0, 0
571 /* local function prototypes */
573 static void dwarf2_locate_sections (bfd
*, asection
*, PTR
);
576 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
579 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
581 static char *scan_partial_symbols (char *, struct objfile
*,
582 CORE_ADDR
*, CORE_ADDR
*,
583 const struct comp_unit_head
*);
585 static void add_partial_symbol (struct partial_die_info
*, struct objfile
*,
586 const struct comp_unit_head
*);
588 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
590 static void psymtab_to_symtab_1 (struct partial_symtab
*);
592 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int);
594 static void dwarf2_read_abbrevs (bfd
*, unsigned int);
596 static void dwarf2_empty_abbrev_table (PTR
);
598 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int);
600 static char *read_partial_die (struct partial_die_info
*,
602 const struct comp_unit_head
*);
604 static char *read_full_die (struct die_info
**, bfd
*, char *,
605 const struct comp_unit_head
*);
607 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
608 bfd
*, char *, const struct comp_unit_head
*);
610 static char *read_attribute_value (struct attribute
*, unsigned,
611 bfd
*, char *, const struct comp_unit_head
*);
613 static unsigned int read_1_byte (bfd
*, char *);
615 static int read_1_signed_byte (bfd
*, char *);
617 static unsigned int read_2_bytes (bfd
*, char *);
619 static unsigned int read_4_bytes (bfd
*, char *);
621 static unsigned long read_8_bytes (bfd
*, char *);
623 static CORE_ADDR
read_address (bfd
*, char *ptr
, const struct comp_unit_head
*,
626 static LONGEST
read_initial_length (bfd
*, char *,
627 struct comp_unit_head
*, int *bytes_read
);
629 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
632 static char *read_n_bytes (bfd
*, char *, unsigned int);
634 static char *read_string (bfd
*, char *, unsigned int *);
636 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
639 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
641 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
643 static void set_cu_language (unsigned int);
645 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
647 static int die_is_declaration (struct die_info
*);
649 static void dwarf_decode_lines (unsigned int, char *, bfd
*,
650 const struct comp_unit_head
*);
652 static void dwarf2_start_subfile (char *, char *);
654 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
655 struct objfile
*, const struct comp_unit_head
*);
657 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
658 struct objfile
*, const struct comp_unit_head
*);
660 static void dwarf2_const_value_data (struct attribute
*attr
,
664 static struct type
*die_type (struct die_info
*, struct objfile
*,
665 const struct comp_unit_head
*);
667 static struct type
*die_containing_type (struct die_info
*, struct objfile
*,
668 const struct comp_unit_head
*);
671 static struct type
*type_at_offset (unsigned int, struct objfile
*);
674 static struct type
*tag_type_to_type (struct die_info
*, struct objfile
*,
675 const struct comp_unit_head
*);
677 static void read_type_die (struct die_info
*, struct objfile
*,
678 const struct comp_unit_head
*);
680 static void read_typedef (struct die_info
*, struct objfile
*,
681 const struct comp_unit_head
*);
683 static void read_base_type (struct die_info
*, struct objfile
*);
685 static void read_file_scope (struct die_info
*, struct objfile
*,
686 const struct comp_unit_head
*);
688 static void read_func_scope (struct die_info
*, struct objfile
*,
689 const struct comp_unit_head
*);
691 static void read_lexical_block_scope (struct die_info
*, struct objfile
*,
692 const struct comp_unit_head
*);
694 static int dwarf2_get_pc_bounds (struct die_info
*,
695 CORE_ADDR
*, CORE_ADDR
*, struct objfile
*);
697 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
698 struct objfile
*, const struct comp_unit_head
*);
700 static void dwarf2_attach_fields_to_type (struct field_info
*,
701 struct type
*, struct objfile
*);
703 static void dwarf2_add_member_fn (struct field_info
*,
704 struct die_info
*, struct type
*,
705 struct objfile
*objfile
,
706 const struct comp_unit_head
*);
708 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
709 struct type
*, struct objfile
*);
711 static void read_structure_scope (struct die_info
*, struct objfile
*,
712 const struct comp_unit_head
*);
714 static void read_common_block (struct die_info
*, struct objfile
*,
715 const struct comp_unit_head
*);
717 static void read_enumeration (struct die_info
*, struct objfile
*,
718 const struct comp_unit_head
*);
720 static struct type
*dwarf_base_type (int, int, struct objfile
*);
722 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct objfile
*,
723 const struct comp_unit_head
*);
725 static void read_array_type (struct die_info
*, struct objfile
*,
726 const struct comp_unit_head
*);
728 static void read_tag_pointer_type (struct die_info
*, struct objfile
*,
729 const struct comp_unit_head
*);
731 static void read_tag_ptr_to_member_type (struct die_info
*, struct objfile
*,
732 const struct comp_unit_head
*);
734 static void read_tag_reference_type (struct die_info
*, struct objfile
*,
735 const struct comp_unit_head
*);
737 static void read_tag_const_type (struct die_info
*, struct objfile
*,
738 const struct comp_unit_head
*);
740 static void read_tag_volatile_type (struct die_info
*, struct objfile
*,
741 const struct comp_unit_head
*);
743 static void read_tag_string_type (struct die_info
*, struct objfile
*);
745 static void read_subroutine_type (struct die_info
*, struct objfile
*,
746 const struct comp_unit_head
*);
748 static struct die_info
*read_comp_unit (char *, bfd
*,
749 const struct comp_unit_head
*);
751 static void free_die_list (struct die_info
*);
753 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
755 static void process_die (struct die_info
*, struct objfile
*,
756 const struct comp_unit_head
*);
758 static char *dwarf2_linkage_name (struct die_info
*);
760 static char *dwarf_tag_name (unsigned int);
762 static char *dwarf_attr_name (unsigned int);
764 static char *dwarf_form_name (unsigned int);
766 static char *dwarf_stack_op_name (unsigned int);
768 static char *dwarf_bool_name (unsigned int);
770 static char *dwarf_type_encoding_name (unsigned int);
773 static char *dwarf_cfi_name (unsigned int);
775 struct die_info
*copy_die (struct die_info
*);
778 static struct die_info
*sibling_die (struct die_info
*);
780 static void dump_die (struct die_info
*);
782 static void dump_die_list (struct die_info
*);
784 static void store_in_ref_table (unsigned int, struct die_info
*);
786 static void dwarf2_empty_hash_tables (void);
788 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
790 static struct die_info
*follow_die_ref (unsigned int);
792 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
794 /* memory allocation interface */
796 static void dwarf2_free_tmp_obstack (PTR
);
798 static struct dwarf_block
*dwarf_alloc_block (void);
800 static struct abbrev_info
*dwarf_alloc_abbrev (void);
802 static struct die_info
*dwarf_alloc_die (void);
804 /* Try to locate the sections we need for DWARF 2 debugging
805 information and return true if we have enough to do something. */
808 dwarf2_has_info (bfd
*abfd
)
810 dwarf_info_offset
= dwarf_abbrev_offset
= dwarf_line_offset
= 0;
811 dwarf_str_offset
= 0;
812 dwarf_frame_offset
= dwarf_eh_frame_offset
= 0;
813 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
814 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
824 /* This function is mapped across the sections and remembers the
825 offset and size of each of the debugging sections we are interested
829 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, PTR ignore_ptr
)
831 if (STREQ (sectp
->name
, INFO_SECTION
))
833 dwarf_info_offset
= sectp
->filepos
;
834 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
836 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
838 dwarf_abbrev_offset
= sectp
->filepos
;
839 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
841 else if (STREQ (sectp
->name
, LINE_SECTION
))
843 dwarf_line_offset
= sectp
->filepos
;
844 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
846 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
848 dwarf_pubnames_offset
= sectp
->filepos
;
849 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
851 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
853 dwarf_aranges_offset
= sectp
->filepos
;
854 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
856 else if (STREQ (sectp
->name
, LOC_SECTION
))
858 dwarf_loc_offset
= sectp
->filepos
;
859 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
861 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
863 dwarf_macinfo_offset
= sectp
->filepos
;
864 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
866 else if (STREQ (sectp
->name
, STR_SECTION
))
868 dwarf_str_offset
= sectp
->filepos
;
869 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
871 else if (STREQ (sectp
->name
, FRAME_SECTION
))
873 dwarf_frame_offset
= sectp
->filepos
;
874 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
876 else if (STREQ (sectp
->name
, EH_FRAME_SECTION
))
878 dwarf_eh_frame_offset
= sectp
->filepos
;
879 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
883 /* Build a partial symbol table. */
886 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
889 /* We definitely need the .debug_info and .debug_abbrev sections */
891 dwarf_info_buffer
= dwarf2_read_section (objfile
,
894 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
897 dwarf_line_buffer
= dwarf2_read_section (objfile
,
901 if (dwarf_str_offset
)
902 dwarf_str_buffer
= dwarf2_read_section (objfile
,
906 dwarf_str_buffer
= NULL
;
909 || (objfile
->global_psymbols
.size
== 0
910 && objfile
->static_psymbols
.size
== 0))
912 init_psymbol_list (objfile
, 1024);
916 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
918 /* Things are significantly easier if we have .debug_aranges and
919 .debug_pubnames sections */
921 dwarf2_build_psymtabs_easy (objfile
, mainline
);
925 /* only test this case for now */
927 /* In this case we have to work a bit harder */
928 dwarf2_build_psymtabs_hard (objfile
, mainline
);
933 /* Build the partial symbol table from the information in the
934 .debug_pubnames and .debug_aranges sections. */
937 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
939 bfd
*abfd
= objfile
->obfd
;
940 char *aranges_buffer
, *pubnames_buffer
;
941 char *aranges_ptr
, *pubnames_ptr
;
942 unsigned int entry_length
, version
, info_offset
, info_size
;
944 pubnames_buffer
= dwarf2_read_section (objfile
,
945 dwarf_pubnames_offset
,
946 dwarf_pubnames_size
);
947 pubnames_ptr
= pubnames_buffer
;
948 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
950 struct comp_unit_head cu_header
;
953 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
955 pubnames_ptr
+= bytes_read
;
956 version
= read_1_byte (abfd
, pubnames_ptr
);
958 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
960 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
964 aranges_buffer
= dwarf2_read_section (objfile
,
965 dwarf_aranges_offset
,
971 /* Read in the comp unit header information from the debug_info at
975 read_comp_unit_head (struct comp_unit_head
*cu_header
,
976 char *info_ptr
, bfd
*abfd
)
980 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
982 info_ptr
+= bytes_read
;
983 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
985 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
987 info_ptr
+= bytes_read
;
988 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
990 signed_addr
= bfd_get_sign_extend_vma (abfd
);
992 internal_error (__FILE__
, __LINE__
,
993 "read_comp_unit_head: dwarf from non elf file");
994 cu_header
->signed_addr_p
= signed_addr
;
998 /* Build the partial symbol table by doing a quick pass through the
999 .debug_info and .debug_abbrev sections. */
1002 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1004 /* Instead of reading this into a big buffer, we should probably use
1005 mmap() on architectures that support it. (FIXME) */
1006 bfd
*abfd
= objfile
->obfd
;
1007 char *info_ptr
, *abbrev_ptr
;
1008 char *beg_of_comp_unit
;
1009 struct partial_die_info comp_unit_die
;
1010 struct partial_symtab
*pst
;
1011 struct cleanup
*back_to
;
1012 CORE_ADDR lowpc
, highpc
;
1014 info_ptr
= dwarf_info_buffer
;
1015 abbrev_ptr
= dwarf_abbrev_buffer
;
1017 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1018 the partial symbol scan, like attribute values.
1020 We could reduce our peak memory consumption during partial symbol
1021 table construction by freeing stuff from this obstack more often
1022 --- say, after processing each compilation unit, or each die ---
1023 but it turns out that this saves almost nothing. For an
1024 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1025 on dwarf2_tmp_obstack. Some investigation showed:
1027 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1028 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1029 all fixed-length values not requiring dynamic allocation.
1031 2) 30% of the attributes used the form DW_FORM_string. For
1032 DW_FORM_string, read_attribute simply hands back a pointer to
1033 the null-terminated string in dwarf_info_buffer, so no dynamic
1034 allocation is needed there either.
1036 3) The remaining 1% of the attributes all used DW_FORM_block1.
1037 75% of those were DW_AT_frame_base location lists for
1038 functions; the rest were DW_AT_location attributes, probably
1039 for the global variables.
1041 Anyway, what this all means is that the memory the dwarf2
1042 reader uses as temporary space reading partial symbols is about
1043 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1045 obstack_init (&dwarf2_tmp_obstack
);
1046 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1048 /* Since the objects we're extracting from dwarf_info_buffer vary in
1049 length, only the individual functions to extract them (like
1050 read_comp_unit_head and read_partial_die) can really know whether
1051 the buffer is large enough to hold another complete object.
1053 At the moment, they don't actually check that. If
1054 dwarf_info_buffer holds just one extra byte after the last
1055 compilation unit's dies, then read_comp_unit_head will happily
1056 read off the end of the buffer. read_partial_die is similarly
1057 casual. Those functions should be fixed.
1059 For this loop condition, simply checking whether there's any data
1060 left at all should be sufficient. */
1061 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1063 struct comp_unit_head cu_header
;
1064 beg_of_comp_unit
= info_ptr
;
1065 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1067 if (cu_header
.version
!= 2)
1069 error ("Dwarf Error: wrong version in compilation unit header.");
1072 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
1074 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6).",
1075 (long) cu_header
.abbrev_offset
,
1076 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1079 if (beg_of_comp_unit
+ cu_header
.length
+ cu_header
.initial_length_size
1080 > dwarf_info_buffer
+ dwarf_info_size
)
1082 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0).",
1083 (long) cu_header
.length
,
1084 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1087 /* Read the abbrevs for this compilation unit into a table */
1088 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1089 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1091 /* Read the compilation unit die */
1092 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1095 /* Set the language we're debugging */
1096 set_cu_language (comp_unit_die
.language
);
1098 /* Allocate a new partial symbol table structure */
1099 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1100 comp_unit_die
.name
? comp_unit_die
.name
: "",
1101 comp_unit_die
.lowpc
,
1102 objfile
->global_psymbols
.next
,
1103 objfile
->static_psymbols
.next
);
1105 pst
->read_symtab_private
= (char *)
1106 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1107 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1108 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1109 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1110 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1111 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1112 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1113 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1114 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1115 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1117 /* Store the function that reads in the rest of the symbol table */
1118 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1120 /* Check if comp unit has_children.
1121 If so, read the rest of the partial symbols from this comp unit.
1122 If not, there's no more debug_info for this comp unit. */
1123 if (comp_unit_die
.has_children
)
1125 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
,
1128 /* If the compilation unit didn't have an explicit address range,
1129 then use the information extracted from its child dies. */
1130 if (! comp_unit_die
.has_pc_info
)
1132 comp_unit_die
.lowpc
= lowpc
;
1133 comp_unit_die
.highpc
= highpc
;
1136 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1137 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1139 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1140 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1141 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1142 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1143 sort_pst_symbols (pst
);
1145 /* If there is already a psymtab or symtab for a file of this
1146 name, remove it. (If there is a symtab, more drastic things
1147 also happen.) This happens in VxWorks. */
1148 free_named_symtabs (pst
->filename
);
1150 info_ptr
= beg_of_comp_unit
+ cu_header
.length
1151 + cu_header
.initial_length_size
;
1153 do_cleanups (back_to
);
1156 /* Read in all interesting dies to the end of the compilation unit. */
1159 scan_partial_symbols (char *info_ptr
, struct objfile
*objfile
,
1160 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1161 const struct comp_unit_head
*cu_header
)
1163 bfd
*abfd
= objfile
->obfd
;
1164 struct partial_die_info pdi
;
1166 /* This function is called after we've read in the comp_unit_die in
1167 order to read its children. We start the nesting level at 1 since
1168 we have pushed 1 level down in order to read the comp unit's children.
1169 The comp unit itself is at level 0, so we stop reading when we pop
1170 back to that level. */
1172 int nesting_level
= 1;
1174 *lowpc
= ((CORE_ADDR
) -1);
1175 *highpc
= ((CORE_ADDR
) 0);
1177 while (nesting_level
)
1179 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1185 case DW_TAG_subprogram
:
1186 if (pdi
.has_pc_info
)
1188 if (pdi
.lowpc
< *lowpc
)
1192 if (pdi
.highpc
> *highpc
)
1194 *highpc
= pdi
.highpc
;
1196 if ((pdi
.is_external
|| nesting_level
== 1)
1197 && !pdi
.is_declaration
)
1199 add_partial_symbol (&pdi
, objfile
, cu_header
);
1203 case DW_TAG_variable
:
1204 case DW_TAG_typedef
:
1205 case DW_TAG_class_type
:
1206 case DW_TAG_structure_type
:
1207 case DW_TAG_union_type
:
1208 case DW_TAG_enumeration_type
:
1209 if ((pdi
.is_external
|| nesting_level
== 1)
1210 && !pdi
.is_declaration
)
1212 add_partial_symbol (&pdi
, objfile
, cu_header
);
1215 case DW_TAG_enumerator
:
1216 /* File scope enumerators are added to the partial symbol
1218 if (nesting_level
== 2)
1219 add_partial_symbol (&pdi
, objfile
, cu_header
);
1221 case DW_TAG_base_type
:
1222 /* File scope base type definitions are added to the partial
1224 if (nesting_level
== 1)
1225 add_partial_symbol (&pdi
, objfile
, cu_header
);
1232 /* If the die has a sibling, skip to the sibling.
1233 Do not skip enumeration types, we want to record their
1235 if (pdi
.sibling
&& pdi
.tag
!= DW_TAG_enumeration_type
)
1237 info_ptr
= pdi
.sibling
;
1239 else if (pdi
.has_children
)
1241 /* Die has children, but the optional DW_AT_sibling attribute
1252 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1253 from `maint check'. */
1254 if (*lowpc
== ((CORE_ADDR
) -1))
1260 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1261 const struct comp_unit_head
*cu_header
)
1267 case DW_TAG_subprogram
:
1268 if (pdi
->is_external
)
1270 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1271 mst_text, objfile); */
1272 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1273 VAR_NAMESPACE
, LOC_BLOCK
,
1274 &objfile
->global_psymbols
,
1275 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1279 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1280 mst_file_text, objfile); */
1281 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1282 VAR_NAMESPACE
, LOC_BLOCK
,
1283 &objfile
->static_psymbols
,
1284 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1287 case DW_TAG_variable
:
1288 if (pdi
->is_external
)
1291 Don't enter into the minimal symbol tables as there is
1292 a minimal symbol table entry from the ELF symbols already.
1293 Enter into partial symbol table if it has a location
1294 descriptor or a type.
1295 If the location descriptor is missing, new_symbol will create
1296 a LOC_UNRESOLVED symbol, the address of the variable will then
1297 be determined from the minimal symbol table whenever the variable
1299 The address for the partial symbol table entry is not
1300 used by GDB, but it comes in handy for debugging partial symbol
1304 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1305 if (pdi
->locdesc
|| pdi
->has_type
)
1306 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1307 VAR_NAMESPACE
, LOC_STATIC
,
1308 &objfile
->global_psymbols
,
1309 0, addr
+ baseaddr
, cu_language
, objfile
);
1313 /* Static Variable. Skip symbols without location descriptors. */
1314 if (pdi
->locdesc
== NULL
)
1316 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1317 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1318 mst_file_data, objfile); */
1319 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1320 VAR_NAMESPACE
, LOC_STATIC
,
1321 &objfile
->static_psymbols
,
1322 0, addr
+ baseaddr
, cu_language
, objfile
);
1325 case DW_TAG_typedef
:
1326 case DW_TAG_base_type
:
1327 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1328 VAR_NAMESPACE
, LOC_TYPEDEF
,
1329 &objfile
->static_psymbols
,
1330 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1332 case DW_TAG_class_type
:
1333 case DW_TAG_structure_type
:
1334 case DW_TAG_union_type
:
1335 case DW_TAG_enumeration_type
:
1336 /* Skip aggregate types without children, these are external
1338 if (pdi
->has_children
== 0)
1340 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1341 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1342 &objfile
->static_psymbols
,
1343 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1345 if (cu_language
== language_cplus
)
1347 /* For C++, these implicitly act as typedefs as well. */
1348 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1349 VAR_NAMESPACE
, LOC_TYPEDEF
,
1350 &objfile
->static_psymbols
,
1351 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1354 case DW_TAG_enumerator
:
1355 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1356 VAR_NAMESPACE
, LOC_CONST
,
1357 &objfile
->static_psymbols
,
1358 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1365 /* Expand this partial symbol table into a full symbol table. */
1368 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1370 /* FIXME: This is barely more than a stub. */
1375 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1381 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1382 gdb_flush (gdb_stdout
);
1385 psymtab_to_symtab_1 (pst
);
1387 /* Finish up the debug error message. */
1389 printf_filtered ("done.\n");
1395 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1397 struct objfile
*objfile
= pst
->objfile
;
1398 bfd
*abfd
= objfile
->obfd
;
1399 struct comp_unit_head cu_header
;
1400 struct die_info
*dies
;
1401 unsigned long offset
;
1402 CORE_ADDR lowpc
, highpc
;
1403 struct die_info
*child_die
;
1405 struct symtab
*symtab
;
1406 struct cleanup
*back_to
;
1408 /* Set local variables from the partial symbol table info. */
1409 offset
= DWARF_INFO_OFFSET (pst
);
1410 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1411 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1412 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1413 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1414 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1415 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1416 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1417 cu_header_offset
= offset
;
1418 info_ptr
= dwarf_info_buffer
+ offset
;
1420 obstack_init (&dwarf2_tmp_obstack
);
1421 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1424 make_cleanup (really_free_pendings
, NULL
);
1426 /* read in the comp_unit header */
1427 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1429 /* Read the abbrevs for this compilation unit */
1430 dwarf2_read_abbrevs (abfd
, cu_header
.abbrev_offset
);
1431 make_cleanup (dwarf2_empty_abbrev_table
, NULL
);
1433 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
1435 make_cleanup_free_die_list (dies
);
1437 /* Do line number decoding in read_file_scope () */
1438 process_die (dies
, objfile
, &cu_header
);
1440 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1442 /* Some compilers don't define a DW_AT_high_pc attribute for
1443 the compilation unit. If the DW_AT_high_pc is missing,
1444 synthesize it, by scanning the DIE's below the compilation unit. */
1446 if (dies
->has_children
)
1448 child_die
= dies
->next
;
1449 while (child_die
&& child_die
->tag
)
1451 if (child_die
->tag
== DW_TAG_subprogram
)
1453 CORE_ADDR low
, high
;
1455 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1457 highpc
= max (highpc
, high
);
1460 child_die
= sibling_die (child_die
);
1464 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1466 /* Set symtab language to language from DW_AT_language.
1467 If the compilation is from a C file generated by language preprocessors,
1468 do not set the language if it was already deduced by start_subfile. */
1470 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1472 symtab
->language
= cu_language
;
1474 pst
->symtab
= symtab
;
1476 sort_symtab_syms (pst
->symtab
);
1478 do_cleanups (back_to
);
1481 /* Process a die and its children. */
1484 process_die (struct die_info
*die
, struct objfile
*objfile
,
1485 const struct comp_unit_head
*cu_header
)
1489 case DW_TAG_padding
:
1491 case DW_TAG_compile_unit
:
1492 read_file_scope (die
, objfile
, cu_header
);
1494 case DW_TAG_subprogram
:
1495 read_subroutine_type (die
, objfile
, cu_header
);
1496 read_func_scope (die
, objfile
, cu_header
);
1498 case DW_TAG_inlined_subroutine
:
1499 /* FIXME: These are ignored for now.
1500 They could be used to set breakpoints on all inlined instances
1501 of a function and make GDB `next' properly over inlined functions. */
1503 case DW_TAG_lexical_block
:
1504 read_lexical_block_scope (die
, objfile
, cu_header
);
1506 case DW_TAG_class_type
:
1507 case DW_TAG_structure_type
:
1508 case DW_TAG_union_type
:
1509 read_structure_scope (die
, objfile
, cu_header
);
1511 case DW_TAG_enumeration_type
:
1512 read_enumeration (die
, objfile
, cu_header
);
1514 case DW_TAG_subroutine_type
:
1515 read_subroutine_type (die
, objfile
, cu_header
);
1517 case DW_TAG_array_type
:
1518 read_array_type (die
, objfile
, cu_header
);
1520 case DW_TAG_pointer_type
:
1521 read_tag_pointer_type (die
, objfile
, cu_header
);
1523 case DW_TAG_ptr_to_member_type
:
1524 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1526 case DW_TAG_reference_type
:
1527 read_tag_reference_type (die
, objfile
, cu_header
);
1529 case DW_TAG_string_type
:
1530 read_tag_string_type (die
, objfile
);
1532 case DW_TAG_base_type
:
1533 read_base_type (die
, objfile
);
1534 if (dwarf_attr (die
, DW_AT_name
))
1536 /* Add a typedef symbol for the base type definition. */
1537 new_symbol (die
, die
->type
, objfile
, cu_header
);
1540 case DW_TAG_common_block
:
1541 read_common_block (die
, objfile
, cu_header
);
1543 case DW_TAG_common_inclusion
:
1546 new_symbol (die
, NULL
, objfile
, cu_header
);
1552 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1553 const struct comp_unit_head
*cu_header
)
1555 unsigned int line_offset
= 0;
1556 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1557 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1558 struct attribute
*attr
;
1559 char *name
= "<unknown>";
1560 char *comp_dir
= NULL
;
1561 struct die_info
*child_die
;
1562 bfd
*abfd
= objfile
->obfd
;
1564 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1566 if (die
->has_children
)
1568 child_die
= die
->next
;
1569 while (child_die
&& child_die
->tag
)
1571 if (child_die
->tag
== DW_TAG_subprogram
)
1573 CORE_ADDR low
, high
;
1575 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1577 lowpc
= min (lowpc
, low
);
1578 highpc
= max (highpc
, high
);
1581 child_die
= sibling_die (child_die
);
1586 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1587 from finish_block. */
1588 if (lowpc
== ((CORE_ADDR
) -1))
1593 attr
= dwarf_attr (die
, DW_AT_name
);
1596 name
= DW_STRING (attr
);
1598 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1601 comp_dir
= DW_STRING (attr
);
1604 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1605 directory, get rid of it. */
1606 char *cp
= strchr (comp_dir
, ':');
1608 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1613 if (objfile
->ei
.entry_point
>= lowpc
&&
1614 objfile
->ei
.entry_point
< highpc
)
1616 objfile
->ei
.entry_file_lowpc
= lowpc
;
1617 objfile
->ei
.entry_file_highpc
= highpc
;
1620 attr
= dwarf_attr (die
, DW_AT_language
);
1623 set_cu_language (DW_UNSND (attr
));
1626 /* We assume that we're processing GCC output. */
1627 processing_gcc_compilation
= 2;
1629 /* FIXME:Do something here. */
1630 if (dip
->at_producer
!= NULL
)
1632 handle_producer (dip
->at_producer
);
1636 /* The compilation unit may be in a different language or objfile,
1637 zero out all remembered fundamental types. */
1638 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1640 start_symtab (name
, comp_dir
, lowpc
);
1641 record_debugformat ("DWARF 2");
1643 /* Decode line number information if present. */
1644 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1647 line_offset
= DW_UNSND (attr
);
1648 dwarf_decode_lines (line_offset
, comp_dir
, abfd
, cu_header
);
1651 /* Process all dies in compilation unit. */
1652 if (die
->has_children
)
1654 child_die
= die
->next
;
1655 while (child_die
&& child_die
->tag
)
1657 process_die (child_die
, objfile
, cu_header
);
1658 child_die
= sibling_die (child_die
);
1664 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
1665 const struct comp_unit_head
*cu_header
)
1667 register struct context_stack
*new;
1670 struct die_info
*child_die
;
1671 struct attribute
*attr
;
1674 name
= dwarf2_linkage_name (die
);
1676 /* Ignore functions with missing or empty names and functions with
1677 missing or invalid low and high pc attributes. */
1678 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1684 if (objfile
->ei
.entry_point
>= lowpc
&&
1685 objfile
->ei
.entry_point
< highpc
)
1687 objfile
->ei
.entry_func_lowpc
= lowpc
;
1688 objfile
->ei
.entry_func_highpc
= highpc
;
1691 /* Decode DW_AT_frame_base location descriptor if present, keep result
1692 for DW_OP_fbreg operands in decode_locdesc. */
1693 frame_base_reg
= -1;
1694 frame_base_offset
= 0;
1695 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1698 CORE_ADDR addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
1700 complain (&dwarf2_unsupported_at_frame_base
, name
);
1702 frame_base_reg
= addr
;
1705 frame_base_reg
= basereg
;
1706 frame_base_offset
= addr
;
1709 complain (&dwarf2_unsupported_at_frame_base
, name
);
1712 new = push_context (0, lowpc
);
1713 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
1714 list_in_scope
= &local_symbols
;
1716 if (die
->has_children
)
1718 child_die
= die
->next
;
1719 while (child_die
&& child_die
->tag
)
1721 process_die (child_die
, objfile
, cu_header
);
1722 child_die
= sibling_die (child_die
);
1726 new = pop_context ();
1727 /* Make a block for the local symbols within. */
1728 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1729 lowpc
, highpc
, objfile
);
1730 list_in_scope
= &file_symbols
;
1733 /* Process all the DIES contained within a lexical block scope. Start
1734 a new scope, process the dies, and then close the scope. */
1737 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
1738 const struct comp_unit_head
*cu_header
)
1740 register struct context_stack
*new;
1741 CORE_ADDR lowpc
, highpc
;
1742 struct die_info
*child_die
;
1744 /* Ignore blocks with missing or invalid low and high pc attributes. */
1745 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1750 push_context (0, lowpc
);
1751 if (die
->has_children
)
1753 child_die
= die
->next
;
1754 while (child_die
&& child_die
->tag
)
1756 process_die (child_die
, objfile
, cu_header
);
1757 child_die
= sibling_die (child_die
);
1760 new = pop_context ();
1762 if (local_symbols
!= NULL
)
1764 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
1767 local_symbols
= new->locals
;
1770 /* Get low and high pc attributes from a die.
1771 Return 1 if the attributes are present and valid, otherwise, return 0. */
1774 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1775 struct objfile
*objfile
)
1777 struct attribute
*attr
;
1781 attr
= dwarf_attr (die
, DW_AT_low_pc
);
1783 low
= DW_ADDR (attr
);
1786 attr
= dwarf_attr (die
, DW_AT_high_pc
);
1788 high
= DW_ADDR (attr
);
1795 /* When using the GNU linker, .gnu.linkonce. sections are used to
1796 eliminate duplicate copies of functions and vtables and such.
1797 The linker will arbitrarily choose one and discard the others.
1798 The AT_*_pc values for such functions refer to local labels in
1799 these sections. If the section from that file was discarded, the
1800 labels are not in the output, so the relocs get a value of 0.
1801 If this is a discarded function, mark the pc bounds as invalid,
1802 so that GDB will ignore it. */
1803 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
1811 /* Add an aggregate field to the field list. */
1814 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
1815 struct objfile
*objfile
,
1816 const struct comp_unit_head
*cu_header
)
1818 struct nextfield
*new_field
;
1819 struct attribute
*attr
;
1821 char *fieldname
= "";
1823 /* Allocate a new field list entry and link it in. */
1824 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
1825 make_cleanup (xfree
, new_field
);
1826 memset (new_field
, 0, sizeof (struct nextfield
));
1827 new_field
->next
= fip
->fields
;
1828 fip
->fields
= new_field
;
1831 /* Handle accessibility and virtuality of field.
1832 The default accessibility for members is public, the default
1833 accessibility for inheritance is private. */
1834 if (die
->tag
!= DW_TAG_inheritance
)
1835 new_field
->accessibility
= DW_ACCESS_public
;
1837 new_field
->accessibility
= DW_ACCESS_private
;
1838 new_field
->virtuality
= DW_VIRTUALITY_none
;
1840 attr
= dwarf_attr (die
, DW_AT_accessibility
);
1842 new_field
->accessibility
= DW_UNSND (attr
);
1843 if (new_field
->accessibility
!= DW_ACCESS_public
)
1844 fip
->non_public_fields
= 1;
1845 attr
= dwarf_attr (die
, DW_AT_virtuality
);
1847 new_field
->virtuality
= DW_UNSND (attr
);
1849 fp
= &new_field
->field
;
1850 if (die
->tag
== DW_TAG_member
)
1852 /* Get type of field. */
1853 fp
->type
= die_type (die
, objfile
, cu_header
);
1855 /* Get bit size of field (zero if none). */
1856 attr
= dwarf_attr (die
, DW_AT_bit_size
);
1859 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
1863 FIELD_BITSIZE (*fp
) = 0;
1866 /* Get bit offset of field. */
1867 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
1870 FIELD_BITPOS (*fp
) =
1871 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
1874 FIELD_BITPOS (*fp
) = 0;
1875 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
1878 if (BITS_BIG_ENDIAN
)
1880 /* For big endian bits, the DW_AT_bit_offset gives the
1881 additional bit offset from the MSB of the containing
1882 anonymous object to the MSB of the field. We don't
1883 have to do anything special since we don't need to
1884 know the size of the anonymous object. */
1885 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
1889 /* For little endian bits, compute the bit offset to the
1890 MSB of the anonymous object, subtract off the number of
1891 bits from the MSB of the field to the MSB of the
1892 object, and then subtract off the number of bits of
1893 the field itself. The result is the bit offset of
1894 the LSB of the field. */
1896 int bit_offset
= DW_UNSND (attr
);
1898 attr
= dwarf_attr (die
, DW_AT_byte_size
);
1901 /* The size of the anonymous object containing
1902 the bit field is explicit, so use the
1903 indicated size (in bytes). */
1904 anonymous_size
= DW_UNSND (attr
);
1908 /* The size of the anonymous object containing
1909 the bit field must be inferred from the type
1910 attribute of the data member containing the
1912 anonymous_size
= TYPE_LENGTH (fp
->type
);
1914 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
1915 - bit_offset
- FIELD_BITSIZE (*fp
);
1919 /* Get name of field. */
1920 attr
= dwarf_attr (die
, DW_AT_name
);
1921 if (attr
&& DW_STRING (attr
))
1922 fieldname
= DW_STRING (attr
);
1923 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
1924 &objfile
->type_obstack
);
1926 /* Change accessibility for artificial fields (e.g. virtual table
1927 pointer or virtual base class pointer) to private. */
1928 if (dwarf_attr (die
, DW_AT_artificial
))
1930 new_field
->accessibility
= DW_ACCESS_private
;
1931 fip
->non_public_fields
= 1;
1934 else if (die
->tag
== DW_TAG_variable
)
1938 /* C++ static member.
1939 Get name of field. */
1940 attr
= dwarf_attr (die
, DW_AT_name
);
1941 if (attr
&& DW_STRING (attr
))
1942 fieldname
= DW_STRING (attr
);
1946 /* Get physical name. */
1947 physname
= dwarf2_linkage_name (die
);
1949 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
1950 &objfile
->type_obstack
));
1951 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
1952 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
1953 &objfile
->type_obstack
);
1955 else if (die
->tag
== DW_TAG_inheritance
)
1957 /* C++ base class field. */
1958 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
1960 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
1962 FIELD_BITSIZE (*fp
) = 0;
1963 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
1964 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
1965 fip
->nbaseclasses
++;
1969 /* Create the vector of fields, and attach it to the type. */
1972 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
1973 struct objfile
*objfile
)
1975 int nfields
= fip
->nfields
;
1977 /* Record the field count, allocate space for the array of fields,
1978 and create blank accessibility bitfields if necessary. */
1979 TYPE_NFIELDS (type
) = nfields
;
1980 TYPE_FIELDS (type
) = (struct field
*)
1981 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1982 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
1984 if (fip
->non_public_fields
)
1986 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1988 TYPE_FIELD_PRIVATE_BITS (type
) =
1989 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1990 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
1992 TYPE_FIELD_PROTECTED_BITS (type
) =
1993 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1994 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
1996 TYPE_FIELD_IGNORE_BITS (type
) =
1997 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
1998 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2001 /* If the type has baseclasses, allocate and clear a bit vector for
2002 TYPE_FIELD_VIRTUAL_BITS. */
2003 if (fip
->nbaseclasses
)
2005 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2008 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2009 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2010 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2011 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2012 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2015 /* Copy the saved-up fields into the field vector. Start from the head
2016 of the list, adding to the tail of the field array, so that they end
2017 up in the same order in the array in which they were added to the list. */
2018 while (nfields
-- > 0)
2020 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2021 switch (fip
->fields
->accessibility
)
2023 case DW_ACCESS_private
:
2024 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2027 case DW_ACCESS_protected
:
2028 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2031 case DW_ACCESS_public
:
2035 /* Unknown accessibility. Complain and treat it as public. */
2037 complain (&dwarf2_unsupported_accessibility
,
2038 fip
->fields
->accessibility
);
2042 if (nfields
< fip
->nbaseclasses
)
2044 switch (fip
->fields
->virtuality
)
2046 case DW_VIRTUALITY_virtual
:
2047 case DW_VIRTUALITY_pure_virtual
:
2048 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2052 fip
->fields
= fip
->fields
->next
;
2056 /* Add a member function to the proper fieldlist. */
2059 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2060 struct type
*type
, struct objfile
*objfile
,
2061 const struct comp_unit_head
*cu_header
)
2063 struct attribute
*attr
;
2064 struct fnfieldlist
*flp
;
2066 struct fn_field
*fnp
;
2069 struct nextfnfield
*new_fnfield
;
2071 /* Get name of member function. */
2072 attr
= dwarf_attr (die
, DW_AT_name
);
2073 if (attr
&& DW_STRING (attr
))
2074 fieldname
= DW_STRING (attr
);
2078 /* Get the mangled name. */
2079 physname
= dwarf2_linkage_name (die
);
2081 /* Look up member function name in fieldlist. */
2082 for (i
= 0; i
< fip
->nfnfields
; i
++)
2084 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2088 /* Create new list element if necessary. */
2089 if (i
< fip
->nfnfields
)
2090 flp
= &fip
->fnfieldlists
[i
];
2093 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2095 fip
->fnfieldlists
= (struct fnfieldlist
*)
2096 xrealloc (fip
->fnfieldlists
,
2097 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2098 * sizeof (struct fnfieldlist
));
2099 if (fip
->nfnfields
== 0)
2100 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2102 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2103 flp
->name
= fieldname
;
2109 /* Create a new member function field and chain it to the field list
2111 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2112 make_cleanup (xfree
, new_fnfield
);
2113 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2114 new_fnfield
->next
= flp
->head
;
2115 flp
->head
= new_fnfield
;
2118 /* Fill in the member function field info. */
2119 fnp
= &new_fnfield
->fnfield
;
2120 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2121 &objfile
->type_obstack
);
2122 fnp
->type
= alloc_type (objfile
);
2123 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2125 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2126 struct type
**arg_types
;
2127 int nparams
= TYPE_NFIELDS (die
->type
);
2130 /* Copy argument types from the subroutine type. */
2131 arg_types
= (struct type
**)
2132 TYPE_ALLOC (fnp
->type
, (nparams
+ 1) * sizeof (struct type
*));
2133 for (iparams
= 0; iparams
< nparams
; iparams
++)
2134 arg_types
[iparams
] = TYPE_FIELD_TYPE (die
->type
, iparams
);
2136 /* Set last entry in argument type vector. */
2137 if (TYPE_VARARGS (die
->type
))
2138 arg_types
[nparams
] = NULL
;
2140 arg_types
[nparams
] = dwarf2_fundamental_type (objfile
, FT_VOID
);
2142 smash_to_method_type (fnp
->type
, type
, return_type
, arg_types
);
2144 /* Handle static member functions.
2145 Dwarf2 has no clean way to discern C++ static and non-static
2146 member functions. G++ helps GDB by marking the first
2147 parameter for non-static member functions (which is the
2148 this pointer) as artificial. We obtain this information
2149 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2150 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2151 fnp
->voffset
= VOFFSET_STATIC
;
2154 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2156 /* Get fcontext from DW_AT_containing_type if present. */
2157 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2158 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2160 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2161 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2163 /* Get accessibility. */
2164 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2167 switch (DW_UNSND (attr
))
2169 case DW_ACCESS_private
:
2170 fnp
->is_private
= 1;
2172 case DW_ACCESS_protected
:
2173 fnp
->is_protected
= 1;
2178 /* Get index in virtual function table if it is a virtual member function. */
2179 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2181 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2184 /* Create the vector of member function fields, and attach it to the type. */
2187 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2188 struct objfile
*objfile
)
2190 struct fnfieldlist
*flp
;
2191 int total_length
= 0;
2194 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2195 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2196 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2198 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2200 struct nextfnfield
*nfp
= flp
->head
;
2201 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2204 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2205 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2206 fn_flp
->fn_fields
= (struct fn_field
*)
2207 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2208 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2209 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2211 total_length
+= flp
->length
;
2214 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2215 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2218 /* Called when we find the DIE that starts a structure or union scope
2219 (definition) to process all dies that define the members of the
2222 NOTE: we need to call struct_type regardless of whether or not the
2223 DIE has an at_name attribute, since it might be an anonymous
2224 structure or union. This gets the type entered into our set of
2227 However, if the structure is incomplete (an opaque struct/union)
2228 then suppress creating a symbol table entry for it since gdb only
2229 wants to find the one with the complete definition. Note that if
2230 it is complete, we just call new_symbol, which does it's own
2231 checking about whether the struct/union is anonymous or not (and
2232 suppresses creating a symbol table entry itself). */
2235 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2236 const struct comp_unit_head
*cu_header
)
2239 struct attribute
*attr
;
2241 type
= alloc_type (objfile
);
2243 INIT_CPLUS_SPECIFIC (type
);
2244 attr
= dwarf_attr (die
, DW_AT_name
);
2245 if (attr
&& DW_STRING (attr
))
2247 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2248 strlen (DW_STRING (attr
)),
2249 &objfile
->type_obstack
);
2252 if (die
->tag
== DW_TAG_structure_type
)
2254 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2256 else if (die
->tag
== DW_TAG_union_type
)
2258 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2262 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2264 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2267 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2270 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2274 TYPE_LENGTH (type
) = 0;
2277 /* We need to add the type field to the die immediately so we don't
2278 infinitely recurse when dealing with pointers to the structure
2279 type within the structure itself. */
2282 if (die
->has_children
&& ! die_is_declaration (die
))
2284 struct field_info fi
;
2285 struct die_info
*child_die
;
2286 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2288 memset (&fi
, 0, sizeof (struct field_info
));
2290 child_die
= die
->next
;
2292 while (child_die
&& child_die
->tag
)
2294 if (child_die
->tag
== DW_TAG_member
)
2296 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2298 else if (child_die
->tag
== DW_TAG_variable
)
2300 /* C++ static member. */
2301 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2303 else if (child_die
->tag
== DW_TAG_subprogram
)
2305 /* C++ member function. */
2306 process_die (child_die
, objfile
, cu_header
);
2307 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2309 else if (child_die
->tag
== DW_TAG_inheritance
)
2311 /* C++ base class field. */
2312 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2316 process_die (child_die
, objfile
, cu_header
);
2318 child_die
= sibling_die (child_die
);
2321 /* Attach fields and member functions to the type. */
2323 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2326 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2328 /* Get the type which refers to the base class (possibly this
2329 class itself) which contains the vtable pointer for the current
2330 class from the DW_AT_containing_type attribute. */
2332 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2334 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2336 TYPE_VPTR_BASETYPE (type
) = t
;
2339 static const char vptr_name
[] =
2340 {'_', 'v', 'p', 't', 'r', '\0'};
2343 /* Our own class provides vtbl ptr. */
2344 for (i
= TYPE_NFIELDS (t
) - 1;
2345 i
>= TYPE_N_BASECLASSES (t
);
2348 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2350 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2351 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2353 TYPE_VPTR_FIELDNO (type
) = i
;
2358 /* Complain if virtual function table field not found. */
2359 if (i
< TYPE_N_BASECLASSES (t
))
2360 complain (&dwarf2_vtbl_not_found_complaint
,
2361 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2365 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2370 new_symbol (die
, type
, objfile
, cu_header
);
2372 do_cleanups (back_to
);
2376 /* No children, must be stub. */
2377 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2380 finish_cv_type (die
->type
);
2383 /* Given a pointer to a die which begins an enumeration, process all
2384 the dies that define the members of the enumeration.
2386 This will be much nicer in draft 6 of the DWARF spec when our
2387 members will be dies instead squished into the DW_AT_element_list
2390 NOTE: We reverse the order of the element list. */
2393 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2394 const struct comp_unit_head
*cu_header
)
2396 struct die_info
*child_die
;
2398 struct field
*fields
;
2399 struct attribute
*attr
;
2402 int unsigned_enum
= 1;
2404 type
= alloc_type (objfile
);
2406 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2407 attr
= dwarf_attr (die
, DW_AT_name
);
2408 if (attr
&& DW_STRING (attr
))
2410 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2411 strlen (DW_STRING (attr
)),
2412 &objfile
->type_obstack
);
2415 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2418 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2422 TYPE_LENGTH (type
) = 0;
2427 if (die
->has_children
)
2429 child_die
= die
->next
;
2430 while (child_die
&& child_die
->tag
)
2432 if (child_die
->tag
!= DW_TAG_enumerator
)
2434 process_die (child_die
, objfile
, cu_header
);
2438 attr
= dwarf_attr (child_die
, DW_AT_name
);
2441 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2442 if (SYMBOL_VALUE (sym
) < 0)
2445 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2447 fields
= (struct field
*)
2449 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2450 * sizeof (struct field
));
2453 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2454 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2455 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2456 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2462 child_die
= sibling_die (child_die
);
2467 TYPE_NFIELDS (type
) = num_fields
;
2468 TYPE_FIELDS (type
) = (struct field
*)
2469 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2470 memcpy (TYPE_FIELDS (type
), fields
,
2471 sizeof (struct field
) * num_fields
);
2475 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2478 new_symbol (die
, type
, objfile
, cu_header
);
2481 /* Extract all information from a DW_TAG_array_type DIE and put it in
2482 the DIE's type field. For now, this only handles one dimensional
2486 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2487 const struct comp_unit_head
*cu_header
)
2489 struct die_info
*child_die
;
2490 struct type
*type
= NULL
;
2491 struct type
*element_type
, *range_type
, *index_type
;
2492 struct type
**range_types
= NULL
;
2493 struct attribute
*attr
;
2495 struct cleanup
*back_to
;
2497 /* Return if we've already decoded this type. */
2503 element_type
= die_type (die
, objfile
, cu_header
);
2505 /* Irix 6.2 native cc creates array types without children for
2506 arrays with unspecified length. */
2507 if (die
->has_children
== 0)
2509 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2510 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2511 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2515 back_to
= make_cleanup (null_cleanup
, NULL
);
2516 child_die
= die
->next
;
2517 while (child_die
&& child_die
->tag
)
2519 if (child_die
->tag
== DW_TAG_subrange_type
)
2521 unsigned int low
, high
;
2523 /* Default bounds to an array with unspecified length. */
2526 if (cu_language
== language_fortran
)
2528 /* FORTRAN implies a lower bound of 1, if not given. */
2532 index_type
= die_type (child_die
, objfile
, cu_header
);
2533 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2536 if (attr
->form
== DW_FORM_sdata
)
2538 low
= DW_SND (attr
);
2540 else if (attr
->form
== DW_FORM_udata
2541 || attr
->form
== DW_FORM_data1
2542 || attr
->form
== DW_FORM_data2
2543 || attr
->form
== DW_FORM_data4
)
2545 low
= DW_UNSND (attr
);
2549 complain (&dwarf2_non_const_array_bound_ignored
,
2550 dwarf_form_name (attr
->form
));
2552 die
->type
= lookup_pointer_type (element_type
);
2559 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2562 if (attr
->form
== DW_FORM_sdata
)
2564 high
= DW_SND (attr
);
2566 else if (attr
->form
== DW_FORM_udata
2567 || attr
->form
== DW_FORM_data1
2568 || attr
->form
== DW_FORM_data2
2569 || attr
->form
== DW_FORM_data4
)
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
);
2791 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2792 range_type
= create_range_type (NULL
, index_type
, 1, length
);
2793 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
2794 type
= create_string_type (char_type
, range_type
);
2798 /* Handle DIES due to C code like:
2802 int (*funcp)(int a, long l);
2806 ('funcp' generates a DW_TAG_subroutine_type DIE)
2810 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
2811 const struct comp_unit_head
*cu_header
)
2813 struct type
*type
; /* Type that this function returns */
2814 struct type
*ftype
; /* Function that returns above type */
2815 struct attribute
*attr
;
2817 /* Decode the type that this subroutine returns */
2822 type
= die_type (die
, objfile
, cu_header
);
2823 ftype
= lookup_function_type (type
);
2825 /* All functions in C++ have prototypes. */
2826 attr
= dwarf_attr (die
, DW_AT_prototyped
);
2827 if ((attr
&& (DW_UNSND (attr
) != 0))
2828 || cu_language
== language_cplus
)
2829 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
2831 if (die
->has_children
)
2833 struct die_info
*child_die
;
2837 /* Count the number of parameters.
2838 FIXME: GDB currently ignores vararg functions, but knows about
2839 vararg member functions. */
2840 child_die
= die
->next
;
2841 while (child_die
&& child_die
->tag
)
2843 if (child_die
->tag
== DW_TAG_formal_parameter
)
2845 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
2846 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
2847 child_die
= sibling_die (child_die
);
2850 /* Allocate storage for parameters and fill them in. */
2851 TYPE_NFIELDS (ftype
) = nparams
;
2852 TYPE_FIELDS (ftype
) = (struct field
*)
2853 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
2855 child_die
= die
->next
;
2856 while (child_die
&& child_die
->tag
)
2858 if (child_die
->tag
== DW_TAG_formal_parameter
)
2860 /* Dwarf2 has no clean way to discern C++ static and non-static
2861 member functions. G++ helps GDB by marking the first
2862 parameter for non-static member functions (which is the
2863 this pointer) as artificial. We pass this information
2864 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
2865 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
2867 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
2869 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
2870 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
2874 child_die
= sibling_die (child_die
);
2882 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
2883 const struct comp_unit_head
*cu_header
)
2885 struct attribute
*attr
;
2890 attr
= dwarf_attr (die
, DW_AT_name
);
2891 if (attr
&& DW_STRING (attr
))
2893 name
= DW_STRING (attr
);
2895 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
2896 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
2900 /* Find a representation of a given base type and install
2901 it in the TYPE field of the die. */
2904 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
2907 struct attribute
*attr
;
2908 int encoding
= 0, size
= 0;
2910 /* If we've already decoded this die, this is a no-op. */
2916 attr
= dwarf_attr (die
, DW_AT_encoding
);
2919 encoding
= DW_UNSND (attr
);
2921 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2924 size
= DW_UNSND (attr
);
2926 attr
= dwarf_attr (die
, DW_AT_name
);
2927 if (attr
&& DW_STRING (attr
))
2929 enum type_code code
= TYPE_CODE_INT
;
2934 case DW_ATE_address
:
2935 /* Turn DW_ATE_address into a void * pointer. */
2936 code
= TYPE_CODE_PTR
;
2937 type_flags
|= TYPE_FLAG_UNSIGNED
;
2939 case DW_ATE_boolean
:
2940 code
= TYPE_CODE_BOOL
;
2941 type_flags
|= TYPE_FLAG_UNSIGNED
;
2943 case DW_ATE_complex_float
:
2944 code
= TYPE_CODE_COMPLEX
;
2947 code
= TYPE_CODE_FLT
;
2950 case DW_ATE_signed_char
:
2952 case DW_ATE_unsigned
:
2953 case DW_ATE_unsigned_char
:
2954 type_flags
|= TYPE_FLAG_UNSIGNED
;
2957 complain (&dwarf2_unsupported_at_encoding
,
2958 dwarf_type_encoding_name (encoding
));
2961 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
2962 if (encoding
== DW_ATE_address
)
2963 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
2967 type
= dwarf_base_type (encoding
, size
, objfile
);
2972 /* Read a whole compilation unit into a linked list of dies. */
2974 static struct die_info
*
2975 read_comp_unit (char *info_ptr
, bfd
*abfd
,
2976 const struct comp_unit_head
*cu_header
)
2978 struct die_info
*first_die
, *last_die
, *die
;
2982 /* Reset die reference table; we are
2983 building new ones now. */
2984 dwarf2_empty_hash_tables ();
2988 first_die
= last_die
= NULL
;
2991 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
2992 if (die
->has_children
)
3003 /* Enter die in reference hash table */
3004 store_in_ref_table (die
->offset
, die
);
3008 first_die
= last_die
= die
;
3012 last_die
->next
= die
;
3016 while (nesting_level
> 0);
3020 /* Free a linked list of dies. */
3023 free_die_list (struct die_info
*dies
)
3025 struct die_info
*die
, *next
;
3038 do_free_die_list_cleanup (void *dies
)
3040 free_die_list (dies
);
3043 static struct cleanup
*
3044 make_cleanup_free_die_list (struct die_info
*dies
)
3046 return make_cleanup (do_free_die_list_cleanup
, dies
);
3050 /* Read the contents of the section at OFFSET and of size SIZE from the
3051 object file specified by OBJFILE into the psymbol_obstack and return it. */
3054 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3057 bfd
*abfd
= objfile
->obfd
;
3063 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3064 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3065 (bfd_bread (buf
, size
, abfd
) != size
))
3068 error ("Dwarf Error: Can't read DWARF data from '%s'",
3069 bfd_get_filename (abfd
));
3074 /* In DWARF version 2, the description of the debugging information is
3075 stored in a separate .debug_abbrev section. Before we read any
3076 dies from a section we read in all abbreviations and install them
3080 dwarf2_read_abbrevs (bfd
*abfd
, unsigned int offset
)
3083 struct abbrev_info
*cur_abbrev
;
3084 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3085 unsigned int abbrev_form
, hash_number
;
3087 /* empty the table */
3088 dwarf2_empty_abbrev_table (NULL
);
3090 abbrev_ptr
= dwarf_abbrev_buffer
+ offset
;
3091 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3092 abbrev_ptr
+= bytes_read
;
3094 /* loop until we reach an abbrev number of 0 */
3095 while (abbrev_number
)
3097 cur_abbrev
= dwarf_alloc_abbrev ();
3099 /* read in abbrev header */
3100 cur_abbrev
->number
= abbrev_number
;
3101 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3102 abbrev_ptr
+= bytes_read
;
3103 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3106 /* now read in declarations */
3107 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3108 abbrev_ptr
+= bytes_read
;
3109 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3110 abbrev_ptr
+= bytes_read
;
3113 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3115 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3116 xrealloc (cur_abbrev
->attrs
,
3117 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3118 * sizeof (struct attr_abbrev
));
3120 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3121 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3122 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3123 abbrev_ptr
+= bytes_read
;
3124 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3125 abbrev_ptr
+= bytes_read
;
3128 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3129 cur_abbrev
->next
= dwarf2_abbrevs
[hash_number
];
3130 dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3132 /* Get next abbreviation.
3133 Under Irix6 the abbreviations for a compilation unit are not
3134 always properly terminated with an abbrev number of 0.
3135 Exit loop if we encounter an abbreviation which we have
3136 already read (which means we are about to read the abbreviations
3137 for the next compile unit) or if the end of the abbreviation
3138 table is reached. */
3139 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3140 >= dwarf_abbrev_size
)
3142 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3143 abbrev_ptr
+= bytes_read
;
3144 if (dwarf2_lookup_abbrev (abbrev_number
) != NULL
)
3149 /* Empty the abbrev table for a new compilation unit. */
3153 dwarf2_empty_abbrev_table (PTR ignore
)
3156 struct abbrev_info
*abbrev
, *next
;
3158 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3161 abbrev
= dwarf2_abbrevs
[i
];
3164 next
= abbrev
->next
;
3165 xfree (abbrev
->attrs
);
3169 dwarf2_abbrevs
[i
] = NULL
;
3173 /* Lookup an abbrev_info structure in the abbrev hash table. */
3175 static struct abbrev_info
*
3176 dwarf2_lookup_abbrev (unsigned int number
)
3178 unsigned int hash_number
;
3179 struct abbrev_info
*abbrev
;
3181 hash_number
= number
% ABBREV_HASH_SIZE
;
3182 abbrev
= dwarf2_abbrevs
[hash_number
];
3186 if (abbrev
->number
== number
)
3189 abbrev
= abbrev
->next
;
3194 /* Read a minimal amount of information into the minimal die structure. */
3197 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3198 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3200 unsigned int abbrev_number
, bytes_read
, i
;
3201 struct abbrev_info
*abbrev
;
3202 struct attribute attr
;
3203 struct attribute spec_attr
;
3204 int found_spec_attr
= 0;
3205 int has_low_pc_attr
= 0;
3206 int has_high_pc_attr
= 0;
3208 *part_die
= zeroed_partial_die
;
3209 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3210 info_ptr
+= bytes_read
;
3214 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3217 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3219 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3220 part_die
->tag
= abbrev
->tag
;
3221 part_die
->has_children
= abbrev
->has_children
;
3222 part_die
->abbrev
= abbrev_number
;
3224 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3226 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3227 info_ptr
, cu_header
);
3229 /* Store the data if it is of an attribute we want to keep in a
3230 partial symbol table. */
3235 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3236 if (part_die
->name
== NULL
)
3237 part_die
->name
= DW_STRING (&attr
);
3239 case DW_AT_MIPS_linkage_name
:
3240 part_die
->name
= DW_STRING (&attr
);
3243 has_low_pc_attr
= 1;
3244 part_die
->lowpc
= DW_ADDR (&attr
);
3247 has_high_pc_attr
= 1;
3248 part_die
->highpc
= DW_ADDR (&attr
);
3250 case DW_AT_location
:
3251 part_die
->locdesc
= DW_BLOCK (&attr
);
3253 case DW_AT_language
:
3254 part_die
->language
= DW_UNSND (&attr
);
3256 case DW_AT_external
:
3257 part_die
->is_external
= DW_UNSND (&attr
);
3259 case DW_AT_declaration
:
3260 part_die
->is_declaration
= DW_UNSND (&attr
);
3263 part_die
->has_type
= 1;
3265 case DW_AT_abstract_origin
:
3266 case DW_AT_specification
:
3267 found_spec_attr
= 1;
3271 /* Ignore absolute siblings, they might point outside of
3272 the current compile unit. */
3273 if (attr
.form
== DW_FORM_ref_addr
)
3274 complain (&dwarf2_absolute_sibling_complaint
);
3277 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3284 /* If we found a reference attribute and the die has no name, try
3285 to find a name in the referred to die. */
3287 if (found_spec_attr
&& part_die
->name
== NULL
)
3289 struct partial_die_info spec_die
;
3293 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3294 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3297 part_die
->name
= spec_die
.name
;
3299 /* Copy DW_AT_external attribute if it is set. */
3300 if (spec_die
.is_external
)
3301 part_die
->is_external
= spec_die
.is_external
;
3305 /* When using the GNU linker, .gnu.linkonce. sections are used to
3306 eliminate duplicate copies of functions and vtables and such.
3307 The linker will arbitrarily choose one and discard the others.
3308 The AT_*_pc values for such functions refer to local labels in
3309 these sections. If the section from that file was discarded, the
3310 labels are not in the output, so the relocs get a value of 0.
3311 If this is a discarded function, mark the pc bounds as invalid,
3312 so that GDB will ignore it. */
3313 if (has_low_pc_attr
&& has_high_pc_attr
3314 && part_die
->lowpc
< part_die
->highpc
3315 && (part_die
->lowpc
!= 0
3316 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3317 part_die
->has_pc_info
= 1;
3321 /* Read the die from the .debug_info section buffer. And set diep to
3322 point to a newly allocated die with its information. */
3325 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3326 const struct comp_unit_head
*cu_header
)
3328 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3329 struct abbrev_info
*abbrev
;
3330 struct die_info
*die
;
3332 offset
= info_ptr
- dwarf_info_buffer
;
3333 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3334 info_ptr
+= bytes_read
;
3337 die
= dwarf_alloc_die ();
3339 die
->abbrev
= abbrev_number
;
3345 abbrev
= dwarf2_lookup_abbrev (abbrev_number
);
3348 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3350 die
= dwarf_alloc_die ();
3351 die
->offset
= offset
;
3352 die
->tag
= abbrev
->tag
;
3353 die
->has_children
= abbrev
->has_children
;
3354 die
->abbrev
= abbrev_number
;
3357 die
->num_attrs
= abbrev
->num_attrs
;
3358 die
->attrs
= (struct attribute
*)
3359 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3361 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3363 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3364 abfd
, info_ptr
, cu_header
);
3371 /* Read an attribute value described by an attribute form. */
3374 read_attribute_value (struct attribute
*attr
, unsigned form
,
3375 bfd
*abfd
, char *info_ptr
,
3376 const struct comp_unit_head
*cu_header
)
3378 unsigned int bytes_read
;
3379 struct dwarf_block
*blk
;
3385 case DW_FORM_ref_addr
:
3386 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3387 info_ptr
+= bytes_read
;
3389 case DW_FORM_block2
:
3390 blk
= dwarf_alloc_block ();
3391 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3393 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3394 info_ptr
+= blk
->size
;
3395 DW_BLOCK (attr
) = blk
;
3397 case DW_FORM_block4
:
3398 blk
= dwarf_alloc_block ();
3399 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3401 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3402 info_ptr
+= blk
->size
;
3403 DW_BLOCK (attr
) = blk
;
3406 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3410 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3414 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3417 case DW_FORM_string
:
3418 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3419 info_ptr
+= bytes_read
;
3422 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
3424 info_ptr
+= bytes_read
;
3427 blk
= dwarf_alloc_block ();
3428 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3429 info_ptr
+= bytes_read
;
3430 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3431 info_ptr
+= blk
->size
;
3432 DW_BLOCK (attr
) = blk
;
3434 case DW_FORM_block1
:
3435 blk
= dwarf_alloc_block ();
3436 blk
->size
= read_1_byte (abfd
, info_ptr
);
3438 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3439 info_ptr
+= blk
->size
;
3440 DW_BLOCK (attr
) = blk
;
3443 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3447 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3451 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3452 info_ptr
+= bytes_read
;
3455 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3456 info_ptr
+= bytes_read
;
3459 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3463 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3467 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3471 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3474 case DW_FORM_ref_udata
:
3475 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3476 info_ptr
+= bytes_read
;
3478 case DW_FORM_indirect
:
3479 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3480 info_ptr
+= bytes_read
;
3481 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
3484 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3485 dwarf_form_name (form
));
3490 /* Read an attribute described by an abbreviated attribute. */
3493 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
3494 bfd
*abfd
, char *info_ptr
,
3495 const struct comp_unit_head
*cu_header
)
3497 attr
->name
= abbrev
->name
;
3498 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
3501 /* read dwarf information from a buffer */
3504 read_1_byte (bfd
*abfd
, char *buf
)
3506 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3510 read_1_signed_byte (bfd
*abfd
, char *buf
)
3512 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3516 read_2_bytes (bfd
*abfd
, char *buf
)
3518 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3522 read_2_signed_bytes (bfd
*abfd
, char *buf
)
3524 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3528 read_4_bytes (bfd
*abfd
, char *buf
)
3530 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3534 read_4_signed_bytes (bfd
*abfd
, char *buf
)
3536 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3539 static unsigned long
3540 read_8_bytes (bfd
*abfd
, char *buf
)
3542 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3546 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3549 CORE_ADDR retval
= 0;
3551 if (cu_header
->signed_addr_p
)
3553 switch (cu_header
->addr_size
)
3556 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3559 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3562 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
3565 internal_error (__FILE__
, __LINE__
,
3566 "read_address: bad switch, signed");
3571 switch (cu_header
->addr_size
)
3574 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3577 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3580 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3583 internal_error (__FILE__
, __LINE__
,
3584 "read_address: bad switch, unsigned");
3588 *bytes_read
= cu_header
->addr_size
;
3592 /* Reads the initial length from a section. The (draft) DWARF 2.1
3593 specification allows the initial length to take up either 4 bytes
3594 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
3595 bytes describe the length and all offsets will be 8 bytes in length
3598 The value returned via bytes_read should be used to increment
3599 the relevant pointer after calling read_initial_length().
3601 As a side effect, this function sets the fields initial_length_size
3602 and offset_size in cu_header to the values appropriate for the
3603 length field. (The format of the initial length field determines
3604 the width of file offsets to be fetched later with fetch_offset().)
3606 [ Note: read_initial_length() and read_offset() are based on the
3607 document entitled "DWARF Debugging Information Format", revision
3608 2.1, draft 4, dated July 20, 2000. This document was obtained
3611 http://reality.sgi.com/dehnert_engr/dwarf/dwarf2p1-draft4-000720.pdf
3613 This document is only a draft and is subject to change. (So beware.)
3615 - Kevin, Aug 4, 2000
3619 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
3624 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3626 if (retval
== 0xffffffff)
3628 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
3630 if (cu_header
!= NULL
)
3632 cu_header
->initial_length_size
= 12;
3633 cu_header
->offset_size
= 8;
3639 if (cu_header
!= NULL
)
3641 cu_header
->initial_length_size
= 4;
3642 cu_header
->offset_size
= 4;
3649 /* Read an offset from the data stream. The size of the offset is
3650 given by cu_header->offset_size. */
3653 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3658 switch (cu_header
->offset_size
)
3661 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3665 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3669 internal_error (__FILE__
, __LINE__
,
3670 "read_offset: bad switch");
3677 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
3679 /* If the size of a host char is 8 bits, we can return a pointer
3680 to the buffer, otherwise we have to copy the data to a buffer
3681 allocated on the temporary obstack. */
3682 gdb_assert (HOST_CHAR_BIT
== 8);
3687 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3689 /* If the size of a host char is 8 bits, we can return a pointer
3690 to the string, otherwise we have to copy the string to a buffer
3691 allocated on the temporary obstack. */
3692 gdb_assert (HOST_CHAR_BIT
== 8);
3695 *bytes_read_ptr
= 1;
3698 *bytes_read_ptr
= strlen (buf
) + 1;
3703 read_indirect_string (bfd
*abfd
, char *buf
,
3704 const struct comp_unit_head
*cu_header
,
3705 unsigned int *bytes_read_ptr
)
3707 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
3708 (int *) bytes_read_ptr
);
3710 if (dwarf_str_buffer
== NULL
)
3712 error ("DW_FORM_strp used without .debug_str section");
3715 if (str_offset
>= dwarf_str_size
)
3717 error ("DW_FORM_strp pointing outside of .debug_str section");
3720 gdb_assert (HOST_CHAR_BIT
== 8);
3721 if (dwarf_str_buffer
[str_offset
] == '\0')
3723 return dwarf_str_buffer
+ str_offset
;
3726 static unsigned long
3727 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3729 unsigned long result
;
3730 unsigned int num_read
;
3740 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3743 result
|= ((unsigned long)(byte
& 127) << shift
);
3744 if ((byte
& 128) == 0)
3750 *bytes_read_ptr
= num_read
;
3755 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
3758 int i
, shift
, size
, num_read
;
3768 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3771 result
|= ((long)(byte
& 127) << shift
);
3773 if ((byte
& 128) == 0)
3778 if ((shift
< size
) && (byte
& 0x40))
3780 result
|= -(1 << shift
);
3782 *bytes_read_ptr
= num_read
;
3787 set_cu_language (unsigned int lang
)
3793 cu_language
= language_c
;
3795 case DW_LANG_C_plus_plus
:
3796 cu_language
= language_cplus
;
3798 case DW_LANG_Fortran77
:
3799 case DW_LANG_Fortran90
:
3800 cu_language
= language_fortran
;
3802 case DW_LANG_Mips_Assembler
:
3803 cu_language
= language_asm
;
3806 cu_language
= language_java
;
3809 case DW_LANG_Cobol74
:
3810 case DW_LANG_Cobol85
:
3811 case DW_LANG_Pascal83
:
3812 case DW_LANG_Modula2
:
3814 cu_language
= language_unknown
;
3817 cu_language_defn
= language_def (cu_language
);
3820 /* Return the named attribute or NULL if not there. */
3822 static struct attribute
*
3823 dwarf_attr (struct die_info
*die
, unsigned int name
)
3826 struct attribute
*spec
= NULL
;
3828 for (i
= 0; i
< die
->num_attrs
; ++i
)
3830 if (die
->attrs
[i
].name
== name
)
3832 return &die
->attrs
[i
];
3834 if (die
->attrs
[i
].name
== DW_AT_specification
3835 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
3836 spec
= &die
->attrs
[i
];
3840 struct die_info
*ref_die
=
3841 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
3844 return dwarf_attr (ref_die
, name
);
3851 die_is_declaration (struct die_info
*die
)
3853 return (dwarf_attr (die
, DW_AT_declaration
)
3854 && ! dwarf_attr (die
, DW_AT_specification
));
3857 /* Decode the line number information for the compilation unit whose
3858 line number info is at OFFSET in the .debug_line section.
3859 The compilation directory of the file is passed in COMP_DIR. */
3863 unsigned int num_files
;
3876 unsigned int num_dirs
;
3881 dwarf_decode_lines (unsigned int offset
, char *comp_dir
, bfd
*abfd
,
3882 const struct comp_unit_head
*cu_header
)
3886 struct line_head lh
;
3887 struct cleanup
*back_to
;
3888 unsigned int i
, bytes_read
;
3889 char *cur_file
, *cur_dir
;
3890 unsigned char op_code
, extended_op
, adj_opcode
;
3892 #define FILE_ALLOC_CHUNK 5
3893 #define DIR_ALLOC_CHUNK 5
3895 struct filenames files
;
3896 struct directories dirs
;
3898 if (dwarf_line_buffer
== NULL
)
3900 complain (&dwarf2_missing_line_number_section
);
3904 files
.num_files
= 0;
3910 line_ptr
= dwarf_line_buffer
+ offset
;
3912 /* read in the prologue */
3913 lh
.total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
3914 line_ptr
+= bytes_read
;
3915 line_end
= line_ptr
+ lh
.total_length
;
3916 lh
.version
= read_2_bytes (abfd
, line_ptr
);
3918 lh
.prologue_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
3919 line_ptr
+= bytes_read
;
3920 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
3922 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
3924 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
3926 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
3928 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
3930 lh
.standard_opcode_lengths
= (unsigned char *)
3931 xmalloc (lh
.opcode_base
* sizeof (unsigned char));
3932 back_to
= make_cleanup (free_current_contents
, &lh
.standard_opcode_lengths
);
3934 lh
.standard_opcode_lengths
[0] = 1;
3935 for (i
= 1; i
< lh
.opcode_base
; ++i
)
3937 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
3941 /* Read directory table */
3942 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
3944 line_ptr
+= bytes_read
;
3945 if ((dirs
.num_dirs
% DIR_ALLOC_CHUNK
) == 0)
3947 dirs
.dirs
= (char **)
3948 xrealloc (dirs
.dirs
,
3949 (dirs
.num_dirs
+ DIR_ALLOC_CHUNK
) * sizeof (char *));
3950 if (dirs
.num_dirs
== 0)
3951 make_cleanup (free_current_contents
, &dirs
.dirs
);
3953 dirs
.dirs
[dirs
.num_dirs
++] = cur_dir
;
3955 line_ptr
+= bytes_read
;
3957 /* Read file name table */
3958 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
3960 line_ptr
+= bytes_read
;
3961 if ((files
.num_files
% FILE_ALLOC_CHUNK
) == 0)
3963 files
.files
= (struct fileinfo
*)
3964 xrealloc (files
.files
,
3965 (files
.num_files
+ FILE_ALLOC_CHUNK
)
3966 * sizeof (struct fileinfo
));
3967 if (files
.num_files
== 0)
3968 make_cleanup (free_current_contents
, &files
.files
);
3970 files
.files
[files
.num_files
].name
= cur_file
;
3971 files
.files
[files
.num_files
].dir
=
3972 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3973 line_ptr
+= bytes_read
;
3974 files
.files
[files
.num_files
].time
=
3975 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3976 line_ptr
+= bytes_read
;
3977 files
.files
[files
.num_files
].size
=
3978 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
3979 line_ptr
+= bytes_read
;
3982 line_ptr
+= bytes_read
;
3984 /* Read the statement sequences until there's nothing left. */
3985 while (line_ptr
< line_end
)
3987 /* state machine registers */
3988 CORE_ADDR address
= 0;
3989 unsigned int file
= 1;
3990 unsigned int line
= 1;
3991 unsigned int column
= 0;
3992 int is_stmt
= lh
.default_is_stmt
;
3993 int basic_block
= 0;
3994 int end_sequence
= 0;
3996 /* Start a subfile for the current file of the state machine. */
3997 if (files
.num_files
>= file
)
3999 /* The file and directory tables are 0 based, the references
4001 dwarf2_start_subfile (files
.files
[file
- 1].name
,
4002 (files
.files
[file
- 1].dir
4003 ? dirs
.dirs
[files
.files
[file
- 1].dir
- 1]
4007 /* Decode the table. */
4008 while (!end_sequence
)
4010 op_code
= read_1_byte (abfd
, line_ptr
);
4013 if (op_code
>= lh
.opcode_base
)
4014 { /* Special operand. */
4015 adj_opcode
= op_code
- lh
.opcode_base
;
4016 address
+= (adj_opcode
/ lh
.line_range
)
4017 * lh
.minimum_instruction_length
;
4018 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
4019 /* append row to matrix using current values */
4020 record_line (current_subfile
, line
, address
);
4023 else switch (op_code
)
4025 case DW_LNS_extended_op
:
4026 line_ptr
+= 1; /* ignore length */
4027 extended_op
= read_1_byte (abfd
, line_ptr
);
4029 switch (extended_op
)
4031 case DW_LNE_end_sequence
:
4033 /* Don't call record_line here. The end_sequence
4034 instruction provides the address of the first byte
4035 *after* the last line in the sequence; it's not the
4036 address of any real source line. However, the GDB
4037 linetable structure only records the starts of lines,
4038 not the ends. This is a weakness of GDB. */
4040 case DW_LNE_set_address
:
4041 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4042 line_ptr
+= bytes_read
;
4043 address
+= baseaddr
;
4045 case DW_LNE_define_file
:
4046 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
4047 line_ptr
+= bytes_read
;
4048 if ((files
.num_files
% FILE_ALLOC_CHUNK
) == 0)
4050 files
.files
= (struct fileinfo
*)
4051 xrealloc (files
.files
,
4052 (files
.num_files
+ FILE_ALLOC_CHUNK
)
4053 * sizeof (struct fileinfo
));
4054 if (files
.num_files
== 0)
4055 make_cleanup (free_current_contents
, &files
.files
);
4057 files
.files
[files
.num_files
].name
= cur_file
;
4058 files
.files
[files
.num_files
].dir
=
4059 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4060 line_ptr
+= bytes_read
;
4061 files
.files
[files
.num_files
].time
=
4062 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4063 line_ptr
+= bytes_read
;
4064 files
.files
[files
.num_files
].size
=
4065 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4066 line_ptr
+= bytes_read
;
4070 complain (&dwarf2_mangled_line_number_section
);
4075 record_line (current_subfile
, line
, address
);
4078 case DW_LNS_advance_pc
:
4079 address
+= lh
.minimum_instruction_length
4080 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4081 line_ptr
+= bytes_read
;
4083 case DW_LNS_advance_line
:
4084 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4085 line_ptr
+= bytes_read
;
4087 case DW_LNS_set_file
:
4088 /* The file and directory tables are 0 based, the references
4090 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4091 line_ptr
+= bytes_read
;
4092 dwarf2_start_subfile
4093 (files
.files
[file
- 1].name
,
4094 (files
.files
[file
- 1].dir
4095 ? dirs
.dirs
[files
.files
[file
- 1].dir
- 1]
4098 case DW_LNS_set_column
:
4099 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4100 line_ptr
+= bytes_read
;
4102 case DW_LNS_negate_stmt
:
4103 is_stmt
= (!is_stmt
);
4105 case DW_LNS_set_basic_block
:
4108 /* Add to the address register of the state machine the
4109 address increment value corresponding to special opcode
4110 255. Ie, this value is scaled by the minimum instruction
4111 length since special opcode 255 would have scaled the
4113 case DW_LNS_const_add_pc
:
4114 address
+= (lh
.minimum_instruction_length
4115 * ((255 - lh
.opcode_base
) / lh
.line_range
));
4117 case DW_LNS_fixed_advance_pc
:
4118 address
+= read_2_bytes (abfd
, line_ptr
);
4122 { /* Unknown standard opcode, ignore it. */
4124 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
4126 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4127 line_ptr
+= bytes_read
;
4134 do_cleanups (back_to
);
4137 /* Start a subfile for DWARF. FILENAME is the name of the file and
4138 DIRNAME the name of the source directory which contains FILENAME
4139 or NULL if not known.
4140 This routine tries to keep line numbers from identical absolute and
4141 relative file names in a common subfile.
4143 Using the `list' example from the GDB testsuite, which resides in
4144 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4145 of /srcdir/list0.c yields the following debugging information for list0.c:
4147 DW_AT_name: /srcdir/list0.c
4148 DW_AT_comp_dir: /compdir
4149 files.files[0].name: list0.h
4150 files.files[0].dir: /srcdir
4151 files.files[1].name: list0.c
4152 files.files[1].dir: /srcdir
4154 The line number information for list0.c has to end up in a single
4155 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4158 dwarf2_start_subfile (char *filename
, char *dirname
)
4160 /* If the filename isn't absolute, try to match an existing subfile
4161 with the full pathname. */
4163 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4165 struct subfile
*subfile
;
4166 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4168 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4170 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4172 current_subfile
= subfile
;
4179 start_subfile (filename
, dirname
);
4182 /* Given a pointer to a DWARF information entry, figure out if we need
4183 to make a symbol table entry for it, and if so, create a new entry
4184 and return a pointer to it.
4185 If TYPE is NULL, determine symbol type from the die, otherwise
4186 used the passed type. */
4188 static struct symbol
*
4189 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4190 const struct comp_unit_head
*cu_header
)
4192 struct symbol
*sym
= NULL
;
4194 struct attribute
*attr
= NULL
;
4195 struct attribute
*attr2
= NULL
;
4198 name
= dwarf2_linkage_name (die
);
4201 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4202 sizeof (struct symbol
));
4203 OBJSTAT (objfile
, n_syms
++);
4204 memset (sym
, 0, sizeof (struct symbol
));
4205 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4206 &objfile
->symbol_obstack
);
4208 /* Default assumptions.
4209 Use the passed type or decode it from the die. */
4210 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4211 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4213 SYMBOL_TYPE (sym
) = type
;
4215 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4216 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4219 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4222 /* If this symbol is from a C++ compilation, then attempt to
4223 cache the demangled form for future reference. This is a
4224 typical time versus space tradeoff, that was decided in favor
4225 of time because it sped up C++ symbol lookups by a factor of
4228 SYMBOL_LANGUAGE (sym
) = cu_language
;
4229 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4233 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4236 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4238 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4240 case DW_TAG_subprogram
:
4241 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4243 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4244 attr2
= dwarf_attr (die
, DW_AT_external
);
4245 if (attr2
&& (DW_UNSND (attr2
) != 0))
4247 add_symbol_to_list (sym
, &global_symbols
);
4251 add_symbol_to_list (sym
, list_in_scope
);
4254 case DW_TAG_variable
:
4255 /* Compilation with minimal debug info may result in variables
4256 with missing type entries. Change the misleading `void' type
4257 to something sensible. */
4258 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4259 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4260 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4261 "<variable, no debug info>",
4263 attr
= dwarf_attr (die
, DW_AT_const_value
);
4266 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4267 attr2
= dwarf_attr (die
, DW_AT_external
);
4268 if (attr2
&& (DW_UNSND (attr2
) != 0))
4269 add_symbol_to_list (sym
, &global_symbols
);
4271 add_symbol_to_list (sym
, list_in_scope
);
4274 attr
= dwarf_attr (die
, DW_AT_location
);
4277 attr2
= dwarf_attr (die
, DW_AT_external
);
4278 if (attr2
&& (DW_UNSND (attr2
) != 0))
4280 SYMBOL_VALUE_ADDRESS (sym
) =
4281 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4282 add_symbol_to_list (sym
, &global_symbols
);
4284 /* In shared libraries the address of the variable
4285 in the location descriptor might still be relocatable,
4286 so its value could be zero.
4287 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4288 value is zero, the address of the variable will then
4289 be determined from the minimal symbol table whenever
4290 the variable is referenced. */
4291 if (SYMBOL_VALUE_ADDRESS (sym
))
4293 fixup_symbol_section (sym
, objfile
);
4294 SYMBOL_VALUE_ADDRESS (sym
) +=
4295 ANOFFSET (objfile
->section_offsets
,
4296 SYMBOL_SECTION (sym
));
4297 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4300 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4304 SYMBOL_VALUE (sym
) = addr
=
4305 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4306 add_symbol_to_list (sym
, list_in_scope
);
4309 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4313 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4314 SYMBOL_VALUE (sym
) =
4315 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4319 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4320 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4324 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4328 fixup_symbol_section (sym
, objfile
);
4329 SYMBOL_VALUE_ADDRESS (sym
) =
4330 addr
+ ANOFFSET (objfile
->section_offsets
,
4331 SYMBOL_SECTION (sym
));
4332 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4338 /* We do not know the address of this symbol.
4339 If it is an external symbol and we have type information
4340 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4341 The address of the variable will then be determined from
4342 the minimal symbol table whenever the variable is
4344 attr2
= dwarf_attr (die
, DW_AT_external
);
4345 if (attr2
&& (DW_UNSND (attr2
) != 0)
4346 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4348 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4349 add_symbol_to_list (sym
, &global_symbols
);
4353 case DW_TAG_formal_parameter
:
4354 attr
= dwarf_attr (die
, DW_AT_location
);
4357 SYMBOL_VALUE (sym
) =
4358 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4361 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4362 SYMBOL_VALUE (sym
) =
4363 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4369 if (basereg
!= frame_base_reg
)
4370 complain (&dwarf2_complex_location_expr
);
4371 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
4375 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4376 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4381 SYMBOL_CLASS (sym
) = LOC_ARG
;
4384 attr
= dwarf_attr (die
, DW_AT_const_value
);
4387 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4389 add_symbol_to_list (sym
, list_in_scope
);
4391 case DW_TAG_unspecified_parameters
:
4392 /* From varargs functions; gdb doesn't seem to have any
4393 interest in this information, so just ignore it for now.
4396 case DW_TAG_class_type
:
4397 case DW_TAG_structure_type
:
4398 case DW_TAG_union_type
:
4399 case DW_TAG_enumeration_type
:
4400 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4401 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
4402 add_symbol_to_list (sym
, list_in_scope
);
4404 /* The semantics of C++ state that "struct foo { ... }" also
4405 defines a typedef for "foo". Synthesize a typedef symbol so
4406 that "ptype foo" works as expected. */
4407 if (cu_language
== language_cplus
)
4409 struct symbol
*typedef_sym
= (struct symbol
*)
4410 obstack_alloc (&objfile
->symbol_obstack
,
4411 sizeof (struct symbol
));
4412 *typedef_sym
= *sym
;
4413 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
4414 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
4415 TYPE_NAME (SYMBOL_TYPE (sym
)) =
4416 obsavestring (SYMBOL_NAME (sym
),
4417 strlen (SYMBOL_NAME (sym
)),
4418 &objfile
->type_obstack
);
4419 add_symbol_to_list (typedef_sym
, list_in_scope
);
4422 case DW_TAG_typedef
:
4423 case DW_TAG_base_type
:
4424 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4425 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4426 add_symbol_to_list (sym
, list_in_scope
);
4428 case DW_TAG_enumerator
:
4429 attr
= dwarf_attr (die
, DW_AT_const_value
);
4432 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4434 add_symbol_to_list (sym
, list_in_scope
);
4437 /* Not a tag we recognize. Hopefully we aren't processing
4438 trash data, but since we must specifically ignore things
4439 we don't recognize, there is nothing else we should do at
4441 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
4448 /* Copy constant value from an attribute to a symbol. */
4451 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
4452 struct objfile
*objfile
,
4453 const struct comp_unit_head
*cu_header
)
4455 struct dwarf_block
*blk
;
4460 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
4461 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4462 cu_header
->addr_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4463 SYMBOL_VALUE_BYTES (sym
) = (char *)
4464 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
4465 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
4467 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4469 case DW_FORM_block1
:
4470 case DW_FORM_block2
:
4471 case DW_FORM_block4
:
4473 blk
= DW_BLOCK (attr
);
4474 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
4475 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4476 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4477 SYMBOL_VALUE_BYTES (sym
) = (char *)
4478 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
4479 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
4480 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4483 /* The DW_AT_const_value attributes are supposed to carry the
4484 symbol's value "represented as it would be on the target
4485 architecture." By the time we get here, it's already been
4486 converted to host endianness, so we just need to sign- or
4487 zero-extend it as appropriate. */
4489 dwarf2_const_value_data (attr
, sym
, 8);
4492 dwarf2_const_value_data (attr
, sym
, 16);
4495 dwarf2_const_value_data (attr
, sym
, 32);
4498 dwarf2_const_value_data (attr
, sym
, 64);
4502 SYMBOL_VALUE (sym
) = DW_SND (attr
);
4503 SYMBOL_CLASS (sym
) = LOC_CONST
;
4507 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
4508 SYMBOL_CLASS (sym
) = LOC_CONST
;
4512 complain (&dwarf2_unsupported_const_value_attr
,
4513 dwarf_form_name (attr
->form
));
4514 SYMBOL_VALUE (sym
) = 0;
4515 SYMBOL_CLASS (sym
) = LOC_CONST
;
4521 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
4522 or zero-extend it as appropriate for the symbol's type. */
4524 dwarf2_const_value_data (struct attribute
*attr
,
4528 LONGEST l
= DW_UNSND (attr
);
4530 if (bits
< sizeof (l
) * 8)
4532 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
4533 l
&= ((LONGEST
) 1 << bits
) - 1;
4535 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
4538 SYMBOL_VALUE (sym
) = l
;
4539 SYMBOL_CLASS (sym
) = LOC_CONST
;
4543 /* Return the type of the die in question using its DW_AT_type attribute. */
4545 static struct type
*
4546 die_type (struct die_info
*die
, struct objfile
*objfile
,
4547 const struct comp_unit_head
*cu_header
)
4550 struct attribute
*type_attr
;
4551 struct die_info
*type_die
;
4554 type_attr
= dwarf_attr (die
, DW_AT_type
);
4557 /* A missing DW_AT_type represents a void type. */
4558 return dwarf2_fundamental_type (objfile
, FT_VOID
);
4562 ref
= dwarf2_get_ref_die_offset (type_attr
);
4563 type_die
= follow_die_ref (ref
);
4566 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4570 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
4573 dump_die (type_die
);
4574 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
4579 /* Return the containing type of the die in question using its
4580 DW_AT_containing_type attribute. */
4582 static struct type
*
4583 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
4584 const struct comp_unit_head
*cu_header
)
4586 struct type
*type
= NULL
;
4587 struct attribute
*type_attr
;
4588 struct die_info
*type_die
= NULL
;
4591 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
4594 ref
= dwarf2_get_ref_die_offset (type_attr
);
4595 type_die
= follow_die_ref (ref
);
4598 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
4601 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
4606 dump_die (type_die
);
4607 error ("Dwarf Error: Problem turning containing type into gdb type.");
4613 static struct type
*
4614 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
4616 struct die_info
*die
;
4619 die
= follow_die_ref (offset
);
4622 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
4625 type
= tag_type_to_type (die
, objfile
);
4630 static struct type
*
4631 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
4632 const struct comp_unit_head
*cu_header
)
4640 read_type_die (die
, objfile
, cu_header
);
4644 error ("Dwarf Error: Cannot find type of die.");
4651 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
4652 const struct comp_unit_head
*cu_header
)
4656 case DW_TAG_class_type
:
4657 case DW_TAG_structure_type
:
4658 case DW_TAG_union_type
:
4659 read_structure_scope (die
, objfile
, cu_header
);
4661 case DW_TAG_enumeration_type
:
4662 read_enumeration (die
, objfile
, cu_header
);
4664 case DW_TAG_subprogram
:
4665 case DW_TAG_subroutine_type
:
4666 read_subroutine_type (die
, objfile
, cu_header
);
4668 case DW_TAG_array_type
:
4669 read_array_type (die
, objfile
, cu_header
);
4671 case DW_TAG_pointer_type
:
4672 read_tag_pointer_type (die
, objfile
, cu_header
);
4674 case DW_TAG_ptr_to_member_type
:
4675 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
4677 case DW_TAG_reference_type
:
4678 read_tag_reference_type (die
, objfile
, cu_header
);
4680 case DW_TAG_const_type
:
4681 read_tag_const_type (die
, objfile
, cu_header
);
4683 case DW_TAG_volatile_type
:
4684 read_tag_volatile_type (die
, objfile
, cu_header
);
4686 case DW_TAG_string_type
:
4687 read_tag_string_type (die
, objfile
);
4689 case DW_TAG_typedef
:
4690 read_typedef (die
, objfile
, cu_header
);
4692 case DW_TAG_base_type
:
4693 read_base_type (die
, objfile
);
4696 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
4701 static struct type
*
4702 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
4704 /* FIXME - this should not produce a new (struct type *)
4705 every time. It should cache base types. */
4709 case DW_ATE_address
:
4710 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
4712 case DW_ATE_boolean
:
4713 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
4715 case DW_ATE_complex_float
:
4718 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
4722 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
4728 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
4732 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
4739 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
4742 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
4746 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
4750 case DW_ATE_signed_char
:
4751 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
4753 case DW_ATE_unsigned
:
4757 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
4760 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
4764 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
4768 case DW_ATE_unsigned_char
:
4769 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
4772 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
4779 copy_die (struct die_info
*old_die
)
4781 struct die_info
*new_die
;
4784 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
4785 memset (new_die
, 0, sizeof (struct die_info
));
4787 new_die
->tag
= old_die
->tag
;
4788 new_die
->has_children
= old_die
->has_children
;
4789 new_die
->abbrev
= old_die
->abbrev
;
4790 new_die
->offset
= old_die
->offset
;
4791 new_die
->type
= NULL
;
4793 num_attrs
= old_die
->num_attrs
;
4794 new_die
->num_attrs
= num_attrs
;
4795 new_die
->attrs
= (struct attribute
*)
4796 xmalloc (num_attrs
* sizeof (struct attribute
));
4798 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
4800 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
4801 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
4802 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
4805 new_die
->next
= NULL
;
4810 /* Return sibling of die, NULL if no sibling. */
4812 static struct die_info
*
4813 sibling_die (struct die_info
*die
)
4815 int nesting_level
= 0;
4817 if (!die
->has_children
)
4819 if (die
->next
&& (die
->next
->tag
== 0))
4832 if (die
->has_children
)
4842 while (nesting_level
);
4843 if (die
&& (die
->tag
== 0))
4854 /* Get linkage name of a die, return NULL if not found. */
4857 dwarf2_linkage_name (struct die_info
*die
)
4859 struct attribute
*attr
;
4861 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
4862 if (attr
&& DW_STRING (attr
))
4863 return DW_STRING (attr
);
4864 attr
= dwarf_attr (die
, DW_AT_name
);
4865 if (attr
&& DW_STRING (attr
))
4866 return DW_STRING (attr
);
4870 /* Convert a DIE tag into its string name. */
4873 dwarf_tag_name (register unsigned tag
)
4877 case DW_TAG_padding
:
4878 return "DW_TAG_padding";
4879 case DW_TAG_array_type
:
4880 return "DW_TAG_array_type";
4881 case DW_TAG_class_type
:
4882 return "DW_TAG_class_type";
4883 case DW_TAG_entry_point
:
4884 return "DW_TAG_entry_point";
4885 case DW_TAG_enumeration_type
:
4886 return "DW_TAG_enumeration_type";
4887 case DW_TAG_formal_parameter
:
4888 return "DW_TAG_formal_parameter";
4889 case DW_TAG_imported_declaration
:
4890 return "DW_TAG_imported_declaration";
4892 return "DW_TAG_label";
4893 case DW_TAG_lexical_block
:
4894 return "DW_TAG_lexical_block";
4896 return "DW_TAG_member";
4897 case DW_TAG_pointer_type
:
4898 return "DW_TAG_pointer_type";
4899 case DW_TAG_reference_type
:
4900 return "DW_TAG_reference_type";
4901 case DW_TAG_compile_unit
:
4902 return "DW_TAG_compile_unit";
4903 case DW_TAG_string_type
:
4904 return "DW_TAG_string_type";
4905 case DW_TAG_structure_type
:
4906 return "DW_TAG_structure_type";
4907 case DW_TAG_subroutine_type
:
4908 return "DW_TAG_subroutine_type";
4909 case DW_TAG_typedef
:
4910 return "DW_TAG_typedef";
4911 case DW_TAG_union_type
:
4912 return "DW_TAG_union_type";
4913 case DW_TAG_unspecified_parameters
:
4914 return "DW_TAG_unspecified_parameters";
4915 case DW_TAG_variant
:
4916 return "DW_TAG_variant";
4917 case DW_TAG_common_block
:
4918 return "DW_TAG_common_block";
4919 case DW_TAG_common_inclusion
:
4920 return "DW_TAG_common_inclusion";
4921 case DW_TAG_inheritance
:
4922 return "DW_TAG_inheritance";
4923 case DW_TAG_inlined_subroutine
:
4924 return "DW_TAG_inlined_subroutine";
4926 return "DW_TAG_module";
4927 case DW_TAG_ptr_to_member_type
:
4928 return "DW_TAG_ptr_to_member_type";
4929 case DW_TAG_set_type
:
4930 return "DW_TAG_set_type";
4931 case DW_TAG_subrange_type
:
4932 return "DW_TAG_subrange_type";
4933 case DW_TAG_with_stmt
:
4934 return "DW_TAG_with_stmt";
4935 case DW_TAG_access_declaration
:
4936 return "DW_TAG_access_declaration";
4937 case DW_TAG_base_type
:
4938 return "DW_TAG_base_type";
4939 case DW_TAG_catch_block
:
4940 return "DW_TAG_catch_block";
4941 case DW_TAG_const_type
:
4942 return "DW_TAG_const_type";
4943 case DW_TAG_constant
:
4944 return "DW_TAG_constant";
4945 case DW_TAG_enumerator
:
4946 return "DW_TAG_enumerator";
4947 case DW_TAG_file_type
:
4948 return "DW_TAG_file_type";
4950 return "DW_TAG_friend";
4951 case DW_TAG_namelist
:
4952 return "DW_TAG_namelist";
4953 case DW_TAG_namelist_item
:
4954 return "DW_TAG_namelist_item";
4955 case DW_TAG_packed_type
:
4956 return "DW_TAG_packed_type";
4957 case DW_TAG_subprogram
:
4958 return "DW_TAG_subprogram";
4959 case DW_TAG_template_type_param
:
4960 return "DW_TAG_template_type_param";
4961 case DW_TAG_template_value_param
:
4962 return "DW_TAG_template_value_param";
4963 case DW_TAG_thrown_type
:
4964 return "DW_TAG_thrown_type";
4965 case DW_TAG_try_block
:
4966 return "DW_TAG_try_block";
4967 case DW_TAG_variant_part
:
4968 return "DW_TAG_variant_part";
4969 case DW_TAG_variable
:
4970 return "DW_TAG_variable";
4971 case DW_TAG_volatile_type
:
4972 return "DW_TAG_volatile_type";
4973 case DW_TAG_MIPS_loop
:
4974 return "DW_TAG_MIPS_loop";
4975 case DW_TAG_format_label
:
4976 return "DW_TAG_format_label";
4977 case DW_TAG_function_template
:
4978 return "DW_TAG_function_template";
4979 case DW_TAG_class_template
:
4980 return "DW_TAG_class_template";
4982 return "DW_TAG_<unknown>";
4986 /* Convert a DWARF attribute code into its string name. */
4989 dwarf_attr_name (register unsigned attr
)
4994 return "DW_AT_sibling";
4995 case DW_AT_location
:
4996 return "DW_AT_location";
4998 return "DW_AT_name";
4999 case DW_AT_ordering
:
5000 return "DW_AT_ordering";
5001 case DW_AT_subscr_data
:
5002 return "DW_AT_subscr_data";
5003 case DW_AT_byte_size
:
5004 return "DW_AT_byte_size";
5005 case DW_AT_bit_offset
:
5006 return "DW_AT_bit_offset";
5007 case DW_AT_bit_size
:
5008 return "DW_AT_bit_size";
5009 case DW_AT_element_list
:
5010 return "DW_AT_element_list";
5011 case DW_AT_stmt_list
:
5012 return "DW_AT_stmt_list";
5014 return "DW_AT_low_pc";
5016 return "DW_AT_high_pc";
5017 case DW_AT_language
:
5018 return "DW_AT_language";
5020 return "DW_AT_member";
5022 return "DW_AT_discr";
5023 case DW_AT_discr_value
:
5024 return "DW_AT_discr_value";
5025 case DW_AT_visibility
:
5026 return "DW_AT_visibility";
5028 return "DW_AT_import";
5029 case DW_AT_string_length
:
5030 return "DW_AT_string_length";
5031 case DW_AT_common_reference
:
5032 return "DW_AT_common_reference";
5033 case DW_AT_comp_dir
:
5034 return "DW_AT_comp_dir";
5035 case DW_AT_const_value
:
5036 return "DW_AT_const_value";
5037 case DW_AT_containing_type
:
5038 return "DW_AT_containing_type";
5039 case DW_AT_default_value
:
5040 return "DW_AT_default_value";
5042 return "DW_AT_inline";
5043 case DW_AT_is_optional
:
5044 return "DW_AT_is_optional";
5045 case DW_AT_lower_bound
:
5046 return "DW_AT_lower_bound";
5047 case DW_AT_producer
:
5048 return "DW_AT_producer";
5049 case DW_AT_prototyped
:
5050 return "DW_AT_prototyped";
5051 case DW_AT_return_addr
:
5052 return "DW_AT_return_addr";
5053 case DW_AT_start_scope
:
5054 return "DW_AT_start_scope";
5055 case DW_AT_stride_size
:
5056 return "DW_AT_stride_size";
5057 case DW_AT_upper_bound
:
5058 return "DW_AT_upper_bound";
5059 case DW_AT_abstract_origin
:
5060 return "DW_AT_abstract_origin";
5061 case DW_AT_accessibility
:
5062 return "DW_AT_accessibility";
5063 case DW_AT_address_class
:
5064 return "DW_AT_address_class";
5065 case DW_AT_artificial
:
5066 return "DW_AT_artificial";
5067 case DW_AT_base_types
:
5068 return "DW_AT_base_types";
5069 case DW_AT_calling_convention
:
5070 return "DW_AT_calling_convention";
5072 return "DW_AT_count";
5073 case DW_AT_data_member_location
:
5074 return "DW_AT_data_member_location";
5075 case DW_AT_decl_column
:
5076 return "DW_AT_decl_column";
5077 case DW_AT_decl_file
:
5078 return "DW_AT_decl_file";
5079 case DW_AT_decl_line
:
5080 return "DW_AT_decl_line";
5081 case DW_AT_declaration
:
5082 return "DW_AT_declaration";
5083 case DW_AT_discr_list
:
5084 return "DW_AT_discr_list";
5085 case DW_AT_encoding
:
5086 return "DW_AT_encoding";
5087 case DW_AT_external
:
5088 return "DW_AT_external";
5089 case DW_AT_frame_base
:
5090 return "DW_AT_frame_base";
5092 return "DW_AT_friend";
5093 case DW_AT_identifier_case
:
5094 return "DW_AT_identifier_case";
5095 case DW_AT_macro_info
:
5096 return "DW_AT_macro_info";
5097 case DW_AT_namelist_items
:
5098 return "DW_AT_namelist_items";
5099 case DW_AT_priority
:
5100 return "DW_AT_priority";
5102 return "DW_AT_segment";
5103 case DW_AT_specification
:
5104 return "DW_AT_specification";
5105 case DW_AT_static_link
:
5106 return "DW_AT_static_link";
5108 return "DW_AT_type";
5109 case DW_AT_use_location
:
5110 return "DW_AT_use_location";
5111 case DW_AT_variable_parameter
:
5112 return "DW_AT_variable_parameter";
5113 case DW_AT_virtuality
:
5114 return "DW_AT_virtuality";
5115 case DW_AT_vtable_elem_location
:
5116 return "DW_AT_vtable_elem_location";
5119 case DW_AT_MIPS_fde
:
5120 return "DW_AT_MIPS_fde";
5121 case DW_AT_MIPS_loop_begin
:
5122 return "DW_AT_MIPS_loop_begin";
5123 case DW_AT_MIPS_tail_loop_begin
:
5124 return "DW_AT_MIPS_tail_loop_begin";
5125 case DW_AT_MIPS_epilog_begin
:
5126 return "DW_AT_MIPS_epilog_begin";
5127 case DW_AT_MIPS_loop_unroll_factor
:
5128 return "DW_AT_MIPS_loop_unroll_factor";
5129 case DW_AT_MIPS_software_pipeline_depth
:
5130 return "DW_AT_MIPS_software_pipeline_depth";
5131 case DW_AT_MIPS_linkage_name
:
5132 return "DW_AT_MIPS_linkage_name";
5135 case DW_AT_sf_names
:
5136 return "DW_AT_sf_names";
5137 case DW_AT_src_info
:
5138 return "DW_AT_src_info";
5139 case DW_AT_mac_info
:
5140 return "DW_AT_mac_info";
5141 case DW_AT_src_coords
:
5142 return "DW_AT_src_coords";
5143 case DW_AT_body_begin
:
5144 return "DW_AT_body_begin";
5145 case DW_AT_body_end
:
5146 return "DW_AT_body_end";
5148 return "DW_AT_<unknown>";
5152 /* Convert a DWARF value form code into its string name. */
5155 dwarf_form_name (register unsigned form
)
5160 return "DW_FORM_addr";
5161 case DW_FORM_block2
:
5162 return "DW_FORM_block2";
5163 case DW_FORM_block4
:
5164 return "DW_FORM_block4";
5166 return "DW_FORM_data2";
5168 return "DW_FORM_data4";
5170 return "DW_FORM_data8";
5171 case DW_FORM_string
:
5172 return "DW_FORM_string";
5174 return "DW_FORM_block";
5175 case DW_FORM_block1
:
5176 return "DW_FORM_block1";
5178 return "DW_FORM_data1";
5180 return "DW_FORM_flag";
5182 return "DW_FORM_sdata";
5184 return "DW_FORM_strp";
5186 return "DW_FORM_udata";
5187 case DW_FORM_ref_addr
:
5188 return "DW_FORM_ref_addr";
5190 return "DW_FORM_ref1";
5192 return "DW_FORM_ref2";
5194 return "DW_FORM_ref4";
5196 return "DW_FORM_ref8";
5197 case DW_FORM_ref_udata
:
5198 return "DW_FORM_ref_udata";
5199 case DW_FORM_indirect
:
5200 return "DW_FORM_indirect";
5202 return "DW_FORM_<unknown>";
5206 /* Convert a DWARF stack opcode into its string name. */
5209 dwarf_stack_op_name (register unsigned op
)
5214 return "DW_OP_addr";
5216 return "DW_OP_deref";
5218 return "DW_OP_const1u";
5220 return "DW_OP_const1s";
5222 return "DW_OP_const2u";
5224 return "DW_OP_const2s";
5226 return "DW_OP_const4u";
5228 return "DW_OP_const4s";
5230 return "DW_OP_const8u";
5232 return "DW_OP_const8s";
5234 return "DW_OP_constu";
5236 return "DW_OP_consts";
5240 return "DW_OP_drop";
5242 return "DW_OP_over";
5244 return "DW_OP_pick";
5246 return "DW_OP_swap";
5250 return "DW_OP_xderef";
5258 return "DW_OP_minus";
5270 return "DW_OP_plus";
5271 case DW_OP_plus_uconst
:
5272 return "DW_OP_plus_uconst";
5278 return "DW_OP_shra";
5296 return "DW_OP_skip";
5298 return "DW_OP_lit0";
5300 return "DW_OP_lit1";
5302 return "DW_OP_lit2";
5304 return "DW_OP_lit3";
5306 return "DW_OP_lit4";
5308 return "DW_OP_lit5";
5310 return "DW_OP_lit6";
5312 return "DW_OP_lit7";
5314 return "DW_OP_lit8";
5316 return "DW_OP_lit9";
5318 return "DW_OP_lit10";
5320 return "DW_OP_lit11";
5322 return "DW_OP_lit12";
5324 return "DW_OP_lit13";
5326 return "DW_OP_lit14";
5328 return "DW_OP_lit15";
5330 return "DW_OP_lit16";
5332 return "DW_OP_lit17";
5334 return "DW_OP_lit18";
5336 return "DW_OP_lit19";
5338 return "DW_OP_lit20";
5340 return "DW_OP_lit21";
5342 return "DW_OP_lit22";
5344 return "DW_OP_lit23";
5346 return "DW_OP_lit24";
5348 return "DW_OP_lit25";
5350 return "DW_OP_lit26";
5352 return "DW_OP_lit27";
5354 return "DW_OP_lit28";
5356 return "DW_OP_lit29";
5358 return "DW_OP_lit30";
5360 return "DW_OP_lit31";
5362 return "DW_OP_reg0";
5364 return "DW_OP_reg1";
5366 return "DW_OP_reg2";
5368 return "DW_OP_reg3";
5370 return "DW_OP_reg4";
5372 return "DW_OP_reg5";
5374 return "DW_OP_reg6";
5376 return "DW_OP_reg7";
5378 return "DW_OP_reg8";
5380 return "DW_OP_reg9";
5382 return "DW_OP_reg10";
5384 return "DW_OP_reg11";
5386 return "DW_OP_reg12";
5388 return "DW_OP_reg13";
5390 return "DW_OP_reg14";
5392 return "DW_OP_reg15";
5394 return "DW_OP_reg16";
5396 return "DW_OP_reg17";
5398 return "DW_OP_reg18";
5400 return "DW_OP_reg19";
5402 return "DW_OP_reg20";
5404 return "DW_OP_reg21";
5406 return "DW_OP_reg22";
5408 return "DW_OP_reg23";
5410 return "DW_OP_reg24";
5412 return "DW_OP_reg25";
5414 return "DW_OP_reg26";
5416 return "DW_OP_reg27";
5418 return "DW_OP_reg28";
5420 return "DW_OP_reg29";
5422 return "DW_OP_reg30";
5424 return "DW_OP_reg31";
5426 return "DW_OP_breg0";
5428 return "DW_OP_breg1";
5430 return "DW_OP_breg2";
5432 return "DW_OP_breg3";
5434 return "DW_OP_breg4";
5436 return "DW_OP_breg5";
5438 return "DW_OP_breg6";
5440 return "DW_OP_breg7";
5442 return "DW_OP_breg8";
5444 return "DW_OP_breg9";
5446 return "DW_OP_breg10";
5448 return "DW_OP_breg11";
5450 return "DW_OP_breg12";
5452 return "DW_OP_breg13";
5454 return "DW_OP_breg14";
5456 return "DW_OP_breg15";
5458 return "DW_OP_breg16";
5460 return "DW_OP_breg17";
5462 return "DW_OP_breg18";
5464 return "DW_OP_breg19";
5466 return "DW_OP_breg20";
5468 return "DW_OP_breg21";
5470 return "DW_OP_breg22";
5472 return "DW_OP_breg23";
5474 return "DW_OP_breg24";
5476 return "DW_OP_breg25";
5478 return "DW_OP_breg26";
5480 return "DW_OP_breg27";
5482 return "DW_OP_breg28";
5484 return "DW_OP_breg29";
5486 return "DW_OP_breg30";
5488 return "DW_OP_breg31";
5490 return "DW_OP_regx";
5492 return "DW_OP_fbreg";
5494 return "DW_OP_bregx";
5496 return "DW_OP_piece";
5497 case DW_OP_deref_size
:
5498 return "DW_OP_deref_size";
5499 case DW_OP_xderef_size
:
5500 return "DW_OP_xderef_size";
5504 return "OP_<unknown>";
5509 dwarf_bool_name (unsigned mybool
)
5517 /* Convert a DWARF type code into its string name. */
5520 dwarf_type_encoding_name (register unsigned enc
)
5524 case DW_ATE_address
:
5525 return "DW_ATE_address";
5526 case DW_ATE_boolean
:
5527 return "DW_ATE_boolean";
5528 case DW_ATE_complex_float
:
5529 return "DW_ATE_complex_float";
5531 return "DW_ATE_float";
5533 return "DW_ATE_signed";
5534 case DW_ATE_signed_char
:
5535 return "DW_ATE_signed_char";
5536 case DW_ATE_unsigned
:
5537 return "DW_ATE_unsigned";
5538 case DW_ATE_unsigned_char
:
5539 return "DW_ATE_unsigned_char";
5541 return "DW_ATE_<unknown>";
5545 /* Convert a DWARF call frame info operation to its string name. */
5549 dwarf_cfi_name (register unsigned cfi_opc
)
5553 case DW_CFA_advance_loc
:
5554 return "DW_CFA_advance_loc";
5556 return "DW_CFA_offset";
5557 case DW_CFA_restore
:
5558 return "DW_CFA_restore";
5560 return "DW_CFA_nop";
5561 case DW_CFA_set_loc
:
5562 return "DW_CFA_set_loc";
5563 case DW_CFA_advance_loc1
:
5564 return "DW_CFA_advance_loc1";
5565 case DW_CFA_advance_loc2
:
5566 return "DW_CFA_advance_loc2";
5567 case DW_CFA_advance_loc4
:
5568 return "DW_CFA_advance_loc4";
5569 case DW_CFA_offset_extended
:
5570 return "DW_CFA_offset_extended";
5571 case DW_CFA_restore_extended
:
5572 return "DW_CFA_restore_extended";
5573 case DW_CFA_undefined
:
5574 return "DW_CFA_undefined";
5575 case DW_CFA_same_value
:
5576 return "DW_CFA_same_value";
5577 case DW_CFA_register
:
5578 return "DW_CFA_register";
5579 case DW_CFA_remember_state
:
5580 return "DW_CFA_remember_state";
5581 case DW_CFA_restore_state
:
5582 return "DW_CFA_restore_state";
5583 case DW_CFA_def_cfa
:
5584 return "DW_CFA_def_cfa";
5585 case DW_CFA_def_cfa_register
:
5586 return "DW_CFA_def_cfa_register";
5587 case DW_CFA_def_cfa_offset
:
5588 return "DW_CFA_def_cfa_offset";
5589 /* SGI/MIPS specific */
5590 case DW_CFA_MIPS_advance_loc8
:
5591 return "DW_CFA_MIPS_advance_loc8";
5593 return "DW_CFA_<unknown>";
5599 dump_die (struct die_info
*die
)
5603 fprintf (stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
5604 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
5605 fprintf (stderr
, "\thas children: %s\n",
5606 dwarf_bool_name (die
->has_children
));
5608 fprintf (stderr
, "\tattributes:\n");
5609 for (i
= 0; i
< die
->num_attrs
; ++i
)
5611 fprintf (stderr
, "\t\t%s (%s) ",
5612 dwarf_attr_name (die
->attrs
[i
].name
),
5613 dwarf_form_name (die
->attrs
[i
].form
));
5614 switch (die
->attrs
[i
].form
)
5616 case DW_FORM_ref_addr
:
5618 fprintf (stderr
, "address: ");
5619 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
5621 case DW_FORM_block2
:
5622 case DW_FORM_block4
:
5624 case DW_FORM_block1
:
5625 fprintf (stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
5636 fprintf (stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
5638 case DW_FORM_string
:
5640 fprintf (stderr
, "string: \"%s\"",
5641 DW_STRING (&die
->attrs
[i
])
5642 ? DW_STRING (&die
->attrs
[i
]) : "");
5645 if (DW_UNSND (&die
->attrs
[i
]))
5646 fprintf (stderr
, "flag: TRUE");
5648 fprintf (stderr
, "flag: FALSE");
5650 case DW_FORM_indirect
:
5651 /* the reader will have reduced the indirect form to
5652 the "base form" so this form should not occur */
5653 fprintf (stderr
, "unexpected attribute form: DW_FORM_indirect");
5656 fprintf (stderr
, "unsupported attribute form: %d.",
5657 die
->attrs
[i
].form
);
5659 fprintf (stderr
, "\n");
5664 dump_die_list (struct die_info
*die
)
5674 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
5677 struct die_info
*old
;
5679 h
= (offset
% REF_HASH_SIZE
);
5680 old
= die_ref_table
[h
];
5681 die
->next_ref
= old
;
5682 die_ref_table
[h
] = die
;
5687 dwarf2_empty_hash_tables (void)
5689 memset (die_ref_table
, 0, sizeof (die_ref_table
));
5693 dwarf2_get_ref_die_offset (struct attribute
*attr
)
5695 unsigned int result
= 0;
5699 case DW_FORM_ref_addr
:
5700 result
= DW_ADDR (attr
);
5706 case DW_FORM_ref_udata
:
5707 result
= cu_header_offset
+ DW_UNSND (attr
);
5710 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
5715 static struct die_info
*
5716 follow_die_ref (unsigned int offset
)
5718 struct die_info
*die
;
5721 h
= (offset
% REF_HASH_SIZE
);
5722 die
= die_ref_table
[h
];
5725 if (die
->offset
== offset
)
5729 die
= die
->next_ref
;
5734 static struct type
*
5735 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
5737 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
5739 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
5743 /* Look for this particular type in the fundamental type vector. If
5744 one is not found, create and install one appropriate for the
5745 current language and the current target machine. */
5747 if (ftypes
[typeid] == NULL
)
5749 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
5752 return (ftypes
[typeid]);
5755 /* Decode simple location descriptions.
5756 Given a pointer to a dwarf block that defines a location, compute
5757 the location and return the value.
5759 FIXME: This is a kludge until we figure out a better
5760 way to handle the location descriptions.
5761 Gdb's design does not mesh well with the DWARF2 notion of a location
5762 computing interpreter, which is a shame because the flexibility goes unused.
5763 FIXME: Implement more operations as necessary.
5765 A location description containing no operations indicates that the
5766 object is optimized out. The global optimized_out flag is set for
5767 those, the return value is meaningless.
5769 When the result is a register number, the global isreg flag is set,
5770 otherwise it is cleared.
5772 When the result is a base register offset, the global offreg flag is set
5773 and the register number is returned in basereg, otherwise it is cleared.
5775 When the DW_OP_fbreg operation is encountered without a corresponding
5776 DW_AT_frame_base attribute, the global islocal flag is set.
5777 Hopefully the machine dependent code knows how to set up a virtual
5778 frame pointer for the local references.
5780 Note that stack[0] is unused except as a default error return.
5781 Note that stack overflow is not yet handled. */
5784 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
5785 const struct comp_unit_head
*cu_header
)
5788 int size
= blk
->size
;
5789 char *data
= blk
->data
;
5790 CORE_ADDR stack
[64];
5792 unsigned int bytes_read
, unsnd
;
5843 stack
[++stacki
] = op
- DW_OP_reg0
;
5848 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
5850 #if defined(HARRIS_TARGET) && defined(_M88K)
5851 /* The Harris 88110 gdb ports have long kept their special reg
5852 numbers between their gp-regs and their x-regs. This is
5853 not how our dwarf is generated. Punt. */
5856 stack
[++stacki
] = unsnd
;
5892 basereg
= op
- DW_OP_breg0
;
5893 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5899 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
5901 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5906 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5908 if (frame_base_reg
>= 0)
5911 basereg
= frame_base_reg
;
5912 stack
[stacki
] += frame_base_offset
;
5916 complain (&dwarf2_missing_at_frame_base
);
5922 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
5923 cu_header
, &bytes_read
);
5928 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
5933 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
5938 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
5943 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
5948 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
5953 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
5958 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
5964 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
5969 stack
[stacki
- 1] += stack
[stacki
];
5973 case DW_OP_plus_uconst
:
5974 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
5979 stack
[stacki
- 1] = stack
[stacki
] - stack
[stacki
- 1];
5985 /* If we're not the last op, then we definitely can't encode
5986 this using GDB's address_class enum. */
5988 complain (&dwarf2_complex_location_expr
);
5992 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name (op
));
5993 return (stack
[stacki
]);
5996 return (stack
[stacki
]);
5999 /* memory allocation interface */
6003 dwarf2_free_tmp_obstack (PTR ignore
)
6005 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6008 static struct dwarf_block
*
6009 dwarf_alloc_block (void)
6011 struct dwarf_block
*blk
;
6013 blk
= (struct dwarf_block
*)
6014 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6018 static struct abbrev_info
*
6019 dwarf_alloc_abbrev (void)
6021 struct abbrev_info
*abbrev
;
6023 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6024 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6028 static struct die_info
*
6029 dwarf_alloc_die (void)
6031 struct die_info
*die
;
6033 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6034 memset (die
, 0, sizeof (struct die_info
));