1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
10 support in dwarfread.c
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or (at
17 your option) any later version.
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330,
27 Boston, MA 02111-1307, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
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 file_ptr dwarf_frame_offset
;
137 file_ptr dwarf_eh_frame_offset
;
139 static unsigned int dwarf_info_size
;
140 static unsigned int dwarf_abbrev_size
;
141 static unsigned int dwarf_line_size
;
142 static unsigned int dwarf_pubnames_size
;
143 static unsigned int dwarf_aranges_size
;
144 static unsigned int dwarf_loc_size
;
145 static unsigned int dwarf_macinfo_size
;
146 static unsigned int dwarf_str_size
;
147 unsigned int dwarf_frame_size
;
148 unsigned int dwarf_eh_frame_size
;
150 /* names of the debugging sections */
152 #define INFO_SECTION ".debug_info"
153 #define ABBREV_SECTION ".debug_abbrev"
154 #define LINE_SECTION ".debug_line"
155 #define PUBNAMES_SECTION ".debug_pubnames"
156 #define ARANGES_SECTION ".debug_aranges"
157 #define LOC_SECTION ".debug_loc"
158 #define MACINFO_SECTION ".debug_macinfo"
159 #define STR_SECTION ".debug_str"
160 #define FRAME_SECTION ".debug_frame"
161 #define EH_FRAME_SECTION ".eh_frame"
163 /* local data types */
165 /* We hold several abbreviation tables in memory at the same time. */
166 #ifndef ABBREV_HASH_SIZE
167 #define ABBREV_HASH_SIZE 121
170 /* The data in a compilation unit header, after target2host
171 translation, looks like this. */
172 struct comp_unit_head
174 unsigned long length
;
176 unsigned int abbrev_offset
;
177 unsigned char addr_size
;
178 unsigned char signed_addr_p
;
179 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
180 unsigned int initial_length_size
; /* size of the length field; either
183 /* Offset to the first byte of this compilation unit header in the
184 * .debug_info section, for resolving relative reference dies. */
188 /* Pointer to this compilation unit header in the .debug_info
193 /* Pointer to the first die of this compilatio unit. This will
194 * be the first byte following the compilation unit header. */
198 /* Pointer to the next compilation unit header in the program. */
200 struct comp_unit_head
*next
;
202 /* DWARF abbreviation table associated with this compilation unit */
204 struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
207 /* The line number information for a compilation unit (found in the
208 .debug_line section) begins with a "statement program header",
209 which contains the following information. */
212 unsigned int total_length
;
213 unsigned short version
;
214 unsigned int header_length
;
215 unsigned char minimum_instruction_length
;
216 unsigned char default_is_stmt
;
218 unsigned char line_range
;
219 unsigned char opcode_base
;
221 /* standard_opcode_lengths[i] is the number of operands for the
222 standard opcode whose value is i. This means that
223 standard_opcode_lengths[0] is unused, and the last meaningful
224 element is standard_opcode_lengths[opcode_base - 1]. */
225 unsigned char *standard_opcode_lengths
;
227 /* The include_directories table. NOTE! These strings are not
228 allocated with xmalloc; instead, they are pointers into
229 debug_line_buffer. If you try to free them, `free' will get
231 unsigned int num_include_dirs
, include_dirs_size
;
234 /* The file_names table. NOTE! These strings are not allocated
235 with xmalloc; instead, they are pointers into debug_line_buffer.
236 Don't try to free them directly. */
237 unsigned int num_file_names
, file_names_size
;
241 unsigned int dir_index
;
242 unsigned int mod_time
;
246 /* The start and end of the statement program following this
247 header. These point into dwarf_line_buffer. */
248 char *statement_program_start
, *statement_program_end
;
251 /* When we construct a partial symbol table entry we only
252 need this much information. */
253 struct partial_die_info
256 unsigned char has_children
;
257 unsigned char is_external
;
258 unsigned char is_declaration
;
259 unsigned char has_type
;
266 struct dwarf_block
*locdesc
;
267 unsigned int language
;
271 /* This data structure holds the information of an abbrev. */
274 unsigned int number
; /* number identifying abbrev */
275 enum dwarf_tag tag
; /* dwarf tag */
276 int has_children
; /* boolean */
277 unsigned int num_attrs
; /* number of attributes */
278 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
279 struct abbrev_info
*next
; /* next in chain */
284 enum dwarf_attribute name
;
285 enum dwarf_form form
;
288 /* This data structure holds a complete die structure. */
291 enum dwarf_tag tag
; /* Tag indicating type of die */
292 unsigned short has_children
; /* Does the die have children */
293 unsigned int abbrev
; /* Abbrev number */
294 unsigned int offset
; /* Offset in .debug_info section */
295 unsigned int num_attrs
; /* Number of attributes */
296 struct attribute
*attrs
; /* An array of attributes */
297 struct die_info
*next_ref
; /* Next die in ref hash table */
298 struct die_info
*next
; /* Next die in linked list */
299 struct type
*type
; /* Cached type information */
302 /* Attributes have a name and a value */
305 enum dwarf_attribute name
;
306 enum dwarf_form form
;
310 struct dwarf_block
*blk
;
318 struct function_range
321 CORE_ADDR lowpc
, highpc
;
323 struct function_range
*next
;
326 static struct function_range
*cu_first_fn
, *cu_last_fn
, *cu_cached_fn
;
328 /* Get at parts of an attribute structure */
330 #define DW_STRING(attr) ((attr)->u.str)
331 #define DW_UNSND(attr) ((attr)->u.unsnd)
332 #define DW_BLOCK(attr) ((attr)->u.blk)
333 #define DW_SND(attr) ((attr)->u.snd)
334 #define DW_ADDR(attr) ((attr)->u.addr)
336 /* Blocks are a bunch of untyped bytes. */
343 #ifndef ATTR_ALLOC_CHUNK
344 #define ATTR_ALLOC_CHUNK 4
347 /* A hash table of die offsets for following references. */
348 #ifndef REF_HASH_SIZE
349 #define REF_HASH_SIZE 1021
352 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
354 /* Obstack for allocating temporary storage used during symbol reading. */
355 static struct obstack dwarf2_tmp_obstack
;
357 /* Offset to the first byte of the current compilation unit header,
358 for resolving relative reference dies. */
359 static unsigned int cu_header_offset
;
361 /* Allocate fields for structs, unions and enums in this size. */
362 #ifndef DW_FIELD_ALLOC_CHUNK
363 #define DW_FIELD_ALLOC_CHUNK 4
366 /* The language we are debugging. */
367 static enum language cu_language
;
368 static const struct language_defn
*cu_language_defn
;
370 /* Actually data from the sections. */
371 static char *dwarf_info_buffer
;
372 static char *dwarf_abbrev_buffer
;
373 static char *dwarf_line_buffer
;
374 static char *dwarf_str_buffer
;
375 static char *dwarf_macinfo_buffer
;
377 /* A zeroed version of a partial die for initialization purposes. */
378 static struct partial_die_info zeroed_partial_die
;
380 /* The generic symbol table building routines have separate lists for
381 file scope symbols and all all other scopes (local scopes). So
382 we need to select the right one to pass to add_symbol_to_list().
383 We do it by keeping a pointer to the correct list in list_in_scope.
385 FIXME: The original dwarf code just treated the file scope as the first
386 local scope, and all other local scopes as nested local scopes, and worked
387 fine. Check to see if we really need to distinguish these
389 static struct pending
**list_in_scope
= &file_symbols
;
391 /* FIXME: decode_locdesc sets these variables to describe the location
392 to the caller. These ought to be a structure or something. If
393 none of the flags are set, the object lives at the address returned
394 by decode_locdesc. */
396 static int optimized_out
; /* No ops in location in expression,
397 so object was optimized out. */
398 static int isreg
; /* Object lives in register.
399 decode_locdesc's return value is
400 the register number. */
401 static int offreg
; /* Object's address is the sum of the
402 register specified by basereg, plus
403 the offset returned. */
404 static int basereg
; /* See `offreg'. */
405 static int isderef
; /* Value described by flags above is
406 the address of a pointer to the object. */
407 static int islocal
; /* Variable is at the returned offset
408 from the frame start, but there's
409 no identified frame pointer for
410 this function, so we can't say
411 which register it's relative to;
414 /* DW_AT_frame_base values for the current function.
415 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
416 contains the register number for the frame register.
417 frame_base_offset is the offset from the frame register to the
418 virtual stack frame. */
419 static int frame_base_reg
;
420 static CORE_ADDR frame_base_offset
;
422 /* This value is added to each symbol value. FIXME: Generalize to
423 the section_offsets structure used by dbxread (once this is done,
424 pass the appropriate section number to end_symtab). */
425 static CORE_ADDR baseaddr
; /* Add to each symbol value */
427 /* We put a pointer to this structure in the read_symtab_private field
429 The complete dwarf information for an objfile is kept in the
430 psymbol_obstack, so that absolute die references can be handled.
431 Most of the information in this structure is related to an entire
432 object file and could be passed via the sym_private field of the objfile.
433 It is however conceivable that dwarf2 might not be the only type
434 of symbols read from an object file. */
438 /* Pointer to start of dwarf info buffer for the objfile. */
440 char *dwarf_info_buffer
;
442 /* Offset in dwarf_info_buffer for this compilation unit. */
444 unsigned long dwarf_info_offset
;
446 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
448 char *dwarf_abbrev_buffer
;
450 /* Size of dwarf abbreviation section for the objfile. */
452 unsigned int dwarf_abbrev_size
;
454 /* Pointer to start of dwarf line buffer for the objfile. */
456 char *dwarf_line_buffer
;
458 /* Size of dwarf_line_buffer, in bytes. */
460 unsigned int dwarf_line_size
;
462 /* Pointer to start of dwarf string buffer for the objfile. */
464 char *dwarf_str_buffer
;
466 /* Size of dwarf string section for the objfile. */
468 unsigned int dwarf_str_size
;
470 /* Pointer to start of dwarf macro buffer for the objfile. */
472 char *dwarf_macinfo_buffer
;
474 /* Size of dwarf macinfo section for the objfile. */
476 unsigned int dwarf_macinfo_size
;
480 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
481 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
482 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
483 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
484 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
485 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
486 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
487 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
488 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
489 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
490 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
492 /* Maintain an array of referenced fundamental types for the current
493 compilation unit being read. For DWARF version 1, we have to construct
494 the fundamental types on the fly, since no information about the
495 fundamental types is supplied. Each such fundamental type is created by
496 calling a language dependent routine to create the type, and then a
497 pointer to that type is then placed in the array at the index specified
498 by it's FT_<TYPENAME> value. The array has a fixed size set by the
499 FT_NUM_MEMBERS compile time constant, which is the number of predefined
500 fundamental types gdb knows how to construct. */
501 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
503 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
504 but this would require a corresponding change in unpack_field_as_long
506 static int bits_per_byte
= 8;
508 /* The routines that read and process dies for a C struct or C++ class
509 pass lists of data member fields and lists of member function fields
510 in an instance of a field_info structure, as defined below. */
513 /* List of data member and baseclasses fields. */
516 struct nextfield
*next
;
523 /* Number of fields. */
526 /* Number of baseclasses. */
529 /* Set if the accesibility of one of the fields is not public. */
530 int non_public_fields
;
532 /* Member function fields array, entries are allocated in the order they
533 are encountered in the object file. */
536 struct nextfnfield
*next
;
537 struct fn_field fnfield
;
541 /* Member function fieldlist array, contains name of possibly overloaded
542 member function, number of overloaded member functions and a pointer
543 to the head of the member function field chain. */
548 struct nextfnfield
*head
;
552 /* Number of entries in the fnfieldlists array. */
556 /* Various complaints about symbol reading that don't abort the process */
558 static struct complaint dwarf2_const_ignored
=
560 "type qualifier 'const' ignored", 0, 0
562 static struct complaint dwarf2_volatile_ignored
=
564 "type qualifier 'volatile' ignored", 0, 0
566 static struct complaint dwarf2_non_const_array_bound_ignored
=
568 "non-constant array bounds form '%s' ignored", 0, 0
570 static struct complaint dwarf2_missing_line_number_section
=
572 "missing .debug_line section", 0, 0
574 static struct complaint dwarf2_statement_list_fits_in_line_number_section
=
576 "statement list doesn't fit in .debug_line section", 0, 0
578 static struct complaint dwarf2_mangled_line_number_section
=
580 "mangled .debug_line section", 0, 0
582 static struct complaint dwarf2_unsupported_die_ref_attr
=
584 "unsupported die ref attribute form: '%s'", 0, 0
586 static struct complaint dwarf2_unsupported_stack_op
=
588 "unsupported stack op: '%s'", 0, 0
590 static struct complaint dwarf2_complex_location_expr
=
592 "location expression too complex", 0, 0
594 static struct complaint dwarf2_unsupported_tag
=
596 "unsupported tag: '%s'", 0, 0
598 static struct complaint dwarf2_unsupported_at_encoding
=
600 "unsupported DW_AT_encoding: '%s'", 0, 0
602 static struct complaint dwarf2_unsupported_at_frame_base
=
604 "unsupported DW_AT_frame_base for function '%s'", 0, 0
606 static struct complaint dwarf2_unexpected_tag
=
608 "unexepected tag in read_type_die: '%s'", 0, 0
610 static struct complaint dwarf2_missing_at_frame_base
=
612 "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
614 static struct complaint dwarf2_bad_static_member_name
=
616 "unrecognized static data member name '%s'", 0, 0
618 static struct complaint dwarf2_unsupported_accessibility
=
620 "unsupported accessibility %d", 0, 0
622 static struct complaint dwarf2_bad_member_name_complaint
=
624 "cannot extract member name from '%s'", 0, 0
626 static struct complaint dwarf2_missing_member_fn_type_complaint
=
628 "member function type missing for '%s'", 0, 0
630 static struct complaint dwarf2_vtbl_not_found_complaint
=
632 "virtual function table pointer not found when defining class '%s'", 0, 0
634 static struct complaint dwarf2_absolute_sibling_complaint
=
636 "ignoring absolute DW_AT_sibling", 0, 0
638 static struct complaint dwarf2_const_value_length_mismatch
=
640 "const value length mismatch for '%s', got %d, expected %d", 0, 0
642 static struct complaint dwarf2_unsupported_const_value_attr
=
644 "unsupported const value attribute form: '%s'", 0, 0
646 static struct complaint dwarf2_misplaced_line_number
=
648 "misplaced first line number at 0x%lx for '%s'", 0, 0
650 static struct complaint dwarf2_line_header_too_long
=
652 "line number info header doesn't fit in `.debug_line' section", 0, 0
654 static struct complaint dwarf2_missing_macinfo_section
=
656 "missing .debug_macinfo section", 0, 0
658 static struct complaint dwarf2_macros_too_long
=
660 "macro info runs off end of `.debug_macinfo' section", 0, 0
662 static struct complaint dwarf2_macros_not_terminated
=
664 "no terminating 0-type entry for macros in `.debug_macinfo' section", 0, 0
666 static struct complaint dwarf2_macro_outside_file
=
668 "debug info gives macro %s outside of any file: %s", 0, 0
670 static struct complaint dwarf2_macro_unmatched_end_file
=
672 "macro debug info has an unmatched `close_file' directive", 0, 0
674 static struct complaint dwarf2_macro_malformed_definition
=
676 "macro debug info contains a malformed macro definition:\n`%s'", 0, 0
678 static struct complaint dwarf2_macro_spaces_in_definition
=
680 "macro definition contains spaces in formal argument list:\n`%s'", 0, 0
682 static struct complaint dwarf2_invalid_attrib_class
=
684 "invalid attribute class or form for '%s' in '%s'", 0, 0
687 /* local function prototypes */
689 static void dwarf2_locate_sections (bfd
*, asection
*, PTR
);
692 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
695 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
697 static char *scan_partial_symbols (char *, struct objfile
*,
698 CORE_ADDR
*, CORE_ADDR
*,
699 const struct comp_unit_head
*);
701 static void add_partial_symbol (struct partial_die_info
*, struct objfile
*,
702 const struct comp_unit_head
*);
704 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
706 static void psymtab_to_symtab_1 (struct partial_symtab
*);
708 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int);
710 static void dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
);
712 static void dwarf2_empty_abbrev_table (PTR
);
714 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
715 const struct comp_unit_head
*cu_header
);
717 static char *read_partial_die (struct partial_die_info
*,
719 const struct comp_unit_head
*);
721 static char *read_full_die (struct die_info
**, bfd
*, char *,
722 const struct comp_unit_head
*);
724 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
725 bfd
*, char *, const struct comp_unit_head
*);
727 static char *read_attribute_value (struct attribute
*, unsigned,
728 bfd
*, char *, const struct comp_unit_head
*);
730 static unsigned int read_1_byte (bfd
*, char *);
732 static int read_1_signed_byte (bfd
*, char *);
734 static unsigned int read_2_bytes (bfd
*, char *);
736 static unsigned int read_4_bytes (bfd
*, char *);
738 static unsigned long read_8_bytes (bfd
*, char *);
740 static CORE_ADDR
read_address (bfd
*, char *ptr
, const struct comp_unit_head
*,
743 static LONGEST
read_initial_length (bfd
*, char *,
744 struct comp_unit_head
*, int *bytes_read
);
746 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
749 static char *read_n_bytes (bfd
*, char *, unsigned int);
751 static char *read_string (bfd
*, char *, unsigned int *);
753 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
756 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
758 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
760 static void set_cu_language (unsigned int);
762 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
764 static int die_is_declaration (struct die_info
*);
766 static void free_line_header (struct line_header
*lh
);
768 static struct line_header
*(dwarf_decode_line_header
769 (unsigned int offset
,
771 const struct comp_unit_head
*cu_header
));
773 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
774 const struct comp_unit_head
*);
776 static void dwarf2_start_subfile (char *, char *);
778 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
779 struct objfile
*, const struct comp_unit_head
*);
781 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
782 struct objfile
*, const struct comp_unit_head
*);
784 static void dwarf2_const_value_data (struct attribute
*attr
,
788 static struct type
*die_type (struct die_info
*, struct objfile
*,
789 const struct comp_unit_head
*);
791 static struct type
*die_containing_type (struct die_info
*, struct objfile
*,
792 const struct comp_unit_head
*);
795 static struct type
*type_at_offset (unsigned int, struct objfile
*);
798 static struct type
*tag_type_to_type (struct die_info
*, struct objfile
*,
799 const struct comp_unit_head
*);
801 static void read_type_die (struct die_info
*, struct objfile
*,
802 const struct comp_unit_head
*);
804 static void read_typedef (struct die_info
*, struct objfile
*,
805 const struct comp_unit_head
*);
807 static void read_base_type (struct die_info
*, struct objfile
*);
809 static void read_file_scope (struct die_info
*, struct objfile
*,
810 const struct comp_unit_head
*);
812 static void read_func_scope (struct die_info
*, struct objfile
*,
813 const struct comp_unit_head
*);
815 static void read_lexical_block_scope (struct die_info
*, struct objfile
*,
816 const struct comp_unit_head
*);
818 static int dwarf2_get_pc_bounds (struct die_info
*,
819 CORE_ADDR
*, CORE_ADDR
*, struct objfile
*);
821 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
822 struct objfile
*, const struct comp_unit_head
*);
824 static void dwarf2_attach_fields_to_type (struct field_info
*,
825 struct type
*, struct objfile
*);
827 static void dwarf2_add_member_fn (struct field_info
*,
828 struct die_info
*, struct type
*,
829 struct objfile
*objfile
,
830 const struct comp_unit_head
*);
832 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
833 struct type
*, struct objfile
*);
835 static void read_structure_scope (struct die_info
*, struct objfile
*,
836 const struct comp_unit_head
*);
838 static void read_common_block (struct die_info
*, struct objfile
*,
839 const struct comp_unit_head
*);
841 static void read_enumeration (struct die_info
*, struct objfile
*,
842 const struct comp_unit_head
*);
844 static struct type
*dwarf_base_type (int, int, struct objfile
*);
846 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct objfile
*,
847 const struct comp_unit_head
*);
849 static void read_array_type (struct die_info
*, struct objfile
*,
850 const struct comp_unit_head
*);
852 static void read_tag_pointer_type (struct die_info
*, struct objfile
*,
853 const struct comp_unit_head
*);
855 static void read_tag_ptr_to_member_type (struct die_info
*, struct objfile
*,
856 const struct comp_unit_head
*);
858 static void read_tag_reference_type (struct die_info
*, struct objfile
*,
859 const struct comp_unit_head
*);
861 static void read_tag_const_type (struct die_info
*, struct objfile
*,
862 const struct comp_unit_head
*);
864 static void read_tag_volatile_type (struct die_info
*, struct objfile
*,
865 const struct comp_unit_head
*);
867 static void read_tag_string_type (struct die_info
*, struct objfile
*);
869 static void read_subroutine_type (struct die_info
*, struct objfile
*,
870 const struct comp_unit_head
*);
872 static struct die_info
*read_comp_unit (char *, bfd
*,
873 const struct comp_unit_head
*);
875 static void free_die_list (struct die_info
*);
877 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
879 static void process_die (struct die_info
*, struct objfile
*,
880 const struct comp_unit_head
*);
882 static char *dwarf2_linkage_name (struct die_info
*);
884 static char *dwarf_tag_name (unsigned int);
886 static char *dwarf_attr_name (unsigned int);
888 static char *dwarf_form_name (unsigned int);
890 static char *dwarf_stack_op_name (unsigned int);
892 static char *dwarf_bool_name (unsigned int);
894 static char *dwarf_type_encoding_name (unsigned int);
897 static char *dwarf_cfi_name (unsigned int);
899 struct die_info
*copy_die (struct die_info
*);
902 static struct die_info
*sibling_die (struct die_info
*);
904 static void dump_die (struct die_info
*);
906 static void dump_die_list (struct die_info
*);
908 static void store_in_ref_table (unsigned int, struct die_info
*);
910 static void dwarf2_empty_hash_tables (void);
912 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
914 static struct die_info
*follow_die_ref (unsigned int);
916 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
918 /* memory allocation interface */
920 static void dwarf2_free_tmp_obstack (PTR
);
922 static struct dwarf_block
*dwarf_alloc_block (void);
924 static struct abbrev_info
*dwarf_alloc_abbrev (void);
926 static struct die_info
*dwarf_alloc_die (void);
928 static void initialize_cu_func_list (void);
930 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
932 static void dwarf_decode_macros (struct line_header
*, unsigned int,
933 char *, bfd
*, const struct comp_unit_head
*,
936 static int attr_form_is_block (struct attribute
*);
938 /* Try to locate the sections we need for DWARF 2 debugging
939 information and return true if we have enough to do something. */
942 dwarf2_has_info (bfd
*abfd
)
944 dwarf_info_offset
= 0;
945 dwarf_abbrev_offset
= 0;
946 dwarf_line_offset
= 0;
947 dwarf_str_offset
= 0;
948 dwarf_macinfo_offset
= 0;
949 dwarf_frame_offset
= 0;
950 dwarf_eh_frame_offset
= 0;
951 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
952 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
962 /* This function is mapped across the sections and remembers the
963 offset and size of each of the debugging sections we are interested
967 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, PTR ignore_ptr
)
969 if (STREQ (sectp
->name
, INFO_SECTION
))
971 dwarf_info_offset
= sectp
->filepos
;
972 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
974 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
976 dwarf_abbrev_offset
= sectp
->filepos
;
977 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
979 else if (STREQ (sectp
->name
, LINE_SECTION
))
981 dwarf_line_offset
= sectp
->filepos
;
982 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
984 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
986 dwarf_pubnames_offset
= sectp
->filepos
;
987 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
989 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
991 dwarf_aranges_offset
= sectp
->filepos
;
992 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
994 else if (STREQ (sectp
->name
, LOC_SECTION
))
996 dwarf_loc_offset
= sectp
->filepos
;
997 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
999 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
1001 dwarf_macinfo_offset
= sectp
->filepos
;
1002 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
1004 else if (STREQ (sectp
->name
, STR_SECTION
))
1006 dwarf_str_offset
= sectp
->filepos
;
1007 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
1009 else if (STREQ (sectp
->name
, FRAME_SECTION
))
1011 dwarf_frame_offset
= sectp
->filepos
;
1012 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1014 else if (STREQ (sectp
->name
, EH_FRAME_SECTION
))
1016 dwarf_eh_frame_offset
= sectp
->filepos
;
1017 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1021 /* Build a partial symbol table. */
1024 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1027 /* We definitely need the .debug_info and .debug_abbrev sections */
1029 dwarf_info_buffer
= dwarf2_read_section (objfile
,
1032 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
1033 dwarf_abbrev_offset
,
1036 if (dwarf_line_offset
)
1037 dwarf_line_buffer
= dwarf2_read_section (objfile
,
1041 dwarf_line_buffer
= NULL
;
1043 if (dwarf_str_offset
)
1044 dwarf_str_buffer
= dwarf2_read_section (objfile
,
1048 dwarf_str_buffer
= NULL
;
1050 if (dwarf_macinfo_offset
)
1051 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1052 dwarf_macinfo_offset
,
1053 dwarf_macinfo_size
);
1055 dwarf_macinfo_buffer
= NULL
;
1058 || (objfile
->global_psymbols
.size
== 0
1059 && objfile
->static_psymbols
.size
== 0))
1061 init_psymbol_list (objfile
, 1024);
1065 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1067 /* Things are significantly easier if we have .debug_aranges and
1068 .debug_pubnames sections */
1070 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1074 /* only test this case for now */
1076 /* In this case we have to work a bit harder */
1077 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1082 /* Build the partial symbol table from the information in the
1083 .debug_pubnames and .debug_aranges sections. */
1086 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1088 bfd
*abfd
= objfile
->obfd
;
1089 char *aranges_buffer
, *pubnames_buffer
;
1090 char *aranges_ptr
, *pubnames_ptr
;
1091 unsigned int entry_length
, version
, info_offset
, info_size
;
1093 pubnames_buffer
= dwarf2_read_section (objfile
,
1094 dwarf_pubnames_offset
,
1095 dwarf_pubnames_size
);
1096 pubnames_ptr
= pubnames_buffer
;
1097 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1099 struct comp_unit_head cu_header
;
1102 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1104 pubnames_ptr
+= bytes_read
;
1105 version
= read_1_byte (abfd
, pubnames_ptr
);
1107 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1109 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1113 aranges_buffer
= dwarf2_read_section (objfile
,
1114 dwarf_aranges_offset
,
1115 dwarf_aranges_size
);
1120 /* Read in the comp unit header information from the debug_info at
1124 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1125 char *info_ptr
, bfd
*abfd
)
1129 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1131 info_ptr
+= bytes_read
;
1132 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1134 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1136 info_ptr
+= bytes_read
;
1137 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1139 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1140 if (signed_addr
< 0)
1141 internal_error (__FILE__
, __LINE__
,
1142 "read_comp_unit_head: dwarf from non elf file");
1143 cu_header
->signed_addr_p
= signed_addr
;
1147 /* Build the partial symbol table by doing a quick pass through the
1148 .debug_info and .debug_abbrev sections. */
1151 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1153 /* Instead of reading this into a big buffer, we should probably use
1154 mmap() on architectures that support it. (FIXME) */
1155 bfd
*abfd
= objfile
->obfd
;
1156 char *info_ptr
, *abbrev_ptr
;
1157 char *beg_of_comp_unit
;
1158 struct partial_die_info comp_unit_die
;
1159 struct partial_symtab
*pst
;
1160 struct cleanup
*back_to
;
1161 CORE_ADDR lowpc
, highpc
;
1163 info_ptr
= dwarf_info_buffer
;
1164 abbrev_ptr
= dwarf_abbrev_buffer
;
1166 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1167 the partial symbol scan, like attribute values.
1169 We could reduce our peak memory consumption during partial symbol
1170 table construction by freeing stuff from this obstack more often
1171 --- say, after processing each compilation unit, or each die ---
1172 but it turns out that this saves almost nothing. For an
1173 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1174 on dwarf2_tmp_obstack. Some investigation showed:
1176 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1177 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1178 all fixed-length values not requiring dynamic allocation.
1180 2) 30% of the attributes used the form DW_FORM_string. For
1181 DW_FORM_string, read_attribute simply hands back a pointer to
1182 the null-terminated string in dwarf_info_buffer, so no dynamic
1183 allocation is needed there either.
1185 3) The remaining 1% of the attributes all used DW_FORM_block1.
1186 75% of those were DW_AT_frame_base location lists for
1187 functions; the rest were DW_AT_location attributes, probably
1188 for the global variables.
1190 Anyway, what this all means is that the memory the dwarf2
1191 reader uses as temporary space reading partial symbols is about
1192 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1194 obstack_init (&dwarf2_tmp_obstack
);
1195 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1197 /* Since the objects we're extracting from dwarf_info_buffer vary in
1198 length, only the individual functions to extract them (like
1199 read_comp_unit_head and read_partial_die) can really know whether
1200 the buffer is large enough to hold another complete object.
1202 At the moment, they don't actually check that. If
1203 dwarf_info_buffer holds just one extra byte after the last
1204 compilation unit's dies, then read_comp_unit_head will happily
1205 read off the end of the buffer. read_partial_die is similarly
1206 casual. Those functions should be fixed.
1208 For this loop condition, simply checking whether there's any data
1209 left at all should be sufficient. */
1210 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1212 struct comp_unit_head cu_header
;
1213 beg_of_comp_unit
= info_ptr
;
1214 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1216 if (cu_header
.version
!= 2)
1218 error ("Dwarf Error: wrong version in compilation unit header.");
1221 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
1223 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6).",
1224 (long) cu_header
.abbrev_offset
,
1225 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1228 if (beg_of_comp_unit
+ cu_header
.length
+ cu_header
.initial_length_size
1229 > dwarf_info_buffer
+ dwarf_info_size
)
1231 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0).",
1232 (long) cu_header
.length
,
1233 (long) (beg_of_comp_unit
- dwarf_info_buffer
));
1236 /* Complete the cu_header */
1237 cu_header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1238 cu_header
.first_die_ptr
= info_ptr
;
1239 cu_header
.cu_head_ptr
= beg_of_comp_unit
;
1241 /* Read the abbrevs for this compilation unit into a table */
1242 dwarf2_read_abbrevs (abfd
, &cu_header
);
1243 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1245 /* Read the compilation unit die */
1246 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1249 /* Set the language we're debugging */
1250 set_cu_language (comp_unit_die
.language
);
1252 /* Allocate a new partial symbol table structure */
1253 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1254 comp_unit_die
.name
? comp_unit_die
.name
: "",
1255 comp_unit_die
.lowpc
,
1256 objfile
->global_psymbols
.next
,
1257 objfile
->static_psymbols
.next
);
1259 pst
->read_symtab_private
= (char *)
1260 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1261 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1262 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1263 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1264 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1265 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1266 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1267 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1268 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1269 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1270 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1271 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1272 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1274 /* Store the function that reads in the rest of the symbol table */
1275 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1277 /* Check if comp unit has_children.
1278 If so, read the rest of the partial symbols from this comp unit.
1279 If not, there's no more debug_info for this comp unit. */
1280 if (comp_unit_die
.has_children
)
1282 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
,
1285 /* If the compilation unit didn't have an explicit address range,
1286 then use the information extracted from its child dies. */
1287 if (! comp_unit_die
.has_pc_info
)
1289 comp_unit_die
.lowpc
= lowpc
;
1290 comp_unit_die
.highpc
= highpc
;
1293 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1294 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1296 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1297 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1298 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1299 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1300 sort_pst_symbols (pst
);
1302 /* If there is already a psymtab or symtab for a file of this
1303 name, remove it. (If there is a symtab, more drastic things
1304 also happen.) This happens in VxWorks. */
1305 free_named_symtabs (pst
->filename
);
1307 info_ptr
= beg_of_comp_unit
+ cu_header
.length
1308 + cu_header
.initial_length_size
;
1310 do_cleanups (back_to
);
1313 /* Read in all interesting dies to the end of the compilation unit. */
1316 scan_partial_symbols (char *info_ptr
, struct objfile
*objfile
,
1317 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1318 const struct comp_unit_head
*cu_header
)
1320 bfd
*abfd
= objfile
->obfd
;
1321 struct partial_die_info pdi
;
1323 /* This function is called after we've read in the comp_unit_die in
1324 order to read its children. We start the nesting level at 1 since
1325 we have pushed 1 level down in order to read the comp unit's children.
1326 The comp unit itself is at level 0, so we stop reading when we pop
1327 back to that level. */
1329 int nesting_level
= 1;
1331 *lowpc
= ((CORE_ADDR
) -1);
1332 *highpc
= ((CORE_ADDR
) 0);
1334 while (nesting_level
)
1336 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1342 case DW_TAG_subprogram
:
1343 if (pdi
.has_pc_info
)
1345 if (pdi
.lowpc
< *lowpc
)
1349 if (pdi
.highpc
> *highpc
)
1351 *highpc
= pdi
.highpc
;
1353 if ((pdi
.is_external
|| nesting_level
== 1)
1354 && !pdi
.is_declaration
)
1356 add_partial_symbol (&pdi
, objfile
, cu_header
);
1360 case DW_TAG_variable
:
1361 case DW_TAG_typedef
:
1362 case DW_TAG_class_type
:
1363 case DW_TAG_structure_type
:
1364 case DW_TAG_union_type
:
1365 case DW_TAG_enumeration_type
:
1366 if ((pdi
.is_external
|| nesting_level
== 1)
1367 && !pdi
.is_declaration
)
1369 add_partial_symbol (&pdi
, objfile
, cu_header
);
1372 case DW_TAG_enumerator
:
1373 /* File scope enumerators are added to the partial symbol
1375 if (nesting_level
== 2)
1376 add_partial_symbol (&pdi
, objfile
, cu_header
);
1378 case DW_TAG_base_type
:
1379 /* File scope base type definitions are added to the partial
1381 if (nesting_level
== 1)
1382 add_partial_symbol (&pdi
, objfile
, cu_header
);
1389 /* If the die has a sibling, skip to the sibling.
1390 Do not skip enumeration types, we want to record their
1392 if (pdi
.sibling
&& pdi
.tag
!= DW_TAG_enumeration_type
)
1394 info_ptr
= pdi
.sibling
;
1396 else if (pdi
.has_children
)
1398 /* Die has children, but the optional DW_AT_sibling attribute
1409 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1410 from `maint check'. */
1411 if (*lowpc
== ((CORE_ADDR
) -1))
1417 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1418 const struct comp_unit_head
*cu_header
)
1424 case DW_TAG_subprogram
:
1425 if (pdi
->is_external
)
1427 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1428 mst_text, objfile); */
1429 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1430 VAR_NAMESPACE
, LOC_BLOCK
,
1431 &objfile
->global_psymbols
,
1432 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1436 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1437 mst_file_text, objfile); */
1438 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1439 VAR_NAMESPACE
, LOC_BLOCK
,
1440 &objfile
->static_psymbols
,
1441 0, pdi
->lowpc
+ baseaddr
, cu_language
, objfile
);
1444 case DW_TAG_variable
:
1445 if (pdi
->is_external
)
1448 Don't enter into the minimal symbol tables as there is
1449 a minimal symbol table entry from the ELF symbols already.
1450 Enter into partial symbol table if it has a location
1451 descriptor or a type.
1452 If the location descriptor is missing, new_symbol will create
1453 a LOC_UNRESOLVED symbol, the address of the variable will then
1454 be determined from the minimal symbol table whenever the variable
1456 The address for the partial symbol table entry is not
1457 used by GDB, but it comes in handy for debugging partial symbol
1461 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1462 if (pdi
->locdesc
|| pdi
->has_type
)
1463 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1464 VAR_NAMESPACE
, LOC_STATIC
,
1465 &objfile
->global_psymbols
,
1466 0, addr
+ baseaddr
, cu_language
, objfile
);
1470 /* Static Variable. Skip symbols without location descriptors. */
1471 if (pdi
->locdesc
== NULL
)
1473 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1474 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1475 mst_file_data, objfile); */
1476 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1477 VAR_NAMESPACE
, LOC_STATIC
,
1478 &objfile
->static_psymbols
,
1479 0, addr
+ baseaddr
, cu_language
, objfile
);
1482 case DW_TAG_typedef
:
1483 case DW_TAG_base_type
:
1484 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1485 VAR_NAMESPACE
, LOC_TYPEDEF
,
1486 &objfile
->static_psymbols
,
1487 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1489 case DW_TAG_class_type
:
1490 case DW_TAG_structure_type
:
1491 case DW_TAG_union_type
:
1492 case DW_TAG_enumeration_type
:
1493 /* Skip aggregate types without children, these are external
1495 if (pdi
->has_children
== 0)
1497 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1498 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
1499 &objfile
->static_psymbols
,
1500 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1502 if (cu_language
== language_cplus
)
1504 /* For C++, these implicitly act as typedefs as well. */
1505 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1506 VAR_NAMESPACE
, LOC_TYPEDEF
,
1507 &objfile
->static_psymbols
,
1508 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1511 case DW_TAG_enumerator
:
1512 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1513 VAR_NAMESPACE
, LOC_CONST
,
1514 &objfile
->static_psymbols
,
1515 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1522 /* Expand this partial symbol table into a full symbol table. */
1525 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1527 /* FIXME: This is barely more than a stub. */
1532 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1538 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1539 gdb_flush (gdb_stdout
);
1542 psymtab_to_symtab_1 (pst
);
1544 /* Finish up the debug error message. */
1546 printf_filtered ("done.\n");
1552 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1554 struct objfile
*objfile
= pst
->objfile
;
1555 bfd
*abfd
= objfile
->obfd
;
1556 struct comp_unit_head cu_header
;
1557 struct die_info
*dies
;
1558 unsigned long offset
;
1559 CORE_ADDR lowpc
, highpc
;
1560 struct die_info
*child_die
;
1562 struct symtab
*symtab
;
1563 struct cleanup
*back_to
;
1565 /* Set local variables from the partial symbol table info. */
1566 offset
= DWARF_INFO_OFFSET (pst
);
1567 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1568 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1569 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1570 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1571 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1572 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1573 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1574 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1575 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1576 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1577 cu_header_offset
= offset
;
1578 info_ptr
= dwarf_info_buffer
+ offset
;
1580 obstack_init (&dwarf2_tmp_obstack
);
1581 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1584 make_cleanup (really_free_pendings
, NULL
);
1586 /* read in the comp_unit header */
1587 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1589 /* Read the abbrevs for this compilation unit */
1590 dwarf2_read_abbrevs (abfd
, &cu_header
);
1591 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1593 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
1595 make_cleanup_free_die_list (dies
);
1597 /* Do line number decoding in read_file_scope () */
1598 process_die (dies
, objfile
, &cu_header
);
1600 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
))
1602 /* Some compilers don't define a DW_AT_high_pc attribute for
1603 the compilation unit. If the DW_AT_high_pc is missing,
1604 synthesize it, by scanning the DIE's below the compilation unit. */
1606 if (dies
->has_children
)
1608 child_die
= dies
->next
;
1609 while (child_die
&& child_die
->tag
)
1611 if (child_die
->tag
== DW_TAG_subprogram
)
1613 CORE_ADDR low
, high
;
1615 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1617 highpc
= max (highpc
, high
);
1620 child_die
= sibling_die (child_die
);
1624 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1626 /* Set symtab language to language from DW_AT_language.
1627 If the compilation is from a C file generated by language preprocessors,
1628 do not set the language if it was already deduced by start_subfile. */
1630 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1632 symtab
->language
= cu_language
;
1634 pst
->symtab
= symtab
;
1636 sort_symtab_syms (pst
->symtab
);
1638 do_cleanups (back_to
);
1641 /* Process a die and its children. */
1644 process_die (struct die_info
*die
, struct objfile
*objfile
,
1645 const struct comp_unit_head
*cu_header
)
1649 case DW_TAG_padding
:
1651 case DW_TAG_compile_unit
:
1652 read_file_scope (die
, objfile
, cu_header
);
1654 case DW_TAG_subprogram
:
1655 read_subroutine_type (die
, objfile
, cu_header
);
1656 read_func_scope (die
, objfile
, cu_header
);
1658 case DW_TAG_inlined_subroutine
:
1659 /* FIXME: These are ignored for now.
1660 They could be used to set breakpoints on all inlined instances
1661 of a function and make GDB `next' properly over inlined functions. */
1663 case DW_TAG_lexical_block
:
1664 read_lexical_block_scope (die
, objfile
, cu_header
);
1666 case DW_TAG_class_type
:
1667 case DW_TAG_structure_type
:
1668 case DW_TAG_union_type
:
1669 read_structure_scope (die
, objfile
, cu_header
);
1671 case DW_TAG_enumeration_type
:
1672 read_enumeration (die
, objfile
, cu_header
);
1674 case DW_TAG_subroutine_type
:
1675 read_subroutine_type (die
, objfile
, cu_header
);
1677 case DW_TAG_array_type
:
1678 read_array_type (die
, objfile
, cu_header
);
1680 case DW_TAG_pointer_type
:
1681 read_tag_pointer_type (die
, objfile
, cu_header
);
1683 case DW_TAG_ptr_to_member_type
:
1684 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1686 case DW_TAG_reference_type
:
1687 read_tag_reference_type (die
, objfile
, cu_header
);
1689 case DW_TAG_string_type
:
1690 read_tag_string_type (die
, objfile
);
1692 case DW_TAG_base_type
:
1693 read_base_type (die
, objfile
);
1694 if (dwarf_attr (die
, DW_AT_name
))
1696 /* Add a typedef symbol for the base type definition. */
1697 new_symbol (die
, die
->type
, objfile
, cu_header
);
1700 case DW_TAG_common_block
:
1701 read_common_block (die
, objfile
, cu_header
);
1703 case DW_TAG_common_inclusion
:
1706 new_symbol (die
, NULL
, objfile
, cu_header
);
1712 initialize_cu_func_list (void)
1714 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1718 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1719 const struct comp_unit_head
*cu_header
)
1721 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1722 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1723 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1724 struct attribute
*attr
;
1725 char *name
= "<unknown>";
1726 char *comp_dir
= NULL
;
1727 struct die_info
*child_die
;
1728 bfd
*abfd
= objfile
->obfd
;
1729 struct line_header
*line_header
= 0;
1731 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1733 if (die
->has_children
)
1735 child_die
= die
->next
;
1736 while (child_die
&& child_die
->tag
)
1738 if (child_die
->tag
== DW_TAG_subprogram
)
1740 CORE_ADDR low
, high
;
1742 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, objfile
))
1744 lowpc
= min (lowpc
, low
);
1745 highpc
= max (highpc
, high
);
1748 child_die
= sibling_die (child_die
);
1753 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1754 from finish_block. */
1755 if (lowpc
== ((CORE_ADDR
) -1))
1760 attr
= dwarf_attr (die
, DW_AT_name
);
1763 name
= DW_STRING (attr
);
1765 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
1768 comp_dir
= DW_STRING (attr
);
1771 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1772 directory, get rid of it. */
1773 char *cp
= strchr (comp_dir
, ':');
1775 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1780 if (objfile
->ei
.entry_point
>= lowpc
&&
1781 objfile
->ei
.entry_point
< highpc
)
1783 objfile
->ei
.entry_file_lowpc
= lowpc
;
1784 objfile
->ei
.entry_file_highpc
= highpc
;
1787 attr
= dwarf_attr (die
, DW_AT_language
);
1790 set_cu_language (DW_UNSND (attr
));
1793 /* We assume that we're processing GCC output. */
1794 processing_gcc_compilation
= 2;
1796 /* FIXME:Do something here. */
1797 if (dip
->at_producer
!= NULL
)
1799 handle_producer (dip
->at_producer
);
1803 /* The compilation unit may be in a different language or objfile,
1804 zero out all remembered fundamental types. */
1805 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
1807 start_symtab (name
, comp_dir
, lowpc
);
1808 record_debugformat ("DWARF 2");
1810 initialize_cu_func_list ();
1812 /* Process all dies in compilation unit. */
1813 if (die
->has_children
)
1815 child_die
= die
->next
;
1816 while (child_die
&& child_die
->tag
)
1818 process_die (child_die
, objfile
, cu_header
);
1819 child_die
= sibling_die (child_die
);
1823 /* Decode line number information if present. */
1824 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
1827 unsigned int line_offset
= DW_UNSND (attr
);
1828 line_header
= dwarf_decode_line_header (line_offset
,
1832 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
1833 (void *) line_header
);
1834 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu_header
);
1838 /* Decode macro information, if present. Dwarf 2 macro information
1839 refers to information in the line number info statement program
1840 header, so we can only read it if we've read the header
1842 attr
= dwarf_attr (die
, DW_AT_macro_info
);
1843 if (attr
&& line_header
)
1845 unsigned int macro_offset
= DW_UNSND (attr
);
1846 dwarf_decode_macros (line_header
, macro_offset
,
1847 comp_dir
, abfd
, cu_header
, objfile
);
1849 do_cleanups (back_to
);
1853 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
1855 struct function_range
*thisfn
;
1857 thisfn
= (struct function_range
*)
1858 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
1859 thisfn
->name
= name
;
1860 thisfn
->lowpc
= lowpc
;
1861 thisfn
->highpc
= highpc
;
1862 thisfn
->seen_line
= 0;
1863 thisfn
->next
= NULL
;
1865 if (cu_last_fn
== NULL
)
1866 cu_first_fn
= thisfn
;
1868 cu_last_fn
->next
= thisfn
;
1870 cu_last_fn
= thisfn
;
1874 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
1875 const struct comp_unit_head
*cu_header
)
1877 register struct context_stack
*new;
1880 struct die_info
*child_die
;
1881 struct attribute
*attr
;
1884 name
= dwarf2_linkage_name (die
);
1886 /* Ignore functions with missing or empty names and functions with
1887 missing or invalid low and high pc attributes. */
1888 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1894 /* Record the function range for dwarf_decode_lines. */
1895 add_to_cu_func_list (name
, lowpc
, highpc
);
1897 if (objfile
->ei
.entry_point
>= lowpc
&&
1898 objfile
->ei
.entry_point
< highpc
)
1900 objfile
->ei
.entry_func_lowpc
= lowpc
;
1901 objfile
->ei
.entry_func_highpc
= highpc
;
1904 /* Decode DW_AT_frame_base location descriptor if present, keep result
1905 for DW_OP_fbreg operands in decode_locdesc. */
1906 frame_base_reg
= -1;
1907 frame_base_offset
= 0;
1908 attr
= dwarf_attr (die
, DW_AT_frame_base
);
1913 /* Support the .debug_loc offsets */
1914 if (attr_form_is_block (attr
))
1916 addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
1918 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
1920 complain (&dwarf2_complex_location_expr
);
1925 complain (&dwarf2_invalid_attrib_class
, "DW_AT_frame_base", name
);
1930 complain (&dwarf2_unsupported_at_frame_base
, name
);
1932 frame_base_reg
= addr
;
1935 frame_base_reg
= basereg
;
1936 frame_base_offset
= addr
;
1939 complain (&dwarf2_unsupported_at_frame_base
, name
);
1942 new = push_context (0, lowpc
);
1943 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
1944 list_in_scope
= &local_symbols
;
1946 if (die
->has_children
)
1948 child_die
= die
->next
;
1949 while (child_die
&& child_die
->tag
)
1951 process_die (child_die
, objfile
, cu_header
);
1952 child_die
= sibling_die (child_die
);
1956 new = pop_context ();
1957 /* Make a block for the local symbols within. */
1958 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1959 lowpc
, highpc
, objfile
);
1960 list_in_scope
= &file_symbols
;
1963 /* Process all the DIES contained within a lexical block scope. Start
1964 a new scope, process the dies, and then close the scope. */
1967 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
1968 const struct comp_unit_head
*cu_header
)
1970 register struct context_stack
*new;
1971 CORE_ADDR lowpc
, highpc
;
1972 struct die_info
*child_die
;
1974 /* Ignore blocks with missing or invalid low and high pc attributes. */
1975 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
))
1980 push_context (0, lowpc
);
1981 if (die
->has_children
)
1983 child_die
= die
->next
;
1984 while (child_die
&& child_die
->tag
)
1986 process_die (child_die
, objfile
, cu_header
);
1987 child_die
= sibling_die (child_die
);
1990 new = pop_context ();
1992 if (local_symbols
!= NULL
)
1994 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
1997 local_symbols
= new->locals
;
2000 /* Get low and high pc attributes from a die.
2001 Return 1 if the attributes are present and valid, otherwise, return 0. */
2004 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2005 struct objfile
*objfile
)
2007 struct attribute
*attr
;
2011 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2013 low
= DW_ADDR (attr
);
2016 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2018 high
= DW_ADDR (attr
);
2025 /* When using the GNU linker, .gnu.linkonce. sections are used to
2026 eliminate duplicate copies of functions and vtables and such.
2027 The linker will arbitrarily choose one and discard the others.
2028 The AT_*_pc values for such functions refer to local labels in
2029 these sections. If the section from that file was discarded, the
2030 labels are not in the output, so the relocs get a value of 0.
2031 If this is a discarded function, mark the pc bounds as invalid,
2032 so that GDB will ignore it. */
2033 if (low
== 0 && (bfd_get_file_flags (objfile
->obfd
) & HAS_RELOC
) == 0)
2041 /* Add an aggregate field to the field list. */
2044 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2045 struct objfile
*objfile
,
2046 const struct comp_unit_head
*cu_header
)
2048 struct nextfield
*new_field
;
2049 struct attribute
*attr
;
2051 char *fieldname
= "";
2053 /* Allocate a new field list entry and link it in. */
2054 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2055 make_cleanup (xfree
, new_field
);
2056 memset (new_field
, 0, sizeof (struct nextfield
));
2057 new_field
->next
= fip
->fields
;
2058 fip
->fields
= new_field
;
2061 /* Handle accessibility and virtuality of field.
2062 The default accessibility for members is public, the default
2063 accessibility for inheritance is private. */
2064 if (die
->tag
!= DW_TAG_inheritance
)
2065 new_field
->accessibility
= DW_ACCESS_public
;
2067 new_field
->accessibility
= DW_ACCESS_private
;
2068 new_field
->virtuality
= DW_VIRTUALITY_none
;
2070 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2072 new_field
->accessibility
= DW_UNSND (attr
);
2073 if (new_field
->accessibility
!= DW_ACCESS_public
)
2074 fip
->non_public_fields
= 1;
2075 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2077 new_field
->virtuality
= DW_UNSND (attr
);
2079 fp
= &new_field
->field
;
2080 if (die
->tag
== DW_TAG_member
)
2082 /* Get type of field. */
2083 fp
->type
= die_type (die
, objfile
, cu_header
);
2085 /* Get bit size of field (zero if none). */
2086 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2089 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2093 FIELD_BITSIZE (*fp
) = 0;
2096 /* Get bit offset of field. */
2097 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2100 FIELD_BITPOS (*fp
) =
2101 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
2104 FIELD_BITPOS (*fp
) = 0;
2105 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2108 if (BITS_BIG_ENDIAN
)
2110 /* For big endian bits, the DW_AT_bit_offset gives the
2111 additional bit offset from the MSB of the containing
2112 anonymous object to the MSB of the field. We don't
2113 have to do anything special since we don't need to
2114 know the size of the anonymous object. */
2115 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2119 /* For little endian bits, compute the bit offset to the
2120 MSB of the anonymous object, subtract off the number of
2121 bits from the MSB of the field to the MSB of the
2122 object, and then subtract off the number of bits of
2123 the field itself. The result is the bit offset of
2124 the LSB of the field. */
2126 int bit_offset
= DW_UNSND (attr
);
2128 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2131 /* The size of the anonymous object containing
2132 the bit field is explicit, so use the
2133 indicated size (in bytes). */
2134 anonymous_size
= DW_UNSND (attr
);
2138 /* The size of the anonymous object containing
2139 the bit field must be inferred from the type
2140 attribute of the data member containing the
2142 anonymous_size
= TYPE_LENGTH (fp
->type
);
2144 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2145 - bit_offset
- FIELD_BITSIZE (*fp
);
2149 /* Get name of field. */
2150 attr
= dwarf_attr (die
, DW_AT_name
);
2151 if (attr
&& DW_STRING (attr
))
2152 fieldname
= DW_STRING (attr
);
2153 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2154 &objfile
->type_obstack
);
2156 /* Change accessibility for artificial fields (e.g. virtual table
2157 pointer or virtual base class pointer) to private. */
2158 if (dwarf_attr (die
, DW_AT_artificial
))
2160 new_field
->accessibility
= DW_ACCESS_private
;
2161 fip
->non_public_fields
= 1;
2164 else if (die
->tag
== DW_TAG_variable
)
2168 /* C++ static member.
2169 Get name of field. */
2170 attr
= dwarf_attr (die
, DW_AT_name
);
2171 if (attr
&& DW_STRING (attr
))
2172 fieldname
= DW_STRING (attr
);
2176 /* Get physical name. */
2177 physname
= dwarf2_linkage_name (die
);
2179 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2180 &objfile
->type_obstack
));
2181 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2182 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2183 &objfile
->type_obstack
);
2185 else if (die
->tag
== DW_TAG_inheritance
)
2187 /* C++ base class field. */
2188 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2190 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
2192 FIELD_BITSIZE (*fp
) = 0;
2193 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2194 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2195 fip
->nbaseclasses
++;
2199 /* Create the vector of fields, and attach it to the type. */
2202 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2203 struct objfile
*objfile
)
2205 int nfields
= fip
->nfields
;
2207 /* Record the field count, allocate space for the array of fields,
2208 and create blank accessibility bitfields if necessary. */
2209 TYPE_NFIELDS (type
) = nfields
;
2210 TYPE_FIELDS (type
) = (struct field
*)
2211 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2212 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2214 if (fip
->non_public_fields
)
2216 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2218 TYPE_FIELD_PRIVATE_BITS (type
) =
2219 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2220 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2222 TYPE_FIELD_PROTECTED_BITS (type
) =
2223 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2224 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2226 TYPE_FIELD_IGNORE_BITS (type
) =
2227 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2228 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2231 /* If the type has baseclasses, allocate and clear a bit vector for
2232 TYPE_FIELD_VIRTUAL_BITS. */
2233 if (fip
->nbaseclasses
)
2235 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2238 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2239 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2240 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2241 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2242 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2245 /* Copy the saved-up fields into the field vector. Start from the head
2246 of the list, adding to the tail of the field array, so that they end
2247 up in the same order in the array in which they were added to the list. */
2248 while (nfields
-- > 0)
2250 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2251 switch (fip
->fields
->accessibility
)
2253 case DW_ACCESS_private
:
2254 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2257 case DW_ACCESS_protected
:
2258 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2261 case DW_ACCESS_public
:
2265 /* Unknown accessibility. Complain and treat it as public. */
2267 complain (&dwarf2_unsupported_accessibility
,
2268 fip
->fields
->accessibility
);
2272 if (nfields
< fip
->nbaseclasses
)
2274 switch (fip
->fields
->virtuality
)
2276 case DW_VIRTUALITY_virtual
:
2277 case DW_VIRTUALITY_pure_virtual
:
2278 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2282 fip
->fields
= fip
->fields
->next
;
2286 /* Add a member function to the proper fieldlist. */
2289 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2290 struct type
*type
, struct objfile
*objfile
,
2291 const struct comp_unit_head
*cu_header
)
2293 struct attribute
*attr
;
2294 struct fnfieldlist
*flp
;
2296 struct fn_field
*fnp
;
2299 struct nextfnfield
*new_fnfield
;
2301 /* Get name of member function. */
2302 attr
= dwarf_attr (die
, DW_AT_name
);
2303 if (attr
&& DW_STRING (attr
))
2304 fieldname
= DW_STRING (attr
);
2308 /* Get the mangled name. */
2309 physname
= dwarf2_linkage_name (die
);
2311 /* Look up member function name in fieldlist. */
2312 for (i
= 0; i
< fip
->nfnfields
; i
++)
2314 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2318 /* Create new list element if necessary. */
2319 if (i
< fip
->nfnfields
)
2320 flp
= &fip
->fnfieldlists
[i
];
2323 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2325 fip
->fnfieldlists
= (struct fnfieldlist
*)
2326 xrealloc (fip
->fnfieldlists
,
2327 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2328 * sizeof (struct fnfieldlist
));
2329 if (fip
->nfnfields
== 0)
2330 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2332 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2333 flp
->name
= fieldname
;
2339 /* Create a new member function field and chain it to the field list
2341 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2342 make_cleanup (xfree
, new_fnfield
);
2343 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2344 new_fnfield
->next
= flp
->head
;
2345 flp
->head
= new_fnfield
;
2348 /* Fill in the member function field info. */
2349 fnp
= &new_fnfield
->fnfield
;
2350 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2351 &objfile
->type_obstack
);
2352 fnp
->type
= alloc_type (objfile
);
2353 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2355 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2356 int nparams
= TYPE_NFIELDS (die
->type
);
2358 /* TYPE is the domain of this method, and DIE->TYPE is the type
2359 of the method itself (TYPE_CODE_METHOD). */
2360 smash_to_method_type (fnp
->type
, type
,
2361 TYPE_TARGET_TYPE (die
->type
),
2362 TYPE_FIELDS (die
->type
),
2363 TYPE_NFIELDS (die
->type
),
2364 TYPE_VARARGS (die
->type
));
2366 /* Handle static member functions.
2367 Dwarf2 has no clean way to discern C++ static and non-static
2368 member functions. G++ helps GDB by marking the first
2369 parameter for non-static member functions (which is the
2370 this pointer) as artificial. We obtain this information
2371 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2372 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2373 fnp
->voffset
= VOFFSET_STATIC
;
2376 complain (&dwarf2_missing_member_fn_type_complaint
, physname
);
2378 /* Get fcontext from DW_AT_containing_type if present. */
2379 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2380 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2382 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2383 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2385 /* Get accessibility. */
2386 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2389 switch (DW_UNSND (attr
))
2391 case DW_ACCESS_private
:
2392 fnp
->is_private
= 1;
2394 case DW_ACCESS_protected
:
2395 fnp
->is_protected
= 1;
2400 /* Check for artificial methods. */
2401 attr
= dwarf_attr (die
, DW_AT_artificial
);
2402 if (attr
&& DW_UNSND (attr
) != 0)
2403 fnp
->is_artificial
= 1;
2405 /* Get index in virtual function table if it is a virtual member function. */
2406 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2409 /* Support the .debug_loc offsets */
2410 if (attr_form_is_block (attr
))
2412 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2414 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2416 complain (&dwarf2_complex_location_expr
);
2420 complain (&dwarf2_invalid_attrib_class
, "DW_AT_vtable_elem_location",
2426 /* Create the vector of member function fields, and attach it to the type. */
2429 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2430 struct objfile
*objfile
)
2432 struct fnfieldlist
*flp
;
2433 int total_length
= 0;
2436 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2437 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2438 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2440 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2442 struct nextfnfield
*nfp
= flp
->head
;
2443 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2446 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2447 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2448 fn_flp
->fn_fields
= (struct fn_field
*)
2449 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2450 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2451 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2453 total_length
+= flp
->length
;
2456 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2457 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2460 /* Called when we find the DIE that starts a structure or union scope
2461 (definition) to process all dies that define the members of the
2464 NOTE: we need to call struct_type regardless of whether or not the
2465 DIE has an at_name attribute, since it might be an anonymous
2466 structure or union. This gets the type entered into our set of
2469 However, if the structure is incomplete (an opaque struct/union)
2470 then suppress creating a symbol table entry for it since gdb only
2471 wants to find the one with the complete definition. Note that if
2472 it is complete, we just call new_symbol, which does it's own
2473 checking about whether the struct/union is anonymous or not (and
2474 suppresses creating a symbol table entry itself). */
2477 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2478 const struct comp_unit_head
*cu_header
)
2481 struct attribute
*attr
;
2483 type
= alloc_type (objfile
);
2485 INIT_CPLUS_SPECIFIC (type
);
2486 attr
= dwarf_attr (die
, DW_AT_name
);
2487 if (attr
&& DW_STRING (attr
))
2489 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2490 strlen (DW_STRING (attr
)),
2491 &objfile
->type_obstack
);
2494 if (die
->tag
== DW_TAG_structure_type
)
2496 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2498 else if (die
->tag
== DW_TAG_union_type
)
2500 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2504 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2506 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2509 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2512 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2516 TYPE_LENGTH (type
) = 0;
2519 /* We need to add the type field to the die immediately so we don't
2520 infinitely recurse when dealing with pointers to the structure
2521 type within the structure itself. */
2524 if (die
->has_children
&& ! die_is_declaration (die
))
2526 struct field_info fi
;
2527 struct die_info
*child_die
;
2528 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2530 memset (&fi
, 0, sizeof (struct field_info
));
2532 child_die
= die
->next
;
2534 while (child_die
&& child_die
->tag
)
2536 if (child_die
->tag
== DW_TAG_member
)
2538 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2540 else if (child_die
->tag
== DW_TAG_variable
)
2542 /* C++ static member. */
2543 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2545 else if (child_die
->tag
== DW_TAG_subprogram
)
2547 /* C++ member function. */
2548 process_die (child_die
, objfile
, cu_header
);
2549 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2551 else if (child_die
->tag
== DW_TAG_inheritance
)
2553 /* C++ base class field. */
2554 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2558 process_die (child_die
, objfile
, cu_header
);
2560 child_die
= sibling_die (child_die
);
2563 /* Attach fields and member functions to the type. */
2565 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2568 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2570 /* Get the type which refers to the base class (possibly this
2571 class itself) which contains the vtable pointer for the current
2572 class from the DW_AT_containing_type attribute. */
2574 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2576 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2578 TYPE_VPTR_BASETYPE (type
) = t
;
2581 static const char vptr_name
[] =
2582 {'_', 'v', 'p', 't', 'r', '\0'};
2585 /* Our own class provides vtbl ptr. */
2586 for (i
= TYPE_NFIELDS (t
) - 1;
2587 i
>= TYPE_N_BASECLASSES (t
);
2590 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2592 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2593 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2595 TYPE_VPTR_FIELDNO (type
) = i
;
2600 /* Complain if virtual function table field not found. */
2601 if (i
< TYPE_N_BASECLASSES (t
))
2602 complain (&dwarf2_vtbl_not_found_complaint
,
2603 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "");
2607 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2612 new_symbol (die
, type
, objfile
, cu_header
);
2614 do_cleanups (back_to
);
2618 /* No children, must be stub. */
2619 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2623 /* Given a pointer to a die which begins an enumeration, process all
2624 the dies that define the members of the enumeration.
2626 This will be much nicer in draft 6 of the DWARF spec when our
2627 members will be dies instead squished into the DW_AT_element_list
2630 NOTE: We reverse the order of the element list. */
2633 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
2634 const struct comp_unit_head
*cu_header
)
2636 struct die_info
*child_die
;
2638 struct field
*fields
;
2639 struct attribute
*attr
;
2642 int unsigned_enum
= 1;
2644 type
= alloc_type (objfile
);
2646 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2647 attr
= dwarf_attr (die
, DW_AT_name
);
2648 if (attr
&& DW_STRING (attr
))
2650 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2651 strlen (DW_STRING (attr
)),
2652 &objfile
->type_obstack
);
2655 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2658 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2662 TYPE_LENGTH (type
) = 0;
2667 if (die
->has_children
)
2669 child_die
= die
->next
;
2670 while (child_die
&& child_die
->tag
)
2672 if (child_die
->tag
!= DW_TAG_enumerator
)
2674 process_die (child_die
, objfile
, cu_header
);
2678 attr
= dwarf_attr (child_die
, DW_AT_name
);
2681 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
2682 if (SYMBOL_VALUE (sym
) < 0)
2685 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2687 fields
= (struct field
*)
2689 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
2690 * sizeof (struct field
));
2693 FIELD_NAME (fields
[num_fields
]) = SYMBOL_NAME (sym
);
2694 FIELD_TYPE (fields
[num_fields
]) = NULL
;
2695 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
2696 FIELD_BITSIZE (fields
[num_fields
]) = 0;
2702 child_die
= sibling_die (child_die
);
2707 TYPE_NFIELDS (type
) = num_fields
;
2708 TYPE_FIELDS (type
) = (struct field
*)
2709 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
2710 memcpy (TYPE_FIELDS (type
), fields
,
2711 sizeof (struct field
) * num_fields
);
2715 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
2718 new_symbol (die
, type
, objfile
, cu_header
);
2721 /* Extract all information from a DW_TAG_array_type DIE and put it in
2722 the DIE's type field. For now, this only handles one dimensional
2726 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
2727 const struct comp_unit_head
*cu_header
)
2729 struct die_info
*child_die
;
2730 struct type
*type
= NULL
;
2731 struct type
*element_type
, *range_type
, *index_type
;
2732 struct type
**range_types
= NULL
;
2733 struct attribute
*attr
;
2735 struct cleanup
*back_to
;
2737 /* Return if we've already decoded this type. */
2743 element_type
= die_type (die
, objfile
, cu_header
);
2745 /* Irix 6.2 native cc creates array types without children for
2746 arrays with unspecified length. */
2747 if (die
->has_children
== 0)
2749 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
2750 range_type
= create_range_type (NULL
, index_type
, 0, -1);
2751 die
->type
= create_array_type (NULL
, element_type
, range_type
);
2755 back_to
= make_cleanup (null_cleanup
, NULL
);
2756 child_die
= die
->next
;
2757 while (child_die
&& child_die
->tag
)
2759 if (child_die
->tag
== DW_TAG_subrange_type
)
2761 unsigned int low
, high
;
2763 /* Default bounds to an array with unspecified length. */
2766 if (cu_language
== language_fortran
)
2768 /* FORTRAN implies a lower bound of 1, if not given. */
2772 index_type
= die_type (child_die
, objfile
, cu_header
);
2773 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
2776 if (attr
->form
== DW_FORM_sdata
)
2778 low
= DW_SND (attr
);
2780 else if (attr
->form
== DW_FORM_udata
2781 || attr
->form
== DW_FORM_data1
2782 || attr
->form
== DW_FORM_data2
2783 || attr
->form
== DW_FORM_data4
2784 || attr
->form
== DW_FORM_data8
)
2786 low
= DW_UNSND (attr
);
2790 complain (&dwarf2_non_const_array_bound_ignored
,
2791 dwarf_form_name (attr
->form
));
2793 die
->type
= lookup_pointer_type (element_type
);
2800 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
2803 if (attr
->form
== DW_FORM_sdata
)
2805 high
= DW_SND (attr
);
2807 else if (attr
->form
== DW_FORM_udata
2808 || attr
->form
== DW_FORM_data1
2809 || attr
->form
== DW_FORM_data2
2810 || attr
->form
== DW_FORM_data4
2811 || attr
->form
== DW_FORM_data8
)
2813 high
= DW_UNSND (attr
);
2815 else if (attr
->form
== DW_FORM_block1
)
2817 /* GCC encodes arrays with unspecified or dynamic length
2818 with a DW_FORM_block1 attribute.
2819 FIXME: GDB does not yet know how to handle dynamic
2820 arrays properly, treat them as arrays with unspecified
2826 complain (&dwarf2_non_const_array_bound_ignored
,
2827 dwarf_form_name (attr
->form
));
2829 die
->type
= lookup_pointer_type (element_type
);
2837 /* Create a range type and save it for array type creation. */
2838 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
2840 range_types
= (struct type
**)
2841 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
2842 * sizeof (struct type
*));
2844 make_cleanup (free_current_contents
, &range_types
);
2846 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
2848 child_die
= sibling_die (child_die
);
2851 /* Dwarf2 dimensions are output from left to right, create the
2852 necessary array types in backwards order. */
2853 type
= element_type
;
2855 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
2857 /* Understand Dwarf2 support for vector types (like they occur on
2858 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
2859 array type. This is not part of the Dwarf2/3 standard yet, but a
2860 custom vendor extension. The main difference between a regular
2861 array and the vector variant is that vectors are passed by value
2863 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
2865 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
2867 do_cleanups (back_to
);
2869 /* Install the type in the die. */
2873 /* First cut: install each common block member as a global variable. */
2876 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
2877 const struct comp_unit_head
*cu_header
)
2879 struct die_info
*child_die
;
2880 struct attribute
*attr
;
2882 CORE_ADDR base
= (CORE_ADDR
) 0;
2884 attr
= dwarf_attr (die
, DW_AT_location
);
2887 /* Support the .debug_loc offsets */
2888 if (attr_form_is_block (attr
))
2890 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2892 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2894 complain (&dwarf2_complex_location_expr
);
2898 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
2899 "common block member");
2902 if (die
->has_children
)
2904 child_die
= die
->next
;
2905 while (child_die
&& child_die
->tag
)
2907 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
2908 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
2911 SYMBOL_VALUE_ADDRESS (sym
) =
2912 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2913 add_symbol_to_list (sym
, &global_symbols
);
2915 child_die
= sibling_die (child_die
);
2920 /* Extract all information from a DW_TAG_pointer_type DIE and add to
2921 the user defined type vector. */
2924 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
2925 const struct comp_unit_head
*cu_header
)
2928 struct attribute
*attr
;
2935 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
2936 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2939 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2943 TYPE_LENGTH (type
) = cu_header
->addr_size
;
2948 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
2949 the user defined type vector. */
2952 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
2953 const struct comp_unit_head
*cu_header
)
2956 struct type
*to_type
;
2957 struct type
*domain
;
2964 type
= alloc_type (objfile
);
2965 to_type
= die_type (die
, objfile
, cu_header
);
2966 domain
= die_containing_type (die
, objfile
, cu_header
);
2967 smash_to_member_type (type
, domain
, to_type
);
2972 /* Extract all information from a DW_TAG_reference_type DIE and add to
2973 the user defined type vector. */
2976 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
2977 const struct comp_unit_head
*cu_header
)
2980 struct attribute
*attr
;
2987 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
2988 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2991 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2995 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3001 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
3002 const struct comp_unit_head
*cu_header
)
3004 struct type
*base_type
;
3011 base_type
= die_type (die
, objfile
, cu_header
);
3012 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3016 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
3017 const struct comp_unit_head
*cu_header
)
3019 struct type
*base_type
;
3026 base_type
= die_type (die
, objfile
, cu_header
);
3027 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3030 /* Extract all information from a DW_TAG_string_type DIE and add to
3031 the user defined type vector. It isn't really a user defined type,
3032 but it behaves like one, with other DIE's using an AT_user_def_type
3033 attribute to reference it. */
3036 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
3038 struct type
*type
, *range_type
, *index_type
, *char_type
;
3039 struct attribute
*attr
;
3040 unsigned int length
;
3047 attr
= dwarf_attr (die
, DW_AT_string_length
);
3050 length
= DW_UNSND (attr
);
3054 /* check for the DW_AT_byte_size attribute */
3055 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3058 length
= DW_UNSND (attr
);
3065 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3066 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3067 if (cu_language
== language_fortran
)
3069 /* Need to create a unique string type for bounds
3071 type
= create_string_type (0, range_type
);
3075 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3076 type
= create_string_type (char_type
, range_type
);
3081 /* Handle DIES due to C code like:
3085 int (*funcp)(int a, long l);
3089 ('funcp' generates a DW_TAG_subroutine_type DIE)
3093 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
3094 const struct comp_unit_head
*cu_header
)
3096 struct type
*type
; /* Type that this function returns */
3097 struct type
*ftype
; /* Function that returns above type */
3098 struct attribute
*attr
;
3100 /* Decode the type that this subroutine returns */
3105 type
= die_type (die
, objfile
, cu_header
);
3106 ftype
= lookup_function_type (type
);
3108 /* All functions in C++ have prototypes. */
3109 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3110 if ((attr
&& (DW_UNSND (attr
) != 0))
3111 || cu_language
== language_cplus
)
3112 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3114 if (die
->has_children
)
3116 struct die_info
*child_die
;
3120 /* Count the number of parameters.
3121 FIXME: GDB currently ignores vararg functions, but knows about
3122 vararg member functions. */
3123 child_die
= die
->next
;
3124 while (child_die
&& child_die
->tag
)
3126 if (child_die
->tag
== DW_TAG_formal_parameter
)
3128 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3129 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3130 child_die
= sibling_die (child_die
);
3133 /* Allocate storage for parameters and fill them in. */
3134 TYPE_NFIELDS (ftype
) = nparams
;
3135 TYPE_FIELDS (ftype
) = (struct field
*)
3136 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3138 child_die
= die
->next
;
3139 while (child_die
&& child_die
->tag
)
3141 if (child_die
->tag
== DW_TAG_formal_parameter
)
3143 /* Dwarf2 has no clean way to discern C++ static and non-static
3144 member functions. G++ helps GDB by marking the first
3145 parameter for non-static member functions (which is the
3146 this pointer) as artificial. We pass this information
3147 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3148 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3150 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3152 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3153 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
3157 child_die
= sibling_die (child_die
);
3165 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
3166 const struct comp_unit_head
*cu_header
)
3168 struct attribute
*attr
;
3173 attr
= dwarf_attr (die
, DW_AT_name
);
3174 if (attr
&& DW_STRING (attr
))
3176 name
= DW_STRING (attr
);
3178 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3179 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
3183 /* Find a representation of a given base type and install
3184 it in the TYPE field of the die. */
3187 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
3190 struct attribute
*attr
;
3191 int encoding
= 0, size
= 0;
3193 /* If we've already decoded this die, this is a no-op. */
3199 attr
= dwarf_attr (die
, DW_AT_encoding
);
3202 encoding
= DW_UNSND (attr
);
3204 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3207 size
= DW_UNSND (attr
);
3209 attr
= dwarf_attr (die
, DW_AT_name
);
3210 if (attr
&& DW_STRING (attr
))
3212 enum type_code code
= TYPE_CODE_INT
;
3217 case DW_ATE_address
:
3218 /* Turn DW_ATE_address into a void * pointer. */
3219 code
= TYPE_CODE_PTR
;
3220 type_flags
|= TYPE_FLAG_UNSIGNED
;
3222 case DW_ATE_boolean
:
3223 code
= TYPE_CODE_BOOL
;
3224 type_flags
|= TYPE_FLAG_UNSIGNED
;
3226 case DW_ATE_complex_float
:
3227 code
= TYPE_CODE_COMPLEX
;
3230 code
= TYPE_CODE_FLT
;
3233 case DW_ATE_signed_char
:
3235 case DW_ATE_unsigned
:
3236 case DW_ATE_unsigned_char
:
3237 type_flags
|= TYPE_FLAG_UNSIGNED
;
3240 complain (&dwarf2_unsupported_at_encoding
,
3241 dwarf_type_encoding_name (encoding
));
3244 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3245 if (encoding
== DW_ATE_address
)
3246 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3247 else if (encoding
== DW_ATE_complex_float
)
3250 TYPE_TARGET_TYPE (type
)
3251 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3252 else if (size
== 16)
3253 TYPE_TARGET_TYPE (type
)
3254 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3256 TYPE_TARGET_TYPE (type
)
3257 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3262 type
= dwarf_base_type (encoding
, size
, objfile
);
3267 /* Read a whole compilation unit into a linked list of dies. */
3269 static struct die_info
*
3270 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3271 const struct comp_unit_head
*cu_header
)
3273 struct die_info
*first_die
, *last_die
, *die
;
3277 /* Reset die reference table; we are
3278 building new ones now. */
3279 dwarf2_empty_hash_tables ();
3283 first_die
= last_die
= NULL
;
3286 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3287 if (die
->has_children
)
3298 /* Enter die in reference hash table */
3299 store_in_ref_table (die
->offset
, die
);
3303 first_die
= last_die
= die
;
3307 last_die
->next
= die
;
3311 while (nesting_level
> 0);
3315 /* Free a linked list of dies. */
3318 free_die_list (struct die_info
*dies
)
3320 struct die_info
*die
, *next
;
3333 do_free_die_list_cleanup (void *dies
)
3335 free_die_list (dies
);
3338 static struct cleanup
*
3339 make_cleanup_free_die_list (struct die_info
*dies
)
3341 return make_cleanup (do_free_die_list_cleanup
, dies
);
3345 /* Read the contents of the section at OFFSET and of size SIZE from the
3346 object file specified by OBJFILE into the psymbol_obstack and return it. */
3349 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3352 bfd
*abfd
= objfile
->obfd
;
3358 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3359 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3360 (bfd_bread (buf
, size
, abfd
) != size
))
3363 error ("Dwarf Error: Can't read DWARF data from '%s'",
3364 bfd_get_filename (abfd
));
3369 /* In DWARF version 2, the description of the debugging information is
3370 stored in a separate .debug_abbrev section. Before we read any
3371 dies from a section we read in all abbreviations and install them
3375 dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
)
3378 struct abbrev_info
*cur_abbrev
;
3379 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3380 unsigned int abbrev_form
, hash_number
;
3382 /* Initialize dwarf2 abbrevs */
3383 memset (cu_header
->dwarf2_abbrevs
, 0,
3384 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
3386 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
3387 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3388 abbrev_ptr
+= bytes_read
;
3390 /* loop until we reach an abbrev number of 0 */
3391 while (abbrev_number
)
3393 cur_abbrev
= dwarf_alloc_abbrev ();
3395 /* read in abbrev header */
3396 cur_abbrev
->number
= abbrev_number
;
3397 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3398 abbrev_ptr
+= bytes_read
;
3399 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3402 /* now read in declarations */
3403 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3404 abbrev_ptr
+= bytes_read
;
3405 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3406 abbrev_ptr
+= bytes_read
;
3409 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3411 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3412 xrealloc (cur_abbrev
->attrs
,
3413 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3414 * sizeof (struct attr_abbrev
));
3416 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3417 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3418 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3419 abbrev_ptr
+= bytes_read
;
3420 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3421 abbrev_ptr
+= bytes_read
;
3424 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3425 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
3426 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3428 /* Get next abbreviation.
3429 Under Irix6 the abbreviations for a compilation unit are not
3430 always properly terminated with an abbrev number of 0.
3431 Exit loop if we encounter an abbreviation which we have
3432 already read (which means we are about to read the abbreviations
3433 for the next compile unit) or if the end of the abbreviation
3434 table is reached. */
3435 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3436 >= dwarf_abbrev_size
)
3438 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3439 abbrev_ptr
+= bytes_read
;
3440 if (dwarf2_lookup_abbrev (abbrev_number
, cu_header
) != NULL
)
3445 /* Empty the abbrev table for a new compilation unit. */
3449 dwarf2_empty_abbrev_table (PTR ptr_to_abbrevs_table
)
3452 struct abbrev_info
*abbrev
, *next
;
3453 struct abbrev_info
**abbrevs
;
3455 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
3457 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
3460 abbrev
= abbrevs
[i
];
3463 next
= abbrev
->next
;
3464 xfree (abbrev
->attrs
);
3472 /* Lookup an abbrev_info structure in the abbrev hash table. */
3474 static struct abbrev_info
*
3475 dwarf2_lookup_abbrev (unsigned int number
, const struct comp_unit_head
*cu_header
)
3477 unsigned int hash_number
;
3478 struct abbrev_info
*abbrev
;
3480 hash_number
= number
% ABBREV_HASH_SIZE
;
3481 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
3485 if (abbrev
->number
== number
)
3488 abbrev
= abbrev
->next
;
3493 /* Read a minimal amount of information into the minimal die structure. */
3496 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
3497 char *info_ptr
, const struct comp_unit_head
*cu_header
)
3499 unsigned int abbrev_number
, bytes_read
, i
;
3500 struct abbrev_info
*abbrev
;
3501 struct attribute attr
;
3502 struct attribute spec_attr
;
3503 int found_spec_attr
= 0;
3504 int has_low_pc_attr
= 0;
3505 int has_high_pc_attr
= 0;
3507 *part_die
= zeroed_partial_die
;
3508 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3509 info_ptr
+= bytes_read
;
3513 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3516 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number
);
3518 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
3519 part_die
->tag
= abbrev
->tag
;
3520 part_die
->has_children
= abbrev
->has_children
;
3521 part_die
->abbrev
= abbrev_number
;
3523 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3525 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
3526 info_ptr
, cu_header
);
3528 /* Store the data if it is of an attribute we want to keep in a
3529 partial symbol table. */
3534 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3535 if (part_die
->name
== NULL
)
3536 part_die
->name
= DW_STRING (&attr
);
3538 case DW_AT_MIPS_linkage_name
:
3539 part_die
->name
= DW_STRING (&attr
);
3542 has_low_pc_attr
= 1;
3543 part_die
->lowpc
= DW_ADDR (&attr
);
3546 has_high_pc_attr
= 1;
3547 part_die
->highpc
= DW_ADDR (&attr
);
3549 case DW_AT_location
:
3550 /* Support the .debug_loc offsets */
3551 if (attr_form_is_block (&attr
))
3553 part_die
->locdesc
= DW_BLOCK (&attr
);
3555 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
3557 complain (&dwarf2_complex_location_expr
);
3561 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
3562 "partial symbol information");
3565 case DW_AT_language
:
3566 part_die
->language
= DW_UNSND (&attr
);
3568 case DW_AT_external
:
3569 part_die
->is_external
= DW_UNSND (&attr
);
3571 case DW_AT_declaration
:
3572 part_die
->is_declaration
= DW_UNSND (&attr
);
3575 part_die
->has_type
= 1;
3577 case DW_AT_abstract_origin
:
3578 case DW_AT_specification
:
3579 found_spec_attr
= 1;
3583 /* Ignore absolute siblings, they might point outside of
3584 the current compile unit. */
3585 if (attr
.form
== DW_FORM_ref_addr
)
3586 complain (&dwarf2_absolute_sibling_complaint
);
3589 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
3596 /* If we found a reference attribute and the die has no name, try
3597 to find a name in the referred to die. */
3599 if (found_spec_attr
&& part_die
->name
== NULL
)
3601 struct partial_die_info spec_die
;
3605 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
3606 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
3609 part_die
->name
= spec_die
.name
;
3611 /* Copy DW_AT_external attribute if it is set. */
3612 if (spec_die
.is_external
)
3613 part_die
->is_external
= spec_die
.is_external
;
3617 /* When using the GNU linker, .gnu.linkonce. sections are used to
3618 eliminate duplicate copies of functions and vtables and such.
3619 The linker will arbitrarily choose one and discard the others.
3620 The AT_*_pc values for such functions refer to local labels in
3621 these sections. If the section from that file was discarded, the
3622 labels are not in the output, so the relocs get a value of 0.
3623 If this is a discarded function, mark the pc bounds as invalid,
3624 so that GDB will ignore it. */
3625 if (has_low_pc_attr
&& has_high_pc_attr
3626 && part_die
->lowpc
< part_die
->highpc
3627 && (part_die
->lowpc
!= 0
3628 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
3629 part_die
->has_pc_info
= 1;
3633 /* Read the die from the .debug_info section buffer. And set diep to
3634 point to a newly allocated die with its information. */
3637 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
3638 const struct comp_unit_head
*cu_header
)
3640 unsigned int abbrev_number
, bytes_read
, i
, offset
;
3641 struct abbrev_info
*abbrev
;
3642 struct die_info
*die
;
3644 offset
= info_ptr
- dwarf_info_buffer
;
3645 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3646 info_ptr
+= bytes_read
;
3649 die
= dwarf_alloc_die ();
3651 die
->abbrev
= abbrev_number
;
3657 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
3660 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number
);
3662 die
= dwarf_alloc_die ();
3663 die
->offset
= offset
;
3664 die
->tag
= abbrev
->tag
;
3665 die
->has_children
= abbrev
->has_children
;
3666 die
->abbrev
= abbrev_number
;
3669 die
->num_attrs
= abbrev
->num_attrs
;
3670 die
->attrs
= (struct attribute
*)
3671 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
3673 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3675 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
3676 abfd
, info_ptr
, cu_header
);
3683 /* Read an attribute value described by an attribute form. */
3686 read_attribute_value (struct attribute
*attr
, unsigned form
,
3687 bfd
*abfd
, char *info_ptr
,
3688 const struct comp_unit_head
*cu_header
)
3690 unsigned int bytes_read
;
3691 struct dwarf_block
*blk
;
3697 case DW_FORM_ref_addr
:
3698 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
3699 info_ptr
+= bytes_read
;
3701 case DW_FORM_block2
:
3702 blk
= dwarf_alloc_block ();
3703 blk
->size
= read_2_bytes (abfd
, info_ptr
);
3705 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3706 info_ptr
+= blk
->size
;
3707 DW_BLOCK (attr
) = blk
;
3709 case DW_FORM_block4
:
3710 blk
= dwarf_alloc_block ();
3711 blk
->size
= read_4_bytes (abfd
, info_ptr
);
3713 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3714 info_ptr
+= blk
->size
;
3715 DW_BLOCK (attr
) = blk
;
3718 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3722 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3726 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3729 case DW_FORM_string
:
3730 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
3731 info_ptr
+= bytes_read
;
3734 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
3736 info_ptr
+= bytes_read
;
3739 blk
= dwarf_alloc_block ();
3740 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3741 info_ptr
+= bytes_read
;
3742 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3743 info_ptr
+= blk
->size
;
3744 DW_BLOCK (attr
) = blk
;
3746 case DW_FORM_block1
:
3747 blk
= dwarf_alloc_block ();
3748 blk
->size
= read_1_byte (abfd
, info_ptr
);
3750 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
3751 info_ptr
+= blk
->size
;
3752 DW_BLOCK (attr
) = blk
;
3755 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3759 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3763 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
3764 info_ptr
+= bytes_read
;
3767 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3768 info_ptr
+= bytes_read
;
3771 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
3775 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
3779 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
3783 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
3786 case DW_FORM_ref_udata
:
3787 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3788 info_ptr
+= bytes_read
;
3790 case DW_FORM_indirect
:
3791 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
3792 info_ptr
+= bytes_read
;
3793 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
3796 error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3797 dwarf_form_name (form
));
3802 /* Read an attribute described by an abbreviated attribute. */
3805 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
3806 bfd
*abfd
, char *info_ptr
,
3807 const struct comp_unit_head
*cu_header
)
3809 attr
->name
= abbrev
->name
;
3810 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
3813 /* read dwarf information from a buffer */
3816 read_1_byte (bfd
*abfd
, char *buf
)
3818 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
3822 read_1_signed_byte (bfd
*abfd
, char *buf
)
3824 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
3828 read_2_bytes (bfd
*abfd
, char *buf
)
3830 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3834 read_2_signed_bytes (bfd
*abfd
, char *buf
)
3836 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3840 read_4_bytes (bfd
*abfd
, char *buf
)
3842 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3846 read_4_signed_bytes (bfd
*abfd
, char *buf
)
3848 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3851 static unsigned long
3852 read_8_bytes (bfd
*abfd
, char *buf
)
3854 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3858 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3861 CORE_ADDR retval
= 0;
3863 if (cu_header
->signed_addr_p
)
3865 switch (cu_header
->addr_size
)
3868 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
3871 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
3874 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
3877 internal_error (__FILE__
, __LINE__
,
3878 "read_address: bad switch, signed");
3883 switch (cu_header
->addr_size
)
3886 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
3889 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3892 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3895 internal_error (__FILE__
, __LINE__
,
3896 "read_address: bad switch, unsigned");
3900 *bytes_read
= cu_header
->addr_size
;
3904 /* Read the initial length from a section. The (draft) DWARF 3
3905 specification allows the initial length to take up either 4 bytes
3906 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
3907 bytes describe the length and all offsets will be 8 bytes in length
3910 An older, non-standard 64-bit format is also handled by this
3911 function. The older format in question stores the initial length
3912 as an 8-byte quantity without an escape value. Lengths greater
3913 than 2^32 aren't very common which means that the initial 4 bytes
3914 is almost always zero. Since a length value of zero doesn't make
3915 sense for the 32-bit format, this initial zero can be considered to
3916 be an escape value which indicates the presence of the older 64-bit
3917 format. As written, the code can't detect (old format) lengths
3918 greater than 4GB. If it becomes necessary to handle lengths somewhat
3919 larger than 4GB, we could allow other small values (such as the
3920 non-sensical values of 1, 2, and 3) to also be used as escape values
3921 indicating the presence of the old format.
3923 The value returned via bytes_read should be used to increment
3924 the relevant pointer after calling read_initial_length().
3926 As a side effect, this function sets the fields initial_length_size
3927 and offset_size in cu_header to the values appropriate for the
3928 length field. (The format of the initial length field determines
3929 the width of file offsets to be fetched later with fetch_offset().)
3931 [ Note: read_initial_length() and read_offset() are based on the
3932 document entitled "DWARF Debugging Information Format", revision
3933 3, draft 8, dated November 19, 2001. This document was obtained
3936 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
3938 This document is only a draft and is subject to change. (So beware.)
3940 Details regarding the older, non-standard 64-bit format were
3941 determined empirically by examining 64-bit ELF files produced
3942 by the SGI toolchain on an IRIX 6.5 machine.
3944 - Kevin, July 16, 2002
3948 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
3953 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
3955 if (retval
== 0xffffffff)
3957 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
3959 if (cu_header
!= NULL
)
3961 cu_header
->initial_length_size
= 12;
3962 cu_header
->offset_size
= 8;
3965 else if (retval
== 0)
3967 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
3969 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
3971 if (cu_header
!= NULL
)
3973 cu_header
->initial_length_size
= 8;
3974 cu_header
->offset_size
= 8;
3980 if (cu_header
!= NULL
)
3982 cu_header
->initial_length_size
= 4;
3983 cu_header
->offset_size
= 4;
3990 /* Read an offset from the data stream. The size of the offset is
3991 given by cu_header->offset_size. */
3994 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
3999 switch (cu_header
->offset_size
)
4002 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4006 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4010 internal_error (__FILE__
, __LINE__
,
4011 "read_offset: bad switch");
4018 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4020 /* If the size of a host char is 8 bits, we can return a pointer
4021 to the buffer, otherwise we have to copy the data to a buffer
4022 allocated on the temporary obstack. */
4023 gdb_assert (HOST_CHAR_BIT
== 8);
4028 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4030 /* If the size of a host char is 8 bits, we can return a pointer
4031 to the string, otherwise we have to copy the string to a buffer
4032 allocated on the temporary obstack. */
4033 gdb_assert (HOST_CHAR_BIT
== 8);
4036 *bytes_read_ptr
= 1;
4039 *bytes_read_ptr
= strlen (buf
) + 1;
4044 read_indirect_string (bfd
*abfd
, char *buf
,
4045 const struct comp_unit_head
*cu_header
,
4046 unsigned int *bytes_read_ptr
)
4048 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4049 (int *) bytes_read_ptr
);
4051 if (dwarf_str_buffer
== NULL
)
4053 error ("DW_FORM_strp used without .debug_str section");
4056 if (str_offset
>= dwarf_str_size
)
4058 error ("DW_FORM_strp pointing outside of .debug_str section");
4061 gdb_assert (HOST_CHAR_BIT
== 8);
4062 if (dwarf_str_buffer
[str_offset
] == '\0')
4064 return dwarf_str_buffer
+ str_offset
;
4067 static unsigned long
4068 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4070 unsigned long result
;
4071 unsigned int num_read
;
4081 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4084 result
|= ((unsigned long)(byte
& 127) << shift
);
4085 if ((byte
& 128) == 0)
4091 *bytes_read_ptr
= num_read
;
4096 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4099 int i
, shift
, size
, num_read
;
4109 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4112 result
|= ((long)(byte
& 127) << shift
);
4114 if ((byte
& 128) == 0)
4119 if ((shift
< size
) && (byte
& 0x40))
4121 result
|= -(1 << shift
);
4123 *bytes_read_ptr
= num_read
;
4128 set_cu_language (unsigned int lang
)
4134 cu_language
= language_c
;
4136 case DW_LANG_C_plus_plus
:
4137 cu_language
= language_cplus
;
4139 case DW_LANG_Fortran77
:
4140 case DW_LANG_Fortran90
:
4141 case DW_LANG_Fortran95
:
4142 cu_language
= language_fortran
;
4144 case DW_LANG_Mips_Assembler
:
4145 cu_language
= language_asm
;
4148 cu_language
= language_java
;
4152 case DW_LANG_Cobol74
:
4153 case DW_LANG_Cobol85
:
4154 case DW_LANG_Pascal83
:
4155 case DW_LANG_Modula2
:
4157 cu_language
= language_unknown
;
4160 cu_language_defn
= language_def (cu_language
);
4163 /* Return the named attribute or NULL if not there. */
4165 static struct attribute
*
4166 dwarf_attr (struct die_info
*die
, unsigned int name
)
4169 struct attribute
*spec
= NULL
;
4171 for (i
= 0; i
< die
->num_attrs
; ++i
)
4173 if (die
->attrs
[i
].name
== name
)
4175 return &die
->attrs
[i
];
4177 if (die
->attrs
[i
].name
== DW_AT_specification
4178 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4179 spec
= &die
->attrs
[i
];
4183 struct die_info
*ref_die
=
4184 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4187 return dwarf_attr (ref_die
, name
);
4194 die_is_declaration (struct die_info
*die
)
4196 return (dwarf_attr (die
, DW_AT_declaration
)
4197 && ! dwarf_attr (die
, DW_AT_specification
));
4201 /* Free the line_header structure *LH, and any arrays and strings it
4204 free_line_header (struct line_header
*lh
)
4206 if (lh
->standard_opcode_lengths
)
4207 xfree (lh
->standard_opcode_lengths
);
4209 /* Remember that all the lh->file_names[i].name pointers are
4210 pointers into debug_line_buffer, and don't need to be freed. */
4212 xfree (lh
->file_names
);
4214 /* Similarly for the include directory names. */
4215 if (lh
->include_dirs
)
4216 xfree (lh
->include_dirs
);
4222 /* Add an entry to LH's include directory table. */
4224 add_include_dir (struct line_header
*lh
, char *include_dir
)
4226 /* Grow the array if necessary. */
4227 if (lh
->include_dirs_size
== 0)
4229 lh
->include_dirs_size
= 1; /* for testing */
4230 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4231 * sizeof (*lh
->include_dirs
));
4233 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4235 lh
->include_dirs_size
*= 2;
4236 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4237 (lh
->include_dirs_size
4238 * sizeof (*lh
->include_dirs
)));
4241 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4245 /* Add an entry to LH's file name table. */
4247 add_file_name (struct line_header
*lh
,
4249 unsigned int dir_index
,
4250 unsigned int mod_time
,
4251 unsigned int length
)
4253 struct file_entry
*fe
;
4255 /* Grow the array if necessary. */
4256 if (lh
->file_names_size
== 0)
4258 lh
->file_names_size
= 1; /* for testing */
4259 lh
->file_names
= xmalloc (lh
->file_names_size
4260 * sizeof (*lh
->file_names
));
4262 else if (lh
->num_file_names
>= lh
->file_names_size
)
4264 lh
->file_names_size
*= 2;
4265 lh
->file_names
= xrealloc (lh
->file_names
,
4266 (lh
->file_names_size
4267 * sizeof (*lh
->file_names
)));
4270 fe
= &lh
->file_names
[lh
->num_file_names
++];
4272 fe
->dir_index
= dir_index
;
4273 fe
->mod_time
= mod_time
;
4274 fe
->length
= length
;
4278 /* Read the statement program header starting at OFFSET in
4279 dwarf_line_buffer, according to the endianness of ABFD. Return a
4280 pointer to a struct line_header, allocated using xmalloc.
4282 NOTE: the strings in the include directory and file name tables of
4283 the returned object point into debug_line_buffer, and must not be
4285 static struct line_header
*
4286 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4287 const struct comp_unit_head
*cu_header
)
4289 struct cleanup
*back_to
;
4290 struct line_header
*lh
;
4294 char *cur_dir
, *cur_file
;
4296 if (dwarf_line_buffer
== NULL
)
4298 complain (&dwarf2_missing_line_number_section
);
4302 /* Make sure that at least there's room for the total_length field. That
4303 could be 12 bytes long, but we're just going to fudge that. */
4304 if (offset
+ 4 >= dwarf_line_size
)
4306 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4310 lh
= xmalloc (sizeof (*lh
));
4311 memset (lh
, 0, sizeof (*lh
));
4312 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4315 line_ptr
= dwarf_line_buffer
+ offset
;
4317 /* read in the header */
4318 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4319 line_ptr
+= bytes_read
;
4320 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4322 complain (&dwarf2_statement_list_fits_in_line_number_section
);
4325 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4326 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4328 lh
->header_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
4329 line_ptr
+= bytes_read
;
4330 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4332 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4334 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4336 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4338 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4340 lh
->standard_opcode_lengths
4341 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4343 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4344 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4346 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4350 /* Read directory table */
4351 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4353 line_ptr
+= bytes_read
;
4354 add_include_dir (lh
, cur_dir
);
4356 line_ptr
+= bytes_read
;
4358 /* Read file name table */
4359 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4361 unsigned int dir_index
, mod_time
, length
;
4363 line_ptr
+= bytes_read
;
4364 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4365 line_ptr
+= bytes_read
;
4366 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4367 line_ptr
+= bytes_read
;
4368 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4369 line_ptr
+= bytes_read
;
4371 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4373 line_ptr
+= bytes_read
;
4374 lh
->statement_program_start
= line_ptr
;
4376 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4377 complain (&dwarf2_line_header_too_long
);
4379 discard_cleanups (back_to
);
4383 /* This function exists to work around a bug in certain compilers
4384 (particularly GCC 2.95), in which the first line number marker of a
4385 function does not show up until after the prologue, right before
4386 the second line number marker. This function shifts ADDRESS down
4387 to the beginning of the function if necessary, and is called on
4388 addresses passed to record_line. */
4391 check_cu_functions (CORE_ADDR address
)
4393 struct function_range
*fn
;
4395 /* Find the function_range containing address. */
4400 cu_cached_fn
= cu_first_fn
;
4404 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4410 while (fn
&& fn
!= cu_cached_fn
)
4411 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4421 if (address
!= fn
->lowpc
)
4422 complain (&dwarf2_misplaced_line_number
,
4423 (unsigned long) address
, fn
->name
);
4428 /* Decode the line number information for the compilation unit whose
4429 line number info is at OFFSET in the .debug_line section.
4430 The compilation directory of the file is passed in COMP_DIR. */
4433 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
4434 const struct comp_unit_head
*cu_header
)
4438 unsigned int i
, bytes_read
;
4440 unsigned char op_code
, extended_op
, adj_opcode
;
4442 line_ptr
= lh
->statement_program_start
;
4443 line_end
= lh
->statement_program_end
;
4445 /* Read the statement sequences until there's nothing left. */
4446 while (line_ptr
< line_end
)
4448 /* state machine registers */
4449 CORE_ADDR address
= 0;
4450 unsigned int file
= 1;
4451 unsigned int line
= 1;
4452 unsigned int column
= 0;
4453 int is_stmt
= lh
->default_is_stmt
;
4454 int basic_block
= 0;
4455 int end_sequence
= 0;
4457 /* Start a subfile for the current file of the state machine. */
4458 if (lh
->num_file_names
>= file
)
4460 /* lh->include_dirs and lh->file_names are 0-based, but the
4461 directory and file name numbers in the statement program
4463 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
4466 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4469 dwarf2_start_subfile (fe
->name
, dir
);
4472 /* Decode the table. */
4473 while (!end_sequence
)
4475 op_code
= read_1_byte (abfd
, line_ptr
);
4478 if (op_code
>= lh
->opcode_base
)
4479 { /* Special operand. */
4480 adj_opcode
= op_code
- lh
->opcode_base
;
4481 address
+= (adj_opcode
/ lh
->line_range
)
4482 * lh
->minimum_instruction_length
;
4483 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
4484 /* append row to matrix using current values */
4485 address
= check_cu_functions (address
);
4486 record_line (current_subfile
, line
, address
);
4489 else switch (op_code
)
4491 case DW_LNS_extended_op
:
4492 line_ptr
+= 1; /* ignore length */
4493 extended_op
= read_1_byte (abfd
, line_ptr
);
4495 switch (extended_op
)
4497 case DW_LNE_end_sequence
:
4499 record_line (current_subfile
, 0, address
);
4501 case DW_LNE_set_address
:
4502 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
4503 line_ptr
+= bytes_read
;
4504 address
+= baseaddr
;
4506 case DW_LNE_define_file
:
4509 unsigned int dir_index
, mod_time
, length
;
4511 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
4512 line_ptr
+= bytes_read
;
4514 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4515 line_ptr
+= bytes_read
;
4517 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4518 line_ptr
+= bytes_read
;
4520 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4521 line_ptr
+= bytes_read
;
4522 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4526 complain (&dwarf2_mangled_line_number_section
);
4531 address
= check_cu_functions (address
);
4532 record_line (current_subfile
, line
, address
);
4535 case DW_LNS_advance_pc
:
4536 address
+= lh
->minimum_instruction_length
4537 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4538 line_ptr
+= bytes_read
;
4540 case DW_LNS_advance_line
:
4541 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
4542 line_ptr
+= bytes_read
;
4544 case DW_LNS_set_file
:
4546 /* lh->include_dirs and lh->file_names are 0-based,
4547 but the directory and file name numbers in the
4548 statement program are 1-based. */
4549 struct file_entry
*fe
;
4551 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4552 line_ptr
+= bytes_read
;
4553 fe
= &lh
->file_names
[file
- 1];
4555 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
4558 dwarf2_start_subfile (fe
->name
, dir
);
4561 case DW_LNS_set_column
:
4562 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4563 line_ptr
+= bytes_read
;
4565 case DW_LNS_negate_stmt
:
4566 is_stmt
= (!is_stmt
);
4568 case DW_LNS_set_basic_block
:
4571 /* Add to the address register of the state machine the
4572 address increment value corresponding to special opcode
4573 255. Ie, this value is scaled by the minimum instruction
4574 length since special opcode 255 would have scaled the
4576 case DW_LNS_const_add_pc
:
4577 address
+= (lh
->minimum_instruction_length
4578 * ((255 - lh
->opcode_base
) / lh
->line_range
));
4580 case DW_LNS_fixed_advance_pc
:
4581 address
+= read_2_bytes (abfd
, line_ptr
);
4585 { /* Unknown standard opcode, ignore it. */
4587 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
4589 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4590 line_ptr
+= bytes_read
;
4598 /* Start a subfile for DWARF. FILENAME is the name of the file and
4599 DIRNAME the name of the source directory which contains FILENAME
4600 or NULL if not known.
4601 This routine tries to keep line numbers from identical absolute and
4602 relative file names in a common subfile.
4604 Using the `list' example from the GDB testsuite, which resides in
4605 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
4606 of /srcdir/list0.c yields the following debugging information for list0.c:
4608 DW_AT_name: /srcdir/list0.c
4609 DW_AT_comp_dir: /compdir
4610 files.files[0].name: list0.h
4611 files.files[0].dir: /srcdir
4612 files.files[1].name: list0.c
4613 files.files[1].dir: /srcdir
4615 The line number information for list0.c has to end up in a single
4616 subfile, so that `break /srcdir/list0.c:1' works as expected. */
4619 dwarf2_start_subfile (char *filename
, char *dirname
)
4621 /* If the filename isn't absolute, try to match an existing subfile
4622 with the full pathname. */
4624 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
4626 struct subfile
*subfile
;
4627 char *fullname
= concat (dirname
, "/", filename
, NULL
);
4629 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
4631 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
4633 current_subfile
= subfile
;
4640 start_subfile (filename
, dirname
);
4643 /* Given a pointer to a DWARF information entry, figure out if we need
4644 to make a symbol table entry for it, and if so, create a new entry
4645 and return a pointer to it.
4646 If TYPE is NULL, determine symbol type from the die, otherwise
4647 used the passed type. */
4649 static struct symbol
*
4650 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
4651 const struct comp_unit_head
*cu_header
)
4653 struct symbol
*sym
= NULL
;
4655 struct attribute
*attr
= NULL
;
4656 struct attribute
*attr2
= NULL
;
4659 name
= dwarf2_linkage_name (die
);
4662 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
4663 sizeof (struct symbol
));
4664 OBJSTAT (objfile
, n_syms
++);
4665 memset (sym
, 0, sizeof (struct symbol
));
4666 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
4667 &objfile
->symbol_obstack
);
4669 /* Default assumptions.
4670 Use the passed type or decode it from the die. */
4671 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4672 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4674 SYMBOL_TYPE (sym
) = type
;
4676 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
4677 attr
= dwarf_attr (die
, DW_AT_decl_line
);
4680 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
4683 /* If this symbol is from a C++ compilation, then attempt to
4684 cache the demangled form for future reference. This is a
4685 typical time versus space tradeoff, that was decided in favor
4686 of time because it sped up C++ symbol lookups by a factor of
4689 SYMBOL_LANGUAGE (sym
) = cu_language
;
4690 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
4694 attr
= dwarf_attr (die
, DW_AT_low_pc
);
4697 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
4699 SYMBOL_CLASS (sym
) = LOC_LABEL
;
4701 case DW_TAG_subprogram
:
4702 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4704 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4705 attr2
= dwarf_attr (die
, DW_AT_external
);
4706 if (attr2
&& (DW_UNSND (attr2
) != 0))
4708 add_symbol_to_list (sym
, &global_symbols
);
4712 add_symbol_to_list (sym
, list_in_scope
);
4715 case DW_TAG_variable
:
4716 /* Compilation with minimal debug info may result in variables
4717 with missing type entries. Change the misleading `void' type
4718 to something sensible. */
4719 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
4720 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
4721 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4722 "<variable, no debug info>",
4724 attr
= dwarf_attr (die
, DW_AT_const_value
);
4727 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4728 attr2
= dwarf_attr (die
, DW_AT_external
);
4729 if (attr2
&& (DW_UNSND (attr2
) != 0))
4730 add_symbol_to_list (sym
, &global_symbols
);
4732 add_symbol_to_list (sym
, list_in_scope
);
4735 attr
= dwarf_attr (die
, DW_AT_location
);
4738 attr2
= dwarf_attr (die
, DW_AT_external
);
4739 if (attr2
&& (DW_UNSND (attr2
) != 0))
4741 /* Support the .debug_loc offsets */
4742 if (attr_form_is_block (attr
))
4744 SYMBOL_VALUE_ADDRESS (sym
) =
4745 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4747 else if (attr
->form
== DW_FORM_data4
4748 || attr
->form
== DW_FORM_data8
)
4750 complain (&dwarf2_complex_location_expr
);
4754 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4755 "external variable");
4757 add_symbol_to_list (sym
, &global_symbols
);
4759 /* In shared libraries the address of the variable
4760 in the location descriptor might still be relocatable,
4761 so its value could be zero.
4762 Enter the symbol as a LOC_UNRESOLVED symbol, if its
4763 value is zero, the address of the variable will then
4764 be determined from the minimal symbol table whenever
4765 the variable is referenced. */
4766 if (SYMBOL_VALUE_ADDRESS (sym
))
4768 fixup_symbol_section (sym
, objfile
);
4769 SYMBOL_VALUE_ADDRESS (sym
) +=
4770 ANOFFSET (objfile
->section_offsets
,
4771 SYMBOL_SECTION (sym
));
4772 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4775 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4779 /* Support the .debug_loc offsets */
4780 if (attr_form_is_block (attr
))
4782 SYMBOL_VALUE (sym
) = addr
=
4783 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4785 else if (attr
->form
== DW_FORM_data4
4786 || attr
->form
== DW_FORM_data8
)
4788 complain (&dwarf2_complex_location_expr
);
4792 complain (&dwarf2_invalid_attrib_class
, "DW_AT_location",
4793 "external variable");
4796 add_symbol_to_list (sym
, list_in_scope
);
4799 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
4803 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
4804 SYMBOL_VALUE (sym
) =
4805 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4809 SYMBOL_CLASS (sym
) = LOC_BASEREG
;
4810 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4814 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
4818 fixup_symbol_section (sym
, objfile
);
4819 SYMBOL_VALUE_ADDRESS (sym
) =
4820 addr
+ ANOFFSET (objfile
->section_offsets
,
4821 SYMBOL_SECTION (sym
));
4822 SYMBOL_CLASS (sym
) = LOC_STATIC
;
4828 /* We do not know the address of this symbol.
4829 If it is an external symbol and we have type information
4830 for it, enter the symbol as a LOC_UNRESOLVED symbol.
4831 The address of the variable will then be determined from
4832 the minimal symbol table whenever the variable is
4834 attr2
= dwarf_attr (die
, DW_AT_external
);
4835 if (attr2
&& (DW_UNSND (attr2
) != 0)
4836 && dwarf_attr (die
, DW_AT_type
) != NULL
)
4838 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
4839 add_symbol_to_list (sym
, &global_symbols
);
4843 case DW_TAG_formal_parameter
:
4844 attr
= dwarf_attr (die
, DW_AT_location
);
4847 SYMBOL_VALUE (sym
) =
4848 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
4851 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
4852 SYMBOL_VALUE (sym
) =
4853 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym
));
4859 if (basereg
!= frame_base_reg
)
4860 complain (&dwarf2_complex_location_expr
);
4861 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
4865 SYMBOL_CLASS (sym
) = LOC_BASEREG_ARG
;
4866 SYMBOL_BASEREG (sym
) = DWARF2_REG_TO_REGNUM (basereg
);
4871 SYMBOL_CLASS (sym
) = LOC_ARG
;
4874 attr
= dwarf_attr (die
, DW_AT_const_value
);
4877 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4879 add_symbol_to_list (sym
, list_in_scope
);
4881 case DW_TAG_unspecified_parameters
:
4882 /* From varargs functions; gdb doesn't seem to have any
4883 interest in this information, so just ignore it for now.
4886 case DW_TAG_class_type
:
4887 case DW_TAG_structure_type
:
4888 case DW_TAG_union_type
:
4889 case DW_TAG_enumeration_type
:
4890 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4891 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
4892 add_symbol_to_list (sym
, list_in_scope
);
4894 /* The semantics of C++ state that "struct foo { ... }" also
4895 defines a typedef for "foo". Synthesize a typedef symbol so
4896 that "ptype foo" works as expected. */
4897 if (cu_language
== language_cplus
)
4899 struct symbol
*typedef_sym
= (struct symbol
*)
4900 obstack_alloc (&objfile
->symbol_obstack
,
4901 sizeof (struct symbol
));
4902 *typedef_sym
= *sym
;
4903 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
4904 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
4905 TYPE_NAME (SYMBOL_TYPE (sym
)) =
4906 obsavestring (SYMBOL_NAME (sym
),
4907 strlen (SYMBOL_NAME (sym
)),
4908 &objfile
->type_obstack
);
4909 add_symbol_to_list (typedef_sym
, list_in_scope
);
4912 case DW_TAG_typedef
:
4913 case DW_TAG_base_type
:
4914 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
4915 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4916 add_symbol_to_list (sym
, list_in_scope
);
4918 case DW_TAG_enumerator
:
4919 attr
= dwarf_attr (die
, DW_AT_const_value
);
4922 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
4924 add_symbol_to_list (sym
, list_in_scope
);
4927 /* Not a tag we recognize. Hopefully we aren't processing
4928 trash data, but since we must specifically ignore things
4929 we don't recognize, there is nothing else we should do at
4931 complain (&dwarf2_unsupported_tag
, dwarf_tag_name (die
->tag
));
4938 /* Copy constant value from an attribute to a symbol. */
4941 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
4942 struct objfile
*objfile
,
4943 const struct comp_unit_head
*cu_header
)
4945 struct dwarf_block
*blk
;
4950 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
4951 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4952 cu_header
->addr_size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4953 SYMBOL_VALUE_BYTES (sym
) = (char *)
4954 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
4955 store_address (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
4957 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4959 case DW_FORM_block1
:
4960 case DW_FORM_block2
:
4961 case DW_FORM_block4
:
4963 blk
= DW_BLOCK (attr
);
4964 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
4965 complain (&dwarf2_const_value_length_mismatch
, SYMBOL_NAME (sym
),
4966 blk
->size
, TYPE_LENGTH (SYMBOL_TYPE (sym
)));
4967 SYMBOL_VALUE_BYTES (sym
) = (char *)
4968 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
4969 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
4970 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
4973 /* The DW_AT_const_value attributes are supposed to carry the
4974 symbol's value "represented as it would be on the target
4975 architecture." By the time we get here, it's already been
4976 converted to host endianness, so we just need to sign- or
4977 zero-extend it as appropriate. */
4979 dwarf2_const_value_data (attr
, sym
, 8);
4982 dwarf2_const_value_data (attr
, sym
, 16);
4985 dwarf2_const_value_data (attr
, sym
, 32);
4988 dwarf2_const_value_data (attr
, sym
, 64);
4992 SYMBOL_VALUE (sym
) = DW_SND (attr
);
4993 SYMBOL_CLASS (sym
) = LOC_CONST
;
4997 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
4998 SYMBOL_CLASS (sym
) = LOC_CONST
;
5002 complain (&dwarf2_unsupported_const_value_attr
,
5003 dwarf_form_name (attr
->form
));
5004 SYMBOL_VALUE (sym
) = 0;
5005 SYMBOL_CLASS (sym
) = LOC_CONST
;
5011 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5012 or zero-extend it as appropriate for the symbol's type. */
5014 dwarf2_const_value_data (struct attribute
*attr
,
5018 LONGEST l
= DW_UNSND (attr
);
5020 if (bits
< sizeof (l
) * 8)
5022 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5023 l
&= ((LONGEST
) 1 << bits
) - 1;
5025 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5028 SYMBOL_VALUE (sym
) = l
;
5029 SYMBOL_CLASS (sym
) = LOC_CONST
;
5033 /* Return the type of the die in question using its DW_AT_type attribute. */
5035 static struct type
*
5036 die_type (struct die_info
*die
, struct objfile
*objfile
,
5037 const struct comp_unit_head
*cu_header
)
5040 struct attribute
*type_attr
;
5041 struct die_info
*type_die
;
5044 type_attr
= dwarf_attr (die
, DW_AT_type
);
5047 /* A missing DW_AT_type represents a void type. */
5048 return dwarf2_fundamental_type (objfile
, FT_VOID
);
5052 ref
= dwarf2_get_ref_die_offset (type_attr
);
5053 type_die
= follow_die_ref (ref
);
5056 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5060 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5063 dump_die (type_die
);
5064 error ("Dwarf Error: Problem turning type die at offset into gdb type.");
5069 /* Return the containing type of the die in question using its
5070 DW_AT_containing_type attribute. */
5072 static struct type
*
5073 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
5074 const struct comp_unit_head
*cu_header
)
5076 struct type
*type
= NULL
;
5077 struct attribute
*type_attr
;
5078 struct die_info
*type_die
= NULL
;
5081 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5084 ref
= dwarf2_get_ref_die_offset (type_attr
);
5085 type_die
= follow_die_ref (ref
);
5088 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5091 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5096 dump_die (type_die
);
5097 error ("Dwarf Error: Problem turning containing type into gdb type.");
5103 static struct type
*
5104 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
5106 struct die_info
*die
;
5109 die
= follow_die_ref (offset
);
5112 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5115 type
= tag_type_to_type (die
, objfile
);
5120 static struct type
*
5121 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
5122 const struct comp_unit_head
*cu_header
)
5130 read_type_die (die
, objfile
, cu_header
);
5134 error ("Dwarf Error: Cannot find type of die.");
5141 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
5142 const struct comp_unit_head
*cu_header
)
5146 case DW_TAG_class_type
:
5147 case DW_TAG_structure_type
:
5148 case DW_TAG_union_type
:
5149 read_structure_scope (die
, objfile
, cu_header
);
5151 case DW_TAG_enumeration_type
:
5152 read_enumeration (die
, objfile
, cu_header
);
5154 case DW_TAG_subprogram
:
5155 case DW_TAG_subroutine_type
:
5156 read_subroutine_type (die
, objfile
, cu_header
);
5158 case DW_TAG_array_type
:
5159 read_array_type (die
, objfile
, cu_header
);
5161 case DW_TAG_pointer_type
:
5162 read_tag_pointer_type (die
, objfile
, cu_header
);
5164 case DW_TAG_ptr_to_member_type
:
5165 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
5167 case DW_TAG_reference_type
:
5168 read_tag_reference_type (die
, objfile
, cu_header
);
5170 case DW_TAG_const_type
:
5171 read_tag_const_type (die
, objfile
, cu_header
);
5173 case DW_TAG_volatile_type
:
5174 read_tag_volatile_type (die
, objfile
, cu_header
);
5176 case DW_TAG_string_type
:
5177 read_tag_string_type (die
, objfile
);
5179 case DW_TAG_typedef
:
5180 read_typedef (die
, objfile
, cu_header
);
5182 case DW_TAG_base_type
:
5183 read_base_type (die
, objfile
);
5186 complain (&dwarf2_unexpected_tag
, dwarf_tag_name (die
->tag
));
5191 static struct type
*
5192 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
5194 /* FIXME - this should not produce a new (struct type *)
5195 every time. It should cache base types. */
5199 case DW_ATE_address
:
5200 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5202 case DW_ATE_boolean
:
5203 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5205 case DW_ATE_complex_float
:
5208 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5212 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5218 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5222 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5229 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5232 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5236 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5240 case DW_ATE_signed_char
:
5241 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5243 case DW_ATE_unsigned
:
5247 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5250 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5254 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5258 case DW_ATE_unsigned_char
:
5259 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5262 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5269 copy_die (struct die_info
*old_die
)
5271 struct die_info
*new_die
;
5274 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5275 memset (new_die
, 0, sizeof (struct die_info
));
5277 new_die
->tag
= old_die
->tag
;
5278 new_die
->has_children
= old_die
->has_children
;
5279 new_die
->abbrev
= old_die
->abbrev
;
5280 new_die
->offset
= old_die
->offset
;
5281 new_die
->type
= NULL
;
5283 num_attrs
= old_die
->num_attrs
;
5284 new_die
->num_attrs
= num_attrs
;
5285 new_die
->attrs
= (struct attribute
*)
5286 xmalloc (num_attrs
* sizeof (struct attribute
));
5288 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5290 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5291 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5292 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5295 new_die
->next
= NULL
;
5300 /* Return sibling of die, NULL if no sibling. */
5302 static struct die_info
*
5303 sibling_die (struct die_info
*die
)
5305 int nesting_level
= 0;
5307 if (!die
->has_children
)
5309 if (die
->next
&& (die
->next
->tag
== 0))
5322 if (die
->has_children
)
5332 while (nesting_level
);
5333 if (die
&& (die
->tag
== 0))
5344 /* Get linkage name of a die, return NULL if not found. */
5347 dwarf2_linkage_name (struct die_info
*die
)
5349 struct attribute
*attr
;
5351 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5352 if (attr
&& DW_STRING (attr
))
5353 return DW_STRING (attr
);
5354 attr
= dwarf_attr (die
, DW_AT_name
);
5355 if (attr
&& DW_STRING (attr
))
5356 return DW_STRING (attr
);
5360 /* Convert a DIE tag into its string name. */
5363 dwarf_tag_name (register unsigned tag
)
5367 case DW_TAG_padding
:
5368 return "DW_TAG_padding";
5369 case DW_TAG_array_type
:
5370 return "DW_TAG_array_type";
5371 case DW_TAG_class_type
:
5372 return "DW_TAG_class_type";
5373 case DW_TAG_entry_point
:
5374 return "DW_TAG_entry_point";
5375 case DW_TAG_enumeration_type
:
5376 return "DW_TAG_enumeration_type";
5377 case DW_TAG_formal_parameter
:
5378 return "DW_TAG_formal_parameter";
5379 case DW_TAG_imported_declaration
:
5380 return "DW_TAG_imported_declaration";
5382 return "DW_TAG_label";
5383 case DW_TAG_lexical_block
:
5384 return "DW_TAG_lexical_block";
5386 return "DW_TAG_member";
5387 case DW_TAG_pointer_type
:
5388 return "DW_TAG_pointer_type";
5389 case DW_TAG_reference_type
:
5390 return "DW_TAG_reference_type";
5391 case DW_TAG_compile_unit
:
5392 return "DW_TAG_compile_unit";
5393 case DW_TAG_string_type
:
5394 return "DW_TAG_string_type";
5395 case DW_TAG_structure_type
:
5396 return "DW_TAG_structure_type";
5397 case DW_TAG_subroutine_type
:
5398 return "DW_TAG_subroutine_type";
5399 case DW_TAG_typedef
:
5400 return "DW_TAG_typedef";
5401 case DW_TAG_union_type
:
5402 return "DW_TAG_union_type";
5403 case DW_TAG_unspecified_parameters
:
5404 return "DW_TAG_unspecified_parameters";
5405 case DW_TAG_variant
:
5406 return "DW_TAG_variant";
5407 case DW_TAG_common_block
:
5408 return "DW_TAG_common_block";
5409 case DW_TAG_common_inclusion
:
5410 return "DW_TAG_common_inclusion";
5411 case DW_TAG_inheritance
:
5412 return "DW_TAG_inheritance";
5413 case DW_TAG_inlined_subroutine
:
5414 return "DW_TAG_inlined_subroutine";
5416 return "DW_TAG_module";
5417 case DW_TAG_ptr_to_member_type
:
5418 return "DW_TAG_ptr_to_member_type";
5419 case DW_TAG_set_type
:
5420 return "DW_TAG_set_type";
5421 case DW_TAG_subrange_type
:
5422 return "DW_TAG_subrange_type";
5423 case DW_TAG_with_stmt
:
5424 return "DW_TAG_with_stmt";
5425 case DW_TAG_access_declaration
:
5426 return "DW_TAG_access_declaration";
5427 case DW_TAG_base_type
:
5428 return "DW_TAG_base_type";
5429 case DW_TAG_catch_block
:
5430 return "DW_TAG_catch_block";
5431 case DW_TAG_const_type
:
5432 return "DW_TAG_const_type";
5433 case DW_TAG_constant
:
5434 return "DW_TAG_constant";
5435 case DW_TAG_enumerator
:
5436 return "DW_TAG_enumerator";
5437 case DW_TAG_file_type
:
5438 return "DW_TAG_file_type";
5440 return "DW_TAG_friend";
5441 case DW_TAG_namelist
:
5442 return "DW_TAG_namelist";
5443 case DW_TAG_namelist_item
:
5444 return "DW_TAG_namelist_item";
5445 case DW_TAG_packed_type
:
5446 return "DW_TAG_packed_type";
5447 case DW_TAG_subprogram
:
5448 return "DW_TAG_subprogram";
5449 case DW_TAG_template_type_param
:
5450 return "DW_TAG_template_type_param";
5451 case DW_TAG_template_value_param
:
5452 return "DW_TAG_template_value_param";
5453 case DW_TAG_thrown_type
:
5454 return "DW_TAG_thrown_type";
5455 case DW_TAG_try_block
:
5456 return "DW_TAG_try_block";
5457 case DW_TAG_variant_part
:
5458 return "DW_TAG_variant_part";
5459 case DW_TAG_variable
:
5460 return "DW_TAG_variable";
5461 case DW_TAG_volatile_type
:
5462 return "DW_TAG_volatile_type";
5463 case DW_TAG_MIPS_loop
:
5464 return "DW_TAG_MIPS_loop";
5465 case DW_TAG_format_label
:
5466 return "DW_TAG_format_label";
5467 case DW_TAG_function_template
:
5468 return "DW_TAG_function_template";
5469 case DW_TAG_class_template
:
5470 return "DW_TAG_class_template";
5472 return "DW_TAG_<unknown>";
5476 /* Convert a DWARF attribute code into its string name. */
5479 dwarf_attr_name (register unsigned attr
)
5484 return "DW_AT_sibling";
5485 case DW_AT_location
:
5486 return "DW_AT_location";
5488 return "DW_AT_name";
5489 case DW_AT_ordering
:
5490 return "DW_AT_ordering";
5491 case DW_AT_subscr_data
:
5492 return "DW_AT_subscr_data";
5493 case DW_AT_byte_size
:
5494 return "DW_AT_byte_size";
5495 case DW_AT_bit_offset
:
5496 return "DW_AT_bit_offset";
5497 case DW_AT_bit_size
:
5498 return "DW_AT_bit_size";
5499 case DW_AT_element_list
:
5500 return "DW_AT_element_list";
5501 case DW_AT_stmt_list
:
5502 return "DW_AT_stmt_list";
5504 return "DW_AT_low_pc";
5506 return "DW_AT_high_pc";
5507 case DW_AT_language
:
5508 return "DW_AT_language";
5510 return "DW_AT_member";
5512 return "DW_AT_discr";
5513 case DW_AT_discr_value
:
5514 return "DW_AT_discr_value";
5515 case DW_AT_visibility
:
5516 return "DW_AT_visibility";
5518 return "DW_AT_import";
5519 case DW_AT_string_length
:
5520 return "DW_AT_string_length";
5521 case DW_AT_common_reference
:
5522 return "DW_AT_common_reference";
5523 case DW_AT_comp_dir
:
5524 return "DW_AT_comp_dir";
5525 case DW_AT_const_value
:
5526 return "DW_AT_const_value";
5527 case DW_AT_containing_type
:
5528 return "DW_AT_containing_type";
5529 case DW_AT_default_value
:
5530 return "DW_AT_default_value";
5532 return "DW_AT_inline";
5533 case DW_AT_is_optional
:
5534 return "DW_AT_is_optional";
5535 case DW_AT_lower_bound
:
5536 return "DW_AT_lower_bound";
5537 case DW_AT_producer
:
5538 return "DW_AT_producer";
5539 case DW_AT_prototyped
:
5540 return "DW_AT_prototyped";
5541 case DW_AT_return_addr
:
5542 return "DW_AT_return_addr";
5543 case DW_AT_start_scope
:
5544 return "DW_AT_start_scope";
5545 case DW_AT_stride_size
:
5546 return "DW_AT_stride_size";
5547 case DW_AT_upper_bound
:
5548 return "DW_AT_upper_bound";
5549 case DW_AT_abstract_origin
:
5550 return "DW_AT_abstract_origin";
5551 case DW_AT_accessibility
:
5552 return "DW_AT_accessibility";
5553 case DW_AT_address_class
:
5554 return "DW_AT_address_class";
5555 case DW_AT_artificial
:
5556 return "DW_AT_artificial";
5557 case DW_AT_base_types
:
5558 return "DW_AT_base_types";
5559 case DW_AT_calling_convention
:
5560 return "DW_AT_calling_convention";
5562 return "DW_AT_count";
5563 case DW_AT_data_member_location
:
5564 return "DW_AT_data_member_location";
5565 case DW_AT_decl_column
:
5566 return "DW_AT_decl_column";
5567 case DW_AT_decl_file
:
5568 return "DW_AT_decl_file";
5569 case DW_AT_decl_line
:
5570 return "DW_AT_decl_line";
5571 case DW_AT_declaration
:
5572 return "DW_AT_declaration";
5573 case DW_AT_discr_list
:
5574 return "DW_AT_discr_list";
5575 case DW_AT_encoding
:
5576 return "DW_AT_encoding";
5577 case DW_AT_external
:
5578 return "DW_AT_external";
5579 case DW_AT_frame_base
:
5580 return "DW_AT_frame_base";
5582 return "DW_AT_friend";
5583 case DW_AT_identifier_case
:
5584 return "DW_AT_identifier_case";
5585 case DW_AT_macro_info
:
5586 return "DW_AT_macro_info";
5587 case DW_AT_namelist_items
:
5588 return "DW_AT_namelist_items";
5589 case DW_AT_priority
:
5590 return "DW_AT_priority";
5592 return "DW_AT_segment";
5593 case DW_AT_specification
:
5594 return "DW_AT_specification";
5595 case DW_AT_static_link
:
5596 return "DW_AT_static_link";
5598 return "DW_AT_type";
5599 case DW_AT_use_location
:
5600 return "DW_AT_use_location";
5601 case DW_AT_variable_parameter
:
5602 return "DW_AT_variable_parameter";
5603 case DW_AT_virtuality
:
5604 return "DW_AT_virtuality";
5605 case DW_AT_vtable_elem_location
:
5606 return "DW_AT_vtable_elem_location";
5609 case DW_AT_MIPS_fde
:
5610 return "DW_AT_MIPS_fde";
5611 case DW_AT_MIPS_loop_begin
:
5612 return "DW_AT_MIPS_loop_begin";
5613 case DW_AT_MIPS_tail_loop_begin
:
5614 return "DW_AT_MIPS_tail_loop_begin";
5615 case DW_AT_MIPS_epilog_begin
:
5616 return "DW_AT_MIPS_epilog_begin";
5617 case DW_AT_MIPS_loop_unroll_factor
:
5618 return "DW_AT_MIPS_loop_unroll_factor";
5619 case DW_AT_MIPS_software_pipeline_depth
:
5620 return "DW_AT_MIPS_software_pipeline_depth";
5621 case DW_AT_MIPS_linkage_name
:
5622 return "DW_AT_MIPS_linkage_name";
5625 case DW_AT_sf_names
:
5626 return "DW_AT_sf_names";
5627 case DW_AT_src_info
:
5628 return "DW_AT_src_info";
5629 case DW_AT_mac_info
:
5630 return "DW_AT_mac_info";
5631 case DW_AT_src_coords
:
5632 return "DW_AT_src_coords";
5633 case DW_AT_body_begin
:
5634 return "DW_AT_body_begin";
5635 case DW_AT_body_end
:
5636 return "DW_AT_body_end";
5637 case DW_AT_GNU_vector
:
5638 return "DW_AT_GNU_vector";
5640 return "DW_AT_<unknown>";
5644 /* Convert a DWARF value form code into its string name. */
5647 dwarf_form_name (register unsigned form
)
5652 return "DW_FORM_addr";
5653 case DW_FORM_block2
:
5654 return "DW_FORM_block2";
5655 case DW_FORM_block4
:
5656 return "DW_FORM_block4";
5658 return "DW_FORM_data2";
5660 return "DW_FORM_data4";
5662 return "DW_FORM_data8";
5663 case DW_FORM_string
:
5664 return "DW_FORM_string";
5666 return "DW_FORM_block";
5667 case DW_FORM_block1
:
5668 return "DW_FORM_block1";
5670 return "DW_FORM_data1";
5672 return "DW_FORM_flag";
5674 return "DW_FORM_sdata";
5676 return "DW_FORM_strp";
5678 return "DW_FORM_udata";
5679 case DW_FORM_ref_addr
:
5680 return "DW_FORM_ref_addr";
5682 return "DW_FORM_ref1";
5684 return "DW_FORM_ref2";
5686 return "DW_FORM_ref4";
5688 return "DW_FORM_ref8";
5689 case DW_FORM_ref_udata
:
5690 return "DW_FORM_ref_udata";
5691 case DW_FORM_indirect
:
5692 return "DW_FORM_indirect";
5694 return "DW_FORM_<unknown>";
5698 /* Convert a DWARF stack opcode into its string name. */
5701 dwarf_stack_op_name (register unsigned op
)
5706 return "DW_OP_addr";
5708 return "DW_OP_deref";
5710 return "DW_OP_const1u";
5712 return "DW_OP_const1s";
5714 return "DW_OP_const2u";
5716 return "DW_OP_const2s";
5718 return "DW_OP_const4u";
5720 return "DW_OP_const4s";
5722 return "DW_OP_const8u";
5724 return "DW_OP_const8s";
5726 return "DW_OP_constu";
5728 return "DW_OP_consts";
5732 return "DW_OP_drop";
5734 return "DW_OP_over";
5736 return "DW_OP_pick";
5738 return "DW_OP_swap";
5742 return "DW_OP_xderef";
5750 return "DW_OP_minus";
5762 return "DW_OP_plus";
5763 case DW_OP_plus_uconst
:
5764 return "DW_OP_plus_uconst";
5770 return "DW_OP_shra";
5788 return "DW_OP_skip";
5790 return "DW_OP_lit0";
5792 return "DW_OP_lit1";
5794 return "DW_OP_lit2";
5796 return "DW_OP_lit3";
5798 return "DW_OP_lit4";
5800 return "DW_OP_lit5";
5802 return "DW_OP_lit6";
5804 return "DW_OP_lit7";
5806 return "DW_OP_lit8";
5808 return "DW_OP_lit9";
5810 return "DW_OP_lit10";
5812 return "DW_OP_lit11";
5814 return "DW_OP_lit12";
5816 return "DW_OP_lit13";
5818 return "DW_OP_lit14";
5820 return "DW_OP_lit15";
5822 return "DW_OP_lit16";
5824 return "DW_OP_lit17";
5826 return "DW_OP_lit18";
5828 return "DW_OP_lit19";
5830 return "DW_OP_lit20";
5832 return "DW_OP_lit21";
5834 return "DW_OP_lit22";
5836 return "DW_OP_lit23";
5838 return "DW_OP_lit24";
5840 return "DW_OP_lit25";
5842 return "DW_OP_lit26";
5844 return "DW_OP_lit27";
5846 return "DW_OP_lit28";
5848 return "DW_OP_lit29";
5850 return "DW_OP_lit30";
5852 return "DW_OP_lit31";
5854 return "DW_OP_reg0";
5856 return "DW_OP_reg1";
5858 return "DW_OP_reg2";
5860 return "DW_OP_reg3";
5862 return "DW_OP_reg4";
5864 return "DW_OP_reg5";
5866 return "DW_OP_reg6";
5868 return "DW_OP_reg7";
5870 return "DW_OP_reg8";
5872 return "DW_OP_reg9";
5874 return "DW_OP_reg10";
5876 return "DW_OP_reg11";
5878 return "DW_OP_reg12";
5880 return "DW_OP_reg13";
5882 return "DW_OP_reg14";
5884 return "DW_OP_reg15";
5886 return "DW_OP_reg16";
5888 return "DW_OP_reg17";
5890 return "DW_OP_reg18";
5892 return "DW_OP_reg19";
5894 return "DW_OP_reg20";
5896 return "DW_OP_reg21";
5898 return "DW_OP_reg22";
5900 return "DW_OP_reg23";
5902 return "DW_OP_reg24";
5904 return "DW_OP_reg25";
5906 return "DW_OP_reg26";
5908 return "DW_OP_reg27";
5910 return "DW_OP_reg28";
5912 return "DW_OP_reg29";
5914 return "DW_OP_reg30";
5916 return "DW_OP_reg31";
5918 return "DW_OP_breg0";
5920 return "DW_OP_breg1";
5922 return "DW_OP_breg2";
5924 return "DW_OP_breg3";
5926 return "DW_OP_breg4";
5928 return "DW_OP_breg5";
5930 return "DW_OP_breg6";
5932 return "DW_OP_breg7";
5934 return "DW_OP_breg8";
5936 return "DW_OP_breg9";
5938 return "DW_OP_breg10";
5940 return "DW_OP_breg11";
5942 return "DW_OP_breg12";
5944 return "DW_OP_breg13";
5946 return "DW_OP_breg14";
5948 return "DW_OP_breg15";
5950 return "DW_OP_breg16";
5952 return "DW_OP_breg17";
5954 return "DW_OP_breg18";
5956 return "DW_OP_breg19";
5958 return "DW_OP_breg20";
5960 return "DW_OP_breg21";
5962 return "DW_OP_breg22";
5964 return "DW_OP_breg23";
5966 return "DW_OP_breg24";
5968 return "DW_OP_breg25";
5970 return "DW_OP_breg26";
5972 return "DW_OP_breg27";
5974 return "DW_OP_breg28";
5976 return "DW_OP_breg29";
5978 return "DW_OP_breg30";
5980 return "DW_OP_breg31";
5982 return "DW_OP_regx";
5984 return "DW_OP_fbreg";
5986 return "DW_OP_bregx";
5988 return "DW_OP_piece";
5989 case DW_OP_deref_size
:
5990 return "DW_OP_deref_size";
5991 case DW_OP_xderef_size
:
5992 return "DW_OP_xderef_size";
5995 /* DWARF 3 extensions. */
5996 case DW_OP_push_object_address
:
5997 return "DW_OP_push_object_address";
5999 return "DW_OP_call2";
6001 return "DW_OP_call4";
6002 case DW_OP_call_ref
:
6003 return "DW_OP_call_ref";
6004 /* GNU extensions. */
6005 case DW_OP_GNU_push_tls_address
:
6006 return "DW_OP_GNU_push_tls_address";
6008 return "OP_<unknown>";
6013 dwarf_bool_name (unsigned mybool
)
6021 /* Convert a DWARF type code into its string name. */
6024 dwarf_type_encoding_name (register unsigned enc
)
6028 case DW_ATE_address
:
6029 return "DW_ATE_address";
6030 case DW_ATE_boolean
:
6031 return "DW_ATE_boolean";
6032 case DW_ATE_complex_float
:
6033 return "DW_ATE_complex_float";
6035 return "DW_ATE_float";
6037 return "DW_ATE_signed";
6038 case DW_ATE_signed_char
:
6039 return "DW_ATE_signed_char";
6040 case DW_ATE_unsigned
:
6041 return "DW_ATE_unsigned";
6042 case DW_ATE_unsigned_char
:
6043 return "DW_ATE_unsigned_char";
6045 return "DW_ATE_<unknown>";
6049 /* Convert a DWARF call frame info operation to its string name. */
6053 dwarf_cfi_name (register unsigned cfi_opc
)
6057 case DW_CFA_advance_loc
:
6058 return "DW_CFA_advance_loc";
6060 return "DW_CFA_offset";
6061 case DW_CFA_restore
:
6062 return "DW_CFA_restore";
6064 return "DW_CFA_nop";
6065 case DW_CFA_set_loc
:
6066 return "DW_CFA_set_loc";
6067 case DW_CFA_advance_loc1
:
6068 return "DW_CFA_advance_loc1";
6069 case DW_CFA_advance_loc2
:
6070 return "DW_CFA_advance_loc2";
6071 case DW_CFA_advance_loc4
:
6072 return "DW_CFA_advance_loc4";
6073 case DW_CFA_offset_extended
:
6074 return "DW_CFA_offset_extended";
6075 case DW_CFA_restore_extended
:
6076 return "DW_CFA_restore_extended";
6077 case DW_CFA_undefined
:
6078 return "DW_CFA_undefined";
6079 case DW_CFA_same_value
:
6080 return "DW_CFA_same_value";
6081 case DW_CFA_register
:
6082 return "DW_CFA_register";
6083 case DW_CFA_remember_state
:
6084 return "DW_CFA_remember_state";
6085 case DW_CFA_restore_state
:
6086 return "DW_CFA_restore_state";
6087 case DW_CFA_def_cfa
:
6088 return "DW_CFA_def_cfa";
6089 case DW_CFA_def_cfa_register
:
6090 return "DW_CFA_def_cfa_register";
6091 case DW_CFA_def_cfa_offset
:
6092 return "DW_CFA_def_cfa_offset";
6095 case DW_CFA_def_cfa_expression
:
6096 return "DW_CFA_def_cfa_expression";
6097 case DW_CFA_expression
:
6098 return "DW_CFA_expression";
6099 case DW_CFA_offset_extended_sf
:
6100 return "DW_CFA_offset_extended_sf";
6101 case DW_CFA_def_cfa_sf
:
6102 return "DW_CFA_def_cfa_sf";
6103 case DW_CFA_def_cfa_offset_sf
:
6104 return "DW_CFA_def_cfa_offset_sf";
6106 /* SGI/MIPS specific */
6107 case DW_CFA_MIPS_advance_loc8
:
6108 return "DW_CFA_MIPS_advance_loc8";
6110 /* GNU extensions */
6111 case DW_CFA_GNU_window_save
:
6112 return "DW_CFA_GNU_window_save";
6113 case DW_CFA_GNU_args_size
:
6114 return "DW_CFA_GNU_args_size";
6115 case DW_CFA_GNU_negative_offset_extended
:
6116 return "DW_CFA_GNU_negative_offset_extended";
6119 return "DW_CFA_<unknown>";
6125 dump_die (struct die_info
*die
)
6129 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6130 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6131 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6132 dwarf_bool_name (die
->has_children
));
6134 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6135 for (i
= 0; i
< die
->num_attrs
; ++i
)
6137 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6138 dwarf_attr_name (die
->attrs
[i
].name
),
6139 dwarf_form_name (die
->attrs
[i
].form
));
6140 switch (die
->attrs
[i
].form
)
6142 case DW_FORM_ref_addr
:
6144 fprintf_unfiltered (gdb_stderr
, "address: ");
6145 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6147 case DW_FORM_block2
:
6148 case DW_FORM_block4
:
6150 case DW_FORM_block1
:
6151 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6162 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6164 case DW_FORM_string
:
6166 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6167 DW_STRING (&die
->attrs
[i
])
6168 ? DW_STRING (&die
->attrs
[i
]) : "");
6171 if (DW_UNSND (&die
->attrs
[i
]))
6172 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6174 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6176 case DW_FORM_indirect
:
6177 /* the reader will have reduced the indirect form to
6178 the "base form" so this form should not occur */
6179 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6182 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6183 die
->attrs
[i
].form
);
6185 fprintf_unfiltered (gdb_stderr
, "\n");
6190 dump_die_list (struct die_info
*die
)
6200 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6203 struct die_info
*old
;
6205 h
= (offset
% REF_HASH_SIZE
);
6206 old
= die_ref_table
[h
];
6207 die
->next_ref
= old
;
6208 die_ref_table
[h
] = die
;
6213 dwarf2_empty_hash_tables (void)
6215 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6219 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6221 unsigned int result
= 0;
6225 case DW_FORM_ref_addr
:
6226 result
= DW_ADDR (attr
);
6232 case DW_FORM_ref_udata
:
6233 result
= cu_header_offset
+ DW_UNSND (attr
);
6236 complain (&dwarf2_unsupported_die_ref_attr
, dwarf_form_name (attr
->form
));
6241 static struct die_info
*
6242 follow_die_ref (unsigned int offset
)
6244 struct die_info
*die
;
6247 h
= (offset
% REF_HASH_SIZE
);
6248 die
= die_ref_table
[h
];
6251 if (die
->offset
== offset
)
6255 die
= die
->next_ref
;
6260 static struct type
*
6261 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6263 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6265 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
6269 /* Look for this particular type in the fundamental type vector. If
6270 one is not found, create and install one appropriate for the
6271 current language and the current target machine. */
6273 if (ftypes
[typeid] == NULL
)
6275 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6278 return (ftypes
[typeid]);
6281 /* Decode simple location descriptions.
6282 Given a pointer to a dwarf block that defines a location, compute
6283 the location and return the value.
6285 FIXME: This is a kludge until we figure out a better
6286 way to handle the location descriptions.
6287 Gdb's design does not mesh well with the DWARF2 notion of a location
6288 computing interpreter, which is a shame because the flexibility goes unused.
6289 FIXME: Implement more operations as necessary.
6291 A location description containing no operations indicates that the
6292 object is optimized out. The global optimized_out flag is set for
6293 those, the return value is meaningless.
6295 When the result is a register number, the global isreg flag is set,
6296 otherwise it is cleared.
6298 When the result is a base register offset, the global offreg flag is set
6299 and the register number is returned in basereg, otherwise it is cleared.
6301 When the DW_OP_fbreg operation is encountered without a corresponding
6302 DW_AT_frame_base attribute, the global islocal flag is set.
6303 Hopefully the machine dependent code knows how to set up a virtual
6304 frame pointer for the local references.
6306 Note that stack[0] is unused except as a default error return.
6307 Note that stack overflow is not yet handled. */
6310 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
6311 const struct comp_unit_head
*cu_header
)
6314 int size
= blk
->size
;
6315 char *data
= blk
->data
;
6316 CORE_ADDR stack
[64];
6318 unsigned int bytes_read
, unsnd
;
6368 stack
[++stacki
] = op
- DW_OP_lit0
;
6404 stack
[++stacki
] = op
- DW_OP_reg0
;
6409 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6411 stack
[++stacki
] = unsnd
;
6447 basereg
= op
- DW_OP_breg0
;
6448 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6454 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6456 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6461 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6463 if (frame_base_reg
>= 0)
6466 basereg
= frame_base_reg
;
6467 stack
[stacki
] += frame_base_offset
;
6471 complain (&dwarf2_missing_at_frame_base
);
6477 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
6478 cu_header
, &bytes_read
);
6483 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
6488 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
6493 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
6498 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
6503 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
6508 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
6513 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
6519 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
6524 stack
[stacki
+ 1] = stack
[stacki
];
6529 stack
[stacki
- 1] += stack
[stacki
];
6533 case DW_OP_plus_uconst
:
6534 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
6539 stack
[stacki
- 1] -= stack
[stacki
];
6545 /* If we're not the last op, then we definitely can't encode
6546 this using GDB's address_class enum. */
6548 complain (&dwarf2_complex_location_expr
);
6552 complain (&dwarf2_unsupported_stack_op
, dwarf_stack_op_name (op
));
6553 return (stack
[stacki
]);
6556 return (stack
[stacki
]);
6559 /* memory allocation interface */
6563 dwarf2_free_tmp_obstack (PTR ignore
)
6565 obstack_free (&dwarf2_tmp_obstack
, NULL
);
6568 static struct dwarf_block
*
6569 dwarf_alloc_block (void)
6571 struct dwarf_block
*blk
;
6573 blk
= (struct dwarf_block
*)
6574 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
6578 static struct abbrev_info
*
6579 dwarf_alloc_abbrev (void)
6581 struct abbrev_info
*abbrev
;
6583 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
6584 memset (abbrev
, 0, sizeof (struct abbrev_info
));
6588 static struct die_info
*
6589 dwarf_alloc_die (void)
6591 struct die_info
*die
;
6593 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6594 memset (die
, 0, sizeof (struct die_info
));
6599 /* Macro support. */
6602 /* Return the full name of file number I in *LH's file name table.
6603 Use COMP_DIR as the name of the current directory of the
6604 compilation. The result is allocated using xmalloc; the caller is
6605 responsible for freeing it. */
6607 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
6609 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6611 if (IS_ABSOLUTE_PATH (fe
->name
))
6612 return xstrdup (fe
->name
);
6620 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6626 dir_len
= strlen (dir
);
6627 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
6628 strcpy (full_name
, dir
);
6629 full_name
[dir_len
] = '/';
6630 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
6634 return xstrdup (fe
->name
);
6639 static struct macro_source_file
*
6640 macro_start_file (int file
, int line
,
6641 struct macro_source_file
*current_file
,
6642 const char *comp_dir
,
6643 struct line_header
*lh
, struct objfile
*objfile
)
6645 /* The full name of this source file. */
6646 char *full_name
= file_full_name (file
, lh
, comp_dir
);
6648 /* We don't create a macro table for this compilation unit
6649 at all until we actually get a filename. */
6650 if (! pending_macros
)
6651 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
6652 objfile
->macro_cache
);
6655 /* If we have no current file, then this must be the start_file
6656 directive for the compilation unit's main source file. */
6657 current_file
= macro_set_main (pending_macros
, full_name
);
6659 current_file
= macro_include (current_file
, line
, full_name
);
6663 return current_file
;
6667 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
6668 followed by a null byte. */
6670 copy_string (const char *buf
, int len
)
6672 char *s
= xmalloc (len
+ 1);
6673 memcpy (s
, buf
, len
);
6681 consume_improper_spaces (const char *p
, const char *body
)
6685 complain (&dwarf2_macro_spaces_in_definition
, body
);
6696 parse_macro_definition (struct macro_source_file
*file
, int line
,
6701 /* The body string takes one of two forms. For object-like macro
6702 definitions, it should be:
6704 <macro name> " " <definition>
6706 For function-like macro definitions, it should be:
6708 <macro name> "() " <definition>
6710 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
6712 Spaces may appear only where explicitly indicated, and in the
6715 The Dwarf 2 spec says that an object-like macro's name is always
6716 followed by a space, but versions of GCC around March 2002 omit
6717 the space when the macro's definition is the empty string.
6719 The Dwarf 2 spec says that there should be no spaces between the
6720 formal arguments in a function-like macro's formal argument list,
6721 but versions of GCC around March 2002 include spaces after the
6725 /* Find the extent of the macro name. The macro name is terminated
6726 by either a space or null character (for an object-like macro) or
6727 an opening paren (for a function-like macro). */
6728 for (p
= body
; *p
; p
++)
6729 if (*p
== ' ' || *p
== '(')
6732 if (*p
== ' ' || *p
== '\0')
6734 /* It's an object-like macro. */
6735 int name_len
= p
- body
;
6736 char *name
= copy_string (body
, name_len
);
6737 const char *replacement
;
6740 replacement
= body
+ name_len
+ 1;
6743 complain (&dwarf2_macro_malformed_definition
, body
);
6744 replacement
= body
+ name_len
;
6747 macro_define_object (file
, line
, name
, replacement
);
6753 /* It's a function-like macro. */
6754 char *name
= copy_string (body
, p
- body
);
6757 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
6761 p
= consume_improper_spaces (p
, body
);
6763 /* Parse the formal argument list. */
6764 while (*p
&& *p
!= ')')
6766 /* Find the extent of the current argument name. */
6767 const char *arg_start
= p
;
6769 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
6772 if (! *p
|| p
== arg_start
)
6773 complain (&dwarf2_macro_malformed_definition
,
6777 /* Make sure argv has room for the new argument. */
6778 if (argc
>= argv_size
)
6781 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
6784 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
6787 p
= consume_improper_spaces (p
, body
);
6789 /* Consume the comma, if present. */
6794 p
= consume_improper_spaces (p
, body
);
6803 /* Perfectly formed definition, no complaints. */
6804 macro_define_function (file
, line
, name
,
6805 argc
, (const char **) argv
,
6807 else if (*p
== '\0')
6809 /* Complain, but do define it. */
6810 complain (&dwarf2_macro_malformed_definition
, body
);
6811 macro_define_function (file
, line
, name
,
6812 argc
, (const char **) argv
,
6816 /* Just complain. */
6817 complain (&dwarf2_macro_malformed_definition
, body
);
6820 /* Just complain. */
6821 complain (&dwarf2_macro_malformed_definition
, body
);
6827 for (i
= 0; i
< argc
; i
++)
6833 complain (&dwarf2_macro_malformed_definition
, body
);
6838 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
6839 char *comp_dir
, bfd
*abfd
,
6840 const struct comp_unit_head
*cu_header
,
6841 struct objfile
*objfile
)
6843 char *mac_ptr
, *mac_end
;
6844 struct macro_source_file
*current_file
= 0;
6846 if (dwarf_macinfo_buffer
== NULL
)
6848 complain (&dwarf2_missing_macinfo_section
);
6852 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
6853 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
6857 enum dwarf_macinfo_record_type macinfo_type
;
6859 /* Do we at least have room for a macinfo type byte? */
6860 if (mac_ptr
>= mac_end
)
6862 complain (&dwarf2_macros_too_long
);
6866 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
6869 switch (macinfo_type
)
6871 /* A zero macinfo type indicates the end of the macro
6876 case DW_MACINFO_define
:
6877 case DW_MACINFO_undef
:
6883 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6884 mac_ptr
+= bytes_read
;
6885 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
6886 mac_ptr
+= bytes_read
;
6889 complain (&dwarf2_macro_outside_file
,
6890 macinfo_type
== DW_MACINFO_define
? "definition" :
6891 macinfo_type
== DW_MACINFO_undef
? "undefinition" :
6892 "something-or-other",
6896 if (macinfo_type
== DW_MACINFO_define
)
6897 parse_macro_definition (current_file
, line
, body
);
6898 else if (macinfo_type
== DW_MACINFO_undef
)
6899 macro_undef (current_file
, line
, body
);
6904 case DW_MACINFO_start_file
:
6909 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6910 mac_ptr
+= bytes_read
;
6911 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6912 mac_ptr
+= bytes_read
;
6914 current_file
= macro_start_file (file
, line
,
6915 current_file
, comp_dir
,
6920 case DW_MACINFO_end_file
:
6922 complain (&dwarf2_macro_unmatched_end_file
);
6925 current_file
= current_file
->included_by
;
6928 enum dwarf_macinfo_record_type next_type
;
6930 /* GCC circa March 2002 doesn't produce the zero
6931 type byte marking the end of the compilation
6932 unit. Complain if it's not there, but exit no
6935 /* Do we at least have room for a macinfo type byte? */
6936 if (mac_ptr
>= mac_end
)
6938 complain (&dwarf2_macros_too_long
);
6942 /* We don't increment mac_ptr here, so this is just
6944 next_type
= read_1_byte (abfd
, mac_ptr
);
6946 complain (&dwarf2_macros_not_terminated
);
6953 case DW_MACINFO_vendor_ext
:
6959 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
6960 mac_ptr
+= bytes_read
;
6961 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
6962 mac_ptr
+= bytes_read
;
6964 /* We don't recognize any vendor extensions. */
6971 /* Check if the attribute's form is a DW_FORM_block*
6972 if so return true else false. */
6974 attr_form_is_block (struct attribute
*attr
)
6976 return (attr
== NULL
? 0 :
6977 attr
->form
== DW_FORM_block1
6978 || attr
->form
== DW_FORM_block2
6979 || attr
->form
== DW_FORM_block4
6980 || attr
->form
== DW_FORM_block
);