1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
10 support in dwarfread.c
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or (at
17 your option) any later version.
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330,
27 Boston, MA 02111-1307, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
46 #include "gdb_string.h"
47 #include "gdb_assert.h"
48 #include <sys/types.h>
50 #ifndef DWARF2_REG_TO_REGNUM
51 #define DWARF2_REG_TO_REGNUM(REG) (REG)
55 /* .debug_info header for a compilation unit
56 Because of alignment constraints, this structure has padding and cannot
57 be mapped directly onto the beginning of the .debug_info section. */
58 typedef struct comp_unit_header
60 unsigned int length
; /* length of the .debug_info
62 unsigned short version
; /* version number -- 2 for DWARF
64 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
65 unsigned char addr_size
; /* byte size of an address -- 4 */
68 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
71 /* .debug_pubnames header
72 Because of alignment constraints, this structure has padding and cannot
73 be mapped directly onto the beginning of the .debug_info section. */
74 typedef struct pubnames_header
76 unsigned int length
; /* length of the .debug_pubnames
78 unsigned char version
; /* version number -- 2 for DWARF
80 unsigned int info_offset
; /* offset into .debug_info section */
81 unsigned int info_size
; /* byte size of .debug_info section
85 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
87 /* .debug_pubnames header
88 Because of alignment constraints, this structure has padding and cannot
89 be mapped directly onto the beginning of the .debug_info section. */
90 typedef struct aranges_header
92 unsigned int length
; /* byte len of the .debug_aranges
94 unsigned short version
; /* version number -- 2 for DWARF
96 unsigned int info_offset
; /* offset into .debug_info section */
97 unsigned char addr_size
; /* byte size of an address */
98 unsigned char seg_size
; /* byte size of segment descriptor */
101 #define _ACTUAL_ARANGES_HEADER_SIZE 12
103 /* .debug_line statement program prologue
104 Because of alignment constraints, this structure has padding and cannot
105 be mapped directly onto the beginning of the .debug_info section. */
106 typedef struct statement_prologue
108 unsigned int total_length
; /* byte length of the statement
110 unsigned short version
; /* version number -- 2 for DWARF
112 unsigned int prologue_length
; /* # bytes between prologue &
114 unsigned char minimum_instruction_length
; /* byte size of
116 unsigned char default_is_stmt
; /* initial value of is_stmt
119 unsigned char line_range
;
120 unsigned char opcode_base
; /* number assigned to first special
122 unsigned char *standard_opcode_lengths
;
126 /* offsets and sizes of debugging sections */
128 static file_ptr dwarf_info_offset
;
129 static file_ptr dwarf_abbrev_offset
;
130 static file_ptr dwarf_line_offset
;
131 static file_ptr dwarf_pubnames_offset
;
132 static file_ptr dwarf_aranges_offset
;
133 static file_ptr dwarf_loc_offset
;
134 static file_ptr dwarf_macinfo_offset
;
135 static file_ptr dwarf_str_offset
;
136 static file_ptr dwarf_ranges_offset
;
137 file_ptr dwarf_frame_offset
;
138 file_ptr dwarf_eh_frame_offset
;
140 static unsigned int dwarf_info_size
;
141 static unsigned int dwarf_abbrev_size
;
142 static unsigned int dwarf_line_size
;
143 static unsigned int dwarf_pubnames_size
;
144 static unsigned int dwarf_aranges_size
;
145 static unsigned int dwarf_loc_size
;
146 static unsigned int dwarf_macinfo_size
;
147 static unsigned int dwarf_str_size
;
148 static unsigned int dwarf_ranges_size
;
149 unsigned int dwarf_frame_size
;
150 unsigned int dwarf_eh_frame_size
;
152 static asection
*dwarf_info_section
;
153 static asection
*dwarf_abbrev_section
;
154 static asection
*dwarf_line_section
;
155 static asection
*dwarf_pubnames_section
;
156 static asection
*dwarf_aranges_section
;
157 static asection
*dwarf_loc_section
;
158 static asection
*dwarf_macinfo_section
;
159 static asection
*dwarf_str_section
;
160 static asection
*dwarf_ranges_section
;
161 asection
*dwarf_frame_section
;
162 asection
*dwarf_eh_frame_section
;
164 /* names of the debugging sections */
166 #define INFO_SECTION ".debug_info"
167 #define ABBREV_SECTION ".debug_abbrev"
168 #define LINE_SECTION ".debug_line"
169 #define PUBNAMES_SECTION ".debug_pubnames"
170 #define ARANGES_SECTION ".debug_aranges"
171 #define LOC_SECTION ".debug_loc"
172 #define MACINFO_SECTION ".debug_macinfo"
173 #define STR_SECTION ".debug_str"
174 #define RANGES_SECTION ".debug_ranges"
175 #define FRAME_SECTION ".debug_frame"
176 #define EH_FRAME_SECTION ".eh_frame"
178 /* local data types */
180 /* We hold several abbreviation tables in memory at the same time. */
181 #ifndef ABBREV_HASH_SIZE
182 #define ABBREV_HASH_SIZE 121
185 /* The data in a compilation unit header, after target2host
186 translation, looks like this. */
187 struct comp_unit_head
189 unsigned long length
;
191 unsigned int abbrev_offset
;
192 unsigned char addr_size
;
193 unsigned char signed_addr_p
;
194 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
195 unsigned int initial_length_size
; /* size of the length field; either
198 /* Offset to the first byte of this compilation unit header in the
199 * .debug_info section, for resolving relative reference dies. */
203 /* Pointer to this compilation unit header in the .debug_info
208 /* Pointer to the first die of this compilatio unit. This will
209 * be the first byte following the compilation unit header. */
213 /* Pointer to the next compilation unit header in the program. */
215 struct comp_unit_head
*next
;
217 /* DWARF abbreviation table associated with this compilation unit */
219 struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
221 /* Pointer to the DIE associated with the compilation unit. */
223 struct die_info
*die
;
226 /* The line number information for a compilation unit (found in the
227 .debug_line section) begins with a "statement program header",
228 which contains the following information. */
231 unsigned int total_length
;
232 unsigned short version
;
233 unsigned int header_length
;
234 unsigned char minimum_instruction_length
;
235 unsigned char default_is_stmt
;
237 unsigned char line_range
;
238 unsigned char opcode_base
;
240 /* standard_opcode_lengths[i] is the number of operands for the
241 standard opcode whose value is i. This means that
242 standard_opcode_lengths[0] is unused, and the last meaningful
243 element is standard_opcode_lengths[opcode_base - 1]. */
244 unsigned char *standard_opcode_lengths
;
246 /* The include_directories table. NOTE! These strings are not
247 allocated with xmalloc; instead, they are pointers into
248 debug_line_buffer. If you try to free them, `free' will get
250 unsigned int num_include_dirs
, include_dirs_size
;
253 /* The file_names table. NOTE! These strings are not allocated
254 with xmalloc; instead, they are pointers into debug_line_buffer.
255 Don't try to free them directly. */
256 unsigned int num_file_names
, file_names_size
;
260 unsigned int dir_index
;
261 unsigned int mod_time
;
265 /* The start and end of the statement program following this
266 header. These point into dwarf_line_buffer. */
267 char *statement_program_start
, *statement_program_end
;
270 /* When we construct a partial symbol table entry we only
271 need this much information. */
272 struct partial_die_info
275 unsigned char has_children
;
276 unsigned char is_external
;
277 unsigned char is_declaration
;
278 unsigned char has_type
;
285 struct dwarf_block
*locdesc
;
286 unsigned int language
;
290 /* This data structure holds the information of an abbrev. */
293 unsigned int number
; /* number identifying abbrev */
294 enum dwarf_tag tag
; /* dwarf tag */
295 int has_children
; /* boolean */
296 unsigned int num_attrs
; /* number of attributes */
297 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
298 struct abbrev_info
*next
; /* next in chain */
303 enum dwarf_attribute name
;
304 enum dwarf_form form
;
307 /* This data structure holds a complete die structure. */
310 enum dwarf_tag tag
; /* Tag indicating type of die */
311 unsigned short has_children
; /* Does the die have children */
312 unsigned int abbrev
; /* Abbrev number */
313 unsigned int offset
; /* Offset in .debug_info section */
314 unsigned int num_attrs
; /* Number of attributes */
315 struct attribute
*attrs
; /* An array of attributes */
316 struct die_info
*next_ref
; /* Next die in ref hash table */
317 struct die_info
*next
; /* Next die in linked list */
318 struct type
*type
; /* Cached type information */
321 /* Attributes have a name and a value */
324 enum dwarf_attribute name
;
325 enum dwarf_form form
;
329 struct dwarf_block
*blk
;
337 struct function_range
340 CORE_ADDR lowpc
, highpc
;
342 struct function_range
*next
;
345 static struct function_range
*cu_first_fn
, *cu_last_fn
, *cu_cached_fn
;
347 /* Get at parts of an attribute structure */
349 #define DW_STRING(attr) ((attr)->u.str)
350 #define DW_UNSND(attr) ((attr)->u.unsnd)
351 #define DW_BLOCK(attr) ((attr)->u.blk)
352 #define DW_SND(attr) ((attr)->u.snd)
353 #define DW_ADDR(attr) ((attr)->u.addr)
355 /* Blocks are a bunch of untyped bytes. */
362 #ifndef ATTR_ALLOC_CHUNK
363 #define ATTR_ALLOC_CHUNK 4
366 /* A hash table of die offsets for following references. */
367 #ifndef REF_HASH_SIZE
368 #define REF_HASH_SIZE 1021
371 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
373 /* Obstack for allocating temporary storage used during symbol reading. */
374 static struct obstack dwarf2_tmp_obstack
;
376 /* Offset to the first byte of the current compilation unit header,
377 for resolving relative reference dies. */
378 static unsigned int cu_header_offset
;
380 /* Allocate fields for structs, unions and enums in this size. */
381 #ifndef DW_FIELD_ALLOC_CHUNK
382 #define DW_FIELD_ALLOC_CHUNK 4
385 /* The language we are debugging. */
386 static enum language cu_language
;
387 static const struct language_defn
*cu_language_defn
;
389 /* Actually data from the sections. */
390 static char *dwarf_info_buffer
;
391 static char *dwarf_abbrev_buffer
;
392 static char *dwarf_line_buffer
;
393 static char *dwarf_str_buffer
;
394 static char *dwarf_macinfo_buffer
;
395 static char *dwarf_ranges_buffer
;
397 /* A zeroed version of a partial die for initialization purposes. */
398 static struct partial_die_info zeroed_partial_die
;
400 /* The generic symbol table building routines have separate lists for
401 file scope symbols and all all other scopes (local scopes). So
402 we need to select the right one to pass to add_symbol_to_list().
403 We do it by keeping a pointer to the correct list in list_in_scope.
405 FIXME: The original dwarf code just treated the file scope as the first
406 local scope, and all other local scopes as nested local scopes, and worked
407 fine. Check to see if we really need to distinguish these
409 static struct pending
**list_in_scope
= &file_symbols
;
411 /* FIXME: decode_locdesc sets these variables to describe the location
412 to the caller. These ought to be a structure or something. If
413 none of the flags are set, the object lives at the address returned
414 by decode_locdesc. */
416 static int optimized_out
; /* No ops in location in expression,
417 so object was optimized out. */
418 static int isreg
; /* Object lives in register.
419 decode_locdesc's return value is
420 the register number. */
421 static int offreg
; /* Object's address is the sum of the
422 register specified by basereg, plus
423 the offset returned. */
424 static int basereg
; /* See `offreg'. */
425 static int isderef
; /* Value described by flags above is
426 the address of a pointer to the object. */
427 static int islocal
; /* Variable is at the returned offset
428 from the frame start, but there's
429 no identified frame pointer for
430 this function, so we can't say
431 which register it's relative to;
433 static int is_thread_local
; /* Variable is at a constant offset in the
434 thread-local storage block for the
435 current thread and the dynamic linker
436 module containing this expression.
437 decode_locdesc returns the offset from
440 /* DW_AT_frame_base values for the current function.
441 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
442 contains the register number for the frame register.
443 frame_base_offset is the offset from the frame register to the
444 virtual stack frame. */
445 static int frame_base_reg
;
446 static CORE_ADDR frame_base_offset
;
448 /* This value is added to each symbol value. FIXME: Generalize to
449 the section_offsets structure used by dbxread (once this is done,
450 pass the appropriate section number to end_symtab). */
451 static CORE_ADDR baseaddr
; /* Add to each symbol value */
453 /* We put a pointer to this structure in the read_symtab_private field
455 The complete dwarf information for an objfile is kept in the
456 psymbol_obstack, so that absolute die references can be handled.
457 Most of the information in this structure is related to an entire
458 object file and could be passed via the sym_private field of the objfile.
459 It is however conceivable that dwarf2 might not be the only type
460 of symbols read from an object file. */
464 /* Pointer to start of dwarf info buffer for the objfile. */
466 char *dwarf_info_buffer
;
468 /* Offset in dwarf_info_buffer for this compilation unit. */
470 unsigned long dwarf_info_offset
;
472 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
474 char *dwarf_abbrev_buffer
;
476 /* Size of dwarf abbreviation section for the objfile. */
478 unsigned int dwarf_abbrev_size
;
480 /* Pointer to start of dwarf line buffer for the objfile. */
482 char *dwarf_line_buffer
;
484 /* Size of dwarf_line_buffer, in bytes. */
486 unsigned int dwarf_line_size
;
488 /* Pointer to start of dwarf string buffer for the objfile. */
490 char *dwarf_str_buffer
;
492 /* Size of dwarf string section for the objfile. */
494 unsigned int dwarf_str_size
;
496 /* Pointer to start of dwarf macro buffer for the objfile. */
498 char *dwarf_macinfo_buffer
;
500 /* Size of dwarf macinfo section for the objfile. */
502 unsigned int dwarf_macinfo_size
;
504 /* Pointer to start of dwarf ranges buffer for the objfile. */
506 char *dwarf_ranges_buffer
;
508 /* Size of dwarf ranges buffer for the objfile. */
510 unsigned int dwarf_ranges_size
;
514 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
515 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
516 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
517 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
518 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
519 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
520 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
521 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
522 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
523 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
524 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
525 #define DWARF_RANGES_BUFFER(p) (PST_PRIVATE(p)->dwarf_ranges_buffer)
526 #define DWARF_RANGES_SIZE(p) (PST_PRIVATE(p)->dwarf_ranges_size)
528 /* Maintain an array of referenced fundamental types for the current
529 compilation unit being read. For DWARF version 1, we have to construct
530 the fundamental types on the fly, since no information about the
531 fundamental types is supplied. Each such fundamental type is created by
532 calling a language dependent routine to create the type, and then a
533 pointer to that type is then placed in the array at the index specified
534 by it's FT_<TYPENAME> value. The array has a fixed size set by the
535 FT_NUM_MEMBERS compile time constant, which is the number of predefined
536 fundamental types gdb knows how to construct. */
537 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
539 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
540 but this would require a corresponding change in unpack_field_as_long
542 static int bits_per_byte
= 8;
544 /* The routines that read and process dies for a C struct or C++ class
545 pass lists of data member fields and lists of member function fields
546 in an instance of a field_info structure, as defined below. */
549 /* List of data member and baseclasses fields. */
552 struct nextfield
*next
;
559 /* Number of fields. */
562 /* Number of baseclasses. */
565 /* Set if the accesibility of one of the fields is not public. */
566 int non_public_fields
;
568 /* Member function fields array, entries are allocated in the order they
569 are encountered in the object file. */
572 struct nextfnfield
*next
;
573 struct fn_field fnfield
;
577 /* Member function fieldlist array, contains name of possibly overloaded
578 member function, number of overloaded member functions and a pointer
579 to the head of the member function field chain. */
584 struct nextfnfield
*head
;
588 /* Number of entries in the fnfieldlists array. */
592 /* Various complaints about symbol reading that don't abort the process */
595 dwarf2_non_const_array_bound_ignored_complaint (const char *arg1
)
597 complaint (&symfile_complaints
, "non-constant array bounds form '%s' ignored",
602 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
604 complaint (&symfile_complaints
,
605 "statement list doesn't fit in .debug_line section");
609 dwarf2_complex_location_expr_complaint (void)
611 complaint (&symfile_complaints
, "location expression too complex");
615 dwarf2_unsupported_at_frame_base_complaint (const char *arg1
)
617 complaint (&symfile_complaints
,
618 "unsupported DW_AT_frame_base for function '%s'", arg1
);
622 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
625 complaint (&symfile_complaints
,
626 "const value length mismatch for '%s', got %d, expected %d", arg1
,
631 dwarf2_macros_too_long_complaint (void)
633 complaint (&symfile_complaints
,
634 "macro info runs off end of `.debug_macinfo' section");
638 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
640 complaint (&symfile_complaints
,
641 "macro debug info contains a malformed macro definition:\n`%s'",
646 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
648 complaint (&symfile_complaints
,
649 "invalid attribute class or form for '%s' in '%s'", arg1
, arg2
);
652 /* local function prototypes */
654 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
657 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
660 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
662 static char *scan_partial_symbols (char *, struct objfile
*,
663 CORE_ADDR
*, CORE_ADDR
*,
664 const struct comp_unit_head
*);
666 static void add_partial_symbol (struct partial_die_info
*, struct objfile
*,
667 const struct comp_unit_head
*);
669 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
671 static void psymtab_to_symtab_1 (struct partial_symtab
*);
673 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int,
676 static void dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
);
678 static void dwarf2_empty_abbrev_table (void *);
680 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
681 const struct comp_unit_head
*cu_header
);
683 static char *read_partial_die (struct partial_die_info
*,
685 const struct comp_unit_head
*);
687 static char *read_full_die (struct die_info
**, bfd
*, char *,
688 const struct comp_unit_head
*);
690 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
691 bfd
*, char *, const struct comp_unit_head
*);
693 static char *read_attribute_value (struct attribute
*, unsigned,
694 bfd
*, char *, const struct comp_unit_head
*);
696 static unsigned int read_1_byte (bfd
*, char *);
698 static int read_1_signed_byte (bfd
*, char *);
700 static unsigned int read_2_bytes (bfd
*, char *);
702 static unsigned int read_4_bytes (bfd
*, char *);
704 static unsigned long read_8_bytes (bfd
*, char *);
706 static CORE_ADDR
read_address (bfd
*, char *ptr
, const struct comp_unit_head
*,
709 static LONGEST
read_initial_length (bfd
*, char *,
710 struct comp_unit_head
*, int *bytes_read
);
712 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
715 static char *read_n_bytes (bfd
*, char *, unsigned int);
717 static char *read_string (bfd
*, char *, unsigned int *);
719 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
722 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
724 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
726 static void set_cu_language (unsigned int);
728 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
730 static int die_is_declaration (struct die_info
*);
732 static void free_line_header (struct line_header
*lh
);
734 static struct line_header
*(dwarf_decode_line_header
735 (unsigned int offset
,
737 const struct comp_unit_head
*cu_header
));
739 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
740 const struct comp_unit_head
*);
742 static void dwarf2_start_subfile (char *, char *);
744 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
745 struct objfile
*, const struct comp_unit_head
*);
747 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
748 struct objfile
*, const struct comp_unit_head
*);
750 static void dwarf2_const_value_data (struct attribute
*attr
,
754 static struct type
*die_type (struct die_info
*, struct objfile
*,
755 const struct comp_unit_head
*);
757 static struct type
*die_containing_type (struct die_info
*, struct objfile
*,
758 const struct comp_unit_head
*);
761 static struct type
*type_at_offset (unsigned int, struct objfile
*);
764 static struct type
*tag_type_to_type (struct die_info
*, struct objfile
*,
765 const struct comp_unit_head
*);
767 static void read_type_die (struct die_info
*, struct objfile
*,
768 const struct comp_unit_head
*);
770 static void read_typedef (struct die_info
*, struct objfile
*,
771 const struct comp_unit_head
*);
773 static void read_base_type (struct die_info
*, struct objfile
*);
775 static void read_file_scope (struct die_info
*, struct objfile
*,
776 const struct comp_unit_head
*);
778 static void read_func_scope (struct die_info
*, struct objfile
*,
779 const struct comp_unit_head
*);
781 static void read_lexical_block_scope (struct die_info
*, struct objfile
*,
782 const struct comp_unit_head
*);
784 static int dwarf2_get_pc_bounds (struct die_info
*,
785 CORE_ADDR
*, CORE_ADDR
*, struct objfile
*,
786 const struct comp_unit_head
*);
788 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
789 struct objfile
*, const struct comp_unit_head
*);
791 static void dwarf2_attach_fields_to_type (struct field_info
*,
792 struct type
*, struct objfile
*);
794 static void dwarf2_add_member_fn (struct field_info
*,
795 struct die_info
*, struct type
*,
796 struct objfile
*objfile
,
797 const struct comp_unit_head
*);
799 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
800 struct type
*, struct objfile
*);
802 static void read_structure_scope (struct die_info
*, struct objfile
*,
803 const struct comp_unit_head
*);
805 static void read_common_block (struct die_info
*, struct objfile
*,
806 const struct comp_unit_head
*);
808 static void read_namespace (struct die_info
*die
, struct objfile
*objfile
,
809 const struct comp_unit_head
*cu_header
);
811 static void read_enumeration (struct die_info
*, struct objfile
*,
812 const struct comp_unit_head
*);
814 static struct type
*dwarf_base_type (int, int, struct objfile
*);
816 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct objfile
*,
817 const struct comp_unit_head
*);
819 static void read_array_type (struct die_info
*, struct objfile
*,
820 const struct comp_unit_head
*);
822 static void read_tag_pointer_type (struct die_info
*, struct objfile
*,
823 const struct comp_unit_head
*);
825 static void read_tag_ptr_to_member_type (struct die_info
*, struct objfile
*,
826 const struct comp_unit_head
*);
828 static void read_tag_reference_type (struct die_info
*, struct objfile
*,
829 const struct comp_unit_head
*);
831 static void read_tag_const_type (struct die_info
*, struct objfile
*,
832 const struct comp_unit_head
*);
834 static void read_tag_volatile_type (struct die_info
*, struct objfile
*,
835 const struct comp_unit_head
*);
837 static void read_tag_string_type (struct die_info
*, struct objfile
*);
839 static void read_subroutine_type (struct die_info
*, struct objfile
*,
840 const struct comp_unit_head
*);
842 static struct die_info
*read_comp_unit (char *, bfd
*,
843 const struct comp_unit_head
*);
845 static void free_die_list (struct die_info
*);
847 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
849 static void process_die (struct die_info
*, struct objfile
*,
850 const struct comp_unit_head
*);
852 static char *dwarf2_linkage_name (struct die_info
*);
854 static char *dwarf_tag_name (unsigned int);
856 static char *dwarf_attr_name (unsigned int);
858 static char *dwarf_form_name (unsigned int);
860 static char *dwarf_stack_op_name (unsigned int);
862 static char *dwarf_bool_name (unsigned int);
864 static char *dwarf_type_encoding_name (unsigned int);
867 static char *dwarf_cfi_name (unsigned int);
869 struct die_info
*copy_die (struct die_info
*);
872 static struct die_info
*sibling_die (struct die_info
*);
874 static void dump_die (struct die_info
*);
876 static void dump_die_list (struct die_info
*);
878 static void store_in_ref_table (unsigned int, struct die_info
*);
880 static void dwarf2_empty_hash_tables (void);
882 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
884 static struct die_info
*follow_die_ref (unsigned int);
886 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
888 /* memory allocation interface */
890 static void dwarf2_free_tmp_obstack (void *);
892 static struct dwarf_block
*dwarf_alloc_block (void);
894 static struct abbrev_info
*dwarf_alloc_abbrev (void);
896 static struct die_info
*dwarf_alloc_die (void);
898 static void initialize_cu_func_list (void);
900 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
902 static void dwarf_decode_macros (struct line_header
*, unsigned int,
903 char *, bfd
*, const struct comp_unit_head
*,
906 static int attr_form_is_block (struct attribute
*);
908 /* Try to locate the sections we need for DWARF 2 debugging
909 information and return true if we have enough to do something. */
912 dwarf2_has_info (bfd
*abfd
)
914 dwarf_info_offset
= 0;
915 dwarf_abbrev_offset
= 0;
916 dwarf_line_offset
= 0;
917 dwarf_str_offset
= 0;
918 dwarf_macinfo_offset
= 0;
919 dwarf_frame_offset
= 0;
920 dwarf_eh_frame_offset
= 0;
921 dwarf_ranges_offset
= 0;
923 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
924 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
934 /* This function is mapped across the sections and remembers the
935 offset and size of each of the debugging sections we are interested
939 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
941 if (STREQ (sectp
->name
, INFO_SECTION
))
943 dwarf_info_offset
= sectp
->filepos
;
944 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
945 dwarf_info_section
= sectp
;
947 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
949 dwarf_abbrev_offset
= sectp
->filepos
;
950 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
951 dwarf_abbrev_section
= sectp
;
953 else if (STREQ (sectp
->name
, LINE_SECTION
))
955 dwarf_line_offset
= sectp
->filepos
;
956 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
957 dwarf_line_section
= sectp
;
959 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
961 dwarf_pubnames_offset
= sectp
->filepos
;
962 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
963 dwarf_pubnames_section
= sectp
;
965 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
967 dwarf_aranges_offset
= sectp
->filepos
;
968 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
969 dwarf_aranges_section
= sectp
;
971 else if (STREQ (sectp
->name
, LOC_SECTION
))
973 dwarf_loc_offset
= sectp
->filepos
;
974 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
975 dwarf_loc_section
= sectp
;
977 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
979 dwarf_macinfo_offset
= sectp
->filepos
;
980 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
981 dwarf_macinfo_section
= sectp
;
983 else if (STREQ (sectp
->name
, STR_SECTION
))
985 dwarf_str_offset
= sectp
->filepos
;
986 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
987 dwarf_str_section
= sectp
;
989 else if (STREQ (sectp
->name
, FRAME_SECTION
))
991 dwarf_frame_offset
= sectp
->filepos
;
992 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
993 dwarf_frame_section
= sectp
;
995 else if (STREQ (sectp
->name
, EH_FRAME_SECTION
))
997 dwarf_eh_frame_offset
= sectp
->filepos
;
998 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
999 dwarf_eh_frame_section
= sectp
;
1001 else if (STREQ (sectp
->name
, RANGES_SECTION
))
1003 dwarf_ranges_offset
= sectp
->filepos
;
1004 dwarf_ranges_size
= bfd_get_section_size_before_reloc (sectp
);
1005 dwarf_ranges_section
= sectp
;
1009 /* Build a partial symbol table. */
1012 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1015 /* We definitely need the .debug_info and .debug_abbrev sections */
1017 dwarf_info_buffer
= dwarf2_read_section (objfile
,
1020 dwarf_info_section
);
1021 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
1022 dwarf_abbrev_offset
,
1024 dwarf_abbrev_section
);
1026 if (dwarf_line_offset
)
1027 dwarf_line_buffer
= dwarf2_read_section (objfile
,
1030 dwarf_line_section
);
1032 dwarf_line_buffer
= NULL
;
1034 if (dwarf_str_offset
)
1035 dwarf_str_buffer
= dwarf2_read_section (objfile
,
1040 dwarf_str_buffer
= NULL
;
1042 if (dwarf_macinfo_offset
)
1043 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1044 dwarf_macinfo_offset
,
1046 dwarf_macinfo_section
);
1048 dwarf_macinfo_buffer
= NULL
;
1050 if (dwarf_ranges_offset
)
1051 dwarf_ranges_buffer
= dwarf2_read_section (objfile
,
1052 dwarf_ranges_offset
,
1054 dwarf_ranges_section
);
1056 dwarf_ranges_buffer
= NULL
;
1059 || (objfile
->global_psymbols
.size
== 0
1060 && objfile
->static_psymbols
.size
== 0))
1062 init_psymbol_list (objfile
, 1024);
1066 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1068 /* Things are significantly easier if we have .debug_aranges and
1069 .debug_pubnames sections */
1071 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1075 /* only test this case for now */
1077 /* In this case we have to work a bit harder */
1078 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1083 /* Build the partial symbol table from the information in the
1084 .debug_pubnames and .debug_aranges sections. */
1087 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1089 bfd
*abfd
= objfile
->obfd
;
1090 char *aranges_buffer
, *pubnames_buffer
;
1091 char *aranges_ptr
, *pubnames_ptr
;
1092 unsigned int entry_length
, version
, info_offset
, info_size
;
1094 pubnames_buffer
= dwarf2_read_section (objfile
,
1095 dwarf_pubnames_offset
,
1096 dwarf_pubnames_size
,
1097 dwarf_pubnames_section
);
1098 pubnames_ptr
= pubnames_buffer
;
1099 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1101 struct comp_unit_head cu_header
;
1104 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1106 pubnames_ptr
+= bytes_read
;
1107 version
= read_1_byte (abfd
, pubnames_ptr
);
1109 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1111 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1115 aranges_buffer
= dwarf2_read_section (objfile
,
1116 dwarf_aranges_offset
,
1118 dwarf_aranges_section
);
1123 /* Read in the comp unit header information from the debug_info at
1127 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1128 char *info_ptr
, bfd
*abfd
)
1132 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1134 info_ptr
+= bytes_read
;
1135 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1137 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1139 info_ptr
+= bytes_read
;
1140 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1142 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1143 if (signed_addr
< 0)
1144 internal_error (__FILE__
, __LINE__
,
1145 "read_comp_unit_head: dwarf from non elf file");
1146 cu_header
->signed_addr_p
= signed_addr
;
1150 /* Build the partial symbol table by doing a quick pass through the
1151 .debug_info and .debug_abbrev sections. */
1154 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1156 /* Instead of reading this into a big buffer, we should probably use
1157 mmap() on architectures that support it. (FIXME) */
1158 bfd
*abfd
= objfile
->obfd
;
1159 char *info_ptr
, *abbrev_ptr
;
1160 char *beg_of_comp_unit
;
1161 struct partial_die_info comp_unit_die
;
1162 struct partial_symtab
*pst
;
1163 struct cleanup
*back_to
;
1164 CORE_ADDR lowpc
, highpc
;
1166 info_ptr
= dwarf_info_buffer
;
1167 abbrev_ptr
= dwarf_abbrev_buffer
;
1169 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1170 the partial symbol scan, like attribute values.
1172 We could reduce our peak memory consumption during partial symbol
1173 table construction by freeing stuff from this obstack more often
1174 --- say, after processing each compilation unit, or each die ---
1175 but it turns out that this saves almost nothing. For an
1176 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1177 on dwarf2_tmp_obstack. Some investigation showed:
1179 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1180 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1181 all fixed-length values not requiring dynamic allocation.
1183 2) 30% of the attributes used the form DW_FORM_string. For
1184 DW_FORM_string, read_attribute simply hands back a pointer to
1185 the null-terminated string in dwarf_info_buffer, so no dynamic
1186 allocation is needed there either.
1188 3) The remaining 1% of the attributes all used DW_FORM_block1.
1189 75% of those were DW_AT_frame_base location lists for
1190 functions; the rest were DW_AT_location attributes, probably
1191 for the global variables.
1193 Anyway, what this all means is that the memory the dwarf2
1194 reader uses as temporary space reading partial symbols is about
1195 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1197 obstack_init (&dwarf2_tmp_obstack
);
1198 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1200 /* Since the objects we're extracting from dwarf_info_buffer vary in
1201 length, only the individual functions to extract them (like
1202 read_comp_unit_head and read_partial_die) can really know whether
1203 the buffer is large enough to hold another complete object.
1205 At the moment, they don't actually check that. If
1206 dwarf_info_buffer holds just one extra byte after the last
1207 compilation unit's dies, then read_comp_unit_head will happily
1208 read off the end of the buffer. read_partial_die is similarly
1209 casual. Those functions should be fixed.
1211 For this loop condition, simply checking whether there's any data
1212 left at all should be sufficient. */
1213 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1215 struct comp_unit_head cu_header
;
1216 beg_of_comp_unit
= info_ptr
;
1217 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1219 if (cu_header
.version
!= 2)
1221 error ("Dwarf Error: wrong version in compilation unit header (is %d, should be %d) [in module %s]", cu_header
.version
, 2, bfd_get_filename (abfd
));
1224 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
1226 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1227 (long) cu_header
.abbrev_offset
,
1228 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1229 bfd_get_filename (abfd
));
1232 if (beg_of_comp_unit
+ cu_header
.length
+ cu_header
.initial_length_size
1233 > dwarf_info_buffer
+ dwarf_info_size
)
1235 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1236 (long) cu_header
.length
,
1237 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1238 bfd_get_filename (abfd
));
1241 /* Complete the cu_header */
1242 cu_header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1243 cu_header
.first_die_ptr
= info_ptr
;
1244 cu_header
.cu_head_ptr
= beg_of_comp_unit
;
1246 /* Read the abbrevs for this compilation unit into a table */
1247 dwarf2_read_abbrevs (abfd
, &cu_header
);
1248 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1250 /* Read the compilation unit die */
1251 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1254 /* Set the language we're debugging */
1255 set_cu_language (comp_unit_die
.language
);
1257 /* Allocate a new partial symbol table structure */
1258 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1259 comp_unit_die
.name
? comp_unit_die
.name
: "",
1260 comp_unit_die
.lowpc
,
1261 objfile
->global_psymbols
.next
,
1262 objfile
->static_psymbols
.next
);
1264 pst
->read_symtab_private
= (char *)
1265 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1266 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1267 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1268 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1269 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1270 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1271 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1272 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1273 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1274 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1275 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1276 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1277 DWARF_RANGES_BUFFER (pst
) = dwarf_ranges_buffer
;
1278 DWARF_RANGES_SIZE (pst
) = dwarf_ranges_size
;
1279 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1281 /* Store the function that reads in the rest of the symbol table */
1282 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1284 /* Check if comp unit has_children.
1285 If so, read the rest of the partial symbols from this comp unit.
1286 If not, there's no more debug_info for this comp unit. */
1287 if (comp_unit_die
.has_children
)
1289 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
,
1292 /* If the compilation unit didn't have an explicit address range,
1293 then use the information extracted from its child dies. */
1294 if (! comp_unit_die
.has_pc_info
)
1296 comp_unit_die
.lowpc
= lowpc
;
1297 comp_unit_die
.highpc
= highpc
;
1300 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1301 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1303 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1304 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1305 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1306 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1307 sort_pst_symbols (pst
);
1309 /* If there is already a psymtab or symtab for a file of this
1310 name, remove it. (If there is a symtab, more drastic things
1311 also happen.) This happens in VxWorks. */
1312 free_named_symtabs (pst
->filename
);
1314 info_ptr
= beg_of_comp_unit
+ cu_header
.length
1315 + cu_header
.initial_length_size
;
1317 do_cleanups (back_to
);
1320 /* Read in all interesting dies to the end of the compilation unit. */
1323 scan_partial_symbols (char *info_ptr
, struct objfile
*objfile
,
1324 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1325 const struct comp_unit_head
*cu_header
)
1327 bfd
*abfd
= objfile
->obfd
;
1328 struct partial_die_info pdi
;
1330 /* This function is called after we've read in the comp_unit_die in
1331 order to read its children. We start the nesting level at 1 since
1332 we have pushed 1 level down in order to read the comp unit's children.
1333 The comp unit itself is at level 0, so we stop reading when we pop
1334 back to that level. */
1336 int nesting_level
= 1;
1338 /* We only want to read in symbols corresponding to variables or
1339 other similar objects that are global or static. Normally, these
1340 are all children of the DW_TAG_compile_unit die, so are all at
1341 level 1. But C++ namespaces give ries to DW_TAG_namespace dies
1342 whose children are global objects. So we keep track of what
1343 level we currently think of as referring to file scope; this
1344 should always equal 1 plus the number of namespaces that we are
1345 currently nested within. */
1347 int file_scope_level
= 1;
1349 *lowpc
= ((CORE_ADDR
) -1);
1350 *highpc
= ((CORE_ADDR
) 0);
1352 while (nesting_level
)
1354 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1356 /* Anonymous namespaces have no name but are interesting. */
1358 if (pdi
.name
!= NULL
|| pdi
.tag
== DW_TAG_namespace
)
1362 case DW_TAG_subprogram
:
1363 if (pdi
.has_pc_info
)
1365 if (pdi
.lowpc
< *lowpc
)
1369 if (pdi
.highpc
> *highpc
)
1371 *highpc
= pdi
.highpc
;
1373 if ((pdi
.is_external
|| nesting_level
== file_scope_level
)
1374 && !pdi
.is_declaration
)
1376 add_partial_symbol (&pdi
, objfile
, cu_header
);
1380 case DW_TAG_variable
:
1381 case DW_TAG_typedef
:
1382 case DW_TAG_class_type
:
1383 case DW_TAG_structure_type
:
1384 case DW_TAG_union_type
:
1385 case DW_TAG_enumeration_type
:
1386 if ((pdi
.is_external
|| nesting_level
== file_scope_level
)
1387 && !pdi
.is_declaration
)
1389 add_partial_symbol (&pdi
, objfile
, cu_header
);
1392 case DW_TAG_enumerator
:
1393 /* File scope enumerators are added to the partial
1394 symbol table. They're children of the enumeration
1395 type die, so they occur at a level one higher than we
1396 normally look for. */
1397 if (nesting_level
== file_scope_level
+ 1)
1398 add_partial_symbol (&pdi
, objfile
, cu_header
);
1400 case DW_TAG_base_type
:
1401 /* File scope base type definitions are added to the partial
1403 if (nesting_level
== file_scope_level
)
1404 add_partial_symbol (&pdi
, objfile
, cu_header
);
1406 case DW_TAG_namespace
:
1407 /* FIXME: carlton/2002-10-16: we're not yet doing
1408 anything useful with this, but for now make sure that
1409 these tags at least don't cause us to miss any
1410 important symbols. */
1411 if (pdi
.has_children
)
1418 /* If the die has a sibling, skip to the sibling. Do not skip
1419 enumeration types, we want to record their enumerators. Do
1420 not skip namespaces, we want to record symbols inside
1423 && pdi
.tag
!= DW_TAG_enumeration_type
1424 && pdi
.tag
!= DW_TAG_namespace
)
1426 info_ptr
= pdi
.sibling
;
1428 else if (pdi
.has_children
)
1430 /* Die has children, but either the optional DW_AT_sibling
1431 attribute is missing or we want to look at them. */
1438 /* If this is the end of a DW_TAG_namespace entry, then
1439 decrease the file_scope_level, too. */
1440 if (nesting_level
< file_scope_level
)
1443 gdb_assert (nesting_level
== file_scope_level
);
1448 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1449 from `maint check'. */
1450 if (*lowpc
== ((CORE_ADDR
) -1))
1456 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1457 const struct comp_unit_head
*cu_header
)
1463 case DW_TAG_subprogram
:
1464 if (pdi
->is_external
)
1466 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1467 mst_text, objfile); */
1468 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1469 VAR_NAMESPACE
, LOC_BLOCK
,
1470 &objfile
->global_psymbols
,
1471 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1475 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1476 mst_file_text, objfile); */
1477 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1478 VAR_NAMESPACE
, LOC_BLOCK
,
1479 &objfile
->static_psymbols
,
1480 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1483 case DW_TAG_variable
:
1484 if (pdi
->is_external
)
1487 Don't enter into the minimal symbol tables as there is
1488 a minimal symbol table entry from the ELF symbols already.
1489 Enter into partial symbol table if it has a location
1490 descriptor or a type.
1491 If the location descriptor is missing, new_symbol will create
1492 a LOC_UNRESOLVED symbol, the address of the variable will then
1493 be determined from the minimal symbol table whenever the variable
1495 The address for the partial symbol table entry is not
1496 used by GDB, but it comes in handy for debugging partial symbol
1500 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1501 if (pdi
->locdesc
|| pdi
->has_type
)
1502 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1503 VAR_NAMESPACE
, LOC_STATIC
,
1504 &objfile
->global_psymbols
,
1505 0, addr
+ baseaddr
, cu_language
, objfile
);
1509 /* Static Variable. Skip symbols without location descriptors. */
1510 if (pdi
->locdesc
== NULL
)
1512 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1513 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1514 mst_file_data, objfile); */
1515 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1516 VAR_NAMESPACE
, LOC_STATIC
,
1517 &objfile
->static_psymbols
,
1518 0, addr
+ baseaddr
, cu_language
, objfile
);
1521 case DW_TAG_typedef
:
1522 case DW_TAG_base_type
:
1523 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1524 VAR_NAMESPACE
, LOC_TYPEDEF
,
1525 &objfile
->static_psymbols
,
1526 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1528 case DW_TAG_class_type
:
1529 case DW_TAG_structure_type
:
1530 case DW_TAG_union_type
:
1531 case DW_TAG_enumeration_type
:
1532 /* Skip aggregate types without children, these are external
1534 if (pdi
->has_children
== 0)
1536 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1537 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1538 &objfile
->static_psymbols
,
1539 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1541 if (cu_language
== language_cplus
)
1543 /* For C++, these implicitly act as typedefs as well. */
1544 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1545 VAR_NAMESPACE
, LOC_TYPEDEF
,
1546 &objfile
->static_psymbols
,
1547 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1550 case DW_TAG_enumerator
:
1551 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1552 VAR_NAMESPACE
, LOC_CONST
,
1553 &objfile
->static_psymbols
,
1554 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1561 /* Expand this partial symbol table into a full symbol table. */
1564 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1566 /* FIXME: This is barely more than a stub. */
1571 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1577 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1578 gdb_flush (gdb_stdout
);
1581 psymtab_to_symtab_1 (pst
);
1583 /* Finish up the debug error message. */
1585 printf_filtered ("done.\n");
1591 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1593 struct objfile
*objfile
= pst
->objfile
;
1594 bfd
*abfd
= objfile
->obfd
;
1595 struct comp_unit_head cu_header
;
1596 struct die_info
*dies
;
1597 unsigned long offset
;
1598 CORE_ADDR lowpc
, highpc
;
1599 struct die_info
*child_die
;
1601 struct symtab
*symtab
;
1602 struct cleanup
*back_to
;
1604 /* Set local variables from the partial symbol table info. */
1605 offset
= DWARF_INFO_OFFSET (pst
);
1606 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1607 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1608 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1609 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1610 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1611 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1612 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1613 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1614 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1615 dwarf_ranges_buffer
= DWARF_RANGES_BUFFER (pst
);
1616 dwarf_ranges_size
= DWARF_RANGES_SIZE (pst
);
1617 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1618 cu_header_offset
= offset
;
1619 info_ptr
= dwarf_info_buffer
+ offset
;
1621 obstack_init (&dwarf2_tmp_obstack
);
1622 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1625 make_cleanup (really_free_pendings
, NULL
);
1627 /* read in the comp_unit header */
1628 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1630 /* Read the abbrevs for this compilation unit */
1631 dwarf2_read_abbrevs (abfd
, &cu_header
);
1632 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1634 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
1636 make_cleanup_free_die_list (dies
);
1638 /* Do line number decoding in read_file_scope () */
1639 cu_header
.die
= dies
;
1640 process_die (dies
, objfile
, &cu_header
);
1642 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
, &cu_header
))
1644 /* Some compilers don't define a DW_AT_high_pc attribute for
1645 the compilation unit. If the DW_AT_high_pc is missing,
1646 synthesize it, by scanning the DIE's below the compilation unit. */
1648 if (dies
->has_children
)
1650 child_die
= dies
->next
;
1651 while (child_die
&& child_die
->tag
)
1653 if (child_die
->tag
== DW_TAG_subprogram
)
1655 CORE_ADDR low
, high
;
1657 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
,
1658 objfile
, &cu_header
))
1660 highpc
= max (highpc
, high
);
1663 child_die
= sibling_die (child_die
);
1667 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1669 /* Set symtab language to language from DW_AT_language.
1670 If the compilation is from a C file generated by language preprocessors,
1671 do not set the language if it was already deduced by start_subfile. */
1673 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1675 symtab
->language
= cu_language
;
1677 pst
->symtab
= symtab
;
1679 sort_symtab_syms (pst
->symtab
);
1681 do_cleanups (back_to
);
1684 /* Process a die and its children. */
1687 process_die (struct die_info
*die
, struct objfile
*objfile
,
1688 const struct comp_unit_head
*cu_header
)
1692 case DW_TAG_padding
:
1694 case DW_TAG_compile_unit
:
1695 read_file_scope (die
, objfile
, cu_header
);
1697 case DW_TAG_subprogram
:
1698 read_subroutine_type (die
, objfile
, cu_header
);
1699 read_func_scope (die
, objfile
, cu_header
);
1701 case DW_TAG_inlined_subroutine
:
1702 /* FIXME: These are ignored for now.
1703 They could be used to set breakpoints on all inlined instances
1704 of a function and make GDB `next' properly over inlined functions. */
1706 case DW_TAG_lexical_block
:
1707 read_lexical_block_scope (die
, objfile
, cu_header
);
1709 case DW_TAG_class_type
:
1710 case DW_TAG_structure_type
:
1711 case DW_TAG_union_type
:
1712 read_structure_scope (die
, objfile
, cu_header
);
1714 case DW_TAG_enumeration_type
:
1715 read_enumeration (die
, objfile
, cu_header
);
1717 case DW_TAG_subroutine_type
:
1718 read_subroutine_type (die
, objfile
, cu_header
);
1720 case DW_TAG_array_type
:
1721 read_array_type (die
, objfile
, cu_header
);
1723 case DW_TAG_pointer_type
:
1724 read_tag_pointer_type (die
, objfile
, cu_header
);
1726 case DW_TAG_ptr_to_member_type
:
1727 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1729 case DW_TAG_reference_type
:
1730 read_tag_reference_type (die
, objfile
, cu_header
);
1732 case DW_TAG_string_type
:
1733 read_tag_string_type (die
, objfile
);
1735 case DW_TAG_base_type
:
1736 read_base_type (die
, objfile
);
1737 if (dwarf_attr (die
, DW_AT_name
))
1739 /* Add a typedef symbol for the base type definition. */
1740 new_symbol (die
, die
->type
, objfile
, cu_header
);
1743 case DW_TAG_common_block
:
1744 read_common_block (die
, objfile
, cu_header
);
1746 case DW_TAG_common_inclusion
:
1748 case DW_TAG_namespace
:
1749 read_namespace (die
, objfile
, cu_header
);
1751 case DW_TAG_imported_declaration
:
1752 case DW_TAG_imported_module
:
1753 /* FIXME: carlton/2002-10-16: Eventually, we should use the
1754 information contained in these. DW_TAG_imported_declaration
1755 dies shouldn't have children; DW_TAG_imported_module dies
1756 shouldn't in the C++ case, but conceivably could in the
1757 Fortran case, so we'll have to replace this gdb_assert if
1758 Fortran compilers start generating that info. */
1759 gdb_assert (!die
->has_children
);
1762 new_symbol (die
, NULL
, objfile
, cu_header
);
1768 initialize_cu_func_list (void)
1770 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1774 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1775 const struct comp_unit_head
*cu_header
)
1777 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1778 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1779 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1780 struct attribute
*attr
;
1781 char *name
= "<unknown>";
1782 char *comp_dir
= NULL
;
1783 struct die_info
*child_die
;
1784 bfd
*abfd
= objfile
->obfd
;
1785 struct line_header
*line_header
= 0;
1787 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
, cu_header
))
1789 if (die
->has_children
)
1791 child_die
= die
->next
;
1792 while (child_die
&& child_die
->tag
)
1794 if (child_die
->tag
== DW_TAG_subprogram
)
1796 CORE_ADDR low
, high
;
1798 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
,
1799 objfile
, cu_header
))
1801 lowpc
= min (lowpc
, low
);
1802 highpc
= max (highpc
, high
);
1805 child_die
= sibling_die (child_die
);
1810 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1811 from finish_block. */
1812 if (lowpc
== ((CORE_ADDR
) -1))
1817 attr
= dwarf_attr (die
, DW_AT_name
);
1820 name
= DW_STRING (attr
);
1822 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1825 comp_dir
= DW_STRING (attr
);
1828 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1829 directory, get rid of it. */
1830 char *cp
= strchr (comp_dir
, ':');
1832 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1837 if (objfile
->ei
.entry_point
>= lowpc
&&
1838 objfile
->ei
.entry_point
< highpc
)
1840 objfile
->ei
.entry_file_lowpc
= lowpc
;
1841 objfile
->ei
.entry_file_highpc
= highpc
;
1844 attr
= dwarf_attr (die
, DW_AT_language
);
1847 set_cu_language (DW_UNSND (attr
));
1850 /* We assume that we're processing GCC output. */
1851 processing_gcc_compilation
= 2;
1853 /* FIXME:Do something here. */
1854 if (dip
->at_producer
!= NULL
)
1856 handle_producer (dip
->at_producer
);
1860 /* The compilation unit may be in a different language or objfile,
1861 zero out all remembered fundamental types. */
1862 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1864 start_symtab (name
, comp_dir
, lowpc
);
1865 record_debugformat ("DWARF 2");
1867 initialize_cu_func_list ();
1869 /* Process all dies in compilation unit. */
1870 if (die
->has_children
)
1872 child_die
= die
->next
;
1873 while (child_die
&& child_die
->tag
)
1875 process_die (child_die
, objfile
, cu_header
);
1876 child_die
= sibling_die (child_die
);
1880 /* Decode line number information if present. */
1881 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1884 unsigned int line_offset
= DW_UNSND (attr
);
1885 line_header
= dwarf_decode_line_header (line_offset
,
1889 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
1890 (void *) line_header
);
1891 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu_header
);
1895 /* Decode macro information, if present. Dwarf 2 macro information
1896 refers to information in the line number info statement program
1897 header, so we can only read it if we've read the header
1899 attr
= dwarf_attr (die
, DW_AT_macro_info
);
1900 if (attr
&& line_header
)
1902 unsigned int macro_offset
= DW_UNSND (attr
);
1903 dwarf_decode_macros (line_header
, macro_offset
,
1904 comp_dir
, abfd
, cu_header
, objfile
);
1906 do_cleanups (back_to
);
1910 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
1912 struct function_range
*thisfn
;
1914 thisfn
= (struct function_range
*)
1915 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
1916 thisfn
->name
= name
;
1917 thisfn
->lowpc
= lowpc
;
1918 thisfn
->highpc
= highpc
;
1919 thisfn
->seen_line
= 0;
1920 thisfn
->next
= NULL
;
1922 if (cu_last_fn
== NULL
)
1923 cu_first_fn
= thisfn
;
1925 cu_last_fn
->next
= thisfn
;
1927 cu_last_fn
= thisfn
;
1931 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
1932 const struct comp_unit_head
*cu_header
)
1934 register struct context_stack
*new;
1937 struct die_info
*child_die
;
1938 struct attribute
*attr
;
1941 name
= dwarf2_linkage_name (die
);
1943 /* Ignore functions with missing or empty names and functions with
1944 missing or invalid low and high pc attributes. */
1945 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
, cu_header
))
1951 /* Record the function range for dwarf_decode_lines. */
1952 add_to_cu_func_list (name
, lowpc
, highpc
);
1954 if (objfile
->ei
.entry_point
>= lowpc
&&
1955 objfile
->ei
.entry_point
< highpc
)
1957 objfile
->ei
.entry_func_lowpc
= lowpc
;
1958 objfile
->ei
.entry_func_highpc
= highpc
;
1961 /* Decode DW_AT_frame_base location descriptor if present, keep result
1962 for DW_OP_fbreg operands in decode_locdesc. */
1963 frame_base_reg
= -1;
1964 frame_base_offset
= 0;
1965 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1970 /* Support the .debug_loc offsets */
1971 if (attr_form_is_block (attr
))
1973 addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
1975 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
1977 dwarf2_complex_location_expr_complaint ();
1982 dwarf2_invalid_attrib_class_complaint ("DW_AT_frame_base", name
);
1987 dwarf2_unsupported_at_frame_base_complaint (name
);
1989 frame_base_reg
= addr
;
1992 frame_base_reg
= basereg
;
1993 frame_base_offset
= addr
;
1996 dwarf2_unsupported_at_frame_base_complaint (name
);
1999 new = push_context (0, lowpc
);
2000 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
2001 list_in_scope
= &local_symbols
;
2003 if (die
->has_children
)
2005 child_die
= die
->next
;
2006 while (child_die
&& child_die
->tag
)
2008 process_die (child_die
, objfile
, cu_header
);
2009 child_die
= sibling_die (child_die
);
2013 new = pop_context ();
2014 /* Make a block for the local symbols within. */
2015 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2016 lowpc
, highpc
, objfile
);
2018 /* In C++, we can have functions nested inside functions (e.g., when
2019 a function declares a class that has methods). This means that
2020 when we finish processing a function scope, we may need to go
2021 back to building a containing block's symbol lists. */
2022 local_symbols
= new->locals
;
2023 param_symbols
= new->params
;
2025 /* If we've finished processing a top-level function, subsequent
2026 symbols go in the file symbol list. */
2027 if (outermost_context_p ())
2028 list_in_scope
= &file_symbols
;
2031 /* Process all the DIES contained within a lexical block scope. Start
2032 a new scope, process the dies, and then close the scope. */
2035 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
2036 const struct comp_unit_head
*cu_header
)
2038 register struct context_stack
*new;
2039 CORE_ADDR lowpc
, highpc
;
2040 struct die_info
*child_die
;
2042 /* Ignore blocks with missing or invalid low and high pc attributes. */
2043 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2044 as multiple lexical blocks? Handling children in a sane way would
2045 be nasty. Might be easier to properly extend generic blocks to
2047 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
, cu_header
))
2052 push_context (0, lowpc
);
2053 if (die
->has_children
)
2055 child_die
= die
->next
;
2056 while (child_die
&& child_die
->tag
)
2058 process_die (child_die
, objfile
, cu_header
);
2059 child_die
= sibling_die (child_die
);
2062 new = pop_context ();
2064 if (local_symbols
!= NULL
)
2066 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2069 local_symbols
= new->locals
;
2072 /* Get low and high pc attributes from a die. Return 1 if the attributes
2073 are present and valid, otherwise, return 0. Return -1 if the range is
2074 discontinuous, i.e. derived from DW_AT_ranges information. */
2076 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
2077 CORE_ADDR
*highpc
, struct objfile
*objfile
,
2078 const struct comp_unit_head
*cu_header
)
2080 struct attribute
*attr
;
2081 bfd
*obfd
= objfile
->obfd
;
2086 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2089 high
= DW_ADDR (attr
);
2090 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2092 low
= DW_ADDR (attr
);
2094 /* Found high w/o low attribute. */
2097 /* Found consecutive range of addresses. */
2102 attr
= dwarf_attr (die
, DW_AT_ranges
);
2105 unsigned int addr_size
= cu_header
->addr_size
;
2106 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2107 /* Value of the DW_AT_ranges attribute is the offset in the
2108 .debug_renges section. */
2109 unsigned int offset
= DW_UNSND (attr
);
2110 /* Base address selection entry. */
2119 /* The applicable base address is determined by (1) the closest
2120 preceding base address selection entry in the range list or
2121 (2) the DW_AT_low_pc of the compilation unit. */
2123 /* ??? Was in dwarf3 draft4, and has since been removed.
2124 GCC still uses it though. */
2125 attr
= dwarf_attr (cu_header
->die
, DW_AT_entry_pc
);
2128 base
= DW_ADDR (attr
);
2134 attr
= dwarf_attr (cu_header
->die
, DW_AT_low_pc
);
2137 base
= DW_ADDR (attr
);
2142 buffer
= dwarf_ranges_buffer
+ offset
;
2145 /* Read in the largest possible address. */
2146 marker
= read_address (obfd
, buffer
, cu_header
, &dummy
);
2147 if ((marker
& mask
) == mask
)
2149 /* If we found the largest possible address, then
2150 read the base address. */
2151 base
= read_address (obfd
, buffer
+ addr_size
,
2153 buffer
+= 2 * addr_size
;
2154 offset
+= 2 * addr_size
;
2162 CORE_ADDR range_beginning
, range_end
;
2164 range_beginning
= read_address (obfd
, buffer
,
2166 buffer
+= addr_size
;
2167 range_end
= read_address (obfd
, buffer
, cu_header
, &dummy
);
2168 buffer
+= addr_size
;
2169 offset
+= 2 * addr_size
;
2171 /* An end of list marker is a pair of zero addresses. */
2172 if (range_beginning
== 0 && range_end
== 0)
2173 /* Found the end of list entry. */
2176 /* Each base address selection entry is a pair of 2 values.
2177 The first is the largest possible address, the second is
2178 the base address. Check for a base address here. */
2179 if ((range_beginning
& mask
) == mask
)
2181 /* If we found the largest possible address, then
2182 read the base address. */
2183 base
= read_address (obfd
, buffer
+ addr_size
,
2191 /* We have no valid base address for the ranges
2193 complaint (&symfile_complaints
,
2194 "Invalid .debug_ranges data (no base address)");
2198 /* FIXME: This is recording everything as a low-high
2199 segment of consecutive addresses. We should have a
2200 data structure for discontiguous block ranges
2204 low
= range_beginning
;
2210 if (range_beginning
< low
)
2211 low
= range_beginning
;
2212 if (range_end
> high
)
2218 /* If the first entry is an end-of-list marker, the range
2219 describes an empty scope, i.e. no instructions. */
2229 /* When using the GNU linker, .gnu.linkonce. sections are used to
2230 eliminate duplicate copies of functions and vtables and such.
2231 The linker will arbitrarily choose one and discard the others.
2232 The AT_*_pc values for such functions refer to local labels in
2233 these sections. If the section from that file was discarded, the
2234 labels are not in the output, so the relocs get a value of 0.
2235 If this is a discarded function, mark the pc bounds as invalid,
2236 so that GDB will ignore it. */
2237 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
2245 /* Add an aggregate field to the field list. */
2248 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2249 struct objfile
*objfile
,
2250 const struct comp_unit_head
*cu_header
)
2252 struct nextfield
*new_field
;
2253 struct attribute
*attr
;
2255 char *fieldname
= "";
2257 /* Allocate a new field list entry and link it in. */
2258 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2259 make_cleanup (xfree
, new_field
);
2260 memset (new_field
, 0, sizeof (struct nextfield
));
2261 new_field
->next
= fip
->fields
;
2262 fip
->fields
= new_field
;
2265 /* Handle accessibility and virtuality of field.
2266 The default accessibility for members is public, the default
2267 accessibility for inheritance is private. */
2268 if (die
->tag
!= DW_TAG_inheritance
)
2269 new_field
->accessibility
= DW_ACCESS_public
;
2271 new_field
->accessibility
= DW_ACCESS_private
;
2272 new_field
->virtuality
= DW_VIRTUALITY_none
;
2274 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2276 new_field
->accessibility
= DW_UNSND (attr
);
2277 if (new_field
->accessibility
!= DW_ACCESS_public
)
2278 fip
->non_public_fields
= 1;
2279 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2281 new_field
->virtuality
= DW_UNSND (attr
);
2283 fp
= &new_field
->field
;
2285 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
))
2287 /* Data member other than a C++ static data member. */
2289 /* Get type of field. */
2290 fp
->type
= die_type (die
, objfile
, cu_header
);
2292 FIELD_STATIC_KIND (*fp
) = 0;
2294 /* Get bit size of field (zero if none). */
2295 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2298 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2302 FIELD_BITSIZE (*fp
) = 0;
2305 /* Get bit offset of field. */
2306 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2309 FIELD_BITPOS (*fp
) =
2310 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
2313 FIELD_BITPOS (*fp
) = 0;
2314 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2317 if (BITS_BIG_ENDIAN
)
2319 /* For big endian bits, the DW_AT_bit_offset gives the
2320 additional bit offset from the MSB of the containing
2321 anonymous object to the MSB of the field. We don't
2322 have to do anything special since we don't need to
2323 know the size of the anonymous object. */
2324 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2328 /* For little endian bits, compute the bit offset to the
2329 MSB of the anonymous object, subtract off the number of
2330 bits from the MSB of the field to the MSB of the
2331 object, and then subtract off the number of bits of
2332 the field itself. The result is the bit offset of
2333 the LSB of the field. */
2335 int bit_offset
= DW_UNSND (attr
);
2337 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2340 /* The size of the anonymous object containing
2341 the bit field is explicit, so use the
2342 indicated size (in bytes). */
2343 anonymous_size
= DW_UNSND (attr
);
2347 /* The size of the anonymous object containing
2348 the bit field must be inferred from the type
2349 attribute of the data member containing the
2351 anonymous_size
= TYPE_LENGTH (fp
->type
);
2353 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2354 - bit_offset
- FIELD_BITSIZE (*fp
);
2358 /* Get name of field. */
2359 attr
= dwarf_attr (die
, DW_AT_name
);
2360 if (attr
&& DW_STRING (attr
))
2361 fieldname
= DW_STRING (attr
);
2362 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2363 &objfile
->type_obstack
);
2365 /* Change accessibility for artificial fields (e.g. virtual table
2366 pointer or virtual base class pointer) to private. */
2367 if (dwarf_attr (die
, DW_AT_artificial
))
2369 new_field
->accessibility
= DW_ACCESS_private
;
2370 fip
->non_public_fields
= 1;
2373 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
2375 /* C++ static member. */
2377 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2378 is a declaration, but all versions of G++ as of this writing
2379 (so through at least 3.2.1) incorrectly generate
2380 DW_TAG_variable tags. */
2384 /* Get name of field. */
2385 attr
= dwarf_attr (die
, DW_AT_name
);
2386 if (attr
&& DW_STRING (attr
))
2387 fieldname
= DW_STRING (attr
);
2391 /* Get physical name. */
2392 physname
= dwarf2_linkage_name (die
);
2394 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2395 &objfile
->type_obstack
));
2396 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2397 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2398 &objfile
->type_obstack
);
2400 else if (die
->tag
== DW_TAG_inheritance
)
2402 /* C++ base class field. */
2403 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2405 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
2407 FIELD_BITSIZE (*fp
) = 0;
2408 FIELD_STATIC_KIND (*fp
) = 0;
2409 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2410 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2411 fip
->nbaseclasses
++;
2415 /* Create the vector of fields, and attach it to the type. */
2418 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2419 struct objfile
*objfile
)
2421 int nfields
= fip
->nfields
;
2423 /* Record the field count, allocate space for the array of fields,
2424 and create blank accessibility bitfields if necessary. */
2425 TYPE_NFIELDS (type
) = nfields
;
2426 TYPE_FIELDS (type
) = (struct field
*)
2427 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2428 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2430 if (fip
->non_public_fields
)
2432 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2434 TYPE_FIELD_PRIVATE_BITS (type
) =
2435 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2436 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2438 TYPE_FIELD_PROTECTED_BITS (type
) =
2439 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2440 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2442 TYPE_FIELD_IGNORE_BITS (type
) =
2443 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2444 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2447 /* If the type has baseclasses, allocate and clear a bit vector for
2448 TYPE_FIELD_VIRTUAL_BITS. */
2449 if (fip
->nbaseclasses
)
2451 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2454 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2455 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2456 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2457 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2458 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2461 /* Copy the saved-up fields into the field vector. Start from the head
2462 of the list, adding to the tail of the field array, so that they end
2463 up in the same order in the array in which they were added to the list. */
2464 while (nfields
-- > 0)
2466 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2467 switch (fip
->fields
->accessibility
)
2469 case DW_ACCESS_private
:
2470 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2473 case DW_ACCESS_protected
:
2474 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2477 case DW_ACCESS_public
:
2481 /* Unknown accessibility. Complain and treat it as public. */
2483 complaint (&symfile_complaints
, "unsupported accessibility %d",
2484 fip
->fields
->accessibility
);
2488 if (nfields
< fip
->nbaseclasses
)
2490 switch (fip
->fields
->virtuality
)
2492 case DW_VIRTUALITY_virtual
:
2493 case DW_VIRTUALITY_pure_virtual
:
2494 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2498 fip
->fields
= fip
->fields
->next
;
2502 /* Add a member function to the proper fieldlist. */
2505 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2506 struct type
*type
, struct objfile
*objfile
,
2507 const struct comp_unit_head
*cu_header
)
2509 struct attribute
*attr
;
2510 struct fnfieldlist
*flp
;
2512 struct fn_field
*fnp
;
2515 struct nextfnfield
*new_fnfield
;
2517 /* Get name of member function. */
2518 attr
= dwarf_attr (die
, DW_AT_name
);
2519 if (attr
&& DW_STRING (attr
))
2520 fieldname
= DW_STRING (attr
);
2524 /* Get the mangled name. */
2525 physname
= dwarf2_linkage_name (die
);
2527 /* Look up member function name in fieldlist. */
2528 for (i
= 0; i
< fip
->nfnfields
; i
++)
2530 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2534 /* Create new list element if necessary. */
2535 if (i
< fip
->nfnfields
)
2536 flp
= &fip
->fnfieldlists
[i
];
2539 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2541 fip
->fnfieldlists
= (struct fnfieldlist
*)
2542 xrealloc (fip
->fnfieldlists
,
2543 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2544 * sizeof (struct fnfieldlist
));
2545 if (fip
->nfnfields
== 0)
2546 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2548 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2549 flp
->name
= fieldname
;
2555 /* Create a new member function field and chain it to the field list
2557 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2558 make_cleanup (xfree
, new_fnfield
);
2559 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2560 new_fnfield
->next
= flp
->head
;
2561 flp
->head
= new_fnfield
;
2564 /* Fill in the member function field info. */
2565 fnp
= &new_fnfield
->fnfield
;
2566 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2567 &objfile
->type_obstack
);
2568 fnp
->type
= alloc_type (objfile
);
2569 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2571 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2572 int nparams
= TYPE_NFIELDS (die
->type
);
2574 /* TYPE is the domain of this method, and DIE->TYPE is the type
2575 of the method itself (TYPE_CODE_METHOD). */
2576 smash_to_method_type (fnp
->type
, type
,
2577 TYPE_TARGET_TYPE (die
->type
),
2578 TYPE_FIELDS (die
->type
),
2579 TYPE_NFIELDS (die
->type
),
2580 TYPE_VARARGS (die
->type
));
2582 /* Handle static member functions.
2583 Dwarf2 has no clean way to discern C++ static and non-static
2584 member functions. G++ helps GDB by marking the first
2585 parameter for non-static member functions (which is the
2586 this pointer) as artificial. We obtain this information
2587 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2588 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2589 fnp
->voffset
= VOFFSET_STATIC
;
2592 complaint (&symfile_complaints
, "member function type missing for '%s'",
2595 /* Get fcontext from DW_AT_containing_type if present. */
2596 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2597 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2599 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2600 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2602 /* Get accessibility. */
2603 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2606 switch (DW_UNSND (attr
))
2608 case DW_ACCESS_private
:
2609 fnp
->is_private
= 1;
2611 case DW_ACCESS_protected
:
2612 fnp
->is_protected
= 1;
2617 /* Check for artificial methods. */
2618 attr
= dwarf_attr (die
, DW_AT_artificial
);
2619 if (attr
&& DW_UNSND (attr
) != 0)
2620 fnp
->is_artificial
= 1;
2622 /* Get index in virtual function table if it is a virtual member function. */
2623 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2626 /* Support the .debug_loc offsets */
2627 if (attr_form_is_block (attr
))
2629 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2631 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2633 dwarf2_complex_location_expr_complaint ();
2637 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2643 /* Create the vector of member function fields, and attach it to the type. */
2646 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2647 struct objfile
*objfile
)
2649 struct fnfieldlist
*flp
;
2650 int total_length
= 0;
2653 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2654 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2655 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2657 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2659 struct nextfnfield
*nfp
= flp
->head
;
2660 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2663 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2664 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2665 fn_flp
->fn_fields
= (struct fn_field
*)
2666 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2667 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2668 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2670 total_length
+= flp
->length
;
2673 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2674 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2677 /* Called when we find the DIE that starts a structure or union scope
2678 (definition) to process all dies that define the members of the
2681 NOTE: we need to call struct_type regardless of whether or not the
2682 DIE has an at_name attribute, since it might be an anonymous
2683 structure or union. This gets the type entered into our set of
2686 However, if the structure is incomplete (an opaque struct/union)
2687 then suppress creating a symbol table entry for it since gdb only
2688 wants to find the one with the complete definition. Note that if
2689 it is complete, we just call new_symbol, which does it's own
2690 checking about whether the struct/union is anonymous or not (and
2691 suppresses creating a symbol table entry itself). */
2694 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2695 const struct comp_unit_head
*cu_header
)
2698 struct attribute
*attr
;
2700 type
= alloc_type (objfile
);
2702 INIT_CPLUS_SPECIFIC (type
);
2703 attr
= dwarf_attr (die
, DW_AT_name
);
2704 if (attr
&& DW_STRING (attr
))
2706 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2707 strlen (DW_STRING (attr
)),
2708 &objfile
->type_obstack
);
2711 if (die
->tag
== DW_TAG_structure_type
)
2713 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2715 else if (die
->tag
== DW_TAG_union_type
)
2717 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2721 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2723 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2726 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2729 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2733 TYPE_LENGTH (type
) = 0;
2736 /* We need to add the type field to the die immediately so we don't
2737 infinitely recurse when dealing with pointers to the structure
2738 type within the structure itself. */
2741 if (die
->has_children
&& ! die_is_declaration (die
))
2743 struct field_info fi
;
2744 struct die_info
*child_die
;
2745 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2747 memset (&fi
, 0, sizeof (struct field_info
));
2749 child_die
= die
->next
;
2751 while (child_die
&& child_die
->tag
)
2753 if (child_die
->tag
== DW_TAG_member
2754 || child_die
->tag
== DW_TAG_variable
)
2756 /* NOTE: carlton/2002-11-05: A C++ static data member
2757 should be a DW_TAG_member that is a declaration, but
2758 all versions of G++ as of this writing (so through at
2759 least 3.2.1) incorrectly generate DW_TAG_variable
2760 tags for them instead. */
2761 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2763 else if (child_die
->tag
== DW_TAG_subprogram
)
2765 /* C++ member function. */
2766 process_die (child_die
, objfile
, cu_header
);
2767 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2769 else if (child_die
->tag
== DW_TAG_inheritance
)
2771 /* C++ base class field. */
2772 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2776 process_die (child_die
, objfile
, cu_header
);
2778 child_die
= sibling_die (child_die
);
2781 /* Attach fields and member functions to the type. */
2783 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2786 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2788 /* Get the type which refers to the base class (possibly this
2789 class itself) which contains the vtable pointer for the current
2790 class from the DW_AT_containing_type attribute. */
2792 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2794 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2796 TYPE_VPTR_BASETYPE (type
) = t
;
2799 static const char vptr_name
[] =
2800 {'_', 'v', 'p', 't', 'r', '\0'};
2803 /* Our own class provides vtbl ptr. */
2804 for (i
= TYPE_NFIELDS (t
) - 1;
2805 i
>= TYPE_N_BASECLASSES (t
);
2808 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2810 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2811 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2813 TYPE_VPTR_FIELDNO (type
) = i
;
2818 /* Complain if virtual function table field not found. */
2819 if (i
< TYPE_N_BASECLASSES (t
))
2820 complaint (&symfile_complaints
,
2821 "virtual function table pointer not found when defining class '%s'",
2822 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
2827 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2832 new_symbol (die
, type
, objfile
, cu_header
);
2834 do_cleanups (back_to
);
2838 /* No children, must be stub. */
2839 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2843 /* Given a pointer to a die which begins an enumeration, process all
2844 the dies that define the members of the enumeration.
2846 This will be much nicer in draft 6 of the DWARF spec when our
2847 members will be dies instead squished into the DW_AT_element_list
2850 NOTE: We reverse the order of the element list. */
2853 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2854 const struct comp_unit_head
*cu_header
)
2856 struct die_info
*child_die
;
2858 struct field
*fields
;
2859 struct attribute
*attr
;
2862 int unsigned_enum
= 1;
2864 type
= alloc_type (objfile
);
2866 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2867 attr
= dwarf_attr (die
, DW_AT_name
);
2868 if (attr
&& DW_STRING (attr
))
2870 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2871 strlen (DW_STRING (attr
)),
2872 &objfile
->type_obstack
);
2875 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2878 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2882 TYPE_LENGTH (type
) = 0;
2887 if (die
->has_children
)
2889 child_die
= die
->next
;
2890 while (child_die
&& child_die
->tag
)
2892 if (child_die
->tag
!= DW_TAG_enumerator
)
2894 process_die (child_die
, objfile
, cu_header
);
2898 attr
= dwarf_attr (child_die
, DW_AT_name
);
2901 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2902 if (SYMBOL_VALUE (sym
) < 0)
2905 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2907 fields
= (struct field
*)
2909 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2910 * sizeof (struct field
));
2913 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2914 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2915 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2916 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2917 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
2923 child_die
= sibling_die (child_die
);
2928 TYPE_NFIELDS (type
) = num_fields
;
2929 TYPE_FIELDS (type
) = (struct field
*)
2930 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2931 memcpy (TYPE_FIELDS (type
), fields
,
2932 sizeof (struct field
) * num_fields
);
2936 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2939 new_symbol (die
, type
, objfile
, cu_header
);
2942 /* Extract all information from a DW_TAG_array_type DIE and put it in
2943 the DIE's type field. For now, this only handles one dimensional
2947 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2948 const struct comp_unit_head
*cu_header
)
2950 struct die_info
*child_die
;
2951 struct type
*type
= NULL
;
2952 struct type
*element_type
, *range_type
, *index_type
;
2953 struct type
**range_types
= NULL
;
2954 struct attribute
*attr
;
2956 struct cleanup
*back_to
;
2958 /* Return if we've already decoded this type. */
2964 element_type
= die_type (die
, objfile
, cu_header
);
2966 /* Irix 6.2 native cc creates array types without children for
2967 arrays with unspecified length. */
2968 if (die
->has_children
== 0)
2970 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2971 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2972 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2976 back_to
= make_cleanup (null_cleanup
, NULL
);
2977 child_die
= die
->next
;
2978 while (child_die
&& child_die
->tag
)
2980 if (child_die
->tag
== DW_TAG_subrange_type
)
2982 unsigned int low
, high
;
2984 /* Default bounds to an array with unspecified length. */
2987 if (cu_language
== language_fortran
)
2989 /* FORTRAN implies a lower bound of 1, if not given. */
2993 index_type
= die_type (child_die
, objfile
, cu_header
);
2994 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2997 if (attr
->form
== DW_FORM_sdata
)
2999 low
= DW_SND (attr
);
3001 else if (attr
->form
== DW_FORM_udata
3002 || attr
->form
== DW_FORM_data1
3003 || attr
->form
== DW_FORM_data2
3004 || attr
->form
== DW_FORM_data4
3005 || attr
->form
== DW_FORM_data8
)
3007 low
= DW_UNSND (attr
);
3011 dwarf2_non_const_array_bound_ignored_complaint
3012 (dwarf_form_name (attr
->form
));
3014 die
->type
= lookup_pointer_type (element_type
);
3021 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
3024 if (attr
->form
== DW_FORM_sdata
)
3026 high
= DW_SND (attr
);
3028 else if (attr
->form
== DW_FORM_udata
3029 || attr
->form
== DW_FORM_data1
3030 || attr
->form
== DW_FORM_data2
3031 || attr
->form
== DW_FORM_data4
3032 || attr
->form
== DW_FORM_data8
)
3034 high
= DW_UNSND (attr
);
3036 else if (attr
->form
== DW_FORM_block1
)
3038 /* GCC encodes arrays with unspecified or dynamic length
3039 with a DW_FORM_block1 attribute.
3040 FIXME: GDB does not yet know how to handle dynamic
3041 arrays properly, treat them as arrays with unspecified
3047 dwarf2_non_const_array_bound_ignored_complaint
3048 (dwarf_form_name (attr
->form
));
3050 die
->type
= lookup_pointer_type (element_type
);
3058 /* Create a range type and save it for array type creation. */
3059 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
3061 range_types
= (struct type
**)
3062 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
3063 * sizeof (struct type
*));
3065 make_cleanup (free_current_contents
, &range_types
);
3067 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
3069 child_die
= sibling_die (child_die
);
3072 /* Dwarf2 dimensions are output from left to right, create the
3073 necessary array types in backwards order. */
3074 type
= element_type
;
3076 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
3078 /* Understand Dwarf2 support for vector types (like they occur on
3079 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3080 array type. This is not part of the Dwarf2/3 standard yet, but a
3081 custom vendor extension. The main difference between a regular
3082 array and the vector variant is that vectors are passed by value
3084 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
3086 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
3088 do_cleanups (back_to
);
3090 /* Install the type in the die. */
3094 /* First cut: install each common block member as a global variable. */
3097 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
3098 const struct comp_unit_head
*cu_header
)
3100 struct die_info
*child_die
;
3101 struct attribute
*attr
;
3103 CORE_ADDR base
= (CORE_ADDR
) 0;
3105 attr
= dwarf_attr (die
, DW_AT_location
);
3108 /* Support the .debug_loc offsets */
3109 if (attr_form_is_block (attr
))
3111 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
3113 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3115 dwarf2_complex_location_expr_complaint ();
3119 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3120 "common block member");
3123 if (die
->has_children
)
3125 child_die
= die
->next
;
3126 while (child_die
&& child_die
->tag
)
3128 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
3129 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
3132 SYMBOL_VALUE_ADDRESS (sym
) =
3133 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
3134 add_symbol_to_list (sym
, &global_symbols
);
3136 child_die
= sibling_die (child_die
);
3141 /* Read a C++ namespace. */
3143 /* FIXME: carlton/2002-10-16: For now, we don't actually do anything
3144 useful with the namespace data: we just process its children. */
3147 read_namespace (struct die_info
*die
, struct objfile
*objfile
,
3148 const struct comp_unit_head
*cu_header
)
3150 if (die
->has_children
)
3152 struct die_info
*child_die
= die
->next
;
3154 while (child_die
&& child_die
->tag
)
3156 process_die (child_die
, objfile
, cu_header
);
3157 child_die
= sibling_die (child_die
);
3162 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3163 the user defined type vector. */
3166 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
3167 const struct comp_unit_head
*cu_header
)
3170 struct attribute
*attr_byte_size
;
3171 struct attribute
*attr_address_class
;
3172 int byte_size
, addr_class
;
3179 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
3181 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
3183 byte_size
= DW_UNSND (attr_byte_size
);
3185 byte_size
= cu_header
->addr_size
;
3187 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
3188 if (attr_address_class
)
3189 addr_class
= DW_UNSND (attr_address_class
);
3191 addr_class
= DW_ADDR_none
;
3193 /* If the pointer size or address class is different than the
3194 default, create a type variant marked as such and set the
3195 length accordingly. */
3196 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3198 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3202 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3203 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3204 type
= make_type_with_address_space (type
, type_flags
);
3206 else if (TYPE_LENGTH (type
) != byte_size
)
3208 complaint (&symfile_complaints
, "invalid pointer size %d", byte_size
);
3211 /* Should we also complain about unhandled address classes? */
3215 TYPE_LENGTH (type
) = byte_size
;
3219 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3220 the user defined type vector. */
3223 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
3224 const struct comp_unit_head
*cu_header
)
3227 struct type
*to_type
;
3228 struct type
*domain
;
3235 type
= alloc_type (objfile
);
3236 to_type
= die_type (die
, objfile
, cu_header
);
3237 domain
= die_containing_type (die
, objfile
, cu_header
);
3238 smash_to_member_type (type
, domain
, to_type
);
3243 /* Extract all information from a DW_TAG_reference_type DIE and add to
3244 the user defined type vector. */
3247 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
3248 const struct comp_unit_head
*cu_header
)
3251 struct attribute
*attr
;
3258 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
3259 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3262 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3266 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3272 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
3273 const struct comp_unit_head
*cu_header
)
3275 struct type
*base_type
;
3282 base_type
= die_type (die
, objfile
, cu_header
);
3283 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3287 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
3288 const struct comp_unit_head
*cu_header
)
3290 struct type
*base_type
;
3297 base_type
= die_type (die
, objfile
, cu_header
);
3298 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3301 /* Extract all information from a DW_TAG_string_type DIE and add to
3302 the user defined type vector. It isn't really a user defined type,
3303 but it behaves like one, with other DIE's using an AT_user_def_type
3304 attribute to reference it. */
3307 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
3309 struct type
*type
, *range_type
, *index_type
, *char_type
;
3310 struct attribute
*attr
;
3311 unsigned int length
;
3318 attr
= dwarf_attr (die
, DW_AT_string_length
);
3321 length
= DW_UNSND (attr
);
3325 /* check for the DW_AT_byte_size attribute */
3326 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3329 length
= DW_UNSND (attr
);
3336 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3337 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3338 if (cu_language
== language_fortran
)
3340 /* Need to create a unique string type for bounds
3342 type
= create_string_type (0, range_type
);
3346 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3347 type
= create_string_type (char_type
, range_type
);
3352 /* Handle DIES due to C code like:
3356 int (*funcp)(int a, long l);
3360 ('funcp' generates a DW_TAG_subroutine_type DIE)
3364 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
3365 const struct comp_unit_head
*cu_header
)
3367 struct type
*type
; /* Type that this function returns */
3368 struct type
*ftype
; /* Function that returns above type */
3369 struct attribute
*attr
;
3371 /* Decode the type that this subroutine returns */
3376 type
= die_type (die
, objfile
, cu_header
);
3377 ftype
= lookup_function_type (type
);
3379 /* All functions in C++ have prototypes. */
3380 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3381 if ((attr
&& (DW_UNSND (attr
) != 0))
3382 || cu_language
== language_cplus
)
3383 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3385 if (die
->has_children
)
3387 struct die_info
*child_die
;
3391 /* Count the number of parameters.
3392 FIXME: GDB currently ignores vararg functions, but knows about
3393 vararg member functions. */
3394 child_die
= die
->next
;
3395 while (child_die
&& child_die
->tag
)
3397 if (child_die
->tag
== DW_TAG_formal_parameter
)
3399 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3400 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3401 child_die
= sibling_die (child_die
);
3404 /* Allocate storage for parameters and fill them in. */
3405 TYPE_NFIELDS (ftype
) = nparams
;
3406 TYPE_FIELDS (ftype
) = (struct field
*)
3407 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3409 child_die
= die
->next
;
3410 while (child_die
&& child_die
->tag
)
3412 if (child_die
->tag
== DW_TAG_formal_parameter
)
3414 /* Dwarf2 has no clean way to discern C++ static and non-static
3415 member functions. G++ helps GDB by marking the first
3416 parameter for non-static member functions (which is the
3417 this pointer) as artificial. We pass this information
3418 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3419 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3421 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3423 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3424 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
3428 child_die
= sibling_die (child_die
);
3436 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
3437 const struct comp_unit_head
*cu_header
)
3439 struct attribute
*attr
;
3444 attr
= dwarf_attr (die
, DW_AT_name
);
3445 if (attr
&& DW_STRING (attr
))
3447 name
= DW_STRING (attr
);
3449 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3450 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
3454 /* Find a representation of a given base type and install
3455 it in the TYPE field of the die. */
3458 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
3461 struct attribute
*attr
;
3462 int encoding
= 0, size
= 0;
3464 /* If we've already decoded this die, this is a no-op. */
3470 attr
= dwarf_attr (die
, DW_AT_encoding
);
3473 encoding
= DW_UNSND (attr
);
3475 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3478 size
= DW_UNSND (attr
);
3480 attr
= dwarf_attr (die
, DW_AT_name
);
3481 if (attr
&& DW_STRING (attr
))
3483 enum type_code code
= TYPE_CODE_INT
;
3488 case DW_ATE_address
:
3489 /* Turn DW_ATE_address into a void * pointer. */
3490 code
= TYPE_CODE_PTR
;
3491 type_flags
|= TYPE_FLAG_UNSIGNED
;
3493 case DW_ATE_boolean
:
3494 code
= TYPE_CODE_BOOL
;
3495 type_flags
|= TYPE_FLAG_UNSIGNED
;
3497 case DW_ATE_complex_float
:
3498 code
= TYPE_CODE_COMPLEX
;
3501 code
= TYPE_CODE_FLT
;
3504 case DW_ATE_signed_char
:
3506 case DW_ATE_unsigned
:
3507 case DW_ATE_unsigned_char
:
3508 type_flags
|= TYPE_FLAG_UNSIGNED
;
3511 complaint (&symfile_complaints
, "unsupported DW_AT_encoding: '%s'",
3512 dwarf_type_encoding_name (encoding
));
3515 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3516 if (encoding
== DW_ATE_address
)
3517 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3518 else if (encoding
== DW_ATE_complex_float
)
3521 TYPE_TARGET_TYPE (type
)
3522 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3523 else if (size
== 16)
3524 TYPE_TARGET_TYPE (type
)
3525 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3527 TYPE_TARGET_TYPE (type
)
3528 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3533 type
= dwarf_base_type (encoding
, size
, objfile
);
3538 /* Read a whole compilation unit into a linked list of dies. */
3540 static struct die_info
*
3541 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3542 const struct comp_unit_head
*cu_header
)
3544 struct die_info
*first_die
, *last_die
, *die
;
3548 /* Reset die reference table; we are
3549 building new ones now. */
3550 dwarf2_empty_hash_tables ();
3554 first_die
= last_die
= NULL
;
3557 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3558 if (die
->has_children
)
3569 /* Enter die in reference hash table */
3570 store_in_ref_table (die
->offset
, die
);
3574 first_die
= last_die
= die
;
3578 last_die
->next
= die
;
3582 while (nesting_level
> 0);
3586 /* Free a linked list of dies. */
3589 free_die_list (struct die_info
*dies
)
3591 struct die_info
*die
, *next
;
3604 do_free_die_list_cleanup (void *dies
)
3606 free_die_list (dies
);
3609 static struct cleanup
*
3610 make_cleanup_free_die_list (struct die_info
*dies
)
3612 return make_cleanup (do_free_die_list_cleanup
, dies
);
3616 /* Read the contents of the section at OFFSET and of size SIZE from the
3617 object file specified by OBJFILE into the psymbol_obstack and return it. */
3620 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3621 unsigned int size
, asection
*sectp
)
3623 bfd
*abfd
= objfile
->obfd
;
3629 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3631 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
3635 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3636 (bfd_bread (buf
, size
, abfd
) != size
))
3639 error ("Dwarf Error: Can't read DWARF data from '%s'",
3640 bfd_get_filename (abfd
));
3645 /* In DWARF version 2, the description of the debugging information is
3646 stored in a separate .debug_abbrev section. Before we read any
3647 dies from a section we read in all abbreviations and install them
3651 dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
)
3654 struct abbrev_info
*cur_abbrev
;
3655 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3656 unsigned int abbrev_form
, hash_number
;
3658 /* Initialize dwarf2 abbrevs */
3659 memset (cu_header
->dwarf2_abbrevs
, 0,
3660 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
3662 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
3663 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3664 abbrev_ptr
+= bytes_read
;
3666 /* loop until we reach an abbrev number of 0 */
3667 while (abbrev_number
)
3669 cur_abbrev
= dwarf_alloc_abbrev ();
3671 /* read in abbrev header */
3672 cur_abbrev
->number
= abbrev_number
;
3673 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3674 abbrev_ptr
+= bytes_read
;
3675 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3678 /* now read in declarations */
3679 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3680 abbrev_ptr
+= bytes_read
;
3681 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3682 abbrev_ptr
+= bytes_read
;
3685 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3687 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3688 xrealloc (cur_abbrev
->attrs
,
3689 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3690 * sizeof (struct attr_abbrev
));
3692 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3693 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3694 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3695 abbrev_ptr
+= bytes_read
;
3696 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3697 abbrev_ptr
+= bytes_read
;
3700 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3701 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
3702 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3704 /* Get next abbreviation.
3705 Under Irix6 the abbreviations for a compilation unit are not
3706 always properly terminated with an abbrev number of 0.
3707 Exit loop if we encounter an abbreviation which we have
3708 already read (which means we are about to read the abbreviations
3709 for the next compile unit) or if the end of the abbreviation
3710 table is reached. */
3711 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3712 >= dwarf_abbrev_size
)
3714 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3715 abbrev_ptr
+= bytes_read
;
3716 if (dwarf2_lookup_abbrev (abbrev_number
, cu_header
) != NULL
)
3721 /* Empty the abbrev table for a new compilation unit. */
3725 dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table
)
3728 struct abbrev_info
*abbrev
, *next
;
3729 struct abbrev_info
**abbrevs
;
3731 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
3733 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3736 abbrev
= abbrevs
[i
];
3739 next
= abbrev
->next
;
3740 xfree (abbrev
->attrs
);
3748 /* Lookup an abbrev_info structure in the abbrev hash table. */
3750 static struct abbrev_info
*
3751 dwarf2_lookup_abbrev (unsigned int number
, const struct comp_unit_head
*cu_header
)
3753 unsigned int hash_number
;
3754 struct abbrev_info
*abbrev
;
3756 hash_number
= number
% ABBREV_HASH_SIZE
;
3757 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
3761 if (abbrev
->number
== number
)
3764 abbrev
= abbrev
->next
;
3769 /* Read a minimal amount of information into the minimal die structure. */
3772 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3773 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3775 unsigned int abbrev_number
, bytes_read
, i
;
3776 struct abbrev_info
*abbrev
;
3777 struct attribute attr
;
3778 struct attribute spec_attr
;
3779 int found_spec_attr
= 0;
3780 int has_low_pc_attr
= 0;
3781 int has_high_pc_attr
= 0;
3783 *part_die
= zeroed_partial_die
;
3784 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3785 info_ptr
+= bytes_read
;
3789 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3792 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number
,
3793 bfd_get_filename (abfd
));
3795 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3796 part_die
->tag
= abbrev
->tag
;
3797 part_die
->has_children
= abbrev
->has_children
;
3798 part_die
->abbrev
= abbrev_number
;
3800 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3802 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3803 info_ptr
, cu_header
);
3805 /* Store the data if it is of an attribute we want to keep in a
3806 partial symbol table. */
3811 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3812 if (part_die
->name
== NULL
)
3813 part_die
->name
= DW_STRING (&attr
);
3815 case DW_AT_MIPS_linkage_name
:
3816 part_die
->name
= DW_STRING (&attr
);
3819 has_low_pc_attr
= 1;
3820 part_die
->lowpc
= DW_ADDR (&attr
);
3823 has_high_pc_attr
= 1;
3824 part_die
->highpc
= DW_ADDR (&attr
);
3826 case DW_AT_location
:
3827 /* Support the .debug_loc offsets */
3828 if (attr_form_is_block (&attr
))
3830 part_die
->locdesc
= DW_BLOCK (&attr
);
3832 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
3834 dwarf2_complex_location_expr_complaint ();
3838 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3839 "partial symbol information");
3842 case DW_AT_language
:
3843 part_die
->language
= DW_UNSND (&attr
);
3845 case DW_AT_external
:
3846 part_die
->is_external
= DW_UNSND (&attr
);
3848 case DW_AT_declaration
:
3849 part_die
->is_declaration
= DW_UNSND (&attr
);
3852 part_die
->has_type
= 1;
3854 case DW_AT_abstract_origin
:
3855 case DW_AT_specification
:
3856 found_spec_attr
= 1;
3860 /* Ignore absolute siblings, they might point outside of
3861 the current compile unit. */
3862 if (attr
.form
== DW_FORM_ref_addr
)
3863 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
3866 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3873 /* If we found a reference attribute and the die has no name, try
3874 to find a name in the referred to die. */
3876 if (found_spec_attr
&& part_die
->name
== NULL
)
3878 struct partial_die_info spec_die
;
3882 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3883 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3886 part_die
->name
= spec_die
.name
;
3888 /* Copy DW_AT_external attribute if it is set. */
3889 if (spec_die
.is_external
)
3890 part_die
->is_external
= spec_die
.is_external
;
3894 /* When using the GNU linker, .gnu.linkonce. sections are used to
3895 eliminate duplicate copies of functions and vtables and such.
3896 The linker will arbitrarily choose one and discard the others.
3897 The AT_*_pc values for such functions refer to local labels in
3898 these sections. If the section from that file was discarded, the
3899 labels are not in the output, so the relocs get a value of 0.
3900 If this is a discarded function, mark the pc bounds as invalid,
3901 so that GDB will ignore it. */
3902 if (has_low_pc_attr
&& has_high_pc_attr
3903 && part_die
->lowpc
< part_die
->highpc
3904 && (part_die
->lowpc
!= 0
3905 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3906 part_die
->has_pc_info
= 1;
3910 /* Read the die from the .debug_info section buffer. And set diep to
3911 point to a newly allocated die with its information. */
3914 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3915 const struct comp_unit_head
*cu_header
)
3917 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3918 struct abbrev_info
*abbrev
;
3919 struct die_info
*die
;
3921 offset
= info_ptr
- dwarf_info_buffer
;
3922 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3923 info_ptr
+= bytes_read
;
3926 die
= dwarf_alloc_die ();
3928 die
->abbrev
= abbrev_number
;
3934 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3937 error ("Dwarf Error: could not find abbrev number %d [in module %s]", abbrev_number
,
3938 bfd_get_filename (abfd
));
3940 die
= dwarf_alloc_die ();
3941 die
->offset
= offset
;
3942 die
->tag
= abbrev
->tag
;
3943 die
->has_children
= abbrev
->has_children
;
3944 die
->abbrev
= abbrev_number
;
3947 die
->num_attrs
= abbrev
->num_attrs
;
3948 die
->attrs
= (struct attribute
*)
3949 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3951 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3953 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3954 abfd
, info_ptr
, cu_header
);
3961 /* Read an attribute value described by an attribute form. */
3964 read_attribute_value (struct attribute
*attr
, unsigned form
,
3965 bfd
*abfd
, char *info_ptr
,
3966 const struct comp_unit_head
*cu_header
)
3968 unsigned int bytes_read
;
3969 struct dwarf_block
*blk
;
3975 case DW_FORM_ref_addr
:
3976 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3977 info_ptr
+= bytes_read
;
3979 case DW_FORM_block2
:
3980 blk
= dwarf_alloc_block ();
3981 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3983 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3984 info_ptr
+= blk
->size
;
3985 DW_BLOCK (attr
) = blk
;
3987 case DW_FORM_block4
:
3988 blk
= dwarf_alloc_block ();
3989 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3991 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3992 info_ptr
+= blk
->size
;
3993 DW_BLOCK (attr
) = blk
;
3996 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4000 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4004 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4007 case DW_FORM_string
:
4008 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
4009 info_ptr
+= bytes_read
;
4012 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
4014 info_ptr
+= bytes_read
;
4017 blk
= dwarf_alloc_block ();
4018 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4019 info_ptr
+= bytes_read
;
4020 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4021 info_ptr
+= blk
->size
;
4022 DW_BLOCK (attr
) = blk
;
4024 case DW_FORM_block1
:
4025 blk
= dwarf_alloc_block ();
4026 blk
->size
= read_1_byte (abfd
, info_ptr
);
4028 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4029 info_ptr
+= blk
->size
;
4030 DW_BLOCK (attr
) = blk
;
4033 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4037 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4041 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
4042 info_ptr
+= bytes_read
;
4045 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4046 info_ptr
+= bytes_read
;
4049 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4053 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4057 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4061 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4064 case DW_FORM_ref_udata
:
4065 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4066 info_ptr
+= bytes_read
;
4068 case DW_FORM_indirect
:
4069 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4070 info_ptr
+= bytes_read
;
4071 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
4074 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4075 dwarf_form_name (form
),
4076 bfd_get_filename (abfd
));
4081 /* Read an attribute described by an abbreviated attribute. */
4084 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
4085 bfd
*abfd
, char *info_ptr
,
4086 const struct comp_unit_head
*cu_header
)
4088 attr
->name
= abbrev
->name
;
4089 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
4092 /* read dwarf information from a buffer */
4095 read_1_byte (bfd
*abfd
, char *buf
)
4097 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4101 read_1_signed_byte (bfd
*abfd
, char *buf
)
4103 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
4107 read_2_bytes (bfd
*abfd
, char *buf
)
4109 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4113 read_2_signed_bytes (bfd
*abfd
, char *buf
)
4115 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4119 read_4_bytes (bfd
*abfd
, char *buf
)
4121 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4125 read_4_signed_bytes (bfd
*abfd
, char *buf
)
4127 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4130 static unsigned long
4131 read_8_bytes (bfd
*abfd
, char *buf
)
4133 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4137 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4140 CORE_ADDR retval
= 0;
4142 if (cu_header
->signed_addr_p
)
4144 switch (cu_header
->addr_size
)
4147 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4150 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4153 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
4156 internal_error (__FILE__
, __LINE__
,
4157 "read_address: bad switch, signed [in module %s]",
4158 bfd_get_filename (abfd
));
4163 switch (cu_header
->addr_size
)
4166 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4169 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4172 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4175 internal_error (__FILE__
, __LINE__
,
4176 "read_address: bad switch, unsigned [in module %s]",
4177 bfd_get_filename (abfd
));
4181 *bytes_read
= cu_header
->addr_size
;
4185 /* Read the initial length from a section. The (draft) DWARF 3
4186 specification allows the initial length to take up either 4 bytes
4187 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4188 bytes describe the length and all offsets will be 8 bytes in length
4191 An older, non-standard 64-bit format is also handled by this
4192 function. The older format in question stores the initial length
4193 as an 8-byte quantity without an escape value. Lengths greater
4194 than 2^32 aren't very common which means that the initial 4 bytes
4195 is almost always zero. Since a length value of zero doesn't make
4196 sense for the 32-bit format, this initial zero can be considered to
4197 be an escape value which indicates the presence of the older 64-bit
4198 format. As written, the code can't detect (old format) lengths
4199 greater than 4GB. If it becomes necessary to handle lengths somewhat
4200 larger than 4GB, we could allow other small values (such as the
4201 non-sensical values of 1, 2, and 3) to also be used as escape values
4202 indicating the presence of the old format.
4204 The value returned via bytes_read should be used to increment
4205 the relevant pointer after calling read_initial_length().
4207 As a side effect, this function sets the fields initial_length_size
4208 and offset_size in cu_header to the values appropriate for the
4209 length field. (The format of the initial length field determines
4210 the width of file offsets to be fetched later with fetch_offset().)
4212 [ Note: read_initial_length() and read_offset() are based on the
4213 document entitled "DWARF Debugging Information Format", revision
4214 3, draft 8, dated November 19, 2001. This document was obtained
4217 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4219 This document is only a draft and is subject to change. (So beware.)
4221 Details regarding the older, non-standard 64-bit format were
4222 determined empirically by examining 64-bit ELF files produced
4223 by the SGI toolchain on an IRIX 6.5 machine.
4225 - Kevin, July 16, 2002
4229 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4234 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4236 if (retval
== 0xffffffff)
4238 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4240 if (cu_header
!= NULL
)
4242 cu_header
->initial_length_size
= 12;
4243 cu_header
->offset_size
= 8;
4246 else if (retval
== 0)
4248 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4250 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4252 if (cu_header
!= NULL
)
4254 cu_header
->initial_length_size
= 8;
4255 cu_header
->offset_size
= 8;
4261 if (cu_header
!= NULL
)
4263 cu_header
->initial_length_size
= 4;
4264 cu_header
->offset_size
= 4;
4271 /* Read an offset from the data stream. The size of the offset is
4272 given by cu_header->offset_size. */
4275 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4280 switch (cu_header
->offset_size
)
4283 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4287 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4291 internal_error (__FILE__
, __LINE__
,
4292 "read_offset: bad switch [in module %s]",
4293 bfd_get_filename (abfd
));
4300 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4302 /* If the size of a host char is 8 bits, we can return a pointer
4303 to the buffer, otherwise we have to copy the data to a buffer
4304 allocated on the temporary obstack. */
4305 gdb_assert (HOST_CHAR_BIT
== 8);
4310 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4312 /* If the size of a host char is 8 bits, we can return a pointer
4313 to the string, otherwise we have to copy the string to a buffer
4314 allocated on the temporary obstack. */
4315 gdb_assert (HOST_CHAR_BIT
== 8);
4318 *bytes_read_ptr
= 1;
4321 *bytes_read_ptr
= strlen (buf
) + 1;
4326 read_indirect_string (bfd
*abfd
, char *buf
,
4327 const struct comp_unit_head
*cu_header
,
4328 unsigned int *bytes_read_ptr
)
4330 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4331 (int *) bytes_read_ptr
);
4333 if (dwarf_str_buffer
== NULL
)
4335 error ("DW_FORM_strp used without .debug_str section [in module %s]",
4336 bfd_get_filename (abfd
));
4339 if (str_offset
>= dwarf_str_size
)
4341 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4342 bfd_get_filename (abfd
));
4345 gdb_assert (HOST_CHAR_BIT
== 8);
4346 if (dwarf_str_buffer
[str_offset
] == '\0')
4348 return dwarf_str_buffer
+ str_offset
;
4351 static unsigned long
4352 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4354 unsigned long result
;
4355 unsigned int num_read
;
4365 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4368 result
|= ((unsigned long)(byte
& 127) << shift
);
4369 if ((byte
& 128) == 0)
4375 *bytes_read_ptr
= num_read
;
4380 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4383 int i
, shift
, size
, num_read
;
4393 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4396 result
|= ((long)(byte
& 127) << shift
);
4398 if ((byte
& 128) == 0)
4403 if ((shift
< size
) && (byte
& 0x40))
4405 result
|= -(1 << shift
);
4407 *bytes_read_ptr
= num_read
;
4412 set_cu_language (unsigned int lang
)
4418 cu_language
= language_c
;
4420 case DW_LANG_C_plus_plus
:
4421 cu_language
= language_cplus
;
4423 case DW_LANG_Fortran77
:
4424 case DW_LANG_Fortran90
:
4425 case DW_LANG_Fortran95
:
4426 cu_language
= language_fortran
;
4428 case DW_LANG_Mips_Assembler
:
4429 cu_language
= language_asm
;
4432 cu_language
= language_java
;
4436 case DW_LANG_Cobol74
:
4437 case DW_LANG_Cobol85
:
4438 case DW_LANG_Pascal83
:
4439 case DW_LANG_Modula2
:
4441 cu_language
= language_unknown
;
4444 cu_language_defn
= language_def (cu_language
);
4447 /* Return the named attribute or NULL if not there. */
4449 static struct attribute
*
4450 dwarf_attr (struct die_info
*die
, unsigned int name
)
4453 struct attribute
*spec
= NULL
;
4455 for (i
= 0; i
< die
->num_attrs
; ++i
)
4457 if (die
->attrs
[i
].name
== name
)
4459 return &die
->attrs
[i
];
4461 if (die
->attrs
[i
].name
== DW_AT_specification
4462 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4463 spec
= &die
->attrs
[i
];
4467 struct die_info
*ref_die
=
4468 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4471 return dwarf_attr (ref_die
, name
);
4478 die_is_declaration (struct die_info
*die
)
4480 return (dwarf_attr (die
, DW_AT_declaration
)
4481 && ! dwarf_attr (die
, DW_AT_specification
));
4485 /* Free the line_header structure *LH, and any arrays and strings it
4488 free_line_header (struct line_header
*lh
)
4490 if (lh
->standard_opcode_lengths
)
4491 xfree (lh
->standard_opcode_lengths
);
4493 /* Remember that all the lh->file_names[i].name pointers are
4494 pointers into debug_line_buffer, and don't need to be freed. */
4496 xfree (lh
->file_names
);
4498 /* Similarly for the include directory names. */
4499 if (lh
->include_dirs
)
4500 xfree (lh
->include_dirs
);
4506 /* Add an entry to LH's include directory table. */
4508 add_include_dir (struct line_header
*lh
, char *include_dir
)
4510 /* Grow the array if necessary. */
4511 if (lh
->include_dirs_size
== 0)
4513 lh
->include_dirs_size
= 1; /* for testing */
4514 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4515 * sizeof (*lh
->include_dirs
));
4517 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4519 lh
->include_dirs_size
*= 2;
4520 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4521 (lh
->include_dirs_size
4522 * sizeof (*lh
->include_dirs
)));
4525 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4529 /* Add an entry to LH's file name table. */
4531 add_file_name (struct line_header
*lh
,
4533 unsigned int dir_index
,
4534 unsigned int mod_time
,
4535 unsigned int length
)
4537 struct file_entry
*fe
;
4539 /* Grow the array if necessary. */
4540 if (lh
->file_names_size
== 0)
4542 lh
->file_names_size
= 1; /* for testing */
4543 lh
->file_names
= xmalloc (lh
->file_names_size
4544 * sizeof (*lh
->file_names
));
4546 else if (lh
->num_file_names
>= lh
->file_names_size
)
4548 lh
->file_names_size
*= 2;
4549 lh
->file_names
= xrealloc (lh
->file_names
,
4550 (lh
->file_names_size
4551 * sizeof (*lh
->file_names
)));
4554 fe
= &lh
->file_names
[lh
->num_file_names
++];
4556 fe
->dir_index
= dir_index
;
4557 fe
->mod_time
= mod_time
;
4558 fe
->length
= length
;
4562 /* Read the statement program header starting at OFFSET in
4563 dwarf_line_buffer, according to the endianness of ABFD. Return a
4564 pointer to a struct line_header, allocated using xmalloc.
4566 NOTE: the strings in the include directory and file name tables of
4567 the returned object point into debug_line_buffer, and must not be
4569 static struct line_header
*
4570 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4571 const struct comp_unit_head
*cu_header
)
4573 struct cleanup
*back_to
;
4574 struct line_header
*lh
;
4578 char *cur_dir
, *cur_file
;
4580 if (dwarf_line_buffer
== NULL
)
4582 complaint (&symfile_complaints
, "missing .debug_line section");
4586 /* Make sure that at least there's room for the total_length field. That
4587 could be 12 bytes long, but we're just going to fudge that. */
4588 if (offset
+ 4 >= dwarf_line_size
)
4590 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4594 lh
= xmalloc (sizeof (*lh
));
4595 memset (lh
, 0, sizeof (*lh
));
4596 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4599 line_ptr
= dwarf_line_buffer
+ offset
;
4601 /* read in the header */
4602 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4603 line_ptr
+= bytes_read
;
4604 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4606 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4609 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4610 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4612 lh
->header_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
4613 line_ptr
+= bytes_read
;
4614 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4616 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4618 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4620 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4622 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4624 lh
->standard_opcode_lengths
4625 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4627 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4628 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4630 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4634 /* Read directory table */
4635 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4637 line_ptr
+= bytes_read
;
4638 add_include_dir (lh
, cur_dir
);
4640 line_ptr
+= bytes_read
;
4642 /* Read file name table */
4643 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4645 unsigned int dir_index
, mod_time
, length
;
4647 line_ptr
+= bytes_read
;
4648 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4649 line_ptr
+= bytes_read
;
4650 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4651 line_ptr
+= bytes_read
;
4652 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4653 line_ptr
+= bytes_read
;
4655 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4657 line_ptr
+= bytes_read
;
4658 lh
->statement_program_start
= line_ptr
;
4660 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4661 complaint (&symfile_complaints
,
4662 "line number info header doesn't fit in `.debug_line' section");
4664 discard_cleanups (back_to
);
4668 /* This function exists to work around a bug in certain compilers
4669 (particularly GCC 2.95), in which the first line number marker of a
4670 function does not show up until after the prologue, right before
4671 the second line number marker. This function shifts ADDRESS down
4672 to the beginning of the function if necessary, and is called on
4673 addresses passed to record_line. */
4676 check_cu_functions (CORE_ADDR address
)
4678 struct function_range
*fn
;
4680 /* Find the function_range containing address. */
4685 cu_cached_fn
= cu_first_fn
;
4689 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4695 while (fn
&& fn
!= cu_cached_fn
)
4696 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4706 if (address
!= fn
->lowpc
)
4707 complaint (&symfile_complaints
,
4708 "misplaced first line number at 0x%lx for '%s'",
4709 (unsigned long) address
, fn
->name
);
4714 /* Decode the line number information for the compilation unit whose
4715 line number info is at OFFSET in the .debug_line section.
4716 The compilation directory of the file is passed in COMP_DIR. */
4719 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
4720 const struct comp_unit_head
*cu_header
)
4724 unsigned int i
, bytes_read
;
4726 unsigned char op_code
, extended_op
, adj_opcode
;
4728 line_ptr
= lh
->statement_program_start
;
4729 line_end
= lh
->statement_program_end
;
4731 /* Read the statement sequences until there's nothing left. */
4732 while (line_ptr
< line_end
)
4734 /* state machine registers */
4735 CORE_ADDR address
= 0;
4736 unsigned int file
= 1;
4737 unsigned int line
= 1;
4738 unsigned int column
= 0;
4739 int is_stmt
= lh
->default_is_stmt
;
4740 int basic_block
= 0;
4741 int end_sequence
= 0;
4743 /* Start a subfile for the current file of the state machine. */
4744 if (lh
->num_file_names
>= file
)
4746 /* lh->include_dirs and lh->file_names are 0-based, but the
4747 directory and file name numbers in the statement program
4749 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
4752 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4755 dwarf2_start_subfile (fe
->name
, dir
);
4758 /* Decode the table. */
4759 while (!end_sequence
)
4761 op_code
= read_1_byte (abfd
, line_ptr
);
4764 if (op_code
>= lh
->opcode_base
)
4765 { /* Special operand. */
4766 adj_opcode
= op_code
- lh
->opcode_base
;
4767 address
+= (adj_opcode
/ lh
->line_range
)
4768 * lh
->minimum_instruction_length
;
4769 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
4770 /* append row to matrix using current values */
4771 address
= check_cu_functions (address
);
4772 record_line (current_subfile
, line
, address
);
4775 else switch (op_code
)
4777 case DW_LNS_extended_op
:
4778 line_ptr
+= 1; /* ignore length */
4779 extended_op
= read_1_byte (abfd
, line_ptr
);
4781 switch (extended_op
)
4783 case DW_LNE_end_sequence
:
4785 record_line (current_subfile
, 0, address
);
4787 case DW_LNE_set_address
:
4788 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4789 line_ptr
+= bytes_read
;
4790 address
+= baseaddr
;
4792 case DW_LNE_define_file
:
4795 unsigned int dir_index
, mod_time
, length
;
4797 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
4798 line_ptr
+= bytes_read
;
4800 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4801 line_ptr
+= bytes_read
;
4803 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4804 line_ptr
+= bytes_read
;
4806 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4807 line_ptr
+= bytes_read
;
4808 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4812 complaint (&symfile_complaints
,
4813 "mangled .debug_line section");
4818 address
= check_cu_functions (address
);
4819 record_line (current_subfile
, line
, address
);
4822 case DW_LNS_advance_pc
:
4823 address
+= lh
->minimum_instruction_length
4824 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4825 line_ptr
+= bytes_read
;
4827 case DW_LNS_advance_line
:
4828 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4829 line_ptr
+= bytes_read
;
4831 case DW_LNS_set_file
:
4833 /* lh->include_dirs and lh->file_names are 0-based,
4834 but the directory and file name numbers in the
4835 statement program are 1-based. */
4836 struct file_entry
*fe
;
4838 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4839 line_ptr
+= bytes_read
;
4840 fe
= &lh
->file_names
[file
- 1];
4842 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4845 dwarf2_start_subfile (fe
->name
, dir
);
4848 case DW_LNS_set_column
:
4849 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4850 line_ptr
+= bytes_read
;
4852 case DW_LNS_negate_stmt
:
4853 is_stmt
= (!is_stmt
);
4855 case DW_LNS_set_basic_block
:
4858 /* Add to the address register of the state machine the
4859 address increment value corresponding to special opcode
4860 255. Ie, this value is scaled by the minimum instruction
4861 length since special opcode 255 would have scaled the
4863 case DW_LNS_const_add_pc
:
4864 address
+= (lh
->minimum_instruction_length
4865 * ((255 - lh
->opcode_base
) / lh
->line_range
));
4867 case DW_LNS_fixed_advance_pc
:
4868 address
+= read_2_bytes (abfd
, line_ptr
);
4872 { /* Unknown standard opcode, ignore it. */
4874 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
4876 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4877 line_ptr
+= bytes_read
;
4885 /* Start a subfile for DWARF. FILENAME is the name of the file and
4886 DIRNAME the name of the source directory which contains FILENAME
4887 or NULL if not known.
4888 This routine tries to keep line numbers from identical absolute and
4889 relative file names in a common subfile.
4891 Using the `list' example from the GDB testsuite, which resides in
4892 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4893 of /srcdir/list0.c yields the following debugging information for list0.c:
4895 DW_AT_name: /srcdir/list0.c
4896 DW_AT_comp_dir: /compdir
4897 files.files[0].name: list0.h
4898 files.files[0].dir: /srcdir
4899 files.files[1].name: list0.c
4900 files.files[1].dir: /srcdir
4902 The line number information for list0.c has to end up in a single
4903 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4906 dwarf2_start_subfile (char *filename
, char *dirname
)
4908 /* If the filename isn't absolute, try to match an existing subfile
4909 with the full pathname. */
4911 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4913 struct subfile
*subfile
;
4914 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4916 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4918 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4920 current_subfile
= subfile
;
4927 start_subfile (filename
, dirname
);
4930 /* Given a pointer to a DWARF information entry, figure out if we need
4931 to make a symbol table entry for it, and if so, create a new entry
4932 and return a pointer to it.
4933 If TYPE is NULL, determine symbol type from the die, otherwise
4934 used the passed type. */
4936 static struct symbol
*
4937 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4938 const struct comp_unit_head
*cu_header
)
4940 struct symbol
*sym
= NULL
;
4942 struct attribute
*attr
= NULL
;
4943 struct attribute
*attr2
= NULL
;
4946 name
= dwarf2_linkage_name (die
);
4949 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4950 sizeof (struct symbol
));
4951 OBJSTAT (objfile
, n_syms
++);
4952 memset (sym
, 0, sizeof (struct symbol
));
4954 /* Cache this symbol's name and the name's demangled form (if any). */
4955 SYMBOL_LANGUAGE (sym
) = cu_language
;
4956 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
4958 /* Default assumptions.
4959 Use the passed type or decode it from the die. */
4960 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4961 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4963 SYMBOL_TYPE (sym
) = type
;
4965 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4966 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4969 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4974 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4977 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4979 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4981 case DW_TAG_subprogram
:
4982 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4984 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4985 attr2
= dwarf_attr (die
, DW_AT_external
);
4986 if (attr2
&& (DW_UNSND (attr2
) != 0))
4988 add_symbol_to_list (sym
, &global_symbols
);
4992 add_symbol_to_list (sym
, list_in_scope
);
4995 case DW_TAG_variable
:
4996 /* Compilation with minimal debug info may result in variables
4997 with missing type entries. Change the misleading `void' type
4998 to something sensible. */
4999 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
5000 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
5001 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
5002 "<variable, no debug info>",
5004 attr
= dwarf_attr (die
, DW_AT_const_value
);
5007 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5008 attr2
= dwarf_attr (die
, DW_AT_external
);
5009 if (attr2
&& (DW_UNSND (attr2
) != 0))
5010 add_symbol_to_list (sym
, &global_symbols
);
5012 add_symbol_to_list (sym
, list_in_scope
);
5015 attr
= dwarf_attr (die
, DW_AT_location
);
5018 attr2
= dwarf_attr (die
, DW_AT_external
);
5019 if (attr2
&& (DW_UNSND (attr2
) != 0))
5021 /* Support the .debug_loc offsets */
5022 if (attr_form_is_block (attr
))
5024 SYMBOL_VALUE_ADDRESS (sym
) =
5025 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
5027 else if (attr
->form
== DW_FORM_data4
5028 || attr
->form
== DW_FORM_data8
)
5030 dwarf2_complex_location_expr_complaint ();
5034 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5035 "external variable");
5037 add_symbol_to_list (sym
, &global_symbols
);
5038 if (is_thread_local
)
5040 /* SYMBOL_VALUE_ADDRESS contains at this point the
5041 offset of the variable within the thread local
5043 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
5044 SYMBOL_OBJFILE (sym
) = objfile
;
5047 /* In shared libraries the address of the variable
5048 in the location descriptor might still be relocatable,
5049 so its value could be zero.
5050 Enter the symbol as a LOC_UNRESOLVED symbol, if its
5051 value is zero, the address of the variable will then
5052 be determined from the minimal symbol table whenever
5053 the variable is referenced. */
5054 else if (SYMBOL_VALUE_ADDRESS (sym
))
5056 fixup_symbol_section (sym
, objfile
);
5057 SYMBOL_VALUE_ADDRESS (sym
) +=
5058 ANOFFSET (objfile
->section_offsets
,
5059 SYMBOL_SECTION (sym
));
5060 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5063 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
5067 /* Support the .debug_loc offsets */
5068 if (attr_form_is_block (attr
))
5070 SYMBOL_VALUE (sym
) = addr
=
5071 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
5073 else if (attr
->form
== DW_FORM_data4
5074 || attr
->form
== DW_FORM_data8
)
5076 dwarf2_complex_location_expr_complaint ();
5080 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5081 "external variable");
5084 add_symbol_to_list (sym
, list_in_scope
);
5087 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
5091 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
5092 SYMBOL_VALUE (sym
) =
5093 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
5097 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
5098 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
5102 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
5104 else if (is_thread_local
)
5106 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
5107 SYMBOL_OBJFILE (sym
) = objfile
;
5111 fixup_symbol_section (sym
, objfile
);
5112 SYMBOL_VALUE_ADDRESS (sym
) =
5113 addr
+ ANOFFSET (objfile
->section_offsets
,
5114 SYMBOL_SECTION (sym
));
5115 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5121 /* We do not know the address of this symbol.
5122 If it is an external symbol and we have type information
5123 for it, enter the symbol as a LOC_UNRESOLVED symbol.
5124 The address of the variable will then be determined from
5125 the minimal symbol table whenever the variable is
5127 attr2
= dwarf_attr (die
, DW_AT_external
);
5128 if (attr2
&& (DW_UNSND (attr2
) != 0)
5129 && dwarf_attr (die
, DW_AT_type
) != NULL
)
5131 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
5132 add_symbol_to_list (sym
, &global_symbols
);
5136 case DW_TAG_formal_parameter
:
5137 attr
= dwarf_attr (die
, DW_AT_location
);
5140 SYMBOL_VALUE (sym
) =
5141 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
5144 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
5145 SYMBOL_VALUE (sym
) =
5146 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
5152 if (basereg
!= frame_base_reg
)
5153 dwarf2_complex_location_expr_complaint ();
5154 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
5158 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
5159 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
5164 SYMBOL_CLASS (sym
) = LOC_ARG
;
5167 attr
= dwarf_attr (die
, DW_AT_const_value
);
5170 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5172 add_symbol_to_list (sym
, list_in_scope
);
5174 case DW_TAG_unspecified_parameters
:
5175 /* From varargs functions; gdb doesn't seem to have any
5176 interest in this information, so just ignore it for now.
5179 case DW_TAG_class_type
:
5180 case DW_TAG_structure_type
:
5181 case DW_TAG_union_type
:
5182 case DW_TAG_enumeration_type
:
5183 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5184 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
5185 add_symbol_to_list (sym
, list_in_scope
);
5187 /* The semantics of C++ state that "struct foo { ... }" also
5188 defines a typedef for "foo". Synthesize a typedef symbol so
5189 that "ptype foo" works as expected. */
5190 if (cu_language
== language_cplus
)
5192 struct symbol
*typedef_sym
= (struct symbol
*)
5193 obstack_alloc (&objfile
->symbol_obstack
,
5194 sizeof (struct symbol
));
5195 *typedef_sym
= *sym
;
5196 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
5197 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5198 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5199 obsavestring (SYMBOL_NAME (sym
),
5200 strlen (SYMBOL_NAME (sym
)),
5201 &objfile
->type_obstack
);
5202 add_symbol_to_list (typedef_sym
, list_in_scope
);
5205 case DW_TAG_typedef
:
5206 case DW_TAG_base_type
:
5207 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5208 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
5209 add_symbol_to_list (sym
, list_in_scope
);
5211 case DW_TAG_enumerator
:
5212 attr
= dwarf_attr (die
, DW_AT_const_value
);
5215 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5217 add_symbol_to_list (sym
, list_in_scope
);
5220 /* Not a tag we recognize. Hopefully we aren't processing
5221 trash data, but since we must specifically ignore things
5222 we don't recognize, there is nothing else we should do at
5224 complaint (&symfile_complaints
, "unsupported tag: '%s'",
5225 dwarf_tag_name (die
->tag
));
5232 /* Copy constant value from an attribute to a symbol. */
5235 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5236 struct objfile
*objfile
,
5237 const struct comp_unit_head
*cu_header
)
5239 struct dwarf_block
*blk
;
5244 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5245 dwarf2_const_value_length_mismatch_complaint (SYMBOL_NAME (sym
),
5246 cu_header
->addr_size
,
5247 TYPE_LENGTH (SYMBOL_TYPE
5249 SYMBOL_VALUE_BYTES (sym
) = (char *)
5250 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5251 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5253 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5255 case DW_FORM_block1
:
5256 case DW_FORM_block2
:
5257 case DW_FORM_block4
:
5259 blk
= DW_BLOCK (attr
);
5260 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5261 dwarf2_const_value_length_mismatch_complaint (SYMBOL_NAME (sym
),
5263 TYPE_LENGTH (SYMBOL_TYPE
5265 SYMBOL_VALUE_BYTES (sym
) = (char *)
5266 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5267 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5268 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5271 /* The DW_AT_const_value attributes are supposed to carry the
5272 symbol's value "represented as it would be on the target
5273 architecture." By the time we get here, it's already been
5274 converted to host endianness, so we just need to sign- or
5275 zero-extend it as appropriate. */
5277 dwarf2_const_value_data (attr
, sym
, 8);
5280 dwarf2_const_value_data (attr
, sym
, 16);
5283 dwarf2_const_value_data (attr
, sym
, 32);
5286 dwarf2_const_value_data (attr
, sym
, 64);
5290 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5291 SYMBOL_CLASS (sym
) = LOC_CONST
;
5295 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5296 SYMBOL_CLASS (sym
) = LOC_CONST
;
5300 complaint (&symfile_complaints
,
5301 "unsupported const value attribute form: '%s'",
5302 dwarf_form_name (attr
->form
));
5303 SYMBOL_VALUE (sym
) = 0;
5304 SYMBOL_CLASS (sym
) = LOC_CONST
;
5310 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5311 or zero-extend it as appropriate for the symbol's type. */
5313 dwarf2_const_value_data (struct attribute
*attr
,
5317 LONGEST l
= DW_UNSND (attr
);
5319 if (bits
< sizeof (l
) * 8)
5321 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5322 l
&= ((LONGEST
) 1 << bits
) - 1;
5324 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5327 SYMBOL_VALUE (sym
) = l
;
5328 SYMBOL_CLASS (sym
) = LOC_CONST
;
5332 /* Return the type of the die in question using its DW_AT_type attribute. */
5334 static struct type
*
5335 die_type (struct die_info
*die
, struct objfile
*objfile
,
5336 const struct comp_unit_head
*cu_header
)
5339 struct attribute
*type_attr
;
5340 struct die_info
*type_die
;
5343 type_attr
= dwarf_attr (die
, DW_AT_type
);
5346 /* A missing DW_AT_type represents a void type. */
5347 return dwarf2_fundamental_type (objfile
, FT_VOID
);
5351 ref
= dwarf2_get_ref_die_offset (type_attr
);
5352 type_die
= follow_die_ref (ref
);
5355 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5356 ref
, objfile
->name
);
5360 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5363 dump_die (type_die
);
5364 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5370 /* Return the containing type of the die in question using its
5371 DW_AT_containing_type attribute. */
5373 static struct type
*
5374 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
5375 const struct comp_unit_head
*cu_header
)
5377 struct type
*type
= NULL
;
5378 struct attribute
*type_attr
;
5379 struct die_info
*type_die
= NULL
;
5382 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5385 ref
= dwarf2_get_ref_die_offset (type_attr
);
5386 type_die
= follow_die_ref (ref
);
5389 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref
,
5393 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5398 dump_die (type_die
);
5399 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
5406 static struct type
*
5407 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
5409 struct die_info
*die
;
5412 die
= follow_die_ref (offset
);
5415 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5418 type
= tag_type_to_type (die
, objfile
);
5423 static struct type
*
5424 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
5425 const struct comp_unit_head
*cu_header
)
5433 read_type_die (die
, objfile
, cu_header
);
5437 error ("Dwarf Error: Cannot find type of die [in module %s]",
5445 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
5446 const struct comp_unit_head
*cu_header
)
5450 case DW_TAG_class_type
:
5451 case DW_TAG_structure_type
:
5452 case DW_TAG_union_type
:
5453 read_structure_scope (die
, objfile
, cu_header
);
5455 case DW_TAG_enumeration_type
:
5456 read_enumeration (die
, objfile
, cu_header
);
5458 case DW_TAG_subprogram
:
5459 case DW_TAG_subroutine_type
:
5460 read_subroutine_type (die
, objfile
, cu_header
);
5462 case DW_TAG_array_type
:
5463 read_array_type (die
, objfile
, cu_header
);
5465 case DW_TAG_pointer_type
:
5466 read_tag_pointer_type (die
, objfile
, cu_header
);
5468 case DW_TAG_ptr_to_member_type
:
5469 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
5471 case DW_TAG_reference_type
:
5472 read_tag_reference_type (die
, objfile
, cu_header
);
5474 case DW_TAG_const_type
:
5475 read_tag_const_type (die
, objfile
, cu_header
);
5477 case DW_TAG_volatile_type
:
5478 read_tag_volatile_type (die
, objfile
, cu_header
);
5480 case DW_TAG_string_type
:
5481 read_tag_string_type (die
, objfile
);
5483 case DW_TAG_typedef
:
5484 read_typedef (die
, objfile
, cu_header
);
5486 case DW_TAG_base_type
:
5487 read_base_type (die
, objfile
);
5490 complaint (&symfile_complaints
, "unexepected tag in read_type_die: '%s'",
5491 dwarf_tag_name (die
->tag
));
5496 static struct type
*
5497 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
5499 /* FIXME - this should not produce a new (struct type *)
5500 every time. It should cache base types. */
5504 case DW_ATE_address
:
5505 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5507 case DW_ATE_boolean
:
5508 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5510 case DW_ATE_complex_float
:
5513 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5517 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5523 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5527 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5534 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5537 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5541 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5545 case DW_ATE_signed_char
:
5546 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5548 case DW_ATE_unsigned
:
5552 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5555 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5559 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5563 case DW_ATE_unsigned_char
:
5564 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5567 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5574 copy_die (struct die_info
*old_die
)
5576 struct die_info
*new_die
;
5579 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5580 memset (new_die
, 0, sizeof (struct die_info
));
5582 new_die
->tag
= old_die
->tag
;
5583 new_die
->has_children
= old_die
->has_children
;
5584 new_die
->abbrev
= old_die
->abbrev
;
5585 new_die
->offset
= old_die
->offset
;
5586 new_die
->type
= NULL
;
5588 num_attrs
= old_die
->num_attrs
;
5589 new_die
->num_attrs
= num_attrs
;
5590 new_die
->attrs
= (struct attribute
*)
5591 xmalloc (num_attrs
* sizeof (struct attribute
));
5593 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5595 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5596 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5597 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5600 new_die
->next
= NULL
;
5605 /* Return sibling of die, NULL if no sibling. */
5607 static struct die_info
*
5608 sibling_die (struct die_info
*die
)
5610 int nesting_level
= 0;
5612 if (!die
->has_children
)
5614 if (die
->next
&& (die
->next
->tag
== 0))
5627 if (die
->has_children
)
5637 while (nesting_level
);
5638 if (die
&& (die
->tag
== 0))
5649 /* Get linkage name of a die, return NULL if not found. */
5652 dwarf2_linkage_name (struct die_info
*die
)
5654 struct attribute
*attr
;
5656 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5657 if (attr
&& DW_STRING (attr
))
5658 return DW_STRING (attr
);
5659 attr
= dwarf_attr (die
, DW_AT_name
);
5660 if (attr
&& DW_STRING (attr
))
5661 return DW_STRING (attr
);
5665 /* Convert a DIE tag into its string name. */
5668 dwarf_tag_name (register unsigned tag
)
5672 case DW_TAG_padding
:
5673 return "DW_TAG_padding";
5674 case DW_TAG_array_type
:
5675 return "DW_TAG_array_type";
5676 case DW_TAG_class_type
:
5677 return "DW_TAG_class_type";
5678 case DW_TAG_entry_point
:
5679 return "DW_TAG_entry_point";
5680 case DW_TAG_enumeration_type
:
5681 return "DW_TAG_enumeration_type";
5682 case DW_TAG_formal_parameter
:
5683 return "DW_TAG_formal_parameter";
5684 case DW_TAG_imported_declaration
:
5685 return "DW_TAG_imported_declaration";
5687 return "DW_TAG_label";
5688 case DW_TAG_lexical_block
:
5689 return "DW_TAG_lexical_block";
5691 return "DW_TAG_member";
5692 case DW_TAG_pointer_type
:
5693 return "DW_TAG_pointer_type";
5694 case DW_TAG_reference_type
:
5695 return "DW_TAG_reference_type";
5696 case DW_TAG_compile_unit
:
5697 return "DW_TAG_compile_unit";
5698 case DW_TAG_string_type
:
5699 return "DW_TAG_string_type";
5700 case DW_TAG_structure_type
:
5701 return "DW_TAG_structure_type";
5702 case DW_TAG_subroutine_type
:
5703 return "DW_TAG_subroutine_type";
5704 case DW_TAG_typedef
:
5705 return "DW_TAG_typedef";
5706 case DW_TAG_union_type
:
5707 return "DW_TAG_union_type";
5708 case DW_TAG_unspecified_parameters
:
5709 return "DW_TAG_unspecified_parameters";
5710 case DW_TAG_variant
:
5711 return "DW_TAG_variant";
5712 case DW_TAG_common_block
:
5713 return "DW_TAG_common_block";
5714 case DW_TAG_common_inclusion
:
5715 return "DW_TAG_common_inclusion";
5716 case DW_TAG_inheritance
:
5717 return "DW_TAG_inheritance";
5718 case DW_TAG_inlined_subroutine
:
5719 return "DW_TAG_inlined_subroutine";
5721 return "DW_TAG_module";
5722 case DW_TAG_ptr_to_member_type
:
5723 return "DW_TAG_ptr_to_member_type";
5724 case DW_TAG_set_type
:
5725 return "DW_TAG_set_type";
5726 case DW_TAG_subrange_type
:
5727 return "DW_TAG_subrange_type";
5728 case DW_TAG_with_stmt
:
5729 return "DW_TAG_with_stmt";
5730 case DW_TAG_access_declaration
:
5731 return "DW_TAG_access_declaration";
5732 case DW_TAG_base_type
:
5733 return "DW_TAG_base_type";
5734 case DW_TAG_catch_block
:
5735 return "DW_TAG_catch_block";
5736 case DW_TAG_const_type
:
5737 return "DW_TAG_const_type";
5738 case DW_TAG_constant
:
5739 return "DW_TAG_constant";
5740 case DW_TAG_enumerator
:
5741 return "DW_TAG_enumerator";
5742 case DW_TAG_file_type
:
5743 return "DW_TAG_file_type";
5745 return "DW_TAG_friend";
5746 case DW_TAG_namelist
:
5747 return "DW_TAG_namelist";
5748 case DW_TAG_namelist_item
:
5749 return "DW_TAG_namelist_item";
5750 case DW_TAG_packed_type
:
5751 return "DW_TAG_packed_type";
5752 case DW_TAG_subprogram
:
5753 return "DW_TAG_subprogram";
5754 case DW_TAG_template_type_param
:
5755 return "DW_TAG_template_type_param";
5756 case DW_TAG_template_value_param
:
5757 return "DW_TAG_template_value_param";
5758 case DW_TAG_thrown_type
:
5759 return "DW_TAG_thrown_type";
5760 case DW_TAG_try_block
:
5761 return "DW_TAG_try_block";
5762 case DW_TAG_variant_part
:
5763 return "DW_TAG_variant_part";
5764 case DW_TAG_variable
:
5765 return "DW_TAG_variable";
5766 case DW_TAG_volatile_type
:
5767 return "DW_TAG_volatile_type";
5768 case DW_TAG_dwarf_procedure
:
5769 return "DW_TAG_dwarf_procedure";
5770 case DW_TAG_restrict_type
:
5771 return "DW_TAG_restrict_type";
5772 case DW_TAG_interface_type
:
5773 return "DW_TAG_interface_type";
5774 case DW_TAG_namespace
:
5775 return "DW_TAG_namespace";
5776 case DW_TAG_imported_module
:
5777 return "DW_TAG_imported_module";
5778 case DW_TAG_unspecified_type
:
5779 return "DW_TAG_unspecified_type";
5780 case DW_TAG_partial_unit
:
5781 return "DW_TAG_partial_unit";
5782 case DW_TAG_imported_unit
:
5783 return "DW_TAG_imported_unit";
5784 case DW_TAG_MIPS_loop
:
5785 return "DW_TAG_MIPS_loop";
5786 case DW_TAG_format_label
:
5787 return "DW_TAG_format_label";
5788 case DW_TAG_function_template
:
5789 return "DW_TAG_function_template";
5790 case DW_TAG_class_template
:
5791 return "DW_TAG_class_template";
5793 return "DW_TAG_<unknown>";
5797 /* Convert a DWARF attribute code into its string name. */
5800 dwarf_attr_name (register unsigned attr
)
5805 return "DW_AT_sibling";
5806 case DW_AT_location
:
5807 return "DW_AT_location";
5809 return "DW_AT_name";
5810 case DW_AT_ordering
:
5811 return "DW_AT_ordering";
5812 case DW_AT_subscr_data
:
5813 return "DW_AT_subscr_data";
5814 case DW_AT_byte_size
:
5815 return "DW_AT_byte_size";
5816 case DW_AT_bit_offset
:
5817 return "DW_AT_bit_offset";
5818 case DW_AT_bit_size
:
5819 return "DW_AT_bit_size";
5820 case DW_AT_element_list
:
5821 return "DW_AT_element_list";
5822 case DW_AT_stmt_list
:
5823 return "DW_AT_stmt_list";
5825 return "DW_AT_low_pc";
5827 return "DW_AT_high_pc";
5828 case DW_AT_language
:
5829 return "DW_AT_language";
5831 return "DW_AT_member";
5833 return "DW_AT_discr";
5834 case DW_AT_discr_value
:
5835 return "DW_AT_discr_value";
5836 case DW_AT_visibility
:
5837 return "DW_AT_visibility";
5839 return "DW_AT_import";
5840 case DW_AT_string_length
:
5841 return "DW_AT_string_length";
5842 case DW_AT_common_reference
:
5843 return "DW_AT_common_reference";
5844 case DW_AT_comp_dir
:
5845 return "DW_AT_comp_dir";
5846 case DW_AT_const_value
:
5847 return "DW_AT_const_value";
5848 case DW_AT_containing_type
:
5849 return "DW_AT_containing_type";
5850 case DW_AT_default_value
:
5851 return "DW_AT_default_value";
5853 return "DW_AT_inline";
5854 case DW_AT_is_optional
:
5855 return "DW_AT_is_optional";
5856 case DW_AT_lower_bound
:
5857 return "DW_AT_lower_bound";
5858 case DW_AT_producer
:
5859 return "DW_AT_producer";
5860 case DW_AT_prototyped
:
5861 return "DW_AT_prototyped";
5862 case DW_AT_return_addr
:
5863 return "DW_AT_return_addr";
5864 case DW_AT_start_scope
:
5865 return "DW_AT_start_scope";
5866 case DW_AT_stride_size
:
5867 return "DW_AT_stride_size";
5868 case DW_AT_upper_bound
:
5869 return "DW_AT_upper_bound";
5870 case DW_AT_abstract_origin
:
5871 return "DW_AT_abstract_origin";
5872 case DW_AT_accessibility
:
5873 return "DW_AT_accessibility";
5874 case DW_AT_address_class
:
5875 return "DW_AT_address_class";
5876 case DW_AT_artificial
:
5877 return "DW_AT_artificial";
5878 case DW_AT_base_types
:
5879 return "DW_AT_base_types";
5880 case DW_AT_calling_convention
:
5881 return "DW_AT_calling_convention";
5883 return "DW_AT_count";
5884 case DW_AT_data_member_location
:
5885 return "DW_AT_data_member_location";
5886 case DW_AT_decl_column
:
5887 return "DW_AT_decl_column";
5888 case DW_AT_decl_file
:
5889 return "DW_AT_decl_file";
5890 case DW_AT_decl_line
:
5891 return "DW_AT_decl_line";
5892 case DW_AT_declaration
:
5893 return "DW_AT_declaration";
5894 case DW_AT_discr_list
:
5895 return "DW_AT_discr_list";
5896 case DW_AT_encoding
:
5897 return "DW_AT_encoding";
5898 case DW_AT_external
:
5899 return "DW_AT_external";
5900 case DW_AT_frame_base
:
5901 return "DW_AT_frame_base";
5903 return "DW_AT_friend";
5904 case DW_AT_identifier_case
:
5905 return "DW_AT_identifier_case";
5906 case DW_AT_macro_info
:
5907 return "DW_AT_macro_info";
5908 case DW_AT_namelist_items
:
5909 return "DW_AT_namelist_items";
5910 case DW_AT_priority
:
5911 return "DW_AT_priority";
5913 return "DW_AT_segment";
5914 case DW_AT_specification
:
5915 return "DW_AT_specification";
5916 case DW_AT_static_link
:
5917 return "DW_AT_static_link";
5919 return "DW_AT_type";
5920 case DW_AT_use_location
:
5921 return "DW_AT_use_location";
5922 case DW_AT_variable_parameter
:
5923 return "DW_AT_variable_parameter";
5924 case DW_AT_virtuality
:
5925 return "DW_AT_virtuality";
5926 case DW_AT_vtable_elem_location
:
5927 return "DW_AT_vtable_elem_location";
5928 case DW_AT_allocated
:
5929 return "DW_AT_allocated";
5930 case DW_AT_associated
:
5931 return "DW_AT_associated";
5932 case DW_AT_data_location
:
5933 return "DW_AT_data_location";
5935 return "DW_AT_stride";
5936 case DW_AT_entry_pc
:
5937 return "DW_AT_entry_pc";
5938 case DW_AT_use_UTF8
:
5939 return "DW_AT_use_UTF8";
5940 case DW_AT_extension
:
5941 return "DW_AT_extension";
5943 return "DW_AT_ranges";
5944 case DW_AT_trampoline
:
5945 return "DW_AT_trampoline";
5946 case DW_AT_call_column
:
5947 return "DW_AT_call_column";
5948 case DW_AT_call_file
:
5949 return "DW_AT_call_file";
5950 case DW_AT_call_line
:
5951 return "DW_AT_call_line";
5953 case DW_AT_MIPS_fde
:
5954 return "DW_AT_MIPS_fde";
5955 case DW_AT_MIPS_loop_begin
:
5956 return "DW_AT_MIPS_loop_begin";
5957 case DW_AT_MIPS_tail_loop_begin
:
5958 return "DW_AT_MIPS_tail_loop_begin";
5959 case DW_AT_MIPS_epilog_begin
:
5960 return "DW_AT_MIPS_epilog_begin";
5961 case DW_AT_MIPS_loop_unroll_factor
:
5962 return "DW_AT_MIPS_loop_unroll_factor";
5963 case DW_AT_MIPS_software_pipeline_depth
:
5964 return "DW_AT_MIPS_software_pipeline_depth";
5965 case DW_AT_MIPS_linkage_name
:
5966 return "DW_AT_MIPS_linkage_name";
5969 case DW_AT_sf_names
:
5970 return "DW_AT_sf_names";
5971 case DW_AT_src_info
:
5972 return "DW_AT_src_info";
5973 case DW_AT_mac_info
:
5974 return "DW_AT_mac_info";
5975 case DW_AT_src_coords
:
5976 return "DW_AT_src_coords";
5977 case DW_AT_body_begin
:
5978 return "DW_AT_body_begin";
5979 case DW_AT_body_end
:
5980 return "DW_AT_body_end";
5981 case DW_AT_GNU_vector
:
5982 return "DW_AT_GNU_vector";
5984 return "DW_AT_<unknown>";
5988 /* Convert a DWARF value form code into its string name. */
5991 dwarf_form_name (register unsigned form
)
5996 return "DW_FORM_addr";
5997 case DW_FORM_block2
:
5998 return "DW_FORM_block2";
5999 case DW_FORM_block4
:
6000 return "DW_FORM_block4";
6002 return "DW_FORM_data2";
6004 return "DW_FORM_data4";
6006 return "DW_FORM_data8";
6007 case DW_FORM_string
:
6008 return "DW_FORM_string";
6010 return "DW_FORM_block";
6011 case DW_FORM_block1
:
6012 return "DW_FORM_block1";
6014 return "DW_FORM_data1";
6016 return "DW_FORM_flag";
6018 return "DW_FORM_sdata";
6020 return "DW_FORM_strp";
6022 return "DW_FORM_udata";
6023 case DW_FORM_ref_addr
:
6024 return "DW_FORM_ref_addr";
6026 return "DW_FORM_ref1";
6028 return "DW_FORM_ref2";
6030 return "DW_FORM_ref4";
6032 return "DW_FORM_ref8";
6033 case DW_FORM_ref_udata
:
6034 return "DW_FORM_ref_udata";
6035 case DW_FORM_indirect
:
6036 return "DW_FORM_indirect";
6038 return "DW_FORM_<unknown>";
6042 /* Convert a DWARF stack opcode into its string name. */
6045 dwarf_stack_op_name (register unsigned op
)
6050 return "DW_OP_addr";
6052 return "DW_OP_deref";
6054 return "DW_OP_const1u";
6056 return "DW_OP_const1s";
6058 return "DW_OP_const2u";
6060 return "DW_OP_const2s";
6062 return "DW_OP_const4u";
6064 return "DW_OP_const4s";
6066 return "DW_OP_const8u";
6068 return "DW_OP_const8s";
6070 return "DW_OP_constu";
6072 return "DW_OP_consts";
6076 return "DW_OP_drop";
6078 return "DW_OP_over";
6080 return "DW_OP_pick";
6082 return "DW_OP_swap";
6086 return "DW_OP_xderef";
6094 return "DW_OP_minus";
6106 return "DW_OP_plus";
6107 case DW_OP_plus_uconst
:
6108 return "DW_OP_plus_uconst";
6114 return "DW_OP_shra";
6132 return "DW_OP_skip";
6134 return "DW_OP_lit0";
6136 return "DW_OP_lit1";
6138 return "DW_OP_lit2";
6140 return "DW_OP_lit3";
6142 return "DW_OP_lit4";
6144 return "DW_OP_lit5";
6146 return "DW_OP_lit6";
6148 return "DW_OP_lit7";
6150 return "DW_OP_lit8";
6152 return "DW_OP_lit9";
6154 return "DW_OP_lit10";
6156 return "DW_OP_lit11";
6158 return "DW_OP_lit12";
6160 return "DW_OP_lit13";
6162 return "DW_OP_lit14";
6164 return "DW_OP_lit15";
6166 return "DW_OP_lit16";
6168 return "DW_OP_lit17";
6170 return "DW_OP_lit18";
6172 return "DW_OP_lit19";
6174 return "DW_OP_lit20";
6176 return "DW_OP_lit21";
6178 return "DW_OP_lit22";
6180 return "DW_OP_lit23";
6182 return "DW_OP_lit24";
6184 return "DW_OP_lit25";
6186 return "DW_OP_lit26";
6188 return "DW_OP_lit27";
6190 return "DW_OP_lit28";
6192 return "DW_OP_lit29";
6194 return "DW_OP_lit30";
6196 return "DW_OP_lit31";
6198 return "DW_OP_reg0";
6200 return "DW_OP_reg1";
6202 return "DW_OP_reg2";
6204 return "DW_OP_reg3";
6206 return "DW_OP_reg4";
6208 return "DW_OP_reg5";
6210 return "DW_OP_reg6";
6212 return "DW_OP_reg7";
6214 return "DW_OP_reg8";
6216 return "DW_OP_reg9";
6218 return "DW_OP_reg10";
6220 return "DW_OP_reg11";
6222 return "DW_OP_reg12";
6224 return "DW_OP_reg13";
6226 return "DW_OP_reg14";
6228 return "DW_OP_reg15";
6230 return "DW_OP_reg16";
6232 return "DW_OP_reg17";
6234 return "DW_OP_reg18";
6236 return "DW_OP_reg19";
6238 return "DW_OP_reg20";
6240 return "DW_OP_reg21";
6242 return "DW_OP_reg22";
6244 return "DW_OP_reg23";
6246 return "DW_OP_reg24";
6248 return "DW_OP_reg25";
6250 return "DW_OP_reg26";
6252 return "DW_OP_reg27";
6254 return "DW_OP_reg28";
6256 return "DW_OP_reg29";
6258 return "DW_OP_reg30";
6260 return "DW_OP_reg31";
6262 return "DW_OP_breg0";
6264 return "DW_OP_breg1";
6266 return "DW_OP_breg2";
6268 return "DW_OP_breg3";
6270 return "DW_OP_breg4";
6272 return "DW_OP_breg5";
6274 return "DW_OP_breg6";
6276 return "DW_OP_breg7";
6278 return "DW_OP_breg8";
6280 return "DW_OP_breg9";
6282 return "DW_OP_breg10";
6284 return "DW_OP_breg11";
6286 return "DW_OP_breg12";
6288 return "DW_OP_breg13";
6290 return "DW_OP_breg14";
6292 return "DW_OP_breg15";
6294 return "DW_OP_breg16";
6296 return "DW_OP_breg17";
6298 return "DW_OP_breg18";
6300 return "DW_OP_breg19";
6302 return "DW_OP_breg20";
6304 return "DW_OP_breg21";
6306 return "DW_OP_breg22";
6308 return "DW_OP_breg23";
6310 return "DW_OP_breg24";
6312 return "DW_OP_breg25";
6314 return "DW_OP_breg26";
6316 return "DW_OP_breg27";
6318 return "DW_OP_breg28";
6320 return "DW_OP_breg29";
6322 return "DW_OP_breg30";
6324 return "DW_OP_breg31";
6326 return "DW_OP_regx";
6328 return "DW_OP_fbreg";
6330 return "DW_OP_bregx";
6332 return "DW_OP_piece";
6333 case DW_OP_deref_size
:
6334 return "DW_OP_deref_size";
6335 case DW_OP_xderef_size
:
6336 return "DW_OP_xderef_size";
6339 /* DWARF 3 extensions. */
6340 case DW_OP_push_object_address
:
6341 return "DW_OP_push_object_address";
6343 return "DW_OP_call2";
6345 return "DW_OP_call4";
6346 case DW_OP_call_ref
:
6347 return "DW_OP_call_ref";
6348 /* GNU extensions. */
6349 case DW_OP_GNU_push_tls_address
:
6350 return "DW_OP_GNU_push_tls_address";
6352 return "OP_<unknown>";
6357 dwarf_bool_name (unsigned mybool
)
6365 /* Convert a DWARF type code into its string name. */
6368 dwarf_type_encoding_name (register unsigned enc
)
6372 case DW_ATE_address
:
6373 return "DW_ATE_address";
6374 case DW_ATE_boolean
:
6375 return "DW_ATE_boolean";
6376 case DW_ATE_complex_float
:
6377 return "DW_ATE_complex_float";
6379 return "DW_ATE_float";
6381 return "DW_ATE_signed";
6382 case DW_ATE_signed_char
:
6383 return "DW_ATE_signed_char";
6384 case DW_ATE_unsigned
:
6385 return "DW_ATE_unsigned";
6386 case DW_ATE_unsigned_char
:
6387 return "DW_ATE_unsigned_char";
6388 case DW_ATE_imaginary_float
:
6389 return "DW_ATE_imaginary_float";
6391 return "DW_ATE_<unknown>";
6395 /* Convert a DWARF call frame info operation to its string name. */
6399 dwarf_cfi_name (register unsigned cfi_opc
)
6403 case DW_CFA_advance_loc
:
6404 return "DW_CFA_advance_loc";
6406 return "DW_CFA_offset";
6407 case DW_CFA_restore
:
6408 return "DW_CFA_restore";
6410 return "DW_CFA_nop";
6411 case DW_CFA_set_loc
:
6412 return "DW_CFA_set_loc";
6413 case DW_CFA_advance_loc1
:
6414 return "DW_CFA_advance_loc1";
6415 case DW_CFA_advance_loc2
:
6416 return "DW_CFA_advance_loc2";
6417 case DW_CFA_advance_loc4
:
6418 return "DW_CFA_advance_loc4";
6419 case DW_CFA_offset_extended
:
6420 return "DW_CFA_offset_extended";
6421 case DW_CFA_restore_extended
:
6422 return "DW_CFA_restore_extended";
6423 case DW_CFA_undefined
:
6424 return "DW_CFA_undefined";
6425 case DW_CFA_same_value
:
6426 return "DW_CFA_same_value";
6427 case DW_CFA_register
:
6428 return "DW_CFA_register";
6429 case DW_CFA_remember_state
:
6430 return "DW_CFA_remember_state";
6431 case DW_CFA_restore_state
:
6432 return "DW_CFA_restore_state";
6433 case DW_CFA_def_cfa
:
6434 return "DW_CFA_def_cfa";
6435 case DW_CFA_def_cfa_register
:
6436 return "DW_CFA_def_cfa_register";
6437 case DW_CFA_def_cfa_offset
:
6438 return "DW_CFA_def_cfa_offset";
6441 case DW_CFA_def_cfa_expression
:
6442 return "DW_CFA_def_cfa_expression";
6443 case DW_CFA_expression
:
6444 return "DW_CFA_expression";
6445 case DW_CFA_offset_extended_sf
:
6446 return "DW_CFA_offset_extended_sf";
6447 case DW_CFA_def_cfa_sf
:
6448 return "DW_CFA_def_cfa_sf";
6449 case DW_CFA_def_cfa_offset_sf
:
6450 return "DW_CFA_def_cfa_offset_sf";
6452 /* SGI/MIPS specific */
6453 case DW_CFA_MIPS_advance_loc8
:
6454 return "DW_CFA_MIPS_advance_loc8";
6456 /* GNU extensions */
6457 case DW_CFA_GNU_window_save
:
6458 return "DW_CFA_GNU_window_save";
6459 case DW_CFA_GNU_args_size
:
6460 return "DW_CFA_GNU_args_size";
6461 case DW_CFA_GNU_negative_offset_extended
:
6462 return "DW_CFA_GNU_negative_offset_extended";
6465 return "DW_CFA_<unknown>";
6471 dump_die (struct die_info
*die
)
6475 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6476 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6477 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6478 dwarf_bool_name (die
->has_children
));
6480 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6481 for (i
= 0; i
< die
->num_attrs
; ++i
)
6483 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6484 dwarf_attr_name (die
->attrs
[i
].name
),
6485 dwarf_form_name (die
->attrs
[i
].form
));
6486 switch (die
->attrs
[i
].form
)
6488 case DW_FORM_ref_addr
:
6490 fprintf_unfiltered (gdb_stderr
, "address: ");
6491 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6493 case DW_FORM_block2
:
6494 case DW_FORM_block4
:
6496 case DW_FORM_block1
:
6497 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6508 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6510 case DW_FORM_string
:
6512 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6513 DW_STRING (&die
->attrs
[i
])
6514 ? DW_STRING (&die
->attrs
[i
]) : "");
6517 if (DW_UNSND (&die
->attrs
[i
]))
6518 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6520 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6522 case DW_FORM_indirect
:
6523 /* the reader will have reduced the indirect form to
6524 the "base form" so this form should not occur */
6525 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6528 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6529 die
->attrs
[i
].form
);
6531 fprintf_unfiltered (gdb_stderr
, "\n");
6536 dump_die_list (struct die_info
*die
)
6546 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6549 struct die_info
*old
;
6551 h
= (offset
% REF_HASH_SIZE
);
6552 old
= die_ref_table
[h
];
6553 die
->next_ref
= old
;
6554 die_ref_table
[h
] = die
;
6559 dwarf2_empty_hash_tables (void)
6561 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6565 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6567 unsigned int result
= 0;
6571 case DW_FORM_ref_addr
:
6572 result
= DW_ADDR (attr
);
6578 case DW_FORM_ref_udata
:
6579 result
= cu_header_offset
+ DW_UNSND (attr
);
6582 complaint (&symfile_complaints
,
6583 "unsupported die ref attribute form: '%s'",
6584 dwarf_form_name (attr
->form
));
6589 static struct die_info
*
6590 follow_die_ref (unsigned int offset
)
6592 struct die_info
*die
;
6595 h
= (offset
% REF_HASH_SIZE
);
6596 die
= die_ref_table
[h
];
6599 if (die
->offset
== offset
)
6603 die
= die
->next_ref
;
6608 static struct type
*
6609 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6611 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6613 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
6614 typeid, objfile
->name
);
6617 /* Look for this particular type in the fundamental type vector. If
6618 one is not found, create and install one appropriate for the
6619 current language and the current target machine. */
6621 if (ftypes
[typeid] == NULL
)
6623 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6626 return (ftypes
[typeid]);
6629 /* Decode simple location descriptions.
6630 Given a pointer to a dwarf block that defines a location, compute
6631 the location and return the value.
6633 FIXME: This is a kludge until we figure out a better
6634 way to handle the location descriptions.
6635 Gdb's design does not mesh well with the DWARF2 notion of a location
6636 computing interpreter, which is a shame because the flexibility goes unused.
6637 FIXME: Implement more operations as necessary.
6639 A location description containing no operations indicates that the
6640 object is optimized out. The global optimized_out flag is set for
6641 those, the return value is meaningless.
6643 When the result is a register number, the global isreg flag is set,
6644 otherwise it is cleared.
6646 When the result is a base register offset, the global offreg flag is set
6647 and the register number is returned in basereg, otherwise it is cleared.
6649 When the DW_OP_fbreg operation is encountered without a corresponding
6650 DW_AT_frame_base attribute, the global islocal flag is set.
6651 Hopefully the machine dependent code knows how to set up a virtual
6652 frame pointer for the local references.
6654 Note that stack[0] is unused except as a default error return.
6655 Note that stack overflow is not yet handled. */
6658 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
6659 const struct comp_unit_head
*cu_header
)
6662 int size
= blk
->size
;
6663 char *data
= blk
->data
;
6664 CORE_ADDR stack
[64];
6666 unsigned int bytes_read
, unsnd
;
6676 is_thread_local
= 0;
6717 stack
[++stacki
] = op
- DW_OP_lit0
;
6753 stack
[++stacki
] = op
- DW_OP_reg0
;
6758 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6760 stack
[++stacki
] = unsnd
;
6796 basereg
= op
- DW_OP_breg0
;
6797 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6803 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6805 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6810 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6812 if (frame_base_reg
>= 0)
6815 basereg
= frame_base_reg
;
6816 stack
[stacki
] += frame_base_offset
;
6820 complaint (&symfile_complaints
,
6821 "DW_AT_frame_base missing for DW_OP_fbreg");
6827 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
6828 cu_header
, &bytes_read
);
6833 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
6838 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
6843 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
6848 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
6853 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
6858 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
6863 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
6869 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6874 stack
[stacki
+ 1] = stack
[stacki
];
6879 stack
[stacki
- 1] += stack
[stacki
];
6883 case DW_OP_plus_uconst
:
6884 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6889 stack
[stacki
- 1] -= stack
[stacki
];
6895 /* If we're not the last op, then we definitely can't encode
6896 this using GDB's address_class enum. */
6898 dwarf2_complex_location_expr_complaint ();
6901 case DW_OP_GNU_push_tls_address
:
6902 is_thread_local
= 1;
6903 /* The top of the stack has the offset from the beginning
6904 of the thread control block at which the variable is located. */
6905 /* Nothing should follow this operator, so the top of stack would
6908 dwarf2_complex_location_expr_complaint ();
6912 complaint (&symfile_complaints
, "unsupported stack op: '%s'",
6913 dwarf_stack_op_name (op
));
6914 return (stack
[stacki
]);
6917 return (stack
[stacki
]);
6920 /* memory allocation interface */
6924 dwarf2_free_tmp_obstack (void *ignore
)
6926 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6929 static struct dwarf_block
*
6930 dwarf_alloc_block (void)
6932 struct dwarf_block
*blk
;
6934 blk
= (struct dwarf_block
*)
6935 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6939 static struct abbrev_info
*
6940 dwarf_alloc_abbrev (void)
6942 struct abbrev_info
*abbrev
;
6944 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6945 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6949 static struct die_info
*
6950 dwarf_alloc_die (void)
6952 struct die_info
*die
;
6954 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6955 memset (die
, 0, sizeof (struct die_info
));
6960 /* Macro support. */
6963 /* Return the full name of file number I in *LH's file name table.
6964 Use COMP_DIR as the name of the current directory of the
6965 compilation. The result is allocated using xmalloc; the caller is
6966 responsible for freeing it. */
6968 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
6970 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6972 if (IS_ABSOLUTE_PATH (fe
->name
))
6973 return xstrdup (fe
->name
);
6981 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6987 dir_len
= strlen (dir
);
6988 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
6989 strcpy (full_name
, dir
);
6990 full_name
[dir_len
] = '/';
6991 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
6995 return xstrdup (fe
->name
);
7000 static struct macro_source_file
*
7001 macro_start_file (int file
, int line
,
7002 struct macro_source_file
*current_file
,
7003 const char *comp_dir
,
7004 struct line_header
*lh
, struct objfile
*objfile
)
7006 /* The full name of this source file. */
7007 char *full_name
= file_full_name (file
, lh
, comp_dir
);
7009 /* We don't create a macro table for this compilation unit
7010 at all until we actually get a filename. */
7011 if (! pending_macros
)
7012 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
7013 objfile
->macro_cache
);
7016 /* If we have no current file, then this must be the start_file
7017 directive for the compilation unit's main source file. */
7018 current_file
= macro_set_main (pending_macros
, full_name
);
7020 current_file
= macro_include (current_file
, line
, full_name
);
7024 return current_file
;
7028 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7029 followed by a null byte. */
7031 copy_string (const char *buf
, int len
)
7033 char *s
= xmalloc (len
+ 1);
7034 memcpy (s
, buf
, len
);
7042 consume_improper_spaces (const char *p
, const char *body
)
7046 complaint (&symfile_complaints
,
7047 "macro definition contains spaces in formal argument list:\n`%s'",
7059 parse_macro_definition (struct macro_source_file
*file
, int line
,
7064 /* The body string takes one of two forms. For object-like macro
7065 definitions, it should be:
7067 <macro name> " " <definition>
7069 For function-like macro definitions, it should be:
7071 <macro name> "() " <definition>
7073 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7075 Spaces may appear only where explicitly indicated, and in the
7078 The Dwarf 2 spec says that an object-like macro's name is always
7079 followed by a space, but versions of GCC around March 2002 omit
7080 the space when the macro's definition is the empty string.
7082 The Dwarf 2 spec says that there should be no spaces between the
7083 formal arguments in a function-like macro's formal argument list,
7084 but versions of GCC around March 2002 include spaces after the
7088 /* Find the extent of the macro name. The macro name is terminated
7089 by either a space or null character (for an object-like macro) or
7090 an opening paren (for a function-like macro). */
7091 for (p
= body
; *p
; p
++)
7092 if (*p
== ' ' || *p
== '(')
7095 if (*p
== ' ' || *p
== '\0')
7097 /* It's an object-like macro. */
7098 int name_len
= p
- body
;
7099 char *name
= copy_string (body
, name_len
);
7100 const char *replacement
;
7103 replacement
= body
+ name_len
+ 1;
7106 dwarf2_macro_malformed_definition_complaint (body
);
7107 replacement
= body
+ name_len
;
7110 macro_define_object (file
, line
, name
, replacement
);
7116 /* It's a function-like macro. */
7117 char *name
= copy_string (body
, p
- body
);
7120 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
7124 p
= consume_improper_spaces (p
, body
);
7126 /* Parse the formal argument list. */
7127 while (*p
&& *p
!= ')')
7129 /* Find the extent of the current argument name. */
7130 const char *arg_start
= p
;
7132 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
7135 if (! *p
|| p
== arg_start
)
7136 dwarf2_macro_malformed_definition_complaint (body
);
7139 /* Make sure argv has room for the new argument. */
7140 if (argc
>= argv_size
)
7143 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
7146 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
7149 p
= consume_improper_spaces (p
, body
);
7151 /* Consume the comma, if present. */
7156 p
= consume_improper_spaces (p
, body
);
7165 /* Perfectly formed definition, no complaints. */
7166 macro_define_function (file
, line
, name
,
7167 argc
, (const char **) argv
,
7169 else if (*p
== '\0')
7171 /* Complain, but do define it. */
7172 dwarf2_macro_malformed_definition_complaint (body
);
7173 macro_define_function (file
, line
, name
,
7174 argc
, (const char **) argv
,
7178 /* Just complain. */
7179 dwarf2_macro_malformed_definition_complaint (body
);
7182 /* Just complain. */
7183 dwarf2_macro_malformed_definition_complaint (body
);
7189 for (i
= 0; i
< argc
; i
++)
7195 dwarf2_macro_malformed_definition_complaint (body
);
7200 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7201 char *comp_dir
, bfd
*abfd
,
7202 const struct comp_unit_head
*cu_header
,
7203 struct objfile
*objfile
)
7205 char *mac_ptr
, *mac_end
;
7206 struct macro_source_file
*current_file
= 0;
7208 if (dwarf_macinfo_buffer
== NULL
)
7210 complaint (&symfile_complaints
, "missing .debug_macinfo section");
7214 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7215 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7219 enum dwarf_macinfo_record_type macinfo_type
;
7221 /* Do we at least have room for a macinfo type byte? */
7222 if (mac_ptr
>= mac_end
)
7224 dwarf2_macros_too_long_complaint ();
7228 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7231 switch (macinfo_type
)
7233 /* A zero macinfo type indicates the end of the macro
7238 case DW_MACINFO_define
:
7239 case DW_MACINFO_undef
:
7245 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7246 mac_ptr
+= bytes_read
;
7247 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7248 mac_ptr
+= bytes_read
;
7251 complaint (&symfile_complaints
,
7252 "debug info gives macro %s outside of any file: %s",
7254 DW_MACINFO_define
? "definition" : macinfo_type
==
7255 DW_MACINFO_undef
? "undefinition" :
7256 "something-or-other", body
);
7259 if (macinfo_type
== DW_MACINFO_define
)
7260 parse_macro_definition (current_file
, line
, body
);
7261 else if (macinfo_type
== DW_MACINFO_undef
)
7262 macro_undef (current_file
, line
, body
);
7267 case DW_MACINFO_start_file
:
7272 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7273 mac_ptr
+= bytes_read
;
7274 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7275 mac_ptr
+= bytes_read
;
7277 current_file
= macro_start_file (file
, line
,
7278 current_file
, comp_dir
,
7283 case DW_MACINFO_end_file
:
7285 complaint (&symfile_complaints
,
7286 "macro debug info has an unmatched `close_file' directive");
7289 current_file
= current_file
->included_by
;
7292 enum dwarf_macinfo_record_type next_type
;
7294 /* GCC circa March 2002 doesn't produce the zero
7295 type byte marking the end of the compilation
7296 unit. Complain if it's not there, but exit no
7299 /* Do we at least have room for a macinfo type byte? */
7300 if (mac_ptr
>= mac_end
)
7302 dwarf2_macros_too_long_complaint ();
7306 /* We don't increment mac_ptr here, so this is just
7308 next_type
= read_1_byte (abfd
, mac_ptr
);
7310 complaint (&symfile_complaints
,
7311 "no terminating 0-type entry for macros in `.debug_macinfo' section");
7318 case DW_MACINFO_vendor_ext
:
7324 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7325 mac_ptr
+= bytes_read
;
7326 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7327 mac_ptr
+= bytes_read
;
7329 /* We don't recognize any vendor extensions. */
7336 /* Check if the attribute's form is a DW_FORM_block*
7337 if so return true else false. */
7339 attr_form_is_block (struct attribute
*attr
)
7341 return (attr
== NULL
? 0 :
7342 attr
->form
== DW_FORM_block1
7343 || attr
->form
== DW_FORM_block2
7344 || attr
->form
== DW_FORM_block4
7345 || attr
->form
== DW_FORM_block
);