1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
10 support in dwarfread.c
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or (at
17 your option) any later version.
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330,
27 Boston, MA 02111-1307, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
42 #include "complaints.h"
44 #include "dwarf2expr.h"
45 #include "dwarf2loc.h"
46 #include "cp-support.h"
49 #include "gdb_string.h"
50 #include "gdb_assert.h"
51 #include <sys/types.h>
53 #ifndef DWARF2_REG_TO_REGNUM
54 #define DWARF2_REG_TO_REGNUM(REG) (REG)
58 /* .debug_info header for a compilation unit
59 Because of alignment constraints, this structure has padding and cannot
60 be mapped directly onto the beginning of the .debug_info section. */
61 typedef struct comp_unit_header
63 unsigned int length
; /* length of the .debug_info
65 unsigned short version
; /* version number -- 2 for DWARF
67 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
68 unsigned char addr_size
; /* byte size of an address -- 4 */
71 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
74 /* .debug_pubnames header
75 Because of alignment constraints, this structure has padding and cannot
76 be mapped directly onto the beginning of the .debug_info section. */
77 typedef struct pubnames_header
79 unsigned int length
; /* length of the .debug_pubnames
81 unsigned char version
; /* version number -- 2 for DWARF
83 unsigned int info_offset
; /* offset into .debug_info section */
84 unsigned int info_size
; /* byte size of .debug_info section
88 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
90 /* .debug_pubnames header
91 Because of alignment constraints, this structure has padding and cannot
92 be mapped directly onto the beginning of the .debug_info section. */
93 typedef struct aranges_header
95 unsigned int length
; /* byte len of the .debug_aranges
97 unsigned short version
; /* version number -- 2 for DWARF
99 unsigned int info_offset
; /* offset into .debug_info section */
100 unsigned char addr_size
; /* byte size of an address */
101 unsigned char seg_size
; /* byte size of segment descriptor */
104 #define _ACTUAL_ARANGES_HEADER_SIZE 12
106 /* .debug_line statement program prologue
107 Because of alignment constraints, this structure has padding and cannot
108 be mapped directly onto the beginning of the .debug_info section. */
109 typedef struct statement_prologue
111 unsigned int total_length
; /* byte length of the statement
113 unsigned short version
; /* version number -- 2 for DWARF
115 unsigned int prologue_length
; /* # bytes between prologue &
117 unsigned char minimum_instruction_length
; /* byte size of
119 unsigned char default_is_stmt
; /* initial value of is_stmt
122 unsigned char line_range
;
123 unsigned char opcode_base
; /* number assigned to first special
125 unsigned char *standard_opcode_lengths
;
129 /* offsets and sizes of debugging sections */
131 static file_ptr dwarf_info_offset
;
132 static file_ptr dwarf_abbrev_offset
;
133 static file_ptr dwarf_line_offset
;
134 static file_ptr dwarf_pubnames_offset
;
135 static file_ptr dwarf_aranges_offset
;
136 static file_ptr dwarf_loc_offset
;
137 static file_ptr dwarf_macinfo_offset
;
138 static file_ptr dwarf_str_offset
;
139 static file_ptr dwarf_ranges_offset
;
140 file_ptr dwarf_frame_offset
;
141 file_ptr dwarf_eh_frame_offset
;
143 static unsigned int dwarf_info_size
;
144 static unsigned int dwarf_abbrev_size
;
145 static unsigned int dwarf_line_size
;
146 static unsigned int dwarf_pubnames_size
;
147 static unsigned int dwarf_aranges_size
;
148 static unsigned int dwarf_loc_size
;
149 static unsigned int dwarf_macinfo_size
;
150 static unsigned int dwarf_str_size
;
151 static unsigned int dwarf_ranges_size
;
152 unsigned int dwarf_frame_size
;
153 unsigned int dwarf_eh_frame_size
;
155 static asection
*dwarf_info_section
;
156 static asection
*dwarf_abbrev_section
;
157 static asection
*dwarf_line_section
;
158 static asection
*dwarf_pubnames_section
;
159 static asection
*dwarf_aranges_section
;
160 static asection
*dwarf_loc_section
;
161 static asection
*dwarf_macinfo_section
;
162 static asection
*dwarf_str_section
;
163 static asection
*dwarf_ranges_section
;
164 asection
*dwarf_frame_section
;
165 asection
*dwarf_eh_frame_section
;
167 /* names of the debugging sections */
169 #define INFO_SECTION ".debug_info"
170 #define ABBREV_SECTION ".debug_abbrev"
171 #define LINE_SECTION ".debug_line"
172 #define PUBNAMES_SECTION ".debug_pubnames"
173 #define ARANGES_SECTION ".debug_aranges"
174 #define LOC_SECTION ".debug_loc"
175 #define MACINFO_SECTION ".debug_macinfo"
176 #define STR_SECTION ".debug_str"
177 #define RANGES_SECTION ".debug_ranges"
178 #define FRAME_SECTION ".debug_frame"
179 #define EH_FRAME_SECTION ".eh_frame"
181 /* local data types */
183 /* We hold several abbreviation tables in memory at the same time. */
184 #ifndef ABBREV_HASH_SIZE
185 #define ABBREV_HASH_SIZE 121
188 /* The data in a compilation unit header, after target2host
189 translation, looks like this. */
190 struct comp_unit_head
192 unsigned long length
;
194 unsigned int abbrev_offset
;
195 unsigned char addr_size
;
196 unsigned char signed_addr_p
;
197 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
198 unsigned int initial_length_size
; /* size of the length field; either
201 /* Offset to the first byte of this compilation unit header in the
202 * .debug_info section, for resolving relative reference dies. */
206 /* Pointer to this compilation unit header in the .debug_info
211 /* Pointer to the first die of this compilatio unit. This will
212 * be the first byte following the compilation unit header. */
216 /* Pointer to the next compilation unit header in the program. */
218 struct comp_unit_head
*next
;
220 /* DWARF abbreviation table associated with this compilation unit */
222 struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
224 /* Base address of this compilation unit. */
226 CORE_ADDR base_address
;
228 /* Non-zero if base_address has been set. */
233 /* Internal state when decoding a particular compilation unit. */
236 /* The objfile containing this compilation unit. */
237 struct objfile
*objfile
;
239 /* The header of the compilation unit.
241 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
242 should be moved to the dwarf2_cu structure; for instance the abbrevs
244 struct comp_unit_head header
;
247 /* The line number information for a compilation unit (found in the
248 .debug_line section) begins with a "statement program header",
249 which contains the following information. */
252 unsigned int total_length
;
253 unsigned short version
;
254 unsigned int header_length
;
255 unsigned char minimum_instruction_length
;
256 unsigned char default_is_stmt
;
258 unsigned char line_range
;
259 unsigned char opcode_base
;
261 /* standard_opcode_lengths[i] is the number of operands for the
262 standard opcode whose value is i. This means that
263 standard_opcode_lengths[0] is unused, and the last meaningful
264 element is standard_opcode_lengths[opcode_base - 1]. */
265 unsigned char *standard_opcode_lengths
;
267 /* The include_directories table. NOTE! These strings are not
268 allocated with xmalloc; instead, they are pointers into
269 debug_line_buffer. If you try to free them, `free' will get
271 unsigned int num_include_dirs
, include_dirs_size
;
274 /* The file_names table. NOTE! These strings are not allocated
275 with xmalloc; instead, they are pointers into debug_line_buffer.
276 Don't try to free them directly. */
277 unsigned int num_file_names
, file_names_size
;
281 unsigned int dir_index
;
282 unsigned int mod_time
;
286 /* The start and end of the statement program following this
287 header. These point into dwarf_line_buffer. */
288 char *statement_program_start
, *statement_program_end
;
291 /* When we construct a partial symbol table entry we only
292 need this much information. */
293 struct partial_die_info
296 unsigned char has_children
;
297 unsigned char is_external
;
298 unsigned char is_declaration
;
299 unsigned char has_type
;
306 struct dwarf_block
*locdesc
;
307 unsigned int language
;
311 /* This data structure holds the information of an abbrev. */
314 unsigned int number
; /* number identifying abbrev */
315 enum dwarf_tag tag
; /* dwarf tag */
316 int has_children
; /* boolean */
317 unsigned int num_attrs
; /* number of attributes */
318 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
319 struct abbrev_info
*next
; /* next in chain */
324 enum dwarf_attribute name
;
325 enum dwarf_form form
;
328 /* This data structure holds a complete die structure. */
331 enum dwarf_tag tag
; /* Tag indicating type of die */
332 unsigned int abbrev
; /* Abbrev number */
333 unsigned int offset
; /* Offset in .debug_info section */
334 unsigned int num_attrs
; /* Number of attributes */
335 struct attribute
*attrs
; /* An array of attributes */
336 struct die_info
*next_ref
; /* Next die in ref hash table */
338 /* The dies in a compilation unit form an n-ary tree. PARENT
339 points to this die's parent; CHILD points to the first child of
340 this node; and all the children of a given node are chained
341 together via their SIBLING fields, terminated by a die whose
343 struct die_info
*child
; /* Its first child, if any. */
344 struct die_info
*sibling
; /* Its next sibling, if any. */
345 struct die_info
*parent
; /* Its parent, if any. */
347 struct type
*type
; /* Cached type information */
350 /* Attributes have a name and a value */
353 enum dwarf_attribute name
;
354 enum dwarf_form form
;
358 struct dwarf_block
*blk
;
366 struct function_range
369 CORE_ADDR lowpc
, highpc
;
371 struct function_range
*next
;
374 static struct function_range
*cu_first_fn
, *cu_last_fn
, *cu_cached_fn
;
376 /* Get at parts of an attribute structure */
378 #define DW_STRING(attr) ((attr)->u.str)
379 #define DW_UNSND(attr) ((attr)->u.unsnd)
380 #define DW_BLOCK(attr) ((attr)->u.blk)
381 #define DW_SND(attr) ((attr)->u.snd)
382 #define DW_ADDR(attr) ((attr)->u.addr)
384 /* Blocks are a bunch of untyped bytes. */
391 #ifndef ATTR_ALLOC_CHUNK
392 #define ATTR_ALLOC_CHUNK 4
395 /* A hash table of die offsets for following references. */
396 #ifndef REF_HASH_SIZE
397 #define REF_HASH_SIZE 1021
400 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
402 /* Obstack for allocating temporary storage used during symbol reading. */
403 static struct obstack dwarf2_tmp_obstack
;
405 /* Offset to the first byte of the current compilation unit header,
406 for resolving relative reference dies. */
407 static unsigned int cu_header_offset
;
409 /* Allocate fields for structs, unions and enums in this size. */
410 #ifndef DW_FIELD_ALLOC_CHUNK
411 #define DW_FIELD_ALLOC_CHUNK 4
414 /* The language we are debugging. */
415 static enum language cu_language
;
416 static const struct language_defn
*cu_language_defn
;
418 /* Actually data from the sections. */
419 static char *dwarf_info_buffer
;
420 static char *dwarf_abbrev_buffer
;
421 static char *dwarf_line_buffer
;
422 static char *dwarf_str_buffer
;
423 static char *dwarf_macinfo_buffer
;
424 static char *dwarf_ranges_buffer
;
425 static char *dwarf_loc_buffer
;
427 /* A zeroed version of a partial die for initialization purposes. */
428 static struct partial_die_info zeroed_partial_die
;
430 /* The generic symbol table building routines have separate lists for
431 file scope symbols and all all other scopes (local scopes). So
432 we need to select the right one to pass to add_symbol_to_list().
433 We do it by keeping a pointer to the correct list in list_in_scope.
435 FIXME: The original dwarf code just treated the file scope as the first
436 local scope, and all other local scopes as nested local scopes, and worked
437 fine. Check to see if we really need to distinguish these
439 static struct pending
**list_in_scope
= &file_symbols
;
441 /* FIXME: decode_locdesc sets these variables to describe the location
442 to the caller. These ought to be a structure or something. If
443 none of the flags are set, the object lives at the address returned
444 by decode_locdesc. */
446 static int optimized_out
; /* No ops in location in expression,
447 so object was optimized out. */
448 static int isreg
; /* Object lives in register.
449 decode_locdesc's return value is
450 the register number. */
451 static int offreg
; /* Object's address is the sum of the
452 register specified by basereg, plus
453 the offset returned. */
454 static int basereg
; /* See `offreg'. */
455 static int isderef
; /* Value described by flags above is
456 the address of a pointer to the object. */
457 static int islocal
; /* Variable is at the returned offset
458 from the frame start, but there's
459 no identified frame pointer for
460 this function, so we can't say
461 which register it's relative to;
464 /* DW_AT_frame_base values for the current function.
465 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
466 contains the register number for the frame register.
467 frame_base_offset is the offset from the frame register to the
468 virtual stack frame. */
469 static int frame_base_reg
;
470 static CORE_ADDR frame_base_offset
;
472 /* This value is added to each symbol value. FIXME: Generalize to
473 the section_offsets structure used by dbxread (once this is done,
474 pass the appropriate section number to end_symtab). */
475 static CORE_ADDR baseaddr
; /* Add to each symbol value */
477 /* We put a pointer to this structure in the read_symtab_private field
479 The complete dwarf information for an objfile is kept in the
480 psymbol_obstack, so that absolute die references can be handled.
481 Most of the information in this structure is related to an entire
482 object file and could be passed via the sym_private field of the objfile.
483 It is however conceivable that dwarf2 might not be the only type
484 of symbols read from an object file. */
488 /* Pointer to start of dwarf info buffer for the objfile. */
490 char *dwarf_info_buffer
;
492 /* Offset in dwarf_info_buffer for this compilation unit. */
494 unsigned long dwarf_info_offset
;
496 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
498 char *dwarf_abbrev_buffer
;
500 /* Size of dwarf abbreviation section for the objfile. */
502 unsigned int dwarf_abbrev_size
;
504 /* Pointer to start of dwarf line buffer for the objfile. */
506 char *dwarf_line_buffer
;
508 /* Size of dwarf_line_buffer, in bytes. */
510 unsigned int dwarf_line_size
;
512 /* Pointer to start of dwarf string buffer for the objfile. */
514 char *dwarf_str_buffer
;
516 /* Size of dwarf string section for the objfile. */
518 unsigned int dwarf_str_size
;
520 /* Pointer to start of dwarf macro buffer for the objfile. */
522 char *dwarf_macinfo_buffer
;
524 /* Size of dwarf macinfo section for the objfile. */
526 unsigned int dwarf_macinfo_size
;
528 /* Pointer to start of dwarf ranges buffer for the objfile. */
530 char *dwarf_ranges_buffer
;
532 /* Size of dwarf ranges buffer for the objfile. */
534 unsigned int dwarf_ranges_size
;
536 /* Pointer to start of dwarf locations buffer for the objfile. */
538 char *dwarf_loc_buffer
;
540 /* Size of dwarf locations buffer for the objfile. */
542 unsigned int dwarf_loc_size
;
545 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
546 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
547 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
548 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
549 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
550 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
551 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
552 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
553 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
554 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
555 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
556 #define DWARF_RANGES_BUFFER(p) (PST_PRIVATE(p)->dwarf_ranges_buffer)
557 #define DWARF_RANGES_SIZE(p) (PST_PRIVATE(p)->dwarf_ranges_size)
558 #define DWARF_LOC_BUFFER(p) (PST_PRIVATE(p)->dwarf_loc_buffer)
559 #define DWARF_LOC_SIZE(p) (PST_PRIVATE(p)->dwarf_loc_size)
561 /* Maintain an array of referenced fundamental types for the current
562 compilation unit being read. For DWARF version 1, we have to construct
563 the fundamental types on the fly, since no information about the
564 fundamental types is supplied. Each such fundamental type is created by
565 calling a language dependent routine to create the type, and then a
566 pointer to that type is then placed in the array at the index specified
567 by it's FT_<TYPENAME> value. The array has a fixed size set by the
568 FT_NUM_MEMBERS compile time constant, which is the number of predefined
569 fundamental types gdb knows how to construct. */
570 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
572 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
573 but this would require a corresponding change in unpack_field_as_long
575 static int bits_per_byte
= 8;
577 /* The routines that read and process dies for a C struct or C++ class
578 pass lists of data member fields and lists of member function fields
579 in an instance of a field_info structure, as defined below. */
582 /* List of data member and baseclasses fields. */
585 struct nextfield
*next
;
592 /* Number of fields. */
595 /* Number of baseclasses. */
598 /* Set if the accesibility of one of the fields is not public. */
599 int non_public_fields
;
601 /* Member function fields array, entries are allocated in the order they
602 are encountered in the object file. */
605 struct nextfnfield
*next
;
606 struct fn_field fnfield
;
610 /* Member function fieldlist array, contains name of possibly overloaded
611 member function, number of overloaded member functions and a pointer
612 to the head of the member function field chain. */
617 struct nextfnfield
*head
;
621 /* Number of entries in the fnfieldlists array. */
625 /* Various complaints about symbol reading that don't abort the process */
628 dwarf2_non_const_array_bound_ignored_complaint (const char *arg1
)
630 complaint (&symfile_complaints
, "non-constant array bounds form '%s' ignored",
635 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
637 complaint (&symfile_complaints
,
638 "statement list doesn't fit in .debug_line section");
642 dwarf2_complex_location_expr_complaint (void)
644 complaint (&symfile_complaints
, "location expression too complex");
648 dwarf2_unsupported_at_frame_base_complaint (const char *arg1
)
650 complaint (&symfile_complaints
,
651 "unsupported DW_AT_frame_base for function '%s'", arg1
);
655 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
658 complaint (&symfile_complaints
,
659 "const value length mismatch for '%s', got %d, expected %d", arg1
,
664 dwarf2_macros_too_long_complaint (void)
666 complaint (&symfile_complaints
,
667 "macro info runs off end of `.debug_macinfo' section");
671 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
673 complaint (&symfile_complaints
,
674 "macro debug info contains a malformed macro definition:\n`%s'",
679 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
681 complaint (&symfile_complaints
,
682 "invalid attribute class or form for '%s' in '%s'", arg1
, arg2
);
685 /* local function prototypes */
687 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
690 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
693 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
695 static char *scan_partial_symbols (char *, CORE_ADDR
*, CORE_ADDR
*,
697 const char *namespace);
699 static void add_partial_symbol (struct partial_die_info
*, struct dwarf2_cu
*,
700 const char *namespace);
702 static char *add_partial_namespace (struct partial_die_info
*pdi
,
704 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
705 struct dwarf2_cu
*cu
,
706 const char *namespace);
708 static char *add_partial_enumeration (struct partial_die_info
*enum_pdi
,
710 struct dwarf2_cu
*cu
,
711 const char *namespace);
713 static char *locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
716 struct dwarf2_cu
*cu
);
718 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
720 static void psymtab_to_symtab_1 (struct partial_symtab
*);
722 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int,
725 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
727 static void dwarf2_empty_abbrev_table (void *);
729 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
732 static char *read_partial_die (struct partial_die_info
*,
733 bfd
*, char *, struct dwarf2_cu
*);
735 static char *read_full_die (struct die_info
**, bfd
*, char *,
736 struct dwarf2_cu
*, int *);
738 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
739 bfd
*, char *, struct dwarf2_cu
*);
741 static char *read_attribute_value (struct attribute
*, unsigned,
742 bfd
*, char *, struct dwarf2_cu
*);
744 static unsigned int read_1_byte (bfd
*, char *);
746 static int read_1_signed_byte (bfd
*, char *);
748 static unsigned int read_2_bytes (bfd
*, char *);
750 static unsigned int read_4_bytes (bfd
*, char *);
752 static unsigned long read_8_bytes (bfd
*, char *);
754 static CORE_ADDR
read_address (bfd
*, char *ptr
, struct dwarf2_cu
*,
757 static LONGEST
read_initial_length (bfd
*, char *,
758 struct comp_unit_head
*, int *bytes_read
);
760 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
763 static char *read_n_bytes (bfd
*, char *, unsigned int);
765 static char *read_string (bfd
*, char *, unsigned int *);
767 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
770 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
772 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
774 static void set_cu_language (unsigned int);
776 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
778 static int die_is_declaration (struct die_info
*);
780 static void free_line_header (struct line_header
*lh
);
782 static struct line_header
*(dwarf_decode_line_header
783 (unsigned int offset
,
784 bfd
*abfd
, struct dwarf2_cu
*cu
));
786 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
789 static void dwarf2_start_subfile (char *, char *);
791 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
794 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
797 static void dwarf2_const_value_data (struct attribute
*attr
,
801 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
803 static struct type
*die_containing_type (struct die_info
*,
807 static struct type
*type_at_offset (unsigned int, struct objfile
*);
810 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
812 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
814 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
816 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
818 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
820 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
822 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
824 static int dwarf2_get_pc_bounds (struct die_info
*,
825 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
827 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
830 static void dwarf2_attach_fields_to_type (struct field_info
*,
831 struct type
*, struct dwarf2_cu
*);
833 static void dwarf2_add_member_fn (struct field_info
*,
834 struct die_info
*, struct type
*,
837 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
838 struct type
*, struct dwarf2_cu
*);
840 static void read_structure_scope (struct die_info
*, struct dwarf2_cu
*);
842 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
844 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
846 static void read_enumeration (struct die_info
*, struct dwarf2_cu
*);
848 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
850 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
852 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
854 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
856 static void read_tag_ptr_to_member_type (struct die_info
*,
859 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
861 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
863 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
865 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
867 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
869 static struct die_info
*read_comp_unit (char *, bfd
*, struct dwarf2_cu
*);
871 static struct die_info
*read_die_and_children (char *info_ptr
, bfd
*abfd
,
874 struct die_info
*parent
);
876 static struct die_info
*read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
879 struct die_info
*parent
);
881 static void free_die_list (struct die_info
*);
883 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
885 static void process_die (struct die_info
*, struct dwarf2_cu
*);
887 static char *dwarf2_linkage_name (struct die_info
*);
889 static char *dwarf2_name (struct die_info
*die
);
891 static struct die_info
*dwarf2_extension (struct die_info
*die
);
893 static char *dwarf_tag_name (unsigned int);
895 static char *dwarf_attr_name (unsigned int);
897 static char *dwarf_form_name (unsigned int);
899 static char *dwarf_stack_op_name (unsigned int);
901 static char *dwarf_bool_name (unsigned int);
903 static char *dwarf_type_encoding_name (unsigned int);
906 static char *dwarf_cfi_name (unsigned int);
908 struct die_info
*copy_die (struct die_info
*);
911 static struct die_info
*sibling_die (struct die_info
*);
913 static void dump_die (struct die_info
*);
915 static void dump_die_list (struct die_info
*);
917 static void store_in_ref_table (unsigned int, struct die_info
*);
919 static void dwarf2_empty_hash_tables (void);
921 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
923 static struct die_info
*follow_die_ref (unsigned int);
925 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
927 /* memory allocation interface */
929 static void dwarf2_free_tmp_obstack (void *);
931 static struct dwarf_block
*dwarf_alloc_block (void);
933 static struct abbrev_info
*dwarf_alloc_abbrev (void);
935 static struct die_info
*dwarf_alloc_die (void);
937 static void initialize_cu_func_list (void);
939 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
941 static void dwarf_decode_macros (struct line_header
*, unsigned int,
942 char *, bfd
*, struct dwarf2_cu
*);
944 static int attr_form_is_block (struct attribute
*);
947 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
948 struct dwarf2_cu
*cu
);
950 /* Try to locate the sections we need for DWARF 2 debugging
951 information and return true if we have enough to do something. */
954 dwarf2_has_info (bfd
*abfd
)
956 dwarf_info_offset
= 0;
957 dwarf_abbrev_offset
= 0;
958 dwarf_line_offset
= 0;
959 dwarf_str_offset
= 0;
960 dwarf_macinfo_offset
= 0;
961 dwarf_frame_offset
= 0;
962 dwarf_eh_frame_offset
= 0;
963 dwarf_ranges_offset
= 0;
964 dwarf_loc_offset
= 0;
966 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
967 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
977 /* This function is mapped across the sections and remembers the
978 offset and size of each of the debugging sections we are interested
982 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
984 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
986 dwarf_info_offset
= sectp
->filepos
;
987 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
988 dwarf_info_section
= sectp
;
990 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
992 dwarf_abbrev_offset
= sectp
->filepos
;
993 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
994 dwarf_abbrev_section
= sectp
;
996 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
998 dwarf_line_offset
= sectp
->filepos
;
999 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
1000 dwarf_line_section
= sectp
;
1002 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1004 dwarf_pubnames_offset
= sectp
->filepos
;
1005 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
1006 dwarf_pubnames_section
= sectp
;
1008 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1010 dwarf_aranges_offset
= sectp
->filepos
;
1011 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
1012 dwarf_aranges_section
= sectp
;
1014 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1016 dwarf_loc_offset
= sectp
->filepos
;
1017 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
1018 dwarf_loc_section
= sectp
;
1020 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1022 dwarf_macinfo_offset
= sectp
->filepos
;
1023 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
1024 dwarf_macinfo_section
= sectp
;
1026 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1028 dwarf_str_offset
= sectp
->filepos
;
1029 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
1030 dwarf_str_section
= sectp
;
1032 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1034 dwarf_frame_offset
= sectp
->filepos
;
1035 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1036 dwarf_frame_section
= sectp
;
1038 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1040 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1041 if (aflag
& SEC_HAS_CONTENTS
)
1043 dwarf_eh_frame_offset
= sectp
->filepos
;
1044 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1045 dwarf_eh_frame_section
= sectp
;
1048 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1050 dwarf_ranges_offset
= sectp
->filepos
;
1051 dwarf_ranges_size
= bfd_get_section_size_before_reloc (sectp
);
1052 dwarf_ranges_section
= sectp
;
1056 /* Build a partial symbol table. */
1059 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1062 /* We definitely need the .debug_info and .debug_abbrev sections */
1064 dwarf_info_buffer
= dwarf2_read_section (objfile
,
1067 dwarf_info_section
);
1068 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
1069 dwarf_abbrev_offset
,
1071 dwarf_abbrev_section
);
1073 if (dwarf_line_offset
)
1074 dwarf_line_buffer
= dwarf2_read_section (objfile
,
1077 dwarf_line_section
);
1079 dwarf_line_buffer
= NULL
;
1081 if (dwarf_str_offset
)
1082 dwarf_str_buffer
= dwarf2_read_section (objfile
,
1087 dwarf_str_buffer
= NULL
;
1089 if (dwarf_macinfo_offset
)
1090 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1091 dwarf_macinfo_offset
,
1093 dwarf_macinfo_section
);
1095 dwarf_macinfo_buffer
= NULL
;
1097 if (dwarf_ranges_offset
)
1098 dwarf_ranges_buffer
= dwarf2_read_section (objfile
,
1099 dwarf_ranges_offset
,
1101 dwarf_ranges_section
);
1103 dwarf_ranges_buffer
= NULL
;
1105 if (dwarf_loc_offset
)
1106 dwarf_loc_buffer
= dwarf2_read_section (objfile
,
1111 dwarf_loc_buffer
= NULL
;
1114 || (objfile
->global_psymbols
.size
== 0
1115 && objfile
->static_psymbols
.size
== 0))
1117 init_psymbol_list (objfile
, 1024);
1121 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1123 /* Things are significantly easier if we have .debug_aranges and
1124 .debug_pubnames sections */
1126 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1130 /* only test this case for now */
1132 /* In this case we have to work a bit harder */
1133 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1138 /* Build the partial symbol table from the information in the
1139 .debug_pubnames and .debug_aranges sections. */
1142 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1144 bfd
*abfd
= objfile
->obfd
;
1145 char *aranges_buffer
, *pubnames_buffer
;
1146 char *aranges_ptr
, *pubnames_ptr
;
1147 unsigned int entry_length
, version
, info_offset
, info_size
;
1149 pubnames_buffer
= dwarf2_read_section (objfile
,
1150 dwarf_pubnames_offset
,
1151 dwarf_pubnames_size
,
1152 dwarf_pubnames_section
);
1153 pubnames_ptr
= pubnames_buffer
;
1154 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1156 struct comp_unit_head cu_header
;
1159 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1161 pubnames_ptr
+= bytes_read
;
1162 version
= read_1_byte (abfd
, pubnames_ptr
);
1164 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1166 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1170 aranges_buffer
= dwarf2_read_section (objfile
,
1171 dwarf_aranges_offset
,
1173 dwarf_aranges_section
);
1178 /* Read in the comp unit header information from the debug_info at
1182 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1183 char *info_ptr
, bfd
*abfd
)
1187 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1189 info_ptr
+= bytes_read
;
1190 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1192 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1194 info_ptr
+= bytes_read
;
1195 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1197 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1198 if (signed_addr
< 0)
1199 internal_error (__FILE__
, __LINE__
,
1200 "read_comp_unit_head: dwarf from non elf file");
1201 cu_header
->signed_addr_p
= signed_addr
;
1205 /* Build the partial symbol table by doing a quick pass through the
1206 .debug_info and .debug_abbrev sections. */
1209 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1211 /* Instead of reading this into a big buffer, we should probably use
1212 mmap() on architectures that support it. (FIXME) */
1213 bfd
*abfd
= objfile
->obfd
;
1214 char *info_ptr
, *abbrev_ptr
;
1215 char *beg_of_comp_unit
;
1216 struct partial_die_info comp_unit_die
;
1217 struct partial_symtab
*pst
;
1218 struct cleanup
*back_to
;
1219 CORE_ADDR lowpc
, highpc
;
1221 info_ptr
= dwarf_info_buffer
;
1222 abbrev_ptr
= dwarf_abbrev_buffer
;
1224 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1225 the partial symbol scan, like attribute values.
1227 We could reduce our peak memory consumption during partial symbol
1228 table construction by freeing stuff from this obstack more often
1229 --- say, after processing each compilation unit, or each die ---
1230 but it turns out that this saves almost nothing. For an
1231 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1232 on dwarf2_tmp_obstack. Some investigation showed:
1234 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1235 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1236 all fixed-length values not requiring dynamic allocation.
1238 2) 30% of the attributes used the form DW_FORM_string. For
1239 DW_FORM_string, read_attribute simply hands back a pointer to
1240 the null-terminated string in dwarf_info_buffer, so no dynamic
1241 allocation is needed there either.
1243 3) The remaining 1% of the attributes all used DW_FORM_block1.
1244 75% of those were DW_AT_frame_base location lists for
1245 functions; the rest were DW_AT_location attributes, probably
1246 for the global variables.
1248 Anyway, what this all means is that the memory the dwarf2
1249 reader uses as temporary space reading partial symbols is about
1250 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1252 obstack_init (&dwarf2_tmp_obstack
);
1253 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1255 /* Since the objects we're extracting from dwarf_info_buffer vary in
1256 length, only the individual functions to extract them (like
1257 read_comp_unit_head and read_partial_die) can really know whether
1258 the buffer is large enough to hold another complete object.
1260 At the moment, they don't actually check that. If
1261 dwarf_info_buffer holds just one extra byte after the last
1262 compilation unit's dies, then read_comp_unit_head will happily
1263 read off the end of the buffer. read_partial_die is similarly
1264 casual. Those functions should be fixed.
1266 For this loop condition, simply checking whether there's any data
1267 left at all should be sufficient. */
1268 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1270 struct dwarf2_cu cu
;
1271 beg_of_comp_unit
= info_ptr
;
1273 cu
.objfile
= objfile
;
1274 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1276 if (cu
.header
.version
!= 2)
1278 error ("Dwarf Error: wrong version in compilation unit header (is %d, should be %d) [in module %s]", cu
.header
.version
, 2, bfd_get_filename (abfd
));
1281 if (cu
.header
.abbrev_offset
>= dwarf_abbrev_size
)
1283 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1284 (long) cu
.header
.abbrev_offset
,
1285 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1286 bfd_get_filename (abfd
));
1289 if (beg_of_comp_unit
+ cu
.header
.length
+ cu
.header
.initial_length_size
1290 > dwarf_info_buffer
+ dwarf_info_size
)
1292 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1293 (long) cu
.header
.length
,
1294 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1295 bfd_get_filename (abfd
));
1298 /* Complete the cu_header */
1299 cu
.header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1300 cu
.header
.first_die_ptr
= info_ptr
;
1301 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1303 /* Read the abbrevs for this compilation unit into a table */
1304 dwarf2_read_abbrevs (abfd
, &cu
);
1305 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1307 /* Read the compilation unit die */
1308 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1311 /* Set the language we're debugging */
1312 set_cu_language (comp_unit_die
.language
);
1314 /* Allocate a new partial symbol table structure */
1315 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1316 comp_unit_die
.name
? comp_unit_die
.name
: "",
1317 comp_unit_die
.lowpc
,
1318 objfile
->global_psymbols
.next
,
1319 objfile
->static_psymbols
.next
);
1321 pst
->read_symtab_private
= (char *)
1322 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1323 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1324 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1325 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1326 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1327 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1328 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1329 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1330 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1331 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1332 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1333 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1334 DWARF_RANGES_BUFFER (pst
) = dwarf_ranges_buffer
;
1335 DWARF_RANGES_SIZE (pst
) = dwarf_ranges_size
;
1336 DWARF_LOC_BUFFER (pst
) = dwarf_loc_buffer
;
1337 DWARF_LOC_SIZE (pst
) = dwarf_loc_size
;
1338 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1340 /* Store the function that reads in the rest of the symbol table */
1341 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1343 /* Check if comp unit has_children.
1344 If so, read the rest of the partial symbols from this comp unit.
1345 If not, there's no more debug_info for this comp unit. */
1346 if (comp_unit_die
.has_children
)
1348 lowpc
= ((CORE_ADDR
) -1);
1349 highpc
= ((CORE_ADDR
) 0);
1351 info_ptr
= scan_partial_symbols (info_ptr
, &lowpc
, &highpc
,
1354 /* If we didn't find a lowpc, set it to highpc to avoid
1355 complaints from `maint check'. */
1356 if (lowpc
== ((CORE_ADDR
) -1))
1359 /* If the compilation unit didn't have an explicit address range,
1360 then use the information extracted from its child dies. */
1361 if (! comp_unit_die
.has_pc_info
)
1363 comp_unit_die
.lowpc
= lowpc
;
1364 comp_unit_die
.highpc
= highpc
;
1367 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1368 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1370 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1371 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1372 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1373 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1374 sort_pst_symbols (pst
);
1376 /* If there is already a psymtab or symtab for a file of this
1377 name, remove it. (If there is a symtab, more drastic things
1378 also happen.) This happens in VxWorks. */
1379 free_named_symtabs (pst
->filename
);
1381 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1382 + cu
.header
.initial_length_size
;
1384 do_cleanups (back_to
);
1387 /* Read in all interesting dies to the end of the compilation unit or
1388 to the end of the current namespace. NAMESPACE is NULL if we
1389 haven't yet encountered any DW_TAG_namespace entries; otherwise,
1390 it's the name of the current namespace. In particular, it's the
1391 empty string if we're currently in the global namespace but have
1392 previously encountered a DW_TAG_namespace. */
1395 scan_partial_symbols (char *info_ptr
, CORE_ADDR
*lowpc
,
1396 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
1397 const char *namespace)
1399 struct objfile
*objfile
= cu
->objfile
;
1400 bfd
*abfd
= objfile
->obfd
;
1401 struct partial_die_info pdi
;
1403 /* Now, march along the PDI's, descending into ones which have
1404 interesting children but skipping the children of the other ones,
1405 until we reach the end of the compilation unit. */
1409 /* This flag tells whether or not info_ptr has gotten updated
1411 int info_ptr_updated
= 0;
1413 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1415 /* Anonymous namespaces have no name but have interesting
1416 children, so we need to look at them. Ditto for anonymous
1419 if (pdi
.name
!= NULL
|| pdi
.tag
== DW_TAG_namespace
1420 || pdi
.tag
== DW_TAG_enumeration_type
)
1424 case DW_TAG_subprogram
:
1425 if (pdi
.has_pc_info
)
1427 if (pdi
.lowpc
< *lowpc
)
1431 if (pdi
.highpc
> *highpc
)
1433 *highpc
= pdi
.highpc
;
1435 if (!pdi
.is_declaration
)
1437 add_partial_symbol (&pdi
, cu
, namespace);
1441 case DW_TAG_variable
:
1442 case DW_TAG_typedef
:
1443 case DW_TAG_union_type
:
1444 case DW_TAG_class_type
:
1445 case DW_TAG_structure_type
:
1446 if (!pdi
.is_declaration
)
1448 add_partial_symbol (&pdi
, cu
, namespace);
1451 case DW_TAG_enumeration_type
:
1452 if (!pdi
.is_declaration
)
1454 info_ptr
= add_partial_enumeration (&pdi
, info_ptr
, cu
,
1456 info_ptr_updated
= 1;
1459 case DW_TAG_base_type
:
1460 /* File scope base type definitions are added to the partial
1462 add_partial_symbol (&pdi
, cu
, namespace);
1464 case DW_TAG_namespace
:
1465 /* We've hit a DW_TAG_namespace entry, so we know this
1466 file has been compiled using a compiler that
1467 generates them; update NAMESPACE to reflect that. */
1468 if (namespace == NULL
)
1470 info_ptr
= add_partial_namespace (&pdi
, info_ptr
, lowpc
, highpc
,
1472 info_ptr_updated
= 1;
1482 /* If the die has a sibling, skip to the sibling, unless another
1483 function has already updated info_ptr for us. */
1485 /* NOTE: carlton/2003-06-16: This is a bit hackish, but whether
1486 or not we want to update this depends on enough stuff (not
1487 only pdi.tag but also whether or not pdi.name is NULL) that
1488 this seems like the easiest way to handle the issue. */
1490 if (!info_ptr_updated
)
1491 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1498 add_partial_symbol (struct partial_die_info
*pdi
,
1499 struct dwarf2_cu
*cu
, const char *namespace)
1501 struct objfile
*objfile
= cu
->objfile
;
1503 const struct partial_symbol
*psym
= NULL
;
1507 case DW_TAG_subprogram
:
1508 if (pdi
->is_external
)
1510 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1511 mst_text, objfile); */
1512 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1513 VAR_DOMAIN
, LOC_BLOCK
,
1514 &objfile
->global_psymbols
,
1515 0, pdi
->lowpc
+ baseaddr
,
1516 cu_language
, objfile
);
1520 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1521 mst_file_text, objfile); */
1522 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1523 VAR_DOMAIN
, LOC_BLOCK
,
1524 &objfile
->static_psymbols
,
1525 0, pdi
->lowpc
+ baseaddr
,
1526 cu_language
, objfile
);
1529 case DW_TAG_variable
:
1530 if (pdi
->is_external
)
1533 Don't enter into the minimal symbol tables as there is
1534 a minimal symbol table entry from the ELF symbols already.
1535 Enter into partial symbol table if it has a location
1536 descriptor or a type.
1537 If the location descriptor is missing, new_symbol will create
1538 a LOC_UNRESOLVED symbol, the address of the variable will then
1539 be determined from the minimal symbol table whenever the variable
1541 The address for the partial symbol table entry is not
1542 used by GDB, but it comes in handy for debugging partial symbol
1546 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1547 if (pdi
->locdesc
|| pdi
->has_type
)
1548 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1549 VAR_DOMAIN
, LOC_STATIC
,
1550 &objfile
->global_psymbols
,
1552 cu_language
, objfile
);
1556 /* Static Variable. Skip symbols without location descriptors. */
1557 if (pdi
->locdesc
== NULL
)
1559 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1560 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1561 mst_file_data, objfile); */
1562 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1563 VAR_DOMAIN
, LOC_STATIC
,
1564 &objfile
->static_psymbols
,
1566 cu_language
, objfile
);
1569 case DW_TAG_typedef
:
1570 case DW_TAG_base_type
:
1571 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1572 VAR_DOMAIN
, LOC_TYPEDEF
,
1573 &objfile
->static_psymbols
,
1574 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1576 case DW_TAG_class_type
:
1577 case DW_TAG_structure_type
:
1578 case DW_TAG_union_type
:
1579 case DW_TAG_enumeration_type
:
1580 /* Skip aggregate types without children, these are external
1582 if (pdi
->has_children
== 0)
1584 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1585 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1586 &objfile
->static_psymbols
,
1587 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1589 if (cu_language
== language_cplus
)
1591 /* For C++, these implicitly act as typedefs as well. */
1592 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1593 VAR_DOMAIN
, LOC_TYPEDEF
,
1594 &objfile
->static_psymbols
,
1595 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1598 case DW_TAG_enumerator
:
1599 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1600 VAR_DOMAIN
, LOC_CONST
,
1601 &objfile
->static_psymbols
,
1602 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1608 /* Check to see if we should scan the name for possible namespace
1609 info. Only do this if this is C++, if we don't have namespace
1610 debugging info in the file, if the psym is of an appropriate type
1611 (otherwise we'll have psym == NULL), and if we actually had a
1612 mangled name to begin with. */
1614 if (cu_language
== language_cplus
1615 && namespace == NULL
1617 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
1618 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
1622 /* Read a partial die corresponding to a namespace; also, add a symbol
1623 corresponding to that namespace to the symbol table. NAMESPACE is
1624 the name of the enclosing namespace. */
1627 add_partial_namespace (struct partial_die_info
*pdi
, char *info_ptr
,
1628 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1629 struct dwarf2_cu
*cu
, const char *namespace)
1631 struct objfile
*objfile
= cu
->objfile
;
1632 const char *new_name
= pdi
->name
;
1635 /* Calculate the full name of the namespace that we just entered. */
1637 if (new_name
== NULL
)
1638 new_name
= "(anonymous namespace)";
1639 full_name
= alloca (strlen (namespace) + 2 + strlen (new_name
) + 1);
1640 strcpy (full_name
, namespace);
1641 if (*namespace != '\0')
1642 strcat (full_name
, "::");
1643 strcat (full_name
, new_name
);
1645 /* FIXME: carlton/2003-06-27: Once we build qualified names for more
1646 symbols than just namespaces, we should replace this by a call to
1647 add_partial_symbol. */
1649 add_psymbol_to_list (full_name
, strlen (full_name
),
1650 VAR_DOMAIN
, LOC_TYPEDEF
,
1651 &objfile
->global_psymbols
,
1652 0, 0, cu_language
, objfile
);
1654 /* Now scan partial symbols in that namespace. */
1656 if (pdi
->has_children
)
1657 info_ptr
= scan_partial_symbols (info_ptr
, lowpc
, highpc
, cu
, full_name
);
1662 /* Read a partial die corresponding to an enumeration type. */
1665 add_partial_enumeration (struct partial_die_info
*enum_pdi
, char *info_ptr
,
1666 struct dwarf2_cu
*cu
, const char *namespace)
1668 struct objfile
*objfile
= cu
->objfile
;
1669 bfd
*abfd
= objfile
->obfd
;
1670 struct partial_die_info pdi
;
1672 if (enum_pdi
->name
!= NULL
)
1673 add_partial_symbol (enum_pdi
, cu
, namespace);
1677 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1680 if (pdi
.tag
!= DW_TAG_enumerator
|| pdi
.name
== NULL
)
1681 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
1683 add_partial_symbol (&pdi
, cu
, namespace);
1689 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the next DIE
1693 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
1694 bfd
*abfd
, struct dwarf2_cu
*cu
)
1696 /* Do we know the sibling already? */
1698 if (orig_pdi
->sibling
)
1699 return orig_pdi
->sibling
;
1701 /* Are there any children to deal with? */
1703 if (!orig_pdi
->has_children
)
1706 /* Okay, we don't know the sibling, but we have children that we
1707 want to skip. So read children until we run into one without a
1708 tag; return whatever follows it. */
1712 struct partial_die_info pdi
;
1714 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1719 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1723 /* Expand this partial symbol table into a full symbol table. */
1726 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1728 /* FIXME: This is barely more than a stub. */
1733 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1739 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1740 gdb_flush (gdb_stdout
);
1743 psymtab_to_symtab_1 (pst
);
1745 /* Finish up the debug error message. */
1747 printf_filtered ("done.\n");
1753 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1755 struct objfile
*objfile
= pst
->objfile
;
1756 bfd
*abfd
= objfile
->obfd
;
1757 struct dwarf2_cu cu
;
1758 struct die_info
*dies
;
1759 unsigned long offset
;
1760 CORE_ADDR lowpc
, highpc
;
1761 struct die_info
*child_die
;
1763 struct symtab
*symtab
;
1764 struct cleanup
*back_to
;
1765 struct attribute
*attr
;
1767 /* Set local variables from the partial symbol table info. */
1768 offset
= DWARF_INFO_OFFSET (pst
);
1769 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1770 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1771 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1772 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1773 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1774 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1775 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1776 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1777 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1778 dwarf_ranges_buffer
= DWARF_RANGES_BUFFER (pst
);
1779 dwarf_ranges_size
= DWARF_RANGES_SIZE (pst
);
1780 dwarf_loc_buffer
= DWARF_LOC_BUFFER (pst
);
1781 dwarf_loc_size
= DWARF_LOC_SIZE (pst
);
1782 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1783 cu_header_offset
= offset
;
1784 info_ptr
= dwarf_info_buffer
+ offset
;
1786 obstack_init (&dwarf2_tmp_obstack
);
1787 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1790 make_cleanup (really_free_pendings
, NULL
);
1792 cu
.objfile
= objfile
;
1794 /* read in the comp_unit header */
1795 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1797 /* Read the abbrevs for this compilation unit */
1798 dwarf2_read_abbrevs (abfd
, &cu
);
1799 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1801 dies
= read_comp_unit (info_ptr
, abfd
, &cu
);
1803 make_cleanup_free_die_list (dies
);
1805 /* Find the base address of the compilation unit for range lists and
1806 location lists. It will normally be specified by DW_AT_low_pc.
1807 In DWARF-3 draft 4, the base address could be overridden by
1808 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1809 compilation units with discontinuous ranges. */
1811 cu
.header
.base_known
= 0;
1812 cu
.header
.base_address
= 0;
1814 attr
= dwarf_attr (dies
, DW_AT_entry_pc
);
1817 cu
.header
.base_address
= DW_ADDR (attr
);
1818 cu
.header
.base_known
= 1;
1822 attr
= dwarf_attr (dies
, DW_AT_low_pc
);
1825 cu
.header
.base_address
= DW_ADDR (attr
);
1826 cu
.header
.base_known
= 1;
1830 /* Do line number decoding in read_file_scope () */
1831 process_die (dies
, &cu
);
1833 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, &cu
))
1835 /* Some compilers don't define a DW_AT_high_pc attribute for
1836 the compilation unit. If the DW_AT_high_pc is missing,
1837 synthesize it, by scanning the DIE's below the compilation unit. */
1839 if (dies
->child
!= NULL
)
1841 child_die
= dies
->child
;
1842 while (child_die
&& child_die
->tag
)
1844 if (child_die
->tag
== DW_TAG_subprogram
)
1846 CORE_ADDR low
, high
;
1848 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, &cu
))
1850 highpc
= max (highpc
, high
);
1853 child_die
= sibling_die (child_die
);
1857 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1859 /* Set symtab language to language from DW_AT_language.
1860 If the compilation is from a C file generated by language preprocessors,
1861 do not set the language if it was already deduced by start_subfile. */
1863 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1865 symtab
->language
= cu_language
;
1867 pst
->symtab
= symtab
;
1870 do_cleanups (back_to
);
1873 /* Process a die and its children. */
1876 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
1880 case DW_TAG_padding
:
1882 case DW_TAG_compile_unit
:
1883 read_file_scope (die
, cu
);
1885 case DW_TAG_subprogram
:
1886 read_subroutine_type (die
, cu
);
1887 read_func_scope (die
, cu
);
1889 case DW_TAG_inlined_subroutine
:
1890 /* FIXME: These are ignored for now.
1891 They could be used to set breakpoints on all inlined instances
1892 of a function and make GDB `next' properly over inlined functions. */
1894 case DW_TAG_lexical_block
:
1895 case DW_TAG_try_block
:
1896 case DW_TAG_catch_block
:
1897 read_lexical_block_scope (die
, cu
);
1899 case DW_TAG_class_type
:
1900 case DW_TAG_structure_type
:
1901 case DW_TAG_union_type
:
1902 read_structure_scope (die
, cu
);
1904 case DW_TAG_enumeration_type
:
1905 read_enumeration (die
, cu
);
1907 case DW_TAG_subroutine_type
:
1908 read_subroutine_type (die
, cu
);
1910 case DW_TAG_array_type
:
1911 read_array_type (die
, cu
);
1913 case DW_TAG_pointer_type
:
1914 read_tag_pointer_type (die
, cu
);
1916 case DW_TAG_ptr_to_member_type
:
1917 read_tag_ptr_to_member_type (die
, cu
);
1919 case DW_TAG_reference_type
:
1920 read_tag_reference_type (die
, cu
);
1922 case DW_TAG_string_type
:
1923 read_tag_string_type (die
, cu
);
1925 case DW_TAG_base_type
:
1926 read_base_type (die
, cu
);
1927 if (dwarf_attr (die
, DW_AT_name
))
1929 /* Add a typedef symbol for the base type definition. */
1930 new_symbol (die
, die
->type
, cu
);
1933 case DW_TAG_common_block
:
1934 read_common_block (die
, cu
);
1936 case DW_TAG_common_inclusion
:
1938 case DW_TAG_namespace
:
1939 if (!processing_has_namespace_info
)
1941 processing_has_namespace_info
= 1;
1942 processing_current_namespace
= "";
1944 read_namespace (die
, cu
);
1946 case DW_TAG_imported_declaration
:
1947 case DW_TAG_imported_module
:
1948 /* FIXME: carlton/2002-10-16: Eventually, we should use the
1949 information contained in these. DW_TAG_imported_declaration
1950 dies shouldn't have children; DW_TAG_imported_module dies
1951 shouldn't in the C++ case, but conceivably could in the
1952 Fortran case, so we'll have to replace this gdb_assert if
1953 Fortran compilers start generating that info. */
1954 if (!processing_has_namespace_info
)
1956 processing_has_namespace_info
= 1;
1957 processing_current_namespace
= "";
1959 gdb_assert (die
->child
== NULL
);
1962 new_symbol (die
, NULL
, cu
);
1968 initialize_cu_func_list (void)
1970 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1974 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
1976 struct objfile
*objfile
= cu
->objfile
;
1977 struct comp_unit_head
*cu_header
= &cu
->header
;
1978 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1979 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1980 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1981 struct attribute
*attr
;
1982 char *name
= "<unknown>";
1983 char *comp_dir
= NULL
;
1984 struct die_info
*child_die
;
1985 bfd
*abfd
= objfile
->obfd
;
1986 struct line_header
*line_header
= 0;
1988 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
1990 if (die
->child
!= NULL
)
1992 child_die
= die
->child
;
1993 while (child_die
&& child_die
->tag
)
1995 if (child_die
->tag
== DW_TAG_subprogram
)
1997 CORE_ADDR low
, high
;
1999 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, cu
))
2001 lowpc
= min (lowpc
, low
);
2002 highpc
= max (highpc
, high
);
2005 child_die
= sibling_die (child_die
);
2010 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2011 from finish_block. */
2012 if (lowpc
== ((CORE_ADDR
) -1))
2017 attr
= dwarf_attr (die
, DW_AT_name
);
2020 name
= DW_STRING (attr
);
2022 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
2025 comp_dir
= DW_STRING (attr
);
2028 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2029 directory, get rid of it. */
2030 char *cp
= strchr (comp_dir
, ':');
2032 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2037 if (objfile
->ei
.entry_point
>= lowpc
&&
2038 objfile
->ei
.entry_point
< highpc
)
2040 objfile
->ei
.deprecated_entry_file_lowpc
= lowpc
;
2041 objfile
->ei
.deprecated_entry_file_highpc
= highpc
;
2044 attr
= dwarf_attr (die
, DW_AT_language
);
2047 set_cu_language (DW_UNSND (attr
));
2050 /* We assume that we're processing GCC output. */
2051 processing_gcc_compilation
= 2;
2053 /* FIXME:Do something here. */
2054 if (dip
->at_producer
!= NULL
)
2056 handle_producer (dip
->at_producer
);
2060 /* The compilation unit may be in a different language or objfile,
2061 zero out all remembered fundamental types. */
2062 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2064 start_symtab (name
, comp_dir
, lowpc
);
2065 record_debugformat ("DWARF 2");
2067 initialize_cu_func_list ();
2069 /* Process all dies in compilation unit. */
2070 if (die
->child
!= NULL
)
2072 child_die
= die
->child
;
2073 while (child_die
&& child_die
->tag
)
2075 process_die (child_die
, cu
);
2076 child_die
= sibling_die (child_die
);
2080 /* Decode line number information if present. */
2081 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
2084 unsigned int line_offset
= DW_UNSND (attr
);
2085 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2088 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2089 (void *) line_header
);
2090 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
);
2094 /* Decode macro information, if present. Dwarf 2 macro information
2095 refers to information in the line number info statement program
2096 header, so we can only read it if we've read the header
2098 attr
= dwarf_attr (die
, DW_AT_macro_info
);
2099 if (attr
&& line_header
)
2101 unsigned int macro_offset
= DW_UNSND (attr
);
2102 dwarf_decode_macros (line_header
, macro_offset
,
2103 comp_dir
, abfd
, cu
);
2105 do_cleanups (back_to
);
2109 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
2111 struct function_range
*thisfn
;
2113 thisfn
= (struct function_range
*)
2114 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
2115 thisfn
->name
= name
;
2116 thisfn
->lowpc
= lowpc
;
2117 thisfn
->highpc
= highpc
;
2118 thisfn
->seen_line
= 0;
2119 thisfn
->next
= NULL
;
2121 if (cu_last_fn
== NULL
)
2122 cu_first_fn
= thisfn
;
2124 cu_last_fn
->next
= thisfn
;
2126 cu_last_fn
= thisfn
;
2130 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2132 struct objfile
*objfile
= cu
->objfile
;
2133 struct context_stack
*new;
2136 struct die_info
*child_die
;
2137 struct attribute
*attr
;
2140 name
= dwarf2_linkage_name (die
);
2142 /* Ignore functions with missing or empty names and functions with
2143 missing or invalid low and high pc attributes. */
2144 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2150 /* Record the function range for dwarf_decode_lines. */
2151 add_to_cu_func_list (name
, lowpc
, highpc
);
2153 if (objfile
->ei
.entry_point
>= lowpc
&&
2154 objfile
->ei
.entry_point
< highpc
)
2156 objfile
->ei
.entry_func_lowpc
= lowpc
;
2157 objfile
->ei
.entry_func_highpc
= highpc
;
2160 /* Decode DW_AT_frame_base location descriptor if present, keep result
2161 for DW_OP_fbreg operands in decode_locdesc. */
2162 frame_base_reg
= -1;
2163 frame_base_offset
= 0;
2164 attr
= dwarf_attr (die
, DW_AT_frame_base
);
2169 /* Support the .debug_loc offsets */
2170 if (attr_form_is_block (attr
))
2172 addr
= decode_locdesc (DW_BLOCK (attr
), cu
);
2174 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2176 dwarf2_complex_location_expr_complaint ();
2181 dwarf2_invalid_attrib_class_complaint ("DW_AT_frame_base", name
);
2186 dwarf2_unsupported_at_frame_base_complaint (name
);
2188 frame_base_reg
= addr
;
2191 frame_base_reg
= basereg
;
2192 frame_base_offset
= addr
;
2195 dwarf2_unsupported_at_frame_base_complaint (name
);
2198 new = push_context (0, lowpc
);
2199 new->name
= new_symbol (die
, die
->type
, cu
);
2201 /* If there was a location expression for DW_AT_frame_base above,
2202 record it. We still need to decode it above because not all
2203 symbols use location expressions exclusively. */
2205 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2207 list_in_scope
= &local_symbols
;
2209 if (die
->child
!= NULL
)
2211 child_die
= die
->child
;
2212 while (child_die
&& child_die
->tag
)
2214 process_die (child_die
, cu
);
2215 child_die
= sibling_die (child_die
);
2219 new = pop_context ();
2220 /* Make a block for the local symbols within. */
2221 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2222 lowpc
, highpc
, objfile
);
2224 /* In C++, we can have functions nested inside functions (e.g., when
2225 a function declares a class that has methods). This means that
2226 when we finish processing a function scope, we may need to go
2227 back to building a containing block's symbol lists. */
2228 local_symbols
= new->locals
;
2229 param_symbols
= new->params
;
2231 /* If we've finished processing a top-level function, subsequent
2232 symbols go in the file symbol list. */
2233 if (outermost_context_p ())
2234 list_in_scope
= &file_symbols
;
2237 /* Process all the DIES contained within a lexical block scope. Start
2238 a new scope, process the dies, and then close the scope. */
2241 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2243 struct objfile
*objfile
= cu
->objfile
;
2244 struct context_stack
*new;
2245 CORE_ADDR lowpc
, highpc
;
2246 struct die_info
*child_die
;
2248 /* Ignore blocks with missing or invalid low and high pc attributes. */
2249 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2250 as multiple lexical blocks? Handling children in a sane way would
2251 be nasty. Might be easier to properly extend generic blocks to
2253 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2258 push_context (0, lowpc
);
2259 if (die
->child
!= NULL
)
2261 child_die
= die
->child
;
2262 while (child_die
&& child_die
->tag
)
2264 process_die (child_die
, cu
);
2265 child_die
= sibling_die (child_die
);
2268 new = pop_context ();
2270 if (local_symbols
!= NULL
)
2272 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2275 local_symbols
= new->locals
;
2278 /* Get low and high pc attributes from a die. Return 1 if the attributes
2279 are present and valid, otherwise, return 0. Return -1 if the range is
2280 discontinuous, i.e. derived from DW_AT_ranges information. */
2282 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
2283 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
2285 struct objfile
*objfile
= cu
->objfile
;
2286 struct comp_unit_head
*cu_header
= &cu
->header
;
2287 struct attribute
*attr
;
2288 bfd
*obfd
= objfile
->obfd
;
2293 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2296 high
= DW_ADDR (attr
);
2297 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2299 low
= DW_ADDR (attr
);
2301 /* Found high w/o low attribute. */
2304 /* Found consecutive range of addresses. */
2309 attr
= dwarf_attr (die
, DW_AT_ranges
);
2312 unsigned int addr_size
= cu_header
->addr_size
;
2313 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2314 /* Value of the DW_AT_ranges attribute is the offset in the
2315 .debug_ranges section. */
2316 unsigned int offset
= DW_UNSND (attr
);
2317 /* Base address selection entry. */
2325 found_base
= cu_header
->base_known
;
2326 base
= cu_header
->base_address
;
2328 if (offset
>= dwarf_ranges_size
)
2330 complaint (&symfile_complaints
,
2331 "Offset %d out of bounds for DW_AT_ranges attribute",
2335 buffer
= dwarf_ranges_buffer
+ offset
;
2337 /* Read in the largest possible address. */
2338 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
2339 if ((marker
& mask
) == mask
)
2341 /* If we found the largest possible address, then
2342 read the base address. */
2343 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2344 buffer
+= 2 * addr_size
;
2345 offset
+= 2 * addr_size
;
2353 CORE_ADDR range_beginning
, range_end
;
2355 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
2356 buffer
+= addr_size
;
2357 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
2358 buffer
+= addr_size
;
2359 offset
+= 2 * addr_size
;
2361 /* An end of list marker is a pair of zero addresses. */
2362 if (range_beginning
== 0 && range_end
== 0)
2363 /* Found the end of list entry. */
2366 /* Each base address selection entry is a pair of 2 values.
2367 The first is the largest possible address, the second is
2368 the base address. Check for a base address here. */
2369 if ((range_beginning
& mask
) == mask
)
2371 /* If we found the largest possible address, then
2372 read the base address. */
2373 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2380 /* We have no valid base address for the ranges
2382 complaint (&symfile_complaints
,
2383 "Invalid .debug_ranges data (no base address)");
2387 range_beginning
+= base
;
2390 /* FIXME: This is recording everything as a low-high
2391 segment of consecutive addresses. We should have a
2392 data structure for discontiguous block ranges
2396 low
= range_beginning
;
2402 if (range_beginning
< low
)
2403 low
= range_beginning
;
2404 if (range_end
> high
)
2410 /* If the first entry is an end-of-list marker, the range
2411 describes an empty scope, i.e. no instructions. */
2421 /* When using the GNU linker, .gnu.linkonce. sections are used to
2422 eliminate duplicate copies of functions and vtables and such.
2423 The linker will arbitrarily choose one and discard the others.
2424 The AT_*_pc values for such functions refer to local labels in
2425 these sections. If the section from that file was discarded, the
2426 labels are not in the output, so the relocs get a value of 0.
2427 If this is a discarded function, mark the pc bounds as invalid,
2428 so that GDB will ignore it. */
2429 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
2437 /* Add an aggregate field to the field list. */
2440 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2441 struct dwarf2_cu
*cu
)
2443 struct objfile
*objfile
= cu
->objfile
;
2444 struct nextfield
*new_field
;
2445 struct attribute
*attr
;
2447 char *fieldname
= "";
2449 /* Allocate a new field list entry and link it in. */
2450 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2451 make_cleanup (xfree
, new_field
);
2452 memset (new_field
, 0, sizeof (struct nextfield
));
2453 new_field
->next
= fip
->fields
;
2454 fip
->fields
= new_field
;
2457 /* Handle accessibility and virtuality of field.
2458 The default accessibility for members is public, the default
2459 accessibility for inheritance is private. */
2460 if (die
->tag
!= DW_TAG_inheritance
)
2461 new_field
->accessibility
= DW_ACCESS_public
;
2463 new_field
->accessibility
= DW_ACCESS_private
;
2464 new_field
->virtuality
= DW_VIRTUALITY_none
;
2466 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2468 new_field
->accessibility
= DW_UNSND (attr
);
2469 if (new_field
->accessibility
!= DW_ACCESS_public
)
2470 fip
->non_public_fields
= 1;
2471 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2473 new_field
->virtuality
= DW_UNSND (attr
);
2475 fp
= &new_field
->field
;
2477 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
))
2479 /* Data member other than a C++ static data member. */
2481 /* Get type of field. */
2482 fp
->type
= die_type (die
, cu
);
2484 FIELD_STATIC_KIND (*fp
) = 0;
2486 /* Get bit size of field (zero if none). */
2487 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2490 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2494 FIELD_BITSIZE (*fp
) = 0;
2497 /* Get bit offset of field. */
2498 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2501 FIELD_BITPOS (*fp
) =
2502 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
2505 FIELD_BITPOS (*fp
) = 0;
2506 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2509 if (BITS_BIG_ENDIAN
)
2511 /* For big endian bits, the DW_AT_bit_offset gives the
2512 additional bit offset from the MSB of the containing
2513 anonymous object to the MSB of the field. We don't
2514 have to do anything special since we don't need to
2515 know the size of the anonymous object. */
2516 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2520 /* For little endian bits, compute the bit offset to the
2521 MSB of the anonymous object, subtract off the number of
2522 bits from the MSB of the field to the MSB of the
2523 object, and then subtract off the number of bits of
2524 the field itself. The result is the bit offset of
2525 the LSB of the field. */
2527 int bit_offset
= DW_UNSND (attr
);
2529 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2532 /* The size of the anonymous object containing
2533 the bit field is explicit, so use the
2534 indicated size (in bytes). */
2535 anonymous_size
= DW_UNSND (attr
);
2539 /* The size of the anonymous object containing
2540 the bit field must be inferred from the type
2541 attribute of the data member containing the
2543 anonymous_size
= TYPE_LENGTH (fp
->type
);
2545 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2546 - bit_offset
- FIELD_BITSIZE (*fp
);
2550 /* Get name of field. */
2551 attr
= dwarf_attr (die
, DW_AT_name
);
2552 if (attr
&& DW_STRING (attr
))
2553 fieldname
= DW_STRING (attr
);
2554 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2555 &objfile
->type_obstack
);
2557 /* Change accessibility for artificial fields (e.g. virtual table
2558 pointer or virtual base class pointer) to private. */
2559 if (dwarf_attr (die
, DW_AT_artificial
))
2561 new_field
->accessibility
= DW_ACCESS_private
;
2562 fip
->non_public_fields
= 1;
2565 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
2567 /* C++ static member. */
2569 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2570 is a declaration, but all versions of G++ as of this writing
2571 (so through at least 3.2.1) incorrectly generate
2572 DW_TAG_variable tags. */
2576 /* Get name of field. */
2577 attr
= dwarf_attr (die
, DW_AT_name
);
2578 if (attr
&& DW_STRING (attr
))
2579 fieldname
= DW_STRING (attr
);
2583 /* Get physical name. */
2584 physname
= dwarf2_linkage_name (die
);
2586 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2587 &objfile
->type_obstack
));
2588 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2589 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2590 &objfile
->type_obstack
);
2592 else if (die
->tag
== DW_TAG_inheritance
)
2594 /* C++ base class field. */
2595 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2597 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
2599 FIELD_BITSIZE (*fp
) = 0;
2600 FIELD_STATIC_KIND (*fp
) = 0;
2601 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2602 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2603 fip
->nbaseclasses
++;
2607 /* Create the vector of fields, and attach it to the type. */
2610 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2611 struct dwarf2_cu
*cu
)
2613 int nfields
= fip
->nfields
;
2615 /* Record the field count, allocate space for the array of fields,
2616 and create blank accessibility bitfields if necessary. */
2617 TYPE_NFIELDS (type
) = nfields
;
2618 TYPE_FIELDS (type
) = (struct field
*)
2619 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2620 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2622 if (fip
->non_public_fields
)
2624 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2626 TYPE_FIELD_PRIVATE_BITS (type
) =
2627 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2628 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2630 TYPE_FIELD_PROTECTED_BITS (type
) =
2631 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2632 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2634 TYPE_FIELD_IGNORE_BITS (type
) =
2635 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2636 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2639 /* If the type has baseclasses, allocate and clear a bit vector for
2640 TYPE_FIELD_VIRTUAL_BITS. */
2641 if (fip
->nbaseclasses
)
2643 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2646 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2647 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2648 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2649 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2650 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2653 /* Copy the saved-up fields into the field vector. Start from the head
2654 of the list, adding to the tail of the field array, so that they end
2655 up in the same order in the array in which they were added to the list. */
2656 while (nfields
-- > 0)
2658 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2659 switch (fip
->fields
->accessibility
)
2661 case DW_ACCESS_private
:
2662 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2665 case DW_ACCESS_protected
:
2666 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2669 case DW_ACCESS_public
:
2673 /* Unknown accessibility. Complain and treat it as public. */
2675 complaint (&symfile_complaints
, "unsupported accessibility %d",
2676 fip
->fields
->accessibility
);
2680 if (nfields
< fip
->nbaseclasses
)
2682 switch (fip
->fields
->virtuality
)
2684 case DW_VIRTUALITY_virtual
:
2685 case DW_VIRTUALITY_pure_virtual
:
2686 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2690 fip
->fields
= fip
->fields
->next
;
2694 /* Add a member function to the proper fieldlist. */
2697 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2698 struct type
*type
, struct dwarf2_cu
*cu
)
2700 struct objfile
*objfile
= cu
->objfile
;
2701 struct attribute
*attr
;
2702 struct fnfieldlist
*flp
;
2704 struct fn_field
*fnp
;
2707 struct nextfnfield
*new_fnfield
;
2709 /* Get name of member function. */
2710 attr
= dwarf_attr (die
, DW_AT_name
);
2711 if (attr
&& DW_STRING (attr
))
2712 fieldname
= DW_STRING (attr
);
2716 /* Get the mangled name. */
2717 physname
= dwarf2_linkage_name (die
);
2719 /* Look up member function name in fieldlist. */
2720 for (i
= 0; i
< fip
->nfnfields
; i
++)
2722 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2726 /* Create new list element if necessary. */
2727 if (i
< fip
->nfnfields
)
2728 flp
= &fip
->fnfieldlists
[i
];
2731 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2733 fip
->fnfieldlists
= (struct fnfieldlist
*)
2734 xrealloc (fip
->fnfieldlists
,
2735 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2736 * sizeof (struct fnfieldlist
));
2737 if (fip
->nfnfields
== 0)
2738 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2740 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2741 flp
->name
= fieldname
;
2747 /* Create a new member function field and chain it to the field list
2749 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2750 make_cleanup (xfree
, new_fnfield
);
2751 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2752 new_fnfield
->next
= flp
->head
;
2753 flp
->head
= new_fnfield
;
2756 /* Fill in the member function field info. */
2757 fnp
= &new_fnfield
->fnfield
;
2758 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2759 &objfile
->type_obstack
);
2760 fnp
->type
= alloc_type (objfile
);
2761 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2763 int nparams
= TYPE_NFIELDS (die
->type
);
2765 /* TYPE is the domain of this method, and DIE->TYPE is the type
2766 of the method itself (TYPE_CODE_METHOD). */
2767 smash_to_method_type (fnp
->type
, type
,
2768 TYPE_TARGET_TYPE (die
->type
),
2769 TYPE_FIELDS (die
->type
),
2770 TYPE_NFIELDS (die
->type
),
2771 TYPE_VARARGS (die
->type
));
2773 /* Handle static member functions.
2774 Dwarf2 has no clean way to discern C++ static and non-static
2775 member functions. G++ helps GDB by marking the first
2776 parameter for non-static member functions (which is the
2777 this pointer) as artificial. We obtain this information
2778 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2779 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2780 fnp
->voffset
= VOFFSET_STATIC
;
2783 complaint (&symfile_complaints
, "member function type missing for '%s'",
2786 /* Get fcontext from DW_AT_containing_type if present. */
2787 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2788 fnp
->fcontext
= die_containing_type (die
, cu
);
2790 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2791 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2793 /* Get accessibility. */
2794 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2797 switch (DW_UNSND (attr
))
2799 case DW_ACCESS_private
:
2800 fnp
->is_private
= 1;
2802 case DW_ACCESS_protected
:
2803 fnp
->is_protected
= 1;
2808 /* Check for artificial methods. */
2809 attr
= dwarf_attr (die
, DW_AT_artificial
);
2810 if (attr
&& DW_UNSND (attr
) != 0)
2811 fnp
->is_artificial
= 1;
2813 /* Get index in virtual function table if it is a virtual member function. */
2814 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2817 /* Support the .debug_loc offsets */
2818 if (attr_form_is_block (attr
))
2820 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
2822 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2824 dwarf2_complex_location_expr_complaint ();
2828 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2834 /* Create the vector of member function fields, and attach it to the type. */
2837 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2838 struct dwarf2_cu
*cu
)
2840 struct fnfieldlist
*flp
;
2841 int total_length
= 0;
2844 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2845 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2846 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2848 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2850 struct nextfnfield
*nfp
= flp
->head
;
2851 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2854 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2855 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2856 fn_flp
->fn_fields
= (struct fn_field
*)
2857 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2858 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2859 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2861 total_length
+= flp
->length
;
2864 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2865 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2868 /* Called when we find the DIE that starts a structure or union scope
2869 (definition) to process all dies that define the members of the
2872 NOTE: we need to call struct_type regardless of whether or not the
2873 DIE has an at_name attribute, since it might be an anonymous
2874 structure or union. This gets the type entered into our set of
2877 However, if the structure is incomplete (an opaque struct/union)
2878 then suppress creating a symbol table entry for it since gdb only
2879 wants to find the one with the complete definition. Note that if
2880 it is complete, we just call new_symbol, which does it's own
2881 checking about whether the struct/union is anonymous or not (and
2882 suppresses creating a symbol table entry itself). */
2885 read_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2887 struct objfile
*objfile
= cu
->objfile
;
2889 struct attribute
*attr
;
2891 type
= alloc_type (objfile
);
2893 INIT_CPLUS_SPECIFIC (type
);
2894 attr
= dwarf_attr (die
, DW_AT_name
);
2895 if (attr
&& DW_STRING (attr
))
2897 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2898 strlen (DW_STRING (attr
)),
2899 &objfile
->type_obstack
);
2902 if (die
->tag
== DW_TAG_structure_type
)
2904 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2906 else if (die
->tag
== DW_TAG_union_type
)
2908 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2912 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2914 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2917 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2920 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2924 TYPE_LENGTH (type
) = 0;
2927 /* We need to add the type field to the die immediately so we don't
2928 infinitely recurse when dealing with pointers to the structure
2929 type within the structure itself. */
2932 if (die
->child
!= NULL
&& ! die_is_declaration (die
))
2934 struct field_info fi
;
2935 struct die_info
*child_die
;
2936 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2938 memset (&fi
, 0, sizeof (struct field_info
));
2940 child_die
= die
->child
;
2942 while (child_die
&& child_die
->tag
)
2944 if (child_die
->tag
== DW_TAG_member
2945 || child_die
->tag
== DW_TAG_variable
)
2947 /* NOTE: carlton/2002-11-05: A C++ static data member
2948 should be a DW_TAG_member that is a declaration, but
2949 all versions of G++ as of this writing (so through at
2950 least 3.2.1) incorrectly generate DW_TAG_variable
2951 tags for them instead. */
2952 dwarf2_add_field (&fi
, child_die
, cu
);
2954 else if (child_die
->tag
== DW_TAG_subprogram
)
2956 /* C++ member function. */
2957 process_die (child_die
, cu
);
2958 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
2960 else if (child_die
->tag
== DW_TAG_inheritance
)
2962 /* C++ base class field. */
2963 dwarf2_add_field (&fi
, child_die
, cu
);
2967 process_die (child_die
, cu
);
2969 child_die
= sibling_die (child_die
);
2972 /* Attach fields and member functions to the type. */
2974 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
2977 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
2979 /* Get the type which refers to the base class (possibly this
2980 class itself) which contains the vtable pointer for the current
2981 class from the DW_AT_containing_type attribute. */
2983 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2985 struct type
*t
= die_containing_type (die
, cu
);
2987 TYPE_VPTR_BASETYPE (type
) = t
;
2990 static const char vptr_name
[] =
2991 {'_', 'v', 'p', 't', 'r', '\0'};
2994 /* Our own class provides vtbl ptr. */
2995 for (i
= TYPE_NFIELDS (t
) - 1;
2996 i
>= TYPE_N_BASECLASSES (t
);
2999 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3001 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
3002 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
3004 TYPE_VPTR_FIELDNO (type
) = i
;
3009 /* Complain if virtual function table field not found. */
3010 if (i
< TYPE_N_BASECLASSES (t
))
3011 complaint (&symfile_complaints
,
3012 "virtual function table pointer not found when defining class '%s'",
3013 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3018 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3023 new_symbol (die
, type
, cu
);
3025 do_cleanups (back_to
);
3029 /* No children, must be stub. */
3030 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3034 /* Given a pointer to a die which begins an enumeration, process all
3035 the dies that define the members of the enumeration.
3037 This will be much nicer in draft 6 of the DWARF spec when our
3038 members will be dies instead squished into the DW_AT_element_list
3041 NOTE: We reverse the order of the element list. */
3044 read_enumeration (struct die_info
*die
, struct dwarf2_cu
*cu
)
3046 struct objfile
*objfile
= cu
->objfile
;
3047 struct die_info
*child_die
;
3049 struct field
*fields
;
3050 struct attribute
*attr
;
3053 int unsigned_enum
= 1;
3055 type
= alloc_type (objfile
);
3057 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3058 attr
= dwarf_attr (die
, DW_AT_name
);
3059 if (attr
&& DW_STRING (attr
))
3061 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
3062 strlen (DW_STRING (attr
)),
3063 &objfile
->type_obstack
);
3066 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3069 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3073 TYPE_LENGTH (type
) = 0;
3078 if (die
->child
!= NULL
)
3080 child_die
= die
->child
;
3081 while (child_die
&& child_die
->tag
)
3083 if (child_die
->tag
!= DW_TAG_enumerator
)
3085 process_die (child_die
, cu
);
3089 attr
= dwarf_attr (child_die
, DW_AT_name
);
3092 sym
= new_symbol (child_die
, type
, cu
);
3093 if (SYMBOL_VALUE (sym
) < 0)
3096 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3098 fields
= (struct field
*)
3100 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
3101 * sizeof (struct field
));
3104 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
3105 FIELD_TYPE (fields
[num_fields
]) = NULL
;
3106 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
3107 FIELD_BITSIZE (fields
[num_fields
]) = 0;
3108 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
3114 child_die
= sibling_die (child_die
);
3119 TYPE_NFIELDS (type
) = num_fields
;
3120 TYPE_FIELDS (type
) = (struct field
*)
3121 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
3122 memcpy (TYPE_FIELDS (type
), fields
,
3123 sizeof (struct field
) * num_fields
);
3127 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
3130 new_symbol (die
, type
, cu
);
3133 /* Extract all information from a DW_TAG_array_type DIE and put it in
3134 the DIE's type field. For now, this only handles one dimensional
3138 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3140 struct objfile
*objfile
= cu
->objfile
;
3141 struct die_info
*child_die
;
3142 struct type
*type
= NULL
;
3143 struct type
*element_type
, *range_type
, *index_type
;
3144 struct type
**range_types
= NULL
;
3145 struct attribute
*attr
;
3147 struct cleanup
*back_to
;
3149 /* Return if we've already decoded this type. */
3155 element_type
= die_type (die
, cu
);
3157 /* Irix 6.2 native cc creates array types without children for
3158 arrays with unspecified length. */
3159 if (die
->child
== NULL
)
3161 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3162 range_type
= create_range_type (NULL
, index_type
, 0, -1);
3163 die
->type
= create_array_type (NULL
, element_type
, range_type
);
3167 back_to
= make_cleanup (null_cleanup
, NULL
);
3168 child_die
= die
->child
;
3169 while (child_die
&& child_die
->tag
)
3171 if (child_die
->tag
== DW_TAG_subrange_type
)
3173 unsigned int low
, high
;
3175 /* Default bounds to an array with unspecified length. */
3178 if (cu_language
== language_fortran
)
3180 /* FORTRAN implies a lower bound of 1, if not given. */
3184 index_type
= die_type (child_die
, cu
);
3185 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
3188 if (attr
->form
== DW_FORM_sdata
)
3190 low
= DW_SND (attr
);
3192 else if (attr
->form
== DW_FORM_udata
3193 || attr
->form
== DW_FORM_data1
3194 || attr
->form
== DW_FORM_data2
3195 || attr
->form
== DW_FORM_data4
3196 || attr
->form
== DW_FORM_data8
)
3198 low
= DW_UNSND (attr
);
3202 dwarf2_non_const_array_bound_ignored_complaint
3203 (dwarf_form_name (attr
->form
));
3205 die
->type
= lookup_pointer_type (element_type
);
3212 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
3215 if (attr
->form
== DW_FORM_sdata
)
3217 high
= DW_SND (attr
);
3219 else if (attr
->form
== DW_FORM_udata
3220 || attr
->form
== DW_FORM_data1
3221 || attr
->form
== DW_FORM_data2
3222 || attr
->form
== DW_FORM_data4
3223 || attr
->form
== DW_FORM_data8
)
3225 high
= DW_UNSND (attr
);
3227 else if (attr
->form
== DW_FORM_block1
)
3229 /* GCC encodes arrays with unspecified or dynamic length
3230 with a DW_FORM_block1 attribute.
3231 FIXME: GDB does not yet know how to handle dynamic
3232 arrays properly, treat them as arrays with unspecified
3235 FIXME: jimb/2003-09-22: GDB does not really know
3236 how to handle arrays of unspecified length
3237 either; we just represent them as zero-length
3238 arrays. Choose an appropriate upper bound given
3239 the lower bound we've computed above. */
3244 dwarf2_non_const_array_bound_ignored_complaint
3245 (dwarf_form_name (attr
->form
));
3247 die
->type
= lookup_pointer_type (element_type
);
3255 /* Create a range type and save it for array type creation. */
3256 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
3258 range_types
= (struct type
**)
3259 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
3260 * sizeof (struct type
*));
3262 make_cleanup (free_current_contents
, &range_types
);
3264 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
3266 child_die
= sibling_die (child_die
);
3269 /* Dwarf2 dimensions are output from left to right, create the
3270 necessary array types in backwards order. */
3271 type
= element_type
;
3273 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
3275 /* Understand Dwarf2 support for vector types (like they occur on
3276 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3277 array type. This is not part of the Dwarf2/3 standard yet, but a
3278 custom vendor extension. The main difference between a regular
3279 array and the vector variant is that vectors are passed by value
3281 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
3283 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
3285 do_cleanups (back_to
);
3287 /* Install the type in the die. */
3291 /* First cut: install each common block member as a global variable. */
3294 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
3296 struct die_info
*child_die
;
3297 struct attribute
*attr
;
3299 CORE_ADDR base
= (CORE_ADDR
) 0;
3301 attr
= dwarf_attr (die
, DW_AT_location
);
3304 /* Support the .debug_loc offsets */
3305 if (attr_form_is_block (attr
))
3307 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
3309 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3311 dwarf2_complex_location_expr_complaint ();
3315 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3316 "common block member");
3319 if (die
->child
!= NULL
)
3321 child_die
= die
->child
;
3322 while (child_die
&& child_die
->tag
)
3324 sym
= new_symbol (child_die
, NULL
, cu
);
3325 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
3328 SYMBOL_VALUE_ADDRESS (sym
) =
3329 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
3330 add_symbol_to_list (sym
, &global_symbols
);
3332 child_die
= sibling_die (child_die
);
3337 /* Read a C++ namespace. */
3340 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
3342 struct objfile
*objfile
= cu
->objfile
;
3343 const char *previous_namespace
= processing_current_namespace
;
3344 const char *name
= NULL
;
3346 struct die_info
*current_die
;
3348 /* Loop through the extensions until we find a name. */
3350 for (current_die
= die
;
3351 current_die
!= NULL
;
3352 current_die
= dwarf2_extension (die
))
3354 name
= dwarf2_name (current_die
);
3359 /* Is it an anonymous namespace? */
3361 is_anonymous
= (name
== NULL
);
3363 name
= "(anonymous namespace)";
3365 /* Now build the name of the current namespace. */
3367 if (previous_namespace
[0] == '\0')
3369 processing_current_namespace
= name
;
3373 /* We need temp_name around because processing_current_namespace
3374 is a const char *. */
3375 char *temp_name
= alloca (strlen (previous_namespace
)
3376 + 2 + strlen(name
) + 1);
3377 strcpy (temp_name
, previous_namespace
);
3378 strcat (temp_name
, "::");
3379 strcat (temp_name
, name
);
3381 processing_current_namespace
= temp_name
;
3384 /* Add a symbol associated to this if we haven't seen the namespace
3385 before. Also, add a using directive if it's an anonymous
3388 if (dwarf2_extension (die
) == NULL
)
3392 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3393 this cast will hopefully become unnecessary. */
3394 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
3395 (char *) processing_current_namespace
,
3397 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
3399 new_symbol (die
, type
, cu
);
3402 cp_add_using_directive (processing_current_namespace
,
3403 strlen (previous_namespace
),
3404 strlen (processing_current_namespace
));
3407 if (die
->child
!= NULL
)
3409 struct die_info
*child_die
= die
->child
;
3411 while (child_die
&& child_die
->tag
)
3413 process_die (child_die
, cu
);
3414 child_die
= sibling_die (child_die
);
3418 processing_current_namespace
= previous_namespace
;
3421 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3422 the user defined type vector. */
3425 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3427 struct comp_unit_head
*cu_header
= &cu
->header
;
3429 struct attribute
*attr_byte_size
;
3430 struct attribute
*attr_address_class
;
3431 int byte_size
, addr_class
;
3438 type
= lookup_pointer_type (die_type (die
, cu
));
3440 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
3442 byte_size
= DW_UNSND (attr_byte_size
);
3444 byte_size
= cu_header
->addr_size
;
3446 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
3447 if (attr_address_class
)
3448 addr_class
= DW_UNSND (attr_address_class
);
3450 addr_class
= DW_ADDR_none
;
3452 /* If the pointer size or address class is different than the
3453 default, create a type variant marked as such and set the
3454 length accordingly. */
3455 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3457 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3461 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3462 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3463 type
= make_type_with_address_space (type
, type_flags
);
3465 else if (TYPE_LENGTH (type
) != byte_size
)
3467 complaint (&symfile_complaints
, "invalid pointer size %d", byte_size
);
3470 /* Should we also complain about unhandled address classes? */
3474 TYPE_LENGTH (type
) = byte_size
;
3478 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3479 the user defined type vector. */
3482 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3484 struct objfile
*objfile
= cu
->objfile
;
3486 struct type
*to_type
;
3487 struct type
*domain
;
3494 type
= alloc_type (objfile
);
3495 to_type
= die_type (die
, cu
);
3496 domain
= die_containing_type (die
, cu
);
3497 smash_to_member_type (type
, domain
, to_type
);
3502 /* Extract all information from a DW_TAG_reference_type DIE and add to
3503 the user defined type vector. */
3506 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3508 struct comp_unit_head
*cu_header
= &cu
->header
;
3510 struct attribute
*attr
;
3517 type
= lookup_reference_type (die_type (die
, cu
));
3518 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3521 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3525 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3531 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3533 struct type
*base_type
;
3540 base_type
= die_type (die
, cu
);
3541 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3545 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3547 struct type
*base_type
;
3554 base_type
= die_type (die
, cu
);
3555 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3558 /* Extract all information from a DW_TAG_string_type DIE and add to
3559 the user defined type vector. It isn't really a user defined type,
3560 but it behaves like one, with other DIE's using an AT_user_def_type
3561 attribute to reference it. */
3564 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3566 struct objfile
*objfile
= cu
->objfile
;
3567 struct type
*type
, *range_type
, *index_type
, *char_type
;
3568 struct attribute
*attr
;
3569 unsigned int length
;
3576 attr
= dwarf_attr (die
, DW_AT_string_length
);
3579 length
= DW_UNSND (attr
);
3583 /* check for the DW_AT_byte_size attribute */
3584 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3587 length
= DW_UNSND (attr
);
3594 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3595 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3596 if (cu_language
== language_fortran
)
3598 /* Need to create a unique string type for bounds
3600 type
= create_string_type (0, range_type
);
3604 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3605 type
= create_string_type (char_type
, range_type
);
3610 /* Handle DIES due to C code like:
3614 int (*funcp)(int a, long l);
3618 ('funcp' generates a DW_TAG_subroutine_type DIE)
3622 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3624 struct type
*type
; /* Type that this function returns */
3625 struct type
*ftype
; /* Function that returns above type */
3626 struct attribute
*attr
;
3628 /* Decode the type that this subroutine returns */
3633 type
= die_type (die
, cu
);
3634 ftype
= lookup_function_type (type
);
3636 /* All functions in C++ have prototypes. */
3637 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3638 if ((attr
&& (DW_UNSND (attr
) != 0))
3639 || cu_language
== language_cplus
)
3640 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3642 if (die
->child
!= NULL
)
3644 struct die_info
*child_die
;
3648 /* Count the number of parameters.
3649 FIXME: GDB currently ignores vararg functions, but knows about
3650 vararg member functions. */
3651 child_die
= die
->child
;
3652 while (child_die
&& child_die
->tag
)
3654 if (child_die
->tag
== DW_TAG_formal_parameter
)
3656 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3657 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3658 child_die
= sibling_die (child_die
);
3661 /* Allocate storage for parameters and fill them in. */
3662 TYPE_NFIELDS (ftype
) = nparams
;
3663 TYPE_FIELDS (ftype
) = (struct field
*)
3664 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3666 child_die
= die
->child
;
3667 while (child_die
&& child_die
->tag
)
3669 if (child_die
->tag
== DW_TAG_formal_parameter
)
3671 /* Dwarf2 has no clean way to discern C++ static and non-static
3672 member functions. G++ helps GDB by marking the first
3673 parameter for non-static member functions (which is the
3674 this pointer) as artificial. We pass this information
3675 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3676 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3678 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3680 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3681 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
3684 child_die
= sibling_die (child_die
);
3692 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
3694 struct objfile
*objfile
= cu
->objfile
;
3695 struct attribute
*attr
;
3700 attr
= dwarf_attr (die
, DW_AT_name
);
3701 if (attr
&& DW_STRING (attr
))
3703 name
= DW_STRING (attr
);
3705 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3706 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
3710 /* Find a representation of a given base type and install
3711 it in the TYPE field of the die. */
3714 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3716 struct objfile
*objfile
= cu
->objfile
;
3718 struct attribute
*attr
;
3719 int encoding
= 0, size
= 0;
3721 /* If we've already decoded this die, this is a no-op. */
3727 attr
= dwarf_attr (die
, DW_AT_encoding
);
3730 encoding
= DW_UNSND (attr
);
3732 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3735 size
= DW_UNSND (attr
);
3737 attr
= dwarf_attr (die
, DW_AT_name
);
3738 if (attr
&& DW_STRING (attr
))
3740 enum type_code code
= TYPE_CODE_INT
;
3745 case DW_ATE_address
:
3746 /* Turn DW_ATE_address into a void * pointer. */
3747 code
= TYPE_CODE_PTR
;
3748 type_flags
|= TYPE_FLAG_UNSIGNED
;
3750 case DW_ATE_boolean
:
3751 code
= TYPE_CODE_BOOL
;
3752 type_flags
|= TYPE_FLAG_UNSIGNED
;
3754 case DW_ATE_complex_float
:
3755 code
= TYPE_CODE_COMPLEX
;
3758 code
= TYPE_CODE_FLT
;
3761 case DW_ATE_signed_char
:
3763 case DW_ATE_unsigned
:
3764 case DW_ATE_unsigned_char
:
3765 type_flags
|= TYPE_FLAG_UNSIGNED
;
3768 complaint (&symfile_complaints
, "unsupported DW_AT_encoding: '%s'",
3769 dwarf_type_encoding_name (encoding
));
3772 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3773 if (encoding
== DW_ATE_address
)
3774 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3775 else if (encoding
== DW_ATE_complex_float
)
3778 TYPE_TARGET_TYPE (type
)
3779 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3780 else if (size
== 16)
3781 TYPE_TARGET_TYPE (type
)
3782 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3784 TYPE_TARGET_TYPE (type
)
3785 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3790 type
= dwarf_base_type (encoding
, size
, cu
);
3795 /* Read a whole compilation unit into a linked list of dies. */
3797 static struct die_info
*
3798 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
3800 /* Reset die reference table; we are
3801 building new ones now. */
3802 dwarf2_empty_hash_tables ();
3804 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
3807 /* Read a single die and all its descendents. Set the die's sibling
3808 field to NULL; set other fields in the die correctly, and set all
3809 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
3810 location of the info_ptr after reading all of those dies. PARENT
3811 is the parent of the die in question. */
3813 static struct die_info
*
3814 read_die_and_children (char *info_ptr
, bfd
*abfd
,
3815 struct dwarf2_cu
*cu
,
3816 char **new_info_ptr
,
3817 struct die_info
*parent
)
3819 struct die_info
*die
;
3823 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
3824 store_in_ref_table (die
->offset
, die
);
3828 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
3834 *new_info_ptr
= cur_ptr
;
3837 die
->sibling
= NULL
;
3838 die
->parent
= parent
;
3842 /* Read a die, all of its descendents, and all of its siblings; set
3843 all of the fields of all of the dies correctly. Arguments are as
3844 in read_die_and_children. */
3846 static struct die_info
*
3847 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
3848 struct dwarf2_cu
*cu
,
3849 char **new_info_ptr
,
3850 struct die_info
*parent
)
3852 struct die_info
*first_die
, *last_sibling
;
3856 first_die
= last_sibling
= NULL
;
3860 struct die_info
*die
3861 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
3869 last_sibling
->sibling
= die
;
3874 *new_info_ptr
= cur_ptr
;
3884 /* Free a linked list of dies. */
3887 free_die_list (struct die_info
*dies
)
3889 struct die_info
*die
, *next
;
3894 if (die
->child
!= NULL
)
3895 free_die_list (die
->child
);
3896 next
= die
->sibling
;
3904 do_free_die_list_cleanup (void *dies
)
3906 free_die_list (dies
);
3909 static struct cleanup
*
3910 make_cleanup_free_die_list (struct die_info
*dies
)
3912 return make_cleanup (do_free_die_list_cleanup
, dies
);
3916 /* Read the contents of the section at OFFSET and of size SIZE from the
3917 object file specified by OBJFILE into the psymbol_obstack and return it. */
3920 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3921 unsigned int size
, asection
*sectp
)
3923 bfd
*abfd
= objfile
->obfd
;
3929 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3931 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
3935 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3936 (bfd_bread (buf
, size
, abfd
) != size
))
3939 error ("Dwarf Error: Can't read DWARF data from '%s'",
3940 bfd_get_filename (abfd
));
3945 /* In DWARF version 2, the description of the debugging information is
3946 stored in a separate .debug_abbrev section. Before we read any
3947 dies from a section we read in all abbreviations and install them
3951 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
3953 struct comp_unit_head
*cu_header
= &cu
->header
;
3955 struct abbrev_info
*cur_abbrev
;
3956 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3957 unsigned int abbrev_form
, hash_number
;
3959 /* Initialize dwarf2 abbrevs */
3960 memset (cu_header
->dwarf2_abbrevs
, 0,
3961 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
3963 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
3964 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3965 abbrev_ptr
+= bytes_read
;
3967 /* loop until we reach an abbrev number of 0 */
3968 while (abbrev_number
)
3970 cur_abbrev
= dwarf_alloc_abbrev ();
3972 /* read in abbrev header */
3973 cur_abbrev
->number
= abbrev_number
;
3974 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3975 abbrev_ptr
+= bytes_read
;
3976 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3979 /* now read in declarations */
3980 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3981 abbrev_ptr
+= bytes_read
;
3982 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3983 abbrev_ptr
+= bytes_read
;
3986 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3988 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3989 xrealloc (cur_abbrev
->attrs
,
3990 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3991 * sizeof (struct attr_abbrev
));
3993 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3994 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3995 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3996 abbrev_ptr
+= bytes_read
;
3997 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3998 abbrev_ptr
+= bytes_read
;
4001 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
4002 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
4003 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
4005 /* Get next abbreviation.
4006 Under Irix6 the abbreviations for a compilation unit are not
4007 always properly terminated with an abbrev number of 0.
4008 Exit loop if we encounter an abbreviation which we have
4009 already read (which means we are about to read the abbreviations
4010 for the next compile unit) or if the end of the abbreviation
4011 table is reached. */
4012 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
4013 >= dwarf_abbrev_size
)
4015 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4016 abbrev_ptr
+= bytes_read
;
4017 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
4022 /* Empty the abbrev table for a new compilation unit. */
4025 dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table
)
4028 struct abbrev_info
*abbrev
, *next
;
4029 struct abbrev_info
**abbrevs
;
4031 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
4033 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
4036 abbrev
= abbrevs
[i
];
4039 next
= abbrev
->next
;
4040 xfree (abbrev
->attrs
);
4048 /* Lookup an abbrev_info structure in the abbrev hash table. */
4050 static struct abbrev_info
*
4051 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
4053 struct comp_unit_head
*cu_header
= &cu
->header
;
4054 unsigned int hash_number
;
4055 struct abbrev_info
*abbrev
;
4057 hash_number
= number
% ABBREV_HASH_SIZE
;
4058 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
4062 if (abbrev
->number
== number
)
4065 abbrev
= abbrev
->next
;
4070 /* Read a minimal amount of information into the minimal die structure. */
4073 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
4074 char *info_ptr
, struct dwarf2_cu
*cu
)
4076 unsigned int abbrev_number
, bytes_read
, i
;
4077 struct abbrev_info
*abbrev
;
4078 struct attribute attr
;
4079 struct attribute spec_attr
;
4080 int found_spec_attr
= 0;
4081 int has_low_pc_attr
= 0;
4082 int has_high_pc_attr
= 0;
4084 *part_die
= zeroed_partial_die
;
4085 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4086 info_ptr
+= bytes_read
;
4090 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4093 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number
,
4094 bfd_get_filename (abfd
));
4096 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
4097 part_die
->tag
= abbrev
->tag
;
4098 part_die
->has_children
= abbrev
->has_children
;
4099 part_die
->abbrev
= abbrev_number
;
4101 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4103 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
4105 /* Store the data if it is of an attribute we want to keep in a
4106 partial symbol table. */
4111 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
4112 if (part_die
->name
== NULL
)
4113 part_die
->name
= DW_STRING (&attr
);
4115 case DW_AT_MIPS_linkage_name
:
4116 part_die
->name
= DW_STRING (&attr
);
4119 has_low_pc_attr
= 1;
4120 part_die
->lowpc
= DW_ADDR (&attr
);
4123 has_high_pc_attr
= 1;
4124 part_die
->highpc
= DW_ADDR (&attr
);
4126 case DW_AT_location
:
4127 /* Support the .debug_loc offsets */
4128 if (attr_form_is_block (&attr
))
4130 part_die
->locdesc
= DW_BLOCK (&attr
);
4132 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
4134 dwarf2_complex_location_expr_complaint ();
4138 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4139 "partial symbol information");
4142 case DW_AT_language
:
4143 part_die
->language
= DW_UNSND (&attr
);
4145 case DW_AT_external
:
4146 part_die
->is_external
= DW_UNSND (&attr
);
4148 case DW_AT_declaration
:
4149 part_die
->is_declaration
= DW_UNSND (&attr
);
4152 part_die
->has_type
= 1;
4154 case DW_AT_abstract_origin
:
4155 case DW_AT_specification
:
4156 found_spec_attr
= 1;
4160 /* Ignore absolute siblings, they might point outside of
4161 the current compile unit. */
4162 if (attr
.form
== DW_FORM_ref_addr
)
4163 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
4166 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
4173 /* If we found a reference attribute and the die has no name, try
4174 to find a name in the referred to die. */
4176 if (found_spec_attr
&& part_die
->name
== NULL
)
4178 struct partial_die_info spec_die
;
4181 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
4182 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu
);
4185 part_die
->name
= spec_die
.name
;
4187 /* Copy DW_AT_external attribute if it is set. */
4188 if (spec_die
.is_external
)
4189 part_die
->is_external
= spec_die
.is_external
;
4193 /* When using the GNU linker, .gnu.linkonce. sections are used to
4194 eliminate duplicate copies of functions and vtables and such.
4195 The linker will arbitrarily choose one and discard the others.
4196 The AT_*_pc values for such functions refer to local labels in
4197 these sections. If the section from that file was discarded, the
4198 labels are not in the output, so the relocs get a value of 0.
4199 If this is a discarded function, mark the pc bounds as invalid,
4200 so that GDB will ignore it. */
4201 if (has_low_pc_attr
&& has_high_pc_attr
4202 && part_die
->lowpc
< part_die
->highpc
4203 && (part_die
->lowpc
!= 0
4204 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
4205 part_die
->has_pc_info
= 1;
4209 /* Read the die from the .debug_info section buffer. Set DIEP to
4210 point to a newly allocated die with its information, except for its
4211 child, sibling, and parent fields. Set HAS_CHILDREN to tell
4212 whether the die has children or not. */
4215 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
4216 struct dwarf2_cu
*cu
, int *has_children
)
4218 unsigned int abbrev_number
, bytes_read
, i
, offset
;
4219 struct abbrev_info
*abbrev
;
4220 struct die_info
*die
;
4222 offset
= info_ptr
- dwarf_info_buffer
;
4223 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4224 info_ptr
+= bytes_read
;
4227 die
= dwarf_alloc_die ();
4229 die
->abbrev
= abbrev_number
;
4236 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4239 error ("Dwarf Error: could not find abbrev number %d [in module %s]",
4241 bfd_get_filename (abfd
));
4243 die
= dwarf_alloc_die ();
4244 die
->offset
= offset
;
4245 die
->tag
= abbrev
->tag
;
4246 die
->abbrev
= abbrev_number
;
4249 die
->num_attrs
= abbrev
->num_attrs
;
4250 die
->attrs
= (struct attribute
*)
4251 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
4253 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4255 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
4256 abfd
, info_ptr
, cu
);
4260 *has_children
= abbrev
->has_children
;
4264 /* Read an attribute value described by an attribute form. */
4267 read_attribute_value (struct attribute
*attr
, unsigned form
,
4268 bfd
*abfd
, char *info_ptr
,
4269 struct dwarf2_cu
*cu
)
4271 struct comp_unit_head
*cu_header
= &cu
->header
;
4272 unsigned int bytes_read
;
4273 struct dwarf_block
*blk
;
4279 case DW_FORM_ref_addr
:
4280 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
4281 info_ptr
+= bytes_read
;
4283 case DW_FORM_block2
:
4284 blk
= dwarf_alloc_block ();
4285 blk
->size
= read_2_bytes (abfd
, info_ptr
);
4287 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4288 info_ptr
+= blk
->size
;
4289 DW_BLOCK (attr
) = blk
;
4291 case DW_FORM_block4
:
4292 blk
= dwarf_alloc_block ();
4293 blk
->size
= read_4_bytes (abfd
, info_ptr
);
4295 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4296 info_ptr
+= blk
->size
;
4297 DW_BLOCK (attr
) = blk
;
4300 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4304 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4308 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4311 case DW_FORM_string
:
4312 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
4313 info_ptr
+= bytes_read
;
4316 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
4318 info_ptr
+= bytes_read
;
4321 blk
= dwarf_alloc_block ();
4322 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4323 info_ptr
+= bytes_read
;
4324 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4325 info_ptr
+= blk
->size
;
4326 DW_BLOCK (attr
) = blk
;
4328 case DW_FORM_block1
:
4329 blk
= dwarf_alloc_block ();
4330 blk
->size
= read_1_byte (abfd
, info_ptr
);
4332 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4333 info_ptr
+= blk
->size
;
4334 DW_BLOCK (attr
) = blk
;
4337 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4341 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4345 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
4346 info_ptr
+= bytes_read
;
4349 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4350 info_ptr
+= bytes_read
;
4353 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4357 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4361 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4365 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4368 case DW_FORM_ref_udata
:
4369 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4370 info_ptr
+= bytes_read
;
4372 case DW_FORM_indirect
:
4373 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4374 info_ptr
+= bytes_read
;
4375 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
4378 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4379 dwarf_form_name (form
),
4380 bfd_get_filename (abfd
));
4385 /* Read an attribute described by an abbreviated attribute. */
4388 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
4389 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
4391 attr
->name
= abbrev
->name
;
4392 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
4395 /* read dwarf information from a buffer */
4398 read_1_byte (bfd
*abfd
, char *buf
)
4400 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4404 read_1_signed_byte (bfd
*abfd
, char *buf
)
4406 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
4410 read_2_bytes (bfd
*abfd
, char *buf
)
4412 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4416 read_2_signed_bytes (bfd
*abfd
, char *buf
)
4418 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4422 read_4_bytes (bfd
*abfd
, char *buf
)
4424 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4428 read_4_signed_bytes (bfd
*abfd
, char *buf
)
4430 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4433 static unsigned long
4434 read_8_bytes (bfd
*abfd
, char *buf
)
4436 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4440 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
4442 struct comp_unit_head
*cu_header
= &cu
->header
;
4443 CORE_ADDR retval
= 0;
4445 if (cu_header
->signed_addr_p
)
4447 switch (cu_header
->addr_size
)
4450 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4453 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4456 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
4459 internal_error (__FILE__
, __LINE__
,
4460 "read_address: bad switch, signed [in module %s]",
4461 bfd_get_filename (abfd
));
4466 switch (cu_header
->addr_size
)
4469 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4472 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4475 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4478 internal_error (__FILE__
, __LINE__
,
4479 "read_address: bad switch, unsigned [in module %s]",
4480 bfd_get_filename (abfd
));
4484 *bytes_read
= cu_header
->addr_size
;
4488 /* Read the initial length from a section. The (draft) DWARF 3
4489 specification allows the initial length to take up either 4 bytes
4490 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4491 bytes describe the length and all offsets will be 8 bytes in length
4494 An older, non-standard 64-bit format is also handled by this
4495 function. The older format in question stores the initial length
4496 as an 8-byte quantity without an escape value. Lengths greater
4497 than 2^32 aren't very common which means that the initial 4 bytes
4498 is almost always zero. Since a length value of zero doesn't make
4499 sense for the 32-bit format, this initial zero can be considered to
4500 be an escape value which indicates the presence of the older 64-bit
4501 format. As written, the code can't detect (old format) lengths
4502 greater than 4GB. If it becomes necessary to handle lengths somewhat
4503 larger than 4GB, we could allow other small values (such as the
4504 non-sensical values of 1, 2, and 3) to also be used as escape values
4505 indicating the presence of the old format.
4507 The value returned via bytes_read should be used to increment
4508 the relevant pointer after calling read_initial_length().
4510 As a side effect, this function sets the fields initial_length_size
4511 and offset_size in cu_header to the values appropriate for the
4512 length field. (The format of the initial length field determines
4513 the width of file offsets to be fetched later with fetch_offset().)
4515 [ Note: read_initial_length() and read_offset() are based on the
4516 document entitled "DWARF Debugging Information Format", revision
4517 3, draft 8, dated November 19, 2001. This document was obtained
4520 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4522 This document is only a draft and is subject to change. (So beware.)
4524 Details regarding the older, non-standard 64-bit format were
4525 determined empirically by examining 64-bit ELF files produced
4526 by the SGI toolchain on an IRIX 6.5 machine.
4528 - Kevin, July 16, 2002
4532 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4537 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4539 if (retval
== 0xffffffff)
4541 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4543 if (cu_header
!= NULL
)
4545 cu_header
->initial_length_size
= 12;
4546 cu_header
->offset_size
= 8;
4549 else if (retval
== 0)
4551 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4553 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4555 if (cu_header
!= NULL
)
4557 cu_header
->initial_length_size
= 8;
4558 cu_header
->offset_size
= 8;
4564 if (cu_header
!= NULL
)
4566 cu_header
->initial_length_size
= 4;
4567 cu_header
->offset_size
= 4;
4574 /* Read an offset from the data stream. The size of the offset is
4575 given by cu_header->offset_size. */
4578 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4583 switch (cu_header
->offset_size
)
4586 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4590 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4594 internal_error (__FILE__
, __LINE__
,
4595 "read_offset: bad switch [in module %s]",
4596 bfd_get_filename (abfd
));
4603 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4605 /* If the size of a host char is 8 bits, we can return a pointer
4606 to the buffer, otherwise we have to copy the data to a buffer
4607 allocated on the temporary obstack. */
4608 gdb_assert (HOST_CHAR_BIT
== 8);
4613 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4615 /* If the size of a host char is 8 bits, we can return a pointer
4616 to the string, otherwise we have to copy the string to a buffer
4617 allocated on the temporary obstack. */
4618 gdb_assert (HOST_CHAR_BIT
== 8);
4621 *bytes_read_ptr
= 1;
4624 *bytes_read_ptr
= strlen (buf
) + 1;
4629 read_indirect_string (bfd
*abfd
, char *buf
,
4630 const struct comp_unit_head
*cu_header
,
4631 unsigned int *bytes_read_ptr
)
4633 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4634 (int *) bytes_read_ptr
);
4636 if (dwarf_str_buffer
== NULL
)
4638 error ("DW_FORM_strp used without .debug_str section [in module %s]",
4639 bfd_get_filename (abfd
));
4642 if (str_offset
>= dwarf_str_size
)
4644 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4645 bfd_get_filename (abfd
));
4648 gdb_assert (HOST_CHAR_BIT
== 8);
4649 if (dwarf_str_buffer
[str_offset
] == '\0')
4651 return dwarf_str_buffer
+ str_offset
;
4654 static unsigned long
4655 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4657 unsigned long result
;
4658 unsigned int num_read
;
4668 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4671 result
|= ((unsigned long)(byte
& 127) << shift
);
4672 if ((byte
& 128) == 0)
4678 *bytes_read_ptr
= num_read
;
4683 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4686 int i
, shift
, size
, num_read
;
4696 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4699 result
|= ((long)(byte
& 127) << shift
);
4701 if ((byte
& 128) == 0)
4706 if ((shift
< size
) && (byte
& 0x40))
4708 result
|= -(1 << shift
);
4710 *bytes_read_ptr
= num_read
;
4715 set_cu_language (unsigned int lang
)
4721 cu_language
= language_c
;
4723 case DW_LANG_C_plus_plus
:
4724 cu_language
= language_cplus
;
4726 case DW_LANG_Fortran77
:
4727 case DW_LANG_Fortran90
:
4728 case DW_LANG_Fortran95
:
4729 cu_language
= language_fortran
;
4731 case DW_LANG_Mips_Assembler
:
4732 cu_language
= language_asm
;
4735 cu_language
= language_java
;
4739 case DW_LANG_Cobol74
:
4740 case DW_LANG_Cobol85
:
4741 case DW_LANG_Pascal83
:
4742 case DW_LANG_Modula2
:
4744 cu_language
= language_minimal
;
4747 cu_language_defn
= language_def (cu_language
);
4750 /* Return the named attribute or NULL if not there. */
4752 static struct attribute
*
4753 dwarf_attr (struct die_info
*die
, unsigned int name
)
4756 struct attribute
*spec
= NULL
;
4758 for (i
= 0; i
< die
->num_attrs
; ++i
)
4760 if (die
->attrs
[i
].name
== name
)
4762 return &die
->attrs
[i
];
4764 if (die
->attrs
[i
].name
== DW_AT_specification
4765 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4766 spec
= &die
->attrs
[i
];
4770 struct die_info
*ref_die
=
4771 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4774 return dwarf_attr (ref_die
, name
);
4781 die_is_declaration (struct die_info
*die
)
4783 return (dwarf_attr (die
, DW_AT_declaration
)
4784 && ! dwarf_attr (die
, DW_AT_specification
));
4788 /* Free the line_header structure *LH, and any arrays and strings it
4791 free_line_header (struct line_header
*lh
)
4793 if (lh
->standard_opcode_lengths
)
4794 xfree (lh
->standard_opcode_lengths
);
4796 /* Remember that all the lh->file_names[i].name pointers are
4797 pointers into debug_line_buffer, and don't need to be freed. */
4799 xfree (lh
->file_names
);
4801 /* Similarly for the include directory names. */
4802 if (lh
->include_dirs
)
4803 xfree (lh
->include_dirs
);
4809 /* Add an entry to LH's include directory table. */
4811 add_include_dir (struct line_header
*lh
, char *include_dir
)
4813 /* Grow the array if necessary. */
4814 if (lh
->include_dirs_size
== 0)
4816 lh
->include_dirs_size
= 1; /* for testing */
4817 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4818 * sizeof (*lh
->include_dirs
));
4820 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4822 lh
->include_dirs_size
*= 2;
4823 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4824 (lh
->include_dirs_size
4825 * sizeof (*lh
->include_dirs
)));
4828 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4832 /* Add an entry to LH's file name table. */
4834 add_file_name (struct line_header
*lh
,
4836 unsigned int dir_index
,
4837 unsigned int mod_time
,
4838 unsigned int length
)
4840 struct file_entry
*fe
;
4842 /* Grow the array if necessary. */
4843 if (lh
->file_names_size
== 0)
4845 lh
->file_names_size
= 1; /* for testing */
4846 lh
->file_names
= xmalloc (lh
->file_names_size
4847 * sizeof (*lh
->file_names
));
4849 else if (lh
->num_file_names
>= lh
->file_names_size
)
4851 lh
->file_names_size
*= 2;
4852 lh
->file_names
= xrealloc (lh
->file_names
,
4853 (lh
->file_names_size
4854 * sizeof (*lh
->file_names
)));
4857 fe
= &lh
->file_names
[lh
->num_file_names
++];
4859 fe
->dir_index
= dir_index
;
4860 fe
->mod_time
= mod_time
;
4861 fe
->length
= length
;
4865 /* Read the statement program header starting at OFFSET in
4866 dwarf_line_buffer, according to the endianness of ABFD. Return a
4867 pointer to a struct line_header, allocated using xmalloc.
4869 NOTE: the strings in the include directory and file name tables of
4870 the returned object point into debug_line_buffer, and must not be
4872 static struct line_header
*
4873 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4874 struct dwarf2_cu
*cu
)
4876 struct cleanup
*back_to
;
4877 struct line_header
*lh
;
4881 char *cur_dir
, *cur_file
;
4883 if (dwarf_line_buffer
== NULL
)
4885 complaint (&symfile_complaints
, "missing .debug_line section");
4889 /* Make sure that at least there's room for the total_length field. That
4890 could be 12 bytes long, but we're just going to fudge that. */
4891 if (offset
+ 4 >= dwarf_line_size
)
4893 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4897 lh
= xmalloc (sizeof (*lh
));
4898 memset (lh
, 0, sizeof (*lh
));
4899 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4902 line_ptr
= dwarf_line_buffer
+ offset
;
4904 /* read in the header */
4905 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4906 line_ptr
+= bytes_read
;
4907 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4909 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4912 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4913 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4915 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
4916 line_ptr
+= bytes_read
;
4917 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4919 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4921 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4923 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4925 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4927 lh
->standard_opcode_lengths
4928 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4930 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4931 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4933 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4937 /* Read directory table */
4938 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4940 line_ptr
+= bytes_read
;
4941 add_include_dir (lh
, cur_dir
);
4943 line_ptr
+= bytes_read
;
4945 /* Read file name table */
4946 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4948 unsigned int dir_index
, mod_time
, length
;
4950 line_ptr
+= bytes_read
;
4951 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4952 line_ptr
+= bytes_read
;
4953 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4954 line_ptr
+= bytes_read
;
4955 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4956 line_ptr
+= bytes_read
;
4958 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4960 line_ptr
+= bytes_read
;
4961 lh
->statement_program_start
= line_ptr
;
4963 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4964 complaint (&symfile_complaints
,
4965 "line number info header doesn't fit in `.debug_line' section");
4967 discard_cleanups (back_to
);
4971 /* This function exists to work around a bug in certain compilers
4972 (particularly GCC 2.95), in which the first line number marker of a
4973 function does not show up until after the prologue, right before
4974 the second line number marker. This function shifts ADDRESS down
4975 to the beginning of the function if necessary, and is called on
4976 addresses passed to record_line. */
4979 check_cu_functions (CORE_ADDR address
)
4981 struct function_range
*fn
;
4983 /* Find the function_range containing address. */
4988 cu_cached_fn
= cu_first_fn
;
4992 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4998 while (fn
&& fn
!= cu_cached_fn
)
4999 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5009 if (address
!= fn
->lowpc
)
5010 complaint (&symfile_complaints
,
5011 "misplaced first line number at 0x%lx for '%s'",
5012 (unsigned long) address
, fn
->name
);
5017 /* Decode the line number information for the compilation unit whose
5018 line number info is at OFFSET in the .debug_line section.
5019 The compilation directory of the file is passed in COMP_DIR. */
5022 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
5023 struct dwarf2_cu
*cu
)
5027 unsigned int bytes_read
;
5028 unsigned char op_code
, extended_op
, adj_opcode
;
5030 line_ptr
= lh
->statement_program_start
;
5031 line_end
= lh
->statement_program_end
;
5033 /* Read the statement sequences until there's nothing left. */
5034 while (line_ptr
< line_end
)
5036 /* state machine registers */
5037 CORE_ADDR address
= 0;
5038 unsigned int file
= 1;
5039 unsigned int line
= 1;
5040 unsigned int column
= 0;
5041 int is_stmt
= lh
->default_is_stmt
;
5042 int basic_block
= 0;
5043 int end_sequence
= 0;
5045 /* Start a subfile for the current file of the state machine. */
5046 if (lh
->num_file_names
>= file
)
5048 /* lh->include_dirs and lh->file_names are 0-based, but the
5049 directory and file name numbers in the statement program
5051 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
5054 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5057 dwarf2_start_subfile (fe
->name
, dir
);
5060 /* Decode the table. */
5061 while (!end_sequence
)
5063 op_code
= read_1_byte (abfd
, line_ptr
);
5066 if (op_code
>= lh
->opcode_base
)
5067 { /* Special operand. */
5068 adj_opcode
= op_code
- lh
->opcode_base
;
5069 address
+= (adj_opcode
/ lh
->line_range
)
5070 * lh
->minimum_instruction_length
;
5071 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
5072 /* append row to matrix using current values */
5073 record_line (current_subfile
, line
,
5074 check_cu_functions (address
));
5077 else switch (op_code
)
5079 case DW_LNS_extended_op
:
5080 line_ptr
+= 1; /* ignore length */
5081 extended_op
= read_1_byte (abfd
, line_ptr
);
5083 switch (extended_op
)
5085 case DW_LNE_end_sequence
:
5087 record_line (current_subfile
, 0, address
);
5089 case DW_LNE_set_address
:
5090 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
5091 line_ptr
+= bytes_read
;
5092 address
+= baseaddr
;
5094 case DW_LNE_define_file
:
5097 unsigned int dir_index
, mod_time
, length
;
5099 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
5100 line_ptr
+= bytes_read
;
5102 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5103 line_ptr
+= bytes_read
;
5105 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5106 line_ptr
+= bytes_read
;
5108 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5109 line_ptr
+= bytes_read
;
5110 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5114 complaint (&symfile_complaints
,
5115 "mangled .debug_line section");
5120 record_line (current_subfile
, line
,
5121 check_cu_functions (address
));
5124 case DW_LNS_advance_pc
:
5125 address
+= lh
->minimum_instruction_length
5126 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5127 line_ptr
+= bytes_read
;
5129 case DW_LNS_advance_line
:
5130 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
5131 line_ptr
+= bytes_read
;
5133 case DW_LNS_set_file
:
5135 /* lh->include_dirs and lh->file_names are 0-based,
5136 but the directory and file name numbers in the
5137 statement program are 1-based. */
5138 struct file_entry
*fe
;
5140 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5141 line_ptr
+= bytes_read
;
5142 fe
= &lh
->file_names
[file
- 1];
5144 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5147 dwarf2_start_subfile (fe
->name
, dir
);
5150 case DW_LNS_set_column
:
5151 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5152 line_ptr
+= bytes_read
;
5154 case DW_LNS_negate_stmt
:
5155 is_stmt
= (!is_stmt
);
5157 case DW_LNS_set_basic_block
:
5160 /* Add to the address register of the state machine the
5161 address increment value corresponding to special opcode
5162 255. Ie, this value is scaled by the minimum instruction
5163 length since special opcode 255 would have scaled the
5165 case DW_LNS_const_add_pc
:
5166 address
+= (lh
->minimum_instruction_length
5167 * ((255 - lh
->opcode_base
) / lh
->line_range
));
5169 case DW_LNS_fixed_advance_pc
:
5170 address
+= read_2_bytes (abfd
, line_ptr
);
5174 { /* Unknown standard opcode, ignore it. */
5176 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
5178 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5179 line_ptr
+= bytes_read
;
5187 /* Start a subfile for DWARF. FILENAME is the name of the file and
5188 DIRNAME the name of the source directory which contains FILENAME
5189 or NULL if not known.
5190 This routine tries to keep line numbers from identical absolute and
5191 relative file names in a common subfile.
5193 Using the `list' example from the GDB testsuite, which resides in
5194 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
5195 of /srcdir/list0.c yields the following debugging information for list0.c:
5197 DW_AT_name: /srcdir/list0.c
5198 DW_AT_comp_dir: /compdir
5199 files.files[0].name: list0.h
5200 files.files[0].dir: /srcdir
5201 files.files[1].name: list0.c
5202 files.files[1].dir: /srcdir
5204 The line number information for list0.c has to end up in a single
5205 subfile, so that `break /srcdir/list0.c:1' works as expected. */
5208 dwarf2_start_subfile (char *filename
, char *dirname
)
5210 /* If the filename isn't absolute, try to match an existing subfile
5211 with the full pathname. */
5213 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
5215 struct subfile
*subfile
;
5216 char *fullname
= concat (dirname
, "/", filename
, NULL
);
5218 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
5220 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
5222 current_subfile
= subfile
;
5229 start_subfile (filename
, dirname
);
5233 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
5234 struct dwarf2_cu
*cu
)
5236 struct objfile
*objfile
= cu
->objfile
;
5237 struct comp_unit_head
*cu_header
= &cu
->header
;
5239 /* NOTE drow/2003-01-30: There used to be a comment and some special
5240 code here to turn a symbol with DW_AT_external and a
5241 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
5242 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
5243 with some versions of binutils) where shared libraries could have
5244 relocations against symbols in their debug information - the
5245 minimal symbol would have the right address, but the debug info
5246 would not. It's no longer necessary, because we will explicitly
5247 apply relocations when we read in the debug information now. */
5249 /* A DW_AT_location attribute with no contents indicates that a
5250 variable has been optimized away. */
5251 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
5253 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
5257 /* Handle one degenerate form of location expression specially, to
5258 preserve GDB's previous behavior when section offsets are
5259 specified. If this is just a DW_OP_addr then mark this symbol
5262 if (attr_form_is_block (attr
)
5263 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
5264 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
5268 SYMBOL_VALUE_ADDRESS (sym
) =
5269 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
5270 fixup_symbol_section (sym
, objfile
);
5271 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
5272 SYMBOL_SECTION (sym
));
5273 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5277 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
5278 expression evaluator, and use LOC_COMPUTED only when necessary
5279 (i.e. when the value of a register or memory location is
5280 referenced, or a thread-local block, etc.). Then again, it might
5281 not be worthwhile. I'm assuming that it isn't unless performance
5282 or memory numbers show me otherwise. */
5284 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
5285 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
5288 /* Given a pointer to a DWARF information entry, figure out if we need
5289 to make a symbol table entry for it, and if so, create a new entry
5290 and return a pointer to it.
5291 If TYPE is NULL, determine symbol type from the die, otherwise
5292 used the passed type. */
5294 static struct symbol
*
5295 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
5297 struct objfile
*objfile
= cu
->objfile
;
5298 struct symbol
*sym
= NULL
;
5300 struct attribute
*attr
= NULL
;
5301 struct attribute
*attr2
= NULL
;
5303 if (die
->tag
!= DW_TAG_namespace
)
5304 name
= dwarf2_linkage_name (die
);
5306 name
= TYPE_NAME (type
);
5310 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
5311 sizeof (struct symbol
));
5312 OBJSTAT (objfile
, n_syms
++);
5313 memset (sym
, 0, sizeof (struct symbol
));
5315 /* Cache this symbol's name and the name's demangled form (if any). */
5316 SYMBOL_LANGUAGE (sym
) = cu_language
;
5317 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
5319 /* Default assumptions.
5320 Use the passed type or decode it from the die. */
5321 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5322 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5324 SYMBOL_TYPE (sym
) = type
;
5326 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
5327 attr
= dwarf_attr (die
, DW_AT_decl_line
);
5330 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
5335 attr
= dwarf_attr (die
, DW_AT_low_pc
);
5338 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
5340 SYMBOL_CLASS (sym
) = LOC_LABEL
;
5342 case DW_TAG_subprogram
:
5343 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
5345 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5346 attr2
= dwarf_attr (die
, DW_AT_external
);
5347 if (attr2
&& (DW_UNSND (attr2
) != 0))
5349 add_symbol_to_list (sym
, &global_symbols
);
5353 add_symbol_to_list (sym
, list_in_scope
);
5356 case DW_TAG_variable
:
5357 /* Compilation with minimal debug info may result in variables
5358 with missing type entries. Change the misleading `void' type
5359 to something sensible. */
5360 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
5361 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
5362 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
5363 "<variable, no debug info>",
5365 attr
= dwarf_attr (die
, DW_AT_const_value
);
5368 dwarf2_const_value (attr
, sym
, cu
);
5369 attr2
= dwarf_attr (die
, DW_AT_external
);
5370 if (attr2
&& (DW_UNSND (attr2
) != 0))
5371 add_symbol_to_list (sym
, &global_symbols
);
5373 add_symbol_to_list (sym
, list_in_scope
);
5376 attr
= dwarf_attr (die
, DW_AT_location
);
5379 var_decode_location (attr
, sym
, cu
);
5380 attr2
= dwarf_attr (die
, DW_AT_external
);
5381 if (attr2
&& (DW_UNSND (attr2
) != 0))
5382 add_symbol_to_list (sym
, &global_symbols
);
5384 add_symbol_to_list (sym
, list_in_scope
);
5388 /* We do not know the address of this symbol.
5389 If it is an external symbol and we have type information
5390 for it, enter the symbol as a LOC_UNRESOLVED symbol.
5391 The address of the variable will then be determined from
5392 the minimal symbol table whenever the variable is
5394 attr2
= dwarf_attr (die
, DW_AT_external
);
5395 if (attr2
&& (DW_UNSND (attr2
) != 0)
5396 && dwarf_attr (die
, DW_AT_type
) != NULL
)
5398 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
5399 add_symbol_to_list (sym
, &global_symbols
);
5403 case DW_TAG_formal_parameter
:
5404 attr
= dwarf_attr (die
, DW_AT_location
);
5407 var_decode_location (attr
, sym
, cu
);
5408 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
5409 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
5410 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
5412 attr
= dwarf_attr (die
, DW_AT_const_value
);
5415 dwarf2_const_value (attr
, sym
, cu
);
5417 add_symbol_to_list (sym
, list_in_scope
);
5419 case DW_TAG_unspecified_parameters
:
5420 /* From varargs functions; gdb doesn't seem to have any
5421 interest in this information, so just ignore it for now.
5424 case DW_TAG_class_type
:
5425 case DW_TAG_structure_type
:
5426 case DW_TAG_union_type
:
5427 case DW_TAG_enumeration_type
:
5428 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5429 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
5430 add_symbol_to_list (sym
, list_in_scope
);
5432 /* The semantics of C++ state that "struct foo { ... }" also
5433 defines a typedef for "foo". Synthesize a typedef symbol so
5434 that "ptype foo" works as expected. */
5435 if (cu_language
== language_cplus
)
5437 struct symbol
*typedef_sym
= (struct symbol
*)
5438 obstack_alloc (&objfile
->symbol_obstack
,
5439 sizeof (struct symbol
));
5440 *typedef_sym
= *sym
;
5441 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
5442 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5443 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5444 obsavestring (DEPRECATED_SYMBOL_NAME (sym
),
5445 strlen (DEPRECATED_SYMBOL_NAME (sym
)),
5446 &objfile
->type_obstack
);
5447 add_symbol_to_list (typedef_sym
, list_in_scope
);
5450 case DW_TAG_typedef
:
5451 case DW_TAG_base_type
:
5452 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5453 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5454 add_symbol_to_list (sym
, list_in_scope
);
5456 case DW_TAG_enumerator
:
5457 attr
= dwarf_attr (die
, DW_AT_const_value
);
5460 dwarf2_const_value (attr
, sym
, cu
);
5462 add_symbol_to_list (sym
, list_in_scope
);
5464 case DW_TAG_namespace
:
5465 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5466 add_symbol_to_list (sym
, &global_symbols
);
5469 /* Not a tag we recognize. Hopefully we aren't processing
5470 trash data, but since we must specifically ignore things
5471 we don't recognize, there is nothing else we should do at
5473 complaint (&symfile_complaints
, "unsupported tag: '%s'",
5474 dwarf_tag_name (die
->tag
));
5481 /* Copy constant value from an attribute to a symbol. */
5484 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5485 struct dwarf2_cu
*cu
)
5487 struct objfile
*objfile
= cu
->objfile
;
5488 struct comp_unit_head
*cu_header
= &cu
->header
;
5489 struct dwarf_block
*blk
;
5494 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5495 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5496 cu_header
->addr_size
,
5497 TYPE_LENGTH (SYMBOL_TYPE
5499 SYMBOL_VALUE_BYTES (sym
) = (char *)
5500 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5501 /* NOTE: cagney/2003-05-09: In-lined store_address call with
5502 it's body - store_unsigned_integer. */
5503 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5505 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5507 case DW_FORM_block1
:
5508 case DW_FORM_block2
:
5509 case DW_FORM_block4
:
5511 blk
= DW_BLOCK (attr
);
5512 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5513 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5515 TYPE_LENGTH (SYMBOL_TYPE
5517 SYMBOL_VALUE_BYTES (sym
) = (char *)
5518 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5519 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5520 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5523 /* The DW_AT_const_value attributes are supposed to carry the
5524 symbol's value "represented as it would be on the target
5525 architecture." By the time we get here, it's already been
5526 converted to host endianness, so we just need to sign- or
5527 zero-extend it as appropriate. */
5529 dwarf2_const_value_data (attr
, sym
, 8);
5532 dwarf2_const_value_data (attr
, sym
, 16);
5535 dwarf2_const_value_data (attr
, sym
, 32);
5538 dwarf2_const_value_data (attr
, sym
, 64);
5542 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5543 SYMBOL_CLASS (sym
) = LOC_CONST
;
5547 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5548 SYMBOL_CLASS (sym
) = LOC_CONST
;
5552 complaint (&symfile_complaints
,
5553 "unsupported const value attribute form: '%s'",
5554 dwarf_form_name (attr
->form
));
5555 SYMBOL_VALUE (sym
) = 0;
5556 SYMBOL_CLASS (sym
) = LOC_CONST
;
5562 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5563 or zero-extend it as appropriate for the symbol's type. */
5565 dwarf2_const_value_data (struct attribute
*attr
,
5569 LONGEST l
= DW_UNSND (attr
);
5571 if (bits
< sizeof (l
) * 8)
5573 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5574 l
&= ((LONGEST
) 1 << bits
) - 1;
5576 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5579 SYMBOL_VALUE (sym
) = l
;
5580 SYMBOL_CLASS (sym
) = LOC_CONST
;
5584 /* Return the type of the die in question using its DW_AT_type attribute. */
5586 static struct type
*
5587 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5590 struct attribute
*type_attr
;
5591 struct die_info
*type_die
;
5594 type_attr
= dwarf_attr (die
, DW_AT_type
);
5597 /* A missing DW_AT_type represents a void type. */
5598 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
);
5602 ref
= dwarf2_get_ref_die_offset (type_attr
);
5603 type_die
= follow_die_ref (ref
);
5606 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5607 ref
, cu
->objfile
->name
);
5611 type
= tag_type_to_type (type_die
, cu
);
5614 dump_die (type_die
);
5615 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5621 /* Return the containing type of the die in question using its
5622 DW_AT_containing_type attribute. */
5624 static struct type
*
5625 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5627 struct type
*type
= NULL
;
5628 struct attribute
*type_attr
;
5629 struct die_info
*type_die
= NULL
;
5632 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5635 ref
= dwarf2_get_ref_die_offset (type_attr
);
5636 type_die
= follow_die_ref (ref
);
5639 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref
,
5643 type
= tag_type_to_type (type_die
, cu
);
5648 dump_die (type_die
);
5649 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
5656 static struct type
*
5657 type_at_offset (unsigned int offset
, struct dwarf2_cu
*cu
)
5659 struct die_info
*die
;
5662 die
= follow_die_ref (offset
);
5665 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5668 type
= tag_type_to_type (die
, cu
);
5673 static struct type
*
5674 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5682 read_type_die (die
, cu
);
5686 error ("Dwarf Error: Cannot find type of die [in module %s]",
5694 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
5698 case DW_TAG_class_type
:
5699 case DW_TAG_structure_type
:
5700 case DW_TAG_union_type
:
5701 read_structure_scope (die
, cu
);
5703 case DW_TAG_enumeration_type
:
5704 read_enumeration (die
, cu
);
5706 case DW_TAG_subprogram
:
5707 case DW_TAG_subroutine_type
:
5708 read_subroutine_type (die
, cu
);
5710 case DW_TAG_array_type
:
5711 read_array_type (die
, cu
);
5713 case DW_TAG_pointer_type
:
5714 read_tag_pointer_type (die
, cu
);
5716 case DW_TAG_ptr_to_member_type
:
5717 read_tag_ptr_to_member_type (die
, cu
);
5719 case DW_TAG_reference_type
:
5720 read_tag_reference_type (die
, cu
);
5722 case DW_TAG_const_type
:
5723 read_tag_const_type (die
, cu
);
5725 case DW_TAG_volatile_type
:
5726 read_tag_volatile_type (die
, cu
);
5728 case DW_TAG_string_type
:
5729 read_tag_string_type (die
, cu
);
5731 case DW_TAG_typedef
:
5732 read_typedef (die
, cu
);
5734 case DW_TAG_base_type
:
5735 read_base_type (die
, cu
);
5738 complaint (&symfile_complaints
, "unexepected tag in read_type_die: '%s'",
5739 dwarf_tag_name (die
->tag
));
5744 static struct type
*
5745 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
5747 struct objfile
*objfile
= cu
->objfile
;
5749 /* FIXME - this should not produce a new (struct type *)
5750 every time. It should cache base types. */
5754 case DW_ATE_address
:
5755 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5757 case DW_ATE_boolean
:
5758 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5760 case DW_ATE_complex_float
:
5763 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5767 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5773 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5777 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5784 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5787 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5791 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5795 case DW_ATE_signed_char
:
5796 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5798 case DW_ATE_unsigned
:
5802 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5805 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5809 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5813 case DW_ATE_unsigned_char
:
5814 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5817 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5824 copy_die (struct die_info
*old_die
)
5826 struct die_info
*new_die
;
5829 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5830 memset (new_die
, 0, sizeof (struct die_info
));
5832 new_die
->tag
= old_die
->tag
;
5833 new_die
->has_children
= old_die
->has_children
;
5834 new_die
->abbrev
= old_die
->abbrev
;
5835 new_die
->offset
= old_die
->offset
;
5836 new_die
->type
= NULL
;
5838 num_attrs
= old_die
->num_attrs
;
5839 new_die
->num_attrs
= num_attrs
;
5840 new_die
->attrs
= (struct attribute
*)
5841 xmalloc (num_attrs
* sizeof (struct attribute
));
5843 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5845 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5846 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5847 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5850 new_die
->next
= NULL
;
5855 /* Return sibling of die, NULL if no sibling. */
5857 static struct die_info
*
5858 sibling_die (struct die_info
*die
)
5860 return die
->sibling
;
5863 /* Get linkage name of a die, return NULL if not found. */
5866 dwarf2_linkage_name (struct die_info
*die
)
5868 struct attribute
*attr
;
5870 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5871 if (attr
&& DW_STRING (attr
))
5872 return DW_STRING (attr
);
5873 attr
= dwarf_attr (die
, DW_AT_name
);
5874 if (attr
&& DW_STRING (attr
))
5875 return DW_STRING (attr
);
5879 /* Get name of a die, return NULL if not found. */
5882 dwarf2_name (struct die_info
*die
)
5884 struct attribute
*attr
;
5886 attr
= dwarf_attr (die
, DW_AT_name
);
5887 if (attr
&& DW_STRING (attr
))
5888 return DW_STRING (attr
);
5892 /* Return the die that this die in an extension of, or NULL if there
5895 static struct die_info
*
5896 dwarf2_extension (struct die_info
*die
)
5898 struct attribute
*attr
;
5899 struct die_info
*extension_die
;
5902 attr
= dwarf_attr (die
, DW_AT_extension
);
5906 ref
= dwarf2_get_ref_die_offset (attr
);
5907 extension_die
= follow_die_ref (ref
);
5910 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5913 return extension_die
;
5916 /* Convert a DIE tag into its string name. */
5919 dwarf_tag_name (unsigned tag
)
5923 case DW_TAG_padding
:
5924 return "DW_TAG_padding";
5925 case DW_TAG_array_type
:
5926 return "DW_TAG_array_type";
5927 case DW_TAG_class_type
:
5928 return "DW_TAG_class_type";
5929 case DW_TAG_entry_point
:
5930 return "DW_TAG_entry_point";
5931 case DW_TAG_enumeration_type
:
5932 return "DW_TAG_enumeration_type";
5933 case DW_TAG_formal_parameter
:
5934 return "DW_TAG_formal_parameter";
5935 case DW_TAG_imported_declaration
:
5936 return "DW_TAG_imported_declaration";
5938 return "DW_TAG_label";
5939 case DW_TAG_lexical_block
:
5940 return "DW_TAG_lexical_block";
5942 return "DW_TAG_member";
5943 case DW_TAG_pointer_type
:
5944 return "DW_TAG_pointer_type";
5945 case DW_TAG_reference_type
:
5946 return "DW_TAG_reference_type";
5947 case DW_TAG_compile_unit
:
5948 return "DW_TAG_compile_unit";
5949 case DW_TAG_string_type
:
5950 return "DW_TAG_string_type";
5951 case DW_TAG_structure_type
:
5952 return "DW_TAG_structure_type";
5953 case DW_TAG_subroutine_type
:
5954 return "DW_TAG_subroutine_type";
5955 case DW_TAG_typedef
:
5956 return "DW_TAG_typedef";
5957 case DW_TAG_union_type
:
5958 return "DW_TAG_union_type";
5959 case DW_TAG_unspecified_parameters
:
5960 return "DW_TAG_unspecified_parameters";
5961 case DW_TAG_variant
:
5962 return "DW_TAG_variant";
5963 case DW_TAG_common_block
:
5964 return "DW_TAG_common_block";
5965 case DW_TAG_common_inclusion
:
5966 return "DW_TAG_common_inclusion";
5967 case DW_TAG_inheritance
:
5968 return "DW_TAG_inheritance";
5969 case DW_TAG_inlined_subroutine
:
5970 return "DW_TAG_inlined_subroutine";
5972 return "DW_TAG_module";
5973 case DW_TAG_ptr_to_member_type
:
5974 return "DW_TAG_ptr_to_member_type";
5975 case DW_TAG_set_type
:
5976 return "DW_TAG_set_type";
5977 case DW_TAG_subrange_type
:
5978 return "DW_TAG_subrange_type";
5979 case DW_TAG_with_stmt
:
5980 return "DW_TAG_with_stmt";
5981 case DW_TAG_access_declaration
:
5982 return "DW_TAG_access_declaration";
5983 case DW_TAG_base_type
:
5984 return "DW_TAG_base_type";
5985 case DW_TAG_catch_block
:
5986 return "DW_TAG_catch_block";
5987 case DW_TAG_const_type
:
5988 return "DW_TAG_const_type";
5989 case DW_TAG_constant
:
5990 return "DW_TAG_constant";
5991 case DW_TAG_enumerator
:
5992 return "DW_TAG_enumerator";
5993 case DW_TAG_file_type
:
5994 return "DW_TAG_file_type";
5996 return "DW_TAG_friend";
5997 case DW_TAG_namelist
:
5998 return "DW_TAG_namelist";
5999 case DW_TAG_namelist_item
:
6000 return "DW_TAG_namelist_item";
6001 case DW_TAG_packed_type
:
6002 return "DW_TAG_packed_type";
6003 case DW_TAG_subprogram
:
6004 return "DW_TAG_subprogram";
6005 case DW_TAG_template_type_param
:
6006 return "DW_TAG_template_type_param";
6007 case DW_TAG_template_value_param
:
6008 return "DW_TAG_template_value_param";
6009 case DW_TAG_thrown_type
:
6010 return "DW_TAG_thrown_type";
6011 case DW_TAG_try_block
:
6012 return "DW_TAG_try_block";
6013 case DW_TAG_variant_part
:
6014 return "DW_TAG_variant_part";
6015 case DW_TAG_variable
:
6016 return "DW_TAG_variable";
6017 case DW_TAG_volatile_type
:
6018 return "DW_TAG_volatile_type";
6019 case DW_TAG_dwarf_procedure
:
6020 return "DW_TAG_dwarf_procedure";
6021 case DW_TAG_restrict_type
:
6022 return "DW_TAG_restrict_type";
6023 case DW_TAG_interface_type
:
6024 return "DW_TAG_interface_type";
6025 case DW_TAG_namespace
:
6026 return "DW_TAG_namespace";
6027 case DW_TAG_imported_module
:
6028 return "DW_TAG_imported_module";
6029 case DW_TAG_unspecified_type
:
6030 return "DW_TAG_unspecified_type";
6031 case DW_TAG_partial_unit
:
6032 return "DW_TAG_partial_unit";
6033 case DW_TAG_imported_unit
:
6034 return "DW_TAG_imported_unit";
6035 case DW_TAG_MIPS_loop
:
6036 return "DW_TAG_MIPS_loop";
6037 case DW_TAG_format_label
:
6038 return "DW_TAG_format_label";
6039 case DW_TAG_function_template
:
6040 return "DW_TAG_function_template";
6041 case DW_TAG_class_template
:
6042 return "DW_TAG_class_template";
6044 return "DW_TAG_<unknown>";
6048 /* Convert a DWARF attribute code into its string name. */
6051 dwarf_attr_name (unsigned attr
)
6056 return "DW_AT_sibling";
6057 case DW_AT_location
:
6058 return "DW_AT_location";
6060 return "DW_AT_name";
6061 case DW_AT_ordering
:
6062 return "DW_AT_ordering";
6063 case DW_AT_subscr_data
:
6064 return "DW_AT_subscr_data";
6065 case DW_AT_byte_size
:
6066 return "DW_AT_byte_size";
6067 case DW_AT_bit_offset
:
6068 return "DW_AT_bit_offset";
6069 case DW_AT_bit_size
:
6070 return "DW_AT_bit_size";
6071 case DW_AT_element_list
:
6072 return "DW_AT_element_list";
6073 case DW_AT_stmt_list
:
6074 return "DW_AT_stmt_list";
6076 return "DW_AT_low_pc";
6078 return "DW_AT_high_pc";
6079 case DW_AT_language
:
6080 return "DW_AT_language";
6082 return "DW_AT_member";
6084 return "DW_AT_discr";
6085 case DW_AT_discr_value
:
6086 return "DW_AT_discr_value";
6087 case DW_AT_visibility
:
6088 return "DW_AT_visibility";
6090 return "DW_AT_import";
6091 case DW_AT_string_length
:
6092 return "DW_AT_string_length";
6093 case DW_AT_common_reference
:
6094 return "DW_AT_common_reference";
6095 case DW_AT_comp_dir
:
6096 return "DW_AT_comp_dir";
6097 case DW_AT_const_value
:
6098 return "DW_AT_const_value";
6099 case DW_AT_containing_type
:
6100 return "DW_AT_containing_type";
6101 case DW_AT_default_value
:
6102 return "DW_AT_default_value";
6104 return "DW_AT_inline";
6105 case DW_AT_is_optional
:
6106 return "DW_AT_is_optional";
6107 case DW_AT_lower_bound
:
6108 return "DW_AT_lower_bound";
6109 case DW_AT_producer
:
6110 return "DW_AT_producer";
6111 case DW_AT_prototyped
:
6112 return "DW_AT_prototyped";
6113 case DW_AT_return_addr
:
6114 return "DW_AT_return_addr";
6115 case DW_AT_start_scope
:
6116 return "DW_AT_start_scope";
6117 case DW_AT_stride_size
:
6118 return "DW_AT_stride_size";
6119 case DW_AT_upper_bound
:
6120 return "DW_AT_upper_bound";
6121 case DW_AT_abstract_origin
:
6122 return "DW_AT_abstract_origin";
6123 case DW_AT_accessibility
:
6124 return "DW_AT_accessibility";
6125 case DW_AT_address_class
:
6126 return "DW_AT_address_class";
6127 case DW_AT_artificial
:
6128 return "DW_AT_artificial";
6129 case DW_AT_base_types
:
6130 return "DW_AT_base_types";
6131 case DW_AT_calling_convention
:
6132 return "DW_AT_calling_convention";
6134 return "DW_AT_count";
6135 case DW_AT_data_member_location
:
6136 return "DW_AT_data_member_location";
6137 case DW_AT_decl_column
:
6138 return "DW_AT_decl_column";
6139 case DW_AT_decl_file
:
6140 return "DW_AT_decl_file";
6141 case DW_AT_decl_line
:
6142 return "DW_AT_decl_line";
6143 case DW_AT_declaration
:
6144 return "DW_AT_declaration";
6145 case DW_AT_discr_list
:
6146 return "DW_AT_discr_list";
6147 case DW_AT_encoding
:
6148 return "DW_AT_encoding";
6149 case DW_AT_external
:
6150 return "DW_AT_external";
6151 case DW_AT_frame_base
:
6152 return "DW_AT_frame_base";
6154 return "DW_AT_friend";
6155 case DW_AT_identifier_case
:
6156 return "DW_AT_identifier_case";
6157 case DW_AT_macro_info
:
6158 return "DW_AT_macro_info";
6159 case DW_AT_namelist_items
:
6160 return "DW_AT_namelist_items";
6161 case DW_AT_priority
:
6162 return "DW_AT_priority";
6164 return "DW_AT_segment";
6165 case DW_AT_specification
:
6166 return "DW_AT_specification";
6167 case DW_AT_static_link
:
6168 return "DW_AT_static_link";
6170 return "DW_AT_type";
6171 case DW_AT_use_location
:
6172 return "DW_AT_use_location";
6173 case DW_AT_variable_parameter
:
6174 return "DW_AT_variable_parameter";
6175 case DW_AT_virtuality
:
6176 return "DW_AT_virtuality";
6177 case DW_AT_vtable_elem_location
:
6178 return "DW_AT_vtable_elem_location";
6179 case DW_AT_allocated
:
6180 return "DW_AT_allocated";
6181 case DW_AT_associated
:
6182 return "DW_AT_associated";
6183 case DW_AT_data_location
:
6184 return "DW_AT_data_location";
6186 return "DW_AT_stride";
6187 case DW_AT_entry_pc
:
6188 return "DW_AT_entry_pc";
6189 case DW_AT_use_UTF8
:
6190 return "DW_AT_use_UTF8";
6191 case DW_AT_extension
:
6192 return "DW_AT_extension";
6194 return "DW_AT_ranges";
6195 case DW_AT_trampoline
:
6196 return "DW_AT_trampoline";
6197 case DW_AT_call_column
:
6198 return "DW_AT_call_column";
6199 case DW_AT_call_file
:
6200 return "DW_AT_call_file";
6201 case DW_AT_call_line
:
6202 return "DW_AT_call_line";
6204 case DW_AT_MIPS_fde
:
6205 return "DW_AT_MIPS_fde";
6206 case DW_AT_MIPS_loop_begin
:
6207 return "DW_AT_MIPS_loop_begin";
6208 case DW_AT_MIPS_tail_loop_begin
:
6209 return "DW_AT_MIPS_tail_loop_begin";
6210 case DW_AT_MIPS_epilog_begin
:
6211 return "DW_AT_MIPS_epilog_begin";
6212 case DW_AT_MIPS_loop_unroll_factor
:
6213 return "DW_AT_MIPS_loop_unroll_factor";
6214 case DW_AT_MIPS_software_pipeline_depth
:
6215 return "DW_AT_MIPS_software_pipeline_depth";
6217 case DW_AT_MIPS_linkage_name
:
6218 return "DW_AT_MIPS_linkage_name";
6220 case DW_AT_sf_names
:
6221 return "DW_AT_sf_names";
6222 case DW_AT_src_info
:
6223 return "DW_AT_src_info";
6224 case DW_AT_mac_info
:
6225 return "DW_AT_mac_info";
6226 case DW_AT_src_coords
:
6227 return "DW_AT_src_coords";
6228 case DW_AT_body_begin
:
6229 return "DW_AT_body_begin";
6230 case DW_AT_body_end
:
6231 return "DW_AT_body_end";
6232 case DW_AT_GNU_vector
:
6233 return "DW_AT_GNU_vector";
6235 return "DW_AT_<unknown>";
6239 /* Convert a DWARF value form code into its string name. */
6242 dwarf_form_name (unsigned form
)
6247 return "DW_FORM_addr";
6248 case DW_FORM_block2
:
6249 return "DW_FORM_block2";
6250 case DW_FORM_block4
:
6251 return "DW_FORM_block4";
6253 return "DW_FORM_data2";
6255 return "DW_FORM_data4";
6257 return "DW_FORM_data8";
6258 case DW_FORM_string
:
6259 return "DW_FORM_string";
6261 return "DW_FORM_block";
6262 case DW_FORM_block1
:
6263 return "DW_FORM_block1";
6265 return "DW_FORM_data1";
6267 return "DW_FORM_flag";
6269 return "DW_FORM_sdata";
6271 return "DW_FORM_strp";
6273 return "DW_FORM_udata";
6274 case DW_FORM_ref_addr
:
6275 return "DW_FORM_ref_addr";
6277 return "DW_FORM_ref1";
6279 return "DW_FORM_ref2";
6281 return "DW_FORM_ref4";
6283 return "DW_FORM_ref8";
6284 case DW_FORM_ref_udata
:
6285 return "DW_FORM_ref_udata";
6286 case DW_FORM_indirect
:
6287 return "DW_FORM_indirect";
6289 return "DW_FORM_<unknown>";
6293 /* Convert a DWARF stack opcode into its string name. */
6296 dwarf_stack_op_name (unsigned op
)
6301 return "DW_OP_addr";
6303 return "DW_OP_deref";
6305 return "DW_OP_const1u";
6307 return "DW_OP_const1s";
6309 return "DW_OP_const2u";
6311 return "DW_OP_const2s";
6313 return "DW_OP_const4u";
6315 return "DW_OP_const4s";
6317 return "DW_OP_const8u";
6319 return "DW_OP_const8s";
6321 return "DW_OP_constu";
6323 return "DW_OP_consts";
6327 return "DW_OP_drop";
6329 return "DW_OP_over";
6331 return "DW_OP_pick";
6333 return "DW_OP_swap";
6337 return "DW_OP_xderef";
6345 return "DW_OP_minus";
6357 return "DW_OP_plus";
6358 case DW_OP_plus_uconst
:
6359 return "DW_OP_plus_uconst";
6365 return "DW_OP_shra";
6383 return "DW_OP_skip";
6385 return "DW_OP_lit0";
6387 return "DW_OP_lit1";
6389 return "DW_OP_lit2";
6391 return "DW_OP_lit3";
6393 return "DW_OP_lit4";
6395 return "DW_OP_lit5";
6397 return "DW_OP_lit6";
6399 return "DW_OP_lit7";
6401 return "DW_OP_lit8";
6403 return "DW_OP_lit9";
6405 return "DW_OP_lit10";
6407 return "DW_OP_lit11";
6409 return "DW_OP_lit12";
6411 return "DW_OP_lit13";
6413 return "DW_OP_lit14";
6415 return "DW_OP_lit15";
6417 return "DW_OP_lit16";
6419 return "DW_OP_lit17";
6421 return "DW_OP_lit18";
6423 return "DW_OP_lit19";
6425 return "DW_OP_lit20";
6427 return "DW_OP_lit21";
6429 return "DW_OP_lit22";
6431 return "DW_OP_lit23";
6433 return "DW_OP_lit24";
6435 return "DW_OP_lit25";
6437 return "DW_OP_lit26";
6439 return "DW_OP_lit27";
6441 return "DW_OP_lit28";
6443 return "DW_OP_lit29";
6445 return "DW_OP_lit30";
6447 return "DW_OP_lit31";
6449 return "DW_OP_reg0";
6451 return "DW_OP_reg1";
6453 return "DW_OP_reg2";
6455 return "DW_OP_reg3";
6457 return "DW_OP_reg4";
6459 return "DW_OP_reg5";
6461 return "DW_OP_reg6";
6463 return "DW_OP_reg7";
6465 return "DW_OP_reg8";
6467 return "DW_OP_reg9";
6469 return "DW_OP_reg10";
6471 return "DW_OP_reg11";
6473 return "DW_OP_reg12";
6475 return "DW_OP_reg13";
6477 return "DW_OP_reg14";
6479 return "DW_OP_reg15";
6481 return "DW_OP_reg16";
6483 return "DW_OP_reg17";
6485 return "DW_OP_reg18";
6487 return "DW_OP_reg19";
6489 return "DW_OP_reg20";
6491 return "DW_OP_reg21";
6493 return "DW_OP_reg22";
6495 return "DW_OP_reg23";
6497 return "DW_OP_reg24";
6499 return "DW_OP_reg25";
6501 return "DW_OP_reg26";
6503 return "DW_OP_reg27";
6505 return "DW_OP_reg28";
6507 return "DW_OP_reg29";
6509 return "DW_OP_reg30";
6511 return "DW_OP_reg31";
6513 return "DW_OP_breg0";
6515 return "DW_OP_breg1";
6517 return "DW_OP_breg2";
6519 return "DW_OP_breg3";
6521 return "DW_OP_breg4";
6523 return "DW_OP_breg5";
6525 return "DW_OP_breg6";
6527 return "DW_OP_breg7";
6529 return "DW_OP_breg8";
6531 return "DW_OP_breg9";
6533 return "DW_OP_breg10";
6535 return "DW_OP_breg11";
6537 return "DW_OP_breg12";
6539 return "DW_OP_breg13";
6541 return "DW_OP_breg14";
6543 return "DW_OP_breg15";
6545 return "DW_OP_breg16";
6547 return "DW_OP_breg17";
6549 return "DW_OP_breg18";
6551 return "DW_OP_breg19";
6553 return "DW_OP_breg20";
6555 return "DW_OP_breg21";
6557 return "DW_OP_breg22";
6559 return "DW_OP_breg23";
6561 return "DW_OP_breg24";
6563 return "DW_OP_breg25";
6565 return "DW_OP_breg26";
6567 return "DW_OP_breg27";
6569 return "DW_OP_breg28";
6571 return "DW_OP_breg29";
6573 return "DW_OP_breg30";
6575 return "DW_OP_breg31";
6577 return "DW_OP_regx";
6579 return "DW_OP_fbreg";
6581 return "DW_OP_bregx";
6583 return "DW_OP_piece";
6584 case DW_OP_deref_size
:
6585 return "DW_OP_deref_size";
6586 case DW_OP_xderef_size
:
6587 return "DW_OP_xderef_size";
6590 /* DWARF 3 extensions. */
6591 case DW_OP_push_object_address
:
6592 return "DW_OP_push_object_address";
6594 return "DW_OP_call2";
6596 return "DW_OP_call4";
6597 case DW_OP_call_ref
:
6598 return "DW_OP_call_ref";
6599 /* GNU extensions. */
6600 case DW_OP_GNU_push_tls_address
:
6601 return "DW_OP_GNU_push_tls_address";
6603 return "OP_<unknown>";
6608 dwarf_bool_name (unsigned mybool
)
6616 /* Convert a DWARF type code into its string name. */
6619 dwarf_type_encoding_name (unsigned enc
)
6623 case DW_ATE_address
:
6624 return "DW_ATE_address";
6625 case DW_ATE_boolean
:
6626 return "DW_ATE_boolean";
6627 case DW_ATE_complex_float
:
6628 return "DW_ATE_complex_float";
6630 return "DW_ATE_float";
6632 return "DW_ATE_signed";
6633 case DW_ATE_signed_char
:
6634 return "DW_ATE_signed_char";
6635 case DW_ATE_unsigned
:
6636 return "DW_ATE_unsigned";
6637 case DW_ATE_unsigned_char
:
6638 return "DW_ATE_unsigned_char";
6639 case DW_ATE_imaginary_float
:
6640 return "DW_ATE_imaginary_float";
6642 return "DW_ATE_<unknown>";
6646 /* Convert a DWARF call frame info operation to its string name. */
6650 dwarf_cfi_name (unsigned cfi_opc
)
6654 case DW_CFA_advance_loc
:
6655 return "DW_CFA_advance_loc";
6657 return "DW_CFA_offset";
6658 case DW_CFA_restore
:
6659 return "DW_CFA_restore";
6661 return "DW_CFA_nop";
6662 case DW_CFA_set_loc
:
6663 return "DW_CFA_set_loc";
6664 case DW_CFA_advance_loc1
:
6665 return "DW_CFA_advance_loc1";
6666 case DW_CFA_advance_loc2
:
6667 return "DW_CFA_advance_loc2";
6668 case DW_CFA_advance_loc4
:
6669 return "DW_CFA_advance_loc4";
6670 case DW_CFA_offset_extended
:
6671 return "DW_CFA_offset_extended";
6672 case DW_CFA_restore_extended
:
6673 return "DW_CFA_restore_extended";
6674 case DW_CFA_undefined
:
6675 return "DW_CFA_undefined";
6676 case DW_CFA_same_value
:
6677 return "DW_CFA_same_value";
6678 case DW_CFA_register
:
6679 return "DW_CFA_register";
6680 case DW_CFA_remember_state
:
6681 return "DW_CFA_remember_state";
6682 case DW_CFA_restore_state
:
6683 return "DW_CFA_restore_state";
6684 case DW_CFA_def_cfa
:
6685 return "DW_CFA_def_cfa";
6686 case DW_CFA_def_cfa_register
:
6687 return "DW_CFA_def_cfa_register";
6688 case DW_CFA_def_cfa_offset
:
6689 return "DW_CFA_def_cfa_offset";
6692 case DW_CFA_def_cfa_expression
:
6693 return "DW_CFA_def_cfa_expression";
6694 case DW_CFA_expression
:
6695 return "DW_CFA_expression";
6696 case DW_CFA_offset_extended_sf
:
6697 return "DW_CFA_offset_extended_sf";
6698 case DW_CFA_def_cfa_sf
:
6699 return "DW_CFA_def_cfa_sf";
6700 case DW_CFA_def_cfa_offset_sf
:
6701 return "DW_CFA_def_cfa_offset_sf";
6703 /* SGI/MIPS specific */
6704 case DW_CFA_MIPS_advance_loc8
:
6705 return "DW_CFA_MIPS_advance_loc8";
6707 /* GNU extensions */
6708 case DW_CFA_GNU_window_save
:
6709 return "DW_CFA_GNU_window_save";
6710 case DW_CFA_GNU_args_size
:
6711 return "DW_CFA_GNU_args_size";
6712 case DW_CFA_GNU_negative_offset_extended
:
6713 return "DW_CFA_GNU_negative_offset_extended";
6716 return "DW_CFA_<unknown>";
6722 dump_die (struct die_info
*die
)
6726 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6727 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6728 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6729 dwarf_bool_name (die
->child
!= NULL
));
6731 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6732 for (i
= 0; i
< die
->num_attrs
; ++i
)
6734 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6735 dwarf_attr_name (die
->attrs
[i
].name
),
6736 dwarf_form_name (die
->attrs
[i
].form
));
6737 switch (die
->attrs
[i
].form
)
6739 case DW_FORM_ref_addr
:
6741 fprintf_unfiltered (gdb_stderr
, "address: ");
6742 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6744 case DW_FORM_block2
:
6745 case DW_FORM_block4
:
6747 case DW_FORM_block1
:
6748 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6759 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6761 case DW_FORM_string
:
6763 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6764 DW_STRING (&die
->attrs
[i
])
6765 ? DW_STRING (&die
->attrs
[i
]) : "");
6768 if (DW_UNSND (&die
->attrs
[i
]))
6769 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6771 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6773 case DW_FORM_indirect
:
6774 /* the reader will have reduced the indirect form to
6775 the "base form" so this form should not occur */
6776 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6779 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6780 die
->attrs
[i
].form
);
6782 fprintf_unfiltered (gdb_stderr
, "\n");
6787 dump_die_list (struct die_info
*die
)
6792 if (die
->child
!= NULL
)
6793 dump_die_list (die
->child
);
6794 if (die
->sibling
!= NULL
)
6795 dump_die_list (die
->sibling
);
6800 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6803 struct die_info
*old
;
6805 h
= (offset
% REF_HASH_SIZE
);
6806 old
= die_ref_table
[h
];
6807 die
->next_ref
= old
;
6808 die_ref_table
[h
] = die
;
6813 dwarf2_empty_hash_tables (void)
6815 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6819 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6821 unsigned int result
= 0;
6825 case DW_FORM_ref_addr
:
6826 result
= DW_ADDR (attr
);
6832 case DW_FORM_ref_udata
:
6833 result
= cu_header_offset
+ DW_UNSND (attr
);
6836 complaint (&symfile_complaints
,
6837 "unsupported die ref attribute form: '%s'",
6838 dwarf_form_name (attr
->form
));
6843 static struct die_info
*
6844 follow_die_ref (unsigned int offset
)
6846 struct die_info
*die
;
6849 h
= (offset
% REF_HASH_SIZE
);
6850 die
= die_ref_table
[h
];
6853 if (die
->offset
== offset
)
6857 die
= die
->next_ref
;
6862 static struct type
*
6863 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6865 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6867 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
6868 typeid, objfile
->name
);
6871 /* Look for this particular type in the fundamental type vector. If
6872 one is not found, create and install one appropriate for the
6873 current language and the current target machine. */
6875 if (ftypes
[typeid] == NULL
)
6877 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6880 return (ftypes
[typeid]);
6883 /* Decode simple location descriptions.
6884 Given a pointer to a dwarf block that defines a location, compute
6885 the location and return the value.
6887 FIXME: This is a kludge until we figure out a better
6888 way to handle the location descriptions.
6889 Gdb's design does not mesh well with the DWARF2 notion of a location
6890 computing interpreter, which is a shame because the flexibility goes unused.
6891 FIXME: Implement more operations as necessary.
6893 A location description containing no operations indicates that the
6894 object is optimized out. The global optimized_out flag is set for
6895 those, the return value is meaningless.
6897 When the result is a register number, the global isreg flag is set,
6898 otherwise it is cleared.
6900 When the result is a base register offset, the global offreg flag is set
6901 and the register number is returned in basereg, otherwise it is cleared.
6903 When the DW_OP_fbreg operation is encountered without a corresponding
6904 DW_AT_frame_base attribute, the global islocal flag is set.
6905 Hopefully the machine dependent code knows how to set up a virtual
6906 frame pointer for the local references.
6908 Note that stack[0] is unused except as a default error return.
6909 Note that stack overflow is not yet handled. */
6912 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
6914 struct objfile
*objfile
= cu
->objfile
;
6915 struct comp_unit_head
*cu_header
= &cu
->header
;
6917 int size
= blk
->size
;
6918 char *data
= blk
->data
;
6919 CORE_ADDR stack
[64];
6921 unsigned int bytes_read
, unsnd
;
6971 stack
[++stacki
] = op
- DW_OP_lit0
;
7007 stack
[++stacki
] = op
- DW_OP_reg0
;
7012 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7014 stack
[++stacki
] = unsnd
;
7050 basereg
= op
- DW_OP_breg0
;
7051 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7057 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7059 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7064 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7066 if (frame_base_reg
>= 0)
7069 basereg
= frame_base_reg
;
7070 stack
[stacki
] += frame_base_offset
;
7074 complaint (&symfile_complaints
,
7075 "DW_AT_frame_base missing for DW_OP_fbreg");
7081 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
7087 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
7092 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
7097 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
7102 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
7107 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
7112 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
7117 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
7123 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7128 stack
[stacki
+ 1] = stack
[stacki
];
7133 stack
[stacki
- 1] += stack
[stacki
];
7137 case DW_OP_plus_uconst
:
7138 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7143 stack
[stacki
- 1] -= stack
[stacki
];
7149 /* If we're not the last op, then we definitely can't encode
7150 this using GDB's address_class enum. */
7152 dwarf2_complex_location_expr_complaint ();
7155 case DW_OP_GNU_push_tls_address
:
7156 /* The top of the stack has the offset from the beginning
7157 of the thread control block at which the variable is located. */
7158 /* Nothing should follow this operator, so the top of stack would
7161 dwarf2_complex_location_expr_complaint ();
7165 complaint (&symfile_complaints
, "unsupported stack op: '%s'",
7166 dwarf_stack_op_name (op
));
7167 return (stack
[stacki
]);
7170 return (stack
[stacki
]);
7173 /* memory allocation interface */
7176 dwarf2_free_tmp_obstack (void *ignore
)
7178 obstack_free (&dwarf2_tmp_obstack
, NULL
);
7181 static struct dwarf_block
*
7182 dwarf_alloc_block (void)
7184 struct dwarf_block
*blk
;
7186 blk
= (struct dwarf_block
*)
7187 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
7191 static struct abbrev_info
*
7192 dwarf_alloc_abbrev (void)
7194 struct abbrev_info
*abbrev
;
7196 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
7197 memset (abbrev
, 0, sizeof (struct abbrev_info
));
7201 static struct die_info
*
7202 dwarf_alloc_die (void)
7204 struct die_info
*die
;
7206 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7207 memset (die
, 0, sizeof (struct die_info
));
7212 /* Macro support. */
7215 /* Return the full name of file number I in *LH's file name table.
7216 Use COMP_DIR as the name of the current directory of the
7217 compilation. The result is allocated using xmalloc; the caller is
7218 responsible for freeing it. */
7220 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
7222 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
7224 if (IS_ABSOLUTE_PATH (fe
->name
))
7225 return xstrdup (fe
->name
);
7233 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7239 dir_len
= strlen (dir
);
7240 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
7241 strcpy (full_name
, dir
);
7242 full_name
[dir_len
] = '/';
7243 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
7247 return xstrdup (fe
->name
);
7252 static struct macro_source_file
*
7253 macro_start_file (int file
, int line
,
7254 struct macro_source_file
*current_file
,
7255 const char *comp_dir
,
7256 struct line_header
*lh
, struct objfile
*objfile
)
7258 /* The full name of this source file. */
7259 char *full_name
= file_full_name (file
, lh
, comp_dir
);
7261 /* We don't create a macro table for this compilation unit
7262 at all until we actually get a filename. */
7263 if (! pending_macros
)
7264 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
7265 objfile
->macro_cache
);
7268 /* If we have no current file, then this must be the start_file
7269 directive for the compilation unit's main source file. */
7270 current_file
= macro_set_main (pending_macros
, full_name
);
7272 current_file
= macro_include (current_file
, line
, full_name
);
7276 return current_file
;
7280 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7281 followed by a null byte. */
7283 copy_string (const char *buf
, int len
)
7285 char *s
= xmalloc (len
+ 1);
7286 memcpy (s
, buf
, len
);
7294 consume_improper_spaces (const char *p
, const char *body
)
7298 complaint (&symfile_complaints
,
7299 "macro definition contains spaces in formal argument list:\n`%s'",
7311 parse_macro_definition (struct macro_source_file
*file
, int line
,
7316 /* The body string takes one of two forms. For object-like macro
7317 definitions, it should be:
7319 <macro name> " " <definition>
7321 For function-like macro definitions, it should be:
7323 <macro name> "() " <definition>
7325 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7327 Spaces may appear only where explicitly indicated, and in the
7330 The Dwarf 2 spec says that an object-like macro's name is always
7331 followed by a space, but versions of GCC around March 2002 omit
7332 the space when the macro's definition is the empty string.
7334 The Dwarf 2 spec says that there should be no spaces between the
7335 formal arguments in a function-like macro's formal argument list,
7336 but versions of GCC around March 2002 include spaces after the
7340 /* Find the extent of the macro name. The macro name is terminated
7341 by either a space or null character (for an object-like macro) or
7342 an opening paren (for a function-like macro). */
7343 for (p
= body
; *p
; p
++)
7344 if (*p
== ' ' || *p
== '(')
7347 if (*p
== ' ' || *p
== '\0')
7349 /* It's an object-like macro. */
7350 int name_len
= p
- body
;
7351 char *name
= copy_string (body
, name_len
);
7352 const char *replacement
;
7355 replacement
= body
+ name_len
+ 1;
7358 dwarf2_macro_malformed_definition_complaint (body
);
7359 replacement
= body
+ name_len
;
7362 macro_define_object (file
, line
, name
, replacement
);
7368 /* It's a function-like macro. */
7369 char *name
= copy_string (body
, p
- body
);
7372 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
7376 p
= consume_improper_spaces (p
, body
);
7378 /* Parse the formal argument list. */
7379 while (*p
&& *p
!= ')')
7381 /* Find the extent of the current argument name. */
7382 const char *arg_start
= p
;
7384 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
7387 if (! *p
|| p
== arg_start
)
7388 dwarf2_macro_malformed_definition_complaint (body
);
7391 /* Make sure argv has room for the new argument. */
7392 if (argc
>= argv_size
)
7395 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
7398 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
7401 p
= consume_improper_spaces (p
, body
);
7403 /* Consume the comma, if present. */
7408 p
= consume_improper_spaces (p
, body
);
7417 /* Perfectly formed definition, no complaints. */
7418 macro_define_function (file
, line
, name
,
7419 argc
, (const char **) argv
,
7421 else if (*p
== '\0')
7423 /* Complain, but do define it. */
7424 dwarf2_macro_malformed_definition_complaint (body
);
7425 macro_define_function (file
, line
, name
,
7426 argc
, (const char **) argv
,
7430 /* Just complain. */
7431 dwarf2_macro_malformed_definition_complaint (body
);
7434 /* Just complain. */
7435 dwarf2_macro_malformed_definition_complaint (body
);
7441 for (i
= 0; i
< argc
; i
++)
7447 dwarf2_macro_malformed_definition_complaint (body
);
7452 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7453 char *comp_dir
, bfd
*abfd
,
7454 struct dwarf2_cu
*cu
)
7456 char *mac_ptr
, *mac_end
;
7457 struct macro_source_file
*current_file
= 0;
7459 if (dwarf_macinfo_buffer
== NULL
)
7461 complaint (&symfile_complaints
, "missing .debug_macinfo section");
7465 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7466 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7470 enum dwarf_macinfo_record_type macinfo_type
;
7472 /* Do we at least have room for a macinfo type byte? */
7473 if (mac_ptr
>= mac_end
)
7475 dwarf2_macros_too_long_complaint ();
7479 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7482 switch (macinfo_type
)
7484 /* A zero macinfo type indicates the end of the macro
7489 case DW_MACINFO_define
:
7490 case DW_MACINFO_undef
:
7496 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7497 mac_ptr
+= bytes_read
;
7498 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7499 mac_ptr
+= bytes_read
;
7502 complaint (&symfile_complaints
,
7503 "debug info gives macro %s outside of any file: %s",
7505 DW_MACINFO_define
? "definition" : macinfo_type
==
7506 DW_MACINFO_undef
? "undefinition" :
7507 "something-or-other", body
);
7510 if (macinfo_type
== DW_MACINFO_define
)
7511 parse_macro_definition (current_file
, line
, body
);
7512 else if (macinfo_type
== DW_MACINFO_undef
)
7513 macro_undef (current_file
, line
, body
);
7518 case DW_MACINFO_start_file
:
7523 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7524 mac_ptr
+= bytes_read
;
7525 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7526 mac_ptr
+= bytes_read
;
7528 current_file
= macro_start_file (file
, line
,
7529 current_file
, comp_dir
,
7534 case DW_MACINFO_end_file
:
7536 complaint (&symfile_complaints
,
7537 "macro debug info has an unmatched `close_file' directive");
7540 current_file
= current_file
->included_by
;
7543 enum dwarf_macinfo_record_type next_type
;
7545 /* GCC circa March 2002 doesn't produce the zero
7546 type byte marking the end of the compilation
7547 unit. Complain if it's not there, but exit no
7550 /* Do we at least have room for a macinfo type byte? */
7551 if (mac_ptr
>= mac_end
)
7553 dwarf2_macros_too_long_complaint ();
7557 /* We don't increment mac_ptr here, so this is just
7559 next_type
= read_1_byte (abfd
, mac_ptr
);
7561 complaint (&symfile_complaints
,
7562 "no terminating 0-type entry for macros in `.debug_macinfo' section");
7569 case DW_MACINFO_vendor_ext
:
7575 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7576 mac_ptr
+= bytes_read
;
7577 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7578 mac_ptr
+= bytes_read
;
7580 /* We don't recognize any vendor extensions. */
7587 /* Check if the attribute's form is a DW_FORM_block*
7588 if so return true else false. */
7590 attr_form_is_block (struct attribute
*attr
)
7592 return (attr
== NULL
? 0 :
7593 attr
->form
== DW_FORM_block1
7594 || attr
->form
== DW_FORM_block2
7595 || attr
->form
== DW_FORM_block4
7596 || attr
->form
== DW_FORM_block
);
7600 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
7601 struct dwarf2_cu
*cu
)
7603 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
7605 struct dwarf2_loclist_baton
*baton
;
7607 baton
= obstack_alloc (&cu
->objfile
->symbol_obstack
,
7608 sizeof (struct dwarf2_loclist_baton
));
7609 baton
->objfile
= cu
->objfile
;
7611 /* We don't know how long the location list is, but make sure we
7612 don't run off the edge of the section. */
7613 baton
->size
= dwarf_loc_size
- DW_UNSND (attr
);
7614 baton
->data
= dwarf_loc_buffer
+ DW_UNSND (attr
);
7615 baton
->base_address
= cu
->header
.base_address
;
7616 if (cu
->header
.base_known
== 0)
7617 complaint (&symfile_complaints
,
7618 "Location list used without specifying the CU base address.");
7620 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_loclist_funcs
;
7621 SYMBOL_LOCATION_BATON (sym
) = baton
;
7625 struct dwarf2_locexpr_baton
*baton
;
7627 baton
= obstack_alloc (&cu
->objfile
->symbol_obstack
,
7628 sizeof (struct dwarf2_locexpr_baton
));
7629 baton
->objfile
= cu
->objfile
;
7631 if (attr_form_is_block (attr
))
7633 /* Note that we're just copying the block's data pointer
7634 here, not the actual data. We're still pointing into the
7635 dwarf_info_buffer for SYM's objfile; right now we never
7636 release that buffer, but when we do clean up properly
7637 this may need to change. */
7638 baton
->size
= DW_BLOCK (attr
)->size
;
7639 baton
->data
= DW_BLOCK (attr
)->data
;
7643 dwarf2_invalid_attrib_class_complaint ("location description",
7644 SYMBOL_NATURAL_NAME (sym
));
7649 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_locexpr_funcs
;
7650 SYMBOL_LOCATION_BATON (sym
) = baton
;