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 /* The line number information for a compilation unit (found in the
234 .debug_line section) begins with a "statement program header",
235 which contains the following information. */
238 unsigned int total_length
;
239 unsigned short version
;
240 unsigned int header_length
;
241 unsigned char minimum_instruction_length
;
242 unsigned char default_is_stmt
;
244 unsigned char line_range
;
245 unsigned char opcode_base
;
247 /* standard_opcode_lengths[i] is the number of operands for the
248 standard opcode whose value is i. This means that
249 standard_opcode_lengths[0] is unused, and the last meaningful
250 element is standard_opcode_lengths[opcode_base - 1]. */
251 unsigned char *standard_opcode_lengths
;
253 /* The include_directories table. NOTE! These strings are not
254 allocated with xmalloc; instead, they are pointers into
255 debug_line_buffer. If you try to free them, `free' will get
257 unsigned int num_include_dirs
, include_dirs_size
;
260 /* The file_names table. NOTE! These strings are not allocated
261 with xmalloc; instead, they are pointers into debug_line_buffer.
262 Don't try to free them directly. */
263 unsigned int num_file_names
, file_names_size
;
267 unsigned int dir_index
;
268 unsigned int mod_time
;
272 /* The start and end of the statement program following this
273 header. These point into dwarf_line_buffer. */
274 char *statement_program_start
, *statement_program_end
;
277 /* When we construct a partial symbol table entry we only
278 need this much information. */
279 struct partial_die_info
282 unsigned char has_children
;
283 unsigned char is_external
;
284 unsigned char is_declaration
;
285 unsigned char has_type
;
292 struct dwarf_block
*locdesc
;
293 unsigned int language
;
297 /* This data structure holds the information of an abbrev. */
300 unsigned int number
; /* number identifying abbrev */
301 enum dwarf_tag tag
; /* dwarf tag */
302 int has_children
; /* boolean */
303 unsigned int num_attrs
; /* number of attributes */
304 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
305 struct abbrev_info
*next
; /* next in chain */
310 enum dwarf_attribute name
;
311 enum dwarf_form form
;
314 /* This data structure holds a complete die structure. */
317 enum dwarf_tag tag
; /* Tag indicating type of die */
318 unsigned short has_children
; /* Does the die have children */
319 unsigned int abbrev
; /* Abbrev number */
320 unsigned int offset
; /* Offset in .debug_info section */
321 unsigned int num_attrs
; /* Number of attributes */
322 struct attribute
*attrs
; /* An array of attributes */
323 struct die_info
*next_ref
; /* Next die in ref hash table */
324 struct die_info
*next
; /* Next die in linked list */
325 struct type
*type
; /* Cached type information */
328 /* Attributes have a name and a value */
331 enum dwarf_attribute name
;
332 enum dwarf_form form
;
336 struct dwarf_block
*blk
;
344 struct function_range
347 CORE_ADDR lowpc
, highpc
;
349 struct function_range
*next
;
352 static struct function_range
*cu_first_fn
, *cu_last_fn
, *cu_cached_fn
;
354 /* Get at parts of an attribute structure */
356 #define DW_STRING(attr) ((attr)->u.str)
357 #define DW_UNSND(attr) ((attr)->u.unsnd)
358 #define DW_BLOCK(attr) ((attr)->u.blk)
359 #define DW_SND(attr) ((attr)->u.snd)
360 #define DW_ADDR(attr) ((attr)->u.addr)
362 /* Blocks are a bunch of untyped bytes. */
369 #ifndef ATTR_ALLOC_CHUNK
370 #define ATTR_ALLOC_CHUNK 4
373 /* A hash table of die offsets for following references. */
374 #ifndef REF_HASH_SIZE
375 #define REF_HASH_SIZE 1021
378 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
380 /* Obstack for allocating temporary storage used during symbol reading. */
381 static struct obstack dwarf2_tmp_obstack
;
383 /* Offset to the first byte of the current compilation unit header,
384 for resolving relative reference dies. */
385 static unsigned int cu_header_offset
;
387 /* Allocate fields for structs, unions and enums in this size. */
388 #ifndef DW_FIELD_ALLOC_CHUNK
389 #define DW_FIELD_ALLOC_CHUNK 4
392 /* The language we are debugging. */
393 static enum language cu_language
;
394 static const struct language_defn
*cu_language_defn
;
396 /* Actually data from the sections. */
397 static char *dwarf_info_buffer
;
398 static char *dwarf_abbrev_buffer
;
399 static char *dwarf_line_buffer
;
400 static char *dwarf_str_buffer
;
401 static char *dwarf_macinfo_buffer
;
402 static char *dwarf_ranges_buffer
;
403 static char *dwarf_loc_buffer
;
405 /* A zeroed version of a partial die for initialization purposes. */
406 static struct partial_die_info zeroed_partial_die
;
408 /* The generic symbol table building routines have separate lists for
409 file scope symbols and all all other scopes (local scopes). So
410 we need to select the right one to pass to add_symbol_to_list().
411 We do it by keeping a pointer to the correct list in list_in_scope.
413 FIXME: The original dwarf code just treated the file scope as the first
414 local scope, and all other local scopes as nested local scopes, and worked
415 fine. Check to see if we really need to distinguish these
417 static struct pending
**list_in_scope
= &file_symbols
;
419 /* FIXME: decode_locdesc sets these variables to describe the location
420 to the caller. These ought to be a structure or something. If
421 none of the flags are set, the object lives at the address returned
422 by decode_locdesc. */
424 static int optimized_out
; /* No ops in location in expression,
425 so object was optimized out. */
426 static int isreg
; /* Object lives in register.
427 decode_locdesc's return value is
428 the register number. */
429 static int offreg
; /* Object's address is the sum of the
430 register specified by basereg, plus
431 the offset returned. */
432 static int basereg
; /* See `offreg'. */
433 static int isderef
; /* Value described by flags above is
434 the address of a pointer to the object. */
435 static int islocal
; /* Variable is at the returned offset
436 from the frame start, but there's
437 no identified frame pointer for
438 this function, so we can't say
439 which register it's relative to;
442 /* DW_AT_frame_base values for the current function.
443 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
444 contains the register number for the frame register.
445 frame_base_offset is the offset from the frame register to the
446 virtual stack frame. */
447 static int frame_base_reg
;
448 static CORE_ADDR frame_base_offset
;
450 /* This value is added to each symbol value. FIXME: Generalize to
451 the section_offsets structure used by dbxread (once this is done,
452 pass the appropriate section number to end_symtab). */
453 static CORE_ADDR baseaddr
; /* Add to each symbol value */
455 /* We put a pointer to this structure in the read_symtab_private field
457 The complete dwarf information for an objfile is kept in the
458 psymbol_obstack, so that absolute die references can be handled.
459 Most of the information in this structure is related to an entire
460 object file and could be passed via the sym_private field of the objfile.
461 It is however conceivable that dwarf2 might not be the only type
462 of symbols read from an object file. */
466 /* Pointer to start of dwarf info buffer for the objfile. */
468 char *dwarf_info_buffer
;
470 /* Offset in dwarf_info_buffer for this compilation unit. */
472 unsigned long dwarf_info_offset
;
474 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
476 char *dwarf_abbrev_buffer
;
478 /* Size of dwarf abbreviation section for the objfile. */
480 unsigned int dwarf_abbrev_size
;
482 /* Pointer to start of dwarf line buffer for the objfile. */
484 char *dwarf_line_buffer
;
486 /* Size of dwarf_line_buffer, in bytes. */
488 unsigned int dwarf_line_size
;
490 /* Pointer to start of dwarf string buffer for the objfile. */
492 char *dwarf_str_buffer
;
494 /* Size of dwarf string section for the objfile. */
496 unsigned int dwarf_str_size
;
498 /* Pointer to start of dwarf macro buffer for the objfile. */
500 char *dwarf_macinfo_buffer
;
502 /* Size of dwarf macinfo section for the objfile. */
504 unsigned int dwarf_macinfo_size
;
506 /* Pointer to start of dwarf ranges buffer for the objfile. */
508 char *dwarf_ranges_buffer
;
510 /* Size of dwarf ranges buffer for the objfile. */
512 unsigned int dwarf_ranges_size
;
514 /* Pointer to start of dwarf locations buffer for the objfile. */
516 char *dwarf_loc_buffer
;
518 /* Size of dwarf locations buffer for the objfile. */
520 unsigned int dwarf_loc_size
;
523 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
524 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
525 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
526 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
527 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
528 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
529 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
530 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
531 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
532 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
533 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
534 #define DWARF_RANGES_BUFFER(p) (PST_PRIVATE(p)->dwarf_ranges_buffer)
535 #define DWARF_RANGES_SIZE(p) (PST_PRIVATE(p)->dwarf_ranges_size)
536 #define DWARF_LOC_BUFFER(p) (PST_PRIVATE(p)->dwarf_loc_buffer)
537 #define DWARF_LOC_SIZE(p) (PST_PRIVATE(p)->dwarf_loc_size)
539 /* Maintain an array of referenced fundamental types for the current
540 compilation unit being read. For DWARF version 1, we have to construct
541 the fundamental types on the fly, since no information about the
542 fundamental types is supplied. Each such fundamental type is created by
543 calling a language dependent routine to create the type, and then a
544 pointer to that type is then placed in the array at the index specified
545 by it's FT_<TYPENAME> value. The array has a fixed size set by the
546 FT_NUM_MEMBERS compile time constant, which is the number of predefined
547 fundamental types gdb knows how to construct. */
548 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
550 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
551 but this would require a corresponding change in unpack_field_as_long
553 static int bits_per_byte
= 8;
555 /* The routines that read and process dies for a C struct or C++ class
556 pass lists of data member fields and lists of member function fields
557 in an instance of a field_info structure, as defined below. */
560 /* List of data member and baseclasses fields. */
563 struct nextfield
*next
;
570 /* Number of fields. */
573 /* Number of baseclasses. */
576 /* Set if the accesibility of one of the fields is not public. */
577 int non_public_fields
;
579 /* Member function fields array, entries are allocated in the order they
580 are encountered in the object file. */
583 struct nextfnfield
*next
;
584 struct fn_field fnfield
;
588 /* Member function fieldlist array, contains name of possibly overloaded
589 member function, number of overloaded member functions and a pointer
590 to the head of the member function field chain. */
595 struct nextfnfield
*head
;
599 /* Number of entries in the fnfieldlists array. */
603 /* Various complaints about symbol reading that don't abort the process */
606 dwarf2_non_const_array_bound_ignored_complaint (const char *arg1
)
608 complaint (&symfile_complaints
, "non-constant array bounds form '%s' ignored",
613 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
615 complaint (&symfile_complaints
,
616 "statement list doesn't fit in .debug_line section");
620 dwarf2_complex_location_expr_complaint (void)
622 complaint (&symfile_complaints
, "location expression too complex");
626 dwarf2_unsupported_at_frame_base_complaint (const char *arg1
)
628 complaint (&symfile_complaints
,
629 "unsupported DW_AT_frame_base for function '%s'", arg1
);
633 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
636 complaint (&symfile_complaints
,
637 "const value length mismatch for '%s', got %d, expected %d", arg1
,
642 dwarf2_macros_too_long_complaint (void)
644 complaint (&symfile_complaints
,
645 "macro info runs off end of `.debug_macinfo' section");
649 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
651 complaint (&symfile_complaints
,
652 "macro debug info contains a malformed macro definition:\n`%s'",
657 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
659 complaint (&symfile_complaints
,
660 "invalid attribute class or form for '%s' in '%s'", arg1
, arg2
);
663 /* local function prototypes */
665 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
668 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
671 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
673 static char *scan_partial_symbols (char *, struct objfile
*,
674 CORE_ADDR
*, CORE_ADDR
*,
675 const struct comp_unit_head
*,
676 const char *namespace);
678 static void add_partial_symbol (struct partial_die_info
*, struct objfile
*,
679 const struct comp_unit_head
*,
680 const char *namespace);
682 static char *add_partial_namespace (struct partial_die_info
*pdi
,
684 struct objfile
*objfile
,
685 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
686 const struct comp_unit_head
*cu_header
,
687 const char *namespace);
689 static char *add_partial_enumeration (struct partial_die_info
*enum_pdi
,
691 struct objfile
*objfile
,
692 const struct comp_unit_head
*cu_header
,
693 const char *namespace);
695 static char *locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
698 const struct comp_unit_head
*cu_header
);
700 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
702 static void psymtab_to_symtab_1 (struct partial_symtab
*);
704 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int,
707 static void dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
);
709 static void dwarf2_empty_abbrev_table (void *);
711 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
712 const struct comp_unit_head
*cu_header
);
714 static char *read_partial_die (struct partial_die_info
*,
716 const struct comp_unit_head
*);
718 static char *read_full_die (struct die_info
**, bfd
*, char *,
719 const struct comp_unit_head
*);
721 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
722 bfd
*, char *, const struct comp_unit_head
*);
724 static char *read_attribute_value (struct attribute
*, unsigned,
725 bfd
*, char *, const struct comp_unit_head
*);
727 static unsigned int read_1_byte (bfd
*, char *);
729 static int read_1_signed_byte (bfd
*, char *);
731 static unsigned int read_2_bytes (bfd
*, char *);
733 static unsigned int read_4_bytes (bfd
*, char *);
735 static unsigned long read_8_bytes (bfd
*, char *);
737 static CORE_ADDR
read_address (bfd
*, char *ptr
, const struct comp_unit_head
*,
740 static LONGEST
read_initial_length (bfd
*, char *,
741 struct comp_unit_head
*, int *bytes_read
);
743 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
746 static char *read_n_bytes (bfd
*, char *, unsigned int);
748 static char *read_string (bfd
*, char *, unsigned int *);
750 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
753 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
755 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
757 static void set_cu_language (unsigned int);
759 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
761 static int die_is_declaration (struct die_info
*);
763 static void free_line_header (struct line_header
*lh
);
765 static struct line_header
*(dwarf_decode_line_header
766 (unsigned int offset
,
768 const struct comp_unit_head
*cu_header
));
770 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
771 const struct comp_unit_head
*);
773 static void dwarf2_start_subfile (char *, char *);
775 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
776 struct objfile
*, const struct comp_unit_head
*);
778 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
779 struct objfile
*, const struct comp_unit_head
*);
781 static void dwarf2_const_value_data (struct attribute
*attr
,
785 static struct type
*die_type (struct die_info
*, struct objfile
*,
786 const struct comp_unit_head
*);
788 static struct type
*die_containing_type (struct die_info
*, struct objfile
*,
789 const struct comp_unit_head
*);
792 static struct type
*type_at_offset (unsigned int, struct objfile
*);
795 static struct type
*tag_type_to_type (struct die_info
*, struct objfile
*,
796 const struct comp_unit_head
*);
798 static void read_type_die (struct die_info
*, struct objfile
*,
799 const struct comp_unit_head
*);
801 static void read_typedef (struct die_info
*, struct objfile
*,
802 const struct comp_unit_head
*);
804 static void read_base_type (struct die_info
*, struct objfile
*);
806 static void read_file_scope (struct die_info
*, struct objfile
*,
807 const struct comp_unit_head
*);
809 static void read_func_scope (struct die_info
*, struct objfile
*,
810 const struct comp_unit_head
*);
812 static void read_lexical_block_scope (struct die_info
*, struct objfile
*,
813 const struct comp_unit_head
*);
815 static int dwarf2_get_pc_bounds (struct die_info
*,
816 CORE_ADDR
*, CORE_ADDR
*, struct objfile
*,
817 const struct comp_unit_head
*);
819 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
820 struct objfile
*, const struct comp_unit_head
*);
822 static void dwarf2_attach_fields_to_type (struct field_info
*,
823 struct type
*, struct objfile
*);
825 static void dwarf2_add_member_fn (struct field_info
*,
826 struct die_info
*, struct type
*,
827 struct objfile
*objfile
,
828 const struct comp_unit_head
*);
830 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
831 struct type
*, struct objfile
*);
833 static void read_structure_scope (struct die_info
*, struct objfile
*,
834 const struct comp_unit_head
*);
836 static void read_common_block (struct die_info
*, struct objfile
*,
837 const struct comp_unit_head
*);
839 static void read_namespace (struct die_info
*die
, struct objfile
*objfile
,
840 const struct comp_unit_head
*cu_header
);
842 static void read_enumeration (struct die_info
*, struct objfile
*,
843 const struct comp_unit_head
*);
845 static struct type
*dwarf_base_type (int, int, struct objfile
*);
847 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct objfile
*,
848 const struct comp_unit_head
*);
850 static void read_array_type (struct die_info
*, struct objfile
*,
851 const struct comp_unit_head
*);
853 static void read_tag_pointer_type (struct die_info
*, struct objfile
*,
854 const struct comp_unit_head
*);
856 static void read_tag_ptr_to_member_type (struct die_info
*, struct objfile
*,
857 const struct comp_unit_head
*);
859 static void read_tag_reference_type (struct die_info
*, struct objfile
*,
860 const struct comp_unit_head
*);
862 static void read_tag_const_type (struct die_info
*, struct objfile
*,
863 const struct comp_unit_head
*);
865 static void read_tag_volatile_type (struct die_info
*, struct objfile
*,
866 const struct comp_unit_head
*);
868 static void read_tag_string_type (struct die_info
*, struct objfile
*);
870 static void read_subroutine_type (struct die_info
*, struct objfile
*,
871 const struct comp_unit_head
*);
873 static struct die_info
*read_comp_unit (char *, bfd
*,
874 const struct comp_unit_head
*);
876 static void free_die_list (struct die_info
*);
878 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
880 static void process_die (struct die_info
*, struct objfile
*,
881 const struct comp_unit_head
*);
883 static char *dwarf2_linkage_name (struct die_info
*);
885 static char *dwarf2_name (struct die_info
*die
);
887 static struct die_info
*dwarf2_extension (struct die_info
*die
);
889 static char *dwarf_tag_name (unsigned int);
891 static char *dwarf_attr_name (unsigned int);
893 static char *dwarf_form_name (unsigned int);
895 static char *dwarf_stack_op_name (unsigned int);
897 static char *dwarf_bool_name (unsigned int);
899 static char *dwarf_type_encoding_name (unsigned int);
902 static char *dwarf_cfi_name (unsigned int);
904 struct die_info
*copy_die (struct die_info
*);
907 static struct die_info
*sibling_die (struct die_info
*);
909 static void dump_die (struct die_info
*);
911 static void dump_die_list (struct die_info
*);
913 static void store_in_ref_table (unsigned int, struct die_info
*);
915 static void dwarf2_empty_hash_tables (void);
917 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
919 static struct die_info
*follow_die_ref (unsigned int);
921 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
923 /* memory allocation interface */
925 static void dwarf2_free_tmp_obstack (void *);
927 static struct dwarf_block
*dwarf_alloc_block (void);
929 static struct abbrev_info
*dwarf_alloc_abbrev (void);
931 static struct die_info
*dwarf_alloc_die (void);
933 static void initialize_cu_func_list (void);
935 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
937 static void dwarf_decode_macros (struct line_header
*, unsigned int,
938 char *, bfd
*, const struct comp_unit_head
*,
941 static int attr_form_is_block (struct attribute
*);
944 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
945 const struct comp_unit_head
*,
946 struct objfile
*objfile
);
948 /* Try to locate the sections we need for DWARF 2 debugging
949 information and return true if we have enough to do something. */
952 dwarf2_has_info (bfd
*abfd
)
954 dwarf_info_offset
= 0;
955 dwarf_abbrev_offset
= 0;
956 dwarf_line_offset
= 0;
957 dwarf_str_offset
= 0;
958 dwarf_macinfo_offset
= 0;
959 dwarf_frame_offset
= 0;
960 dwarf_eh_frame_offset
= 0;
961 dwarf_ranges_offset
= 0;
962 dwarf_loc_offset
= 0;
964 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
965 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
975 /* This function is mapped across the sections and remembers the
976 offset and size of each of the debugging sections we are interested
980 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
982 if (STREQ (sectp
->name
, INFO_SECTION
))
984 dwarf_info_offset
= sectp
->filepos
;
985 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
986 dwarf_info_section
= sectp
;
988 else if (STREQ (sectp
->name
, ABBREV_SECTION
))
990 dwarf_abbrev_offset
= sectp
->filepos
;
991 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
992 dwarf_abbrev_section
= sectp
;
994 else if (STREQ (sectp
->name
, LINE_SECTION
))
996 dwarf_line_offset
= sectp
->filepos
;
997 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
998 dwarf_line_section
= sectp
;
1000 else if (STREQ (sectp
->name
, PUBNAMES_SECTION
))
1002 dwarf_pubnames_offset
= sectp
->filepos
;
1003 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
1004 dwarf_pubnames_section
= sectp
;
1006 else if (STREQ (sectp
->name
, ARANGES_SECTION
))
1008 dwarf_aranges_offset
= sectp
->filepos
;
1009 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
1010 dwarf_aranges_section
= sectp
;
1012 else if (STREQ (sectp
->name
, LOC_SECTION
))
1014 dwarf_loc_offset
= sectp
->filepos
;
1015 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
1016 dwarf_loc_section
= sectp
;
1018 else if (STREQ (sectp
->name
, MACINFO_SECTION
))
1020 dwarf_macinfo_offset
= sectp
->filepos
;
1021 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
1022 dwarf_macinfo_section
= sectp
;
1024 else if (STREQ (sectp
->name
, STR_SECTION
))
1026 dwarf_str_offset
= sectp
->filepos
;
1027 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
1028 dwarf_str_section
= sectp
;
1030 else if (STREQ (sectp
->name
, FRAME_SECTION
))
1032 dwarf_frame_offset
= sectp
->filepos
;
1033 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1034 dwarf_frame_section
= sectp
;
1036 else if (STREQ (sectp
->name
, EH_FRAME_SECTION
))
1038 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1039 if (aflag
& SEC_HAS_CONTENTS
)
1041 dwarf_eh_frame_offset
= sectp
->filepos
;
1042 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1043 dwarf_eh_frame_section
= sectp
;
1046 else if (STREQ (sectp
->name
, RANGES_SECTION
))
1048 dwarf_ranges_offset
= sectp
->filepos
;
1049 dwarf_ranges_size
= bfd_get_section_size_before_reloc (sectp
);
1050 dwarf_ranges_section
= sectp
;
1054 /* Build a partial symbol table. */
1057 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1060 /* We definitely need the .debug_info and .debug_abbrev sections */
1062 dwarf_info_buffer
= dwarf2_read_section (objfile
,
1065 dwarf_info_section
);
1066 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
1067 dwarf_abbrev_offset
,
1069 dwarf_abbrev_section
);
1071 if (dwarf_line_offset
)
1072 dwarf_line_buffer
= dwarf2_read_section (objfile
,
1075 dwarf_line_section
);
1077 dwarf_line_buffer
= NULL
;
1079 if (dwarf_str_offset
)
1080 dwarf_str_buffer
= dwarf2_read_section (objfile
,
1085 dwarf_str_buffer
= NULL
;
1087 if (dwarf_macinfo_offset
)
1088 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1089 dwarf_macinfo_offset
,
1091 dwarf_macinfo_section
);
1093 dwarf_macinfo_buffer
= NULL
;
1095 if (dwarf_ranges_offset
)
1096 dwarf_ranges_buffer
= dwarf2_read_section (objfile
,
1097 dwarf_ranges_offset
,
1099 dwarf_ranges_section
);
1101 dwarf_ranges_buffer
= NULL
;
1103 if (dwarf_loc_offset
)
1104 dwarf_loc_buffer
= dwarf2_read_section (objfile
,
1109 dwarf_loc_buffer
= NULL
;
1112 || (objfile
->global_psymbols
.size
== 0
1113 && objfile
->static_psymbols
.size
== 0))
1115 init_psymbol_list (objfile
, 1024);
1119 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1121 /* Things are significantly easier if we have .debug_aranges and
1122 .debug_pubnames sections */
1124 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1128 /* only test this case for now */
1130 /* In this case we have to work a bit harder */
1131 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1136 /* Build the partial symbol table from the information in the
1137 .debug_pubnames and .debug_aranges sections. */
1140 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1142 bfd
*abfd
= objfile
->obfd
;
1143 char *aranges_buffer
, *pubnames_buffer
;
1144 char *aranges_ptr
, *pubnames_ptr
;
1145 unsigned int entry_length
, version
, info_offset
, info_size
;
1147 pubnames_buffer
= dwarf2_read_section (objfile
,
1148 dwarf_pubnames_offset
,
1149 dwarf_pubnames_size
,
1150 dwarf_pubnames_section
);
1151 pubnames_ptr
= pubnames_buffer
;
1152 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1154 struct comp_unit_head cu_header
;
1157 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1159 pubnames_ptr
+= bytes_read
;
1160 version
= read_1_byte (abfd
, pubnames_ptr
);
1162 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1164 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1168 aranges_buffer
= dwarf2_read_section (objfile
,
1169 dwarf_aranges_offset
,
1171 dwarf_aranges_section
);
1176 /* Read in the comp unit header information from the debug_info at
1180 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1181 char *info_ptr
, bfd
*abfd
)
1185 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1187 info_ptr
+= bytes_read
;
1188 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1190 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1192 info_ptr
+= bytes_read
;
1193 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1195 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1196 if (signed_addr
< 0)
1197 internal_error (__FILE__
, __LINE__
,
1198 "read_comp_unit_head: dwarf from non elf file");
1199 cu_header
->signed_addr_p
= signed_addr
;
1203 /* Build the partial symbol table by doing a quick pass through the
1204 .debug_info and .debug_abbrev sections. */
1207 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1209 /* Instead of reading this into a big buffer, we should probably use
1210 mmap() on architectures that support it. (FIXME) */
1211 bfd
*abfd
= objfile
->obfd
;
1212 char *info_ptr
, *abbrev_ptr
;
1213 char *beg_of_comp_unit
;
1214 struct partial_die_info comp_unit_die
;
1215 struct partial_symtab
*pst
;
1216 struct cleanup
*back_to
;
1217 CORE_ADDR lowpc
, highpc
;
1219 info_ptr
= dwarf_info_buffer
;
1220 abbrev_ptr
= dwarf_abbrev_buffer
;
1222 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1223 the partial symbol scan, like attribute values.
1225 We could reduce our peak memory consumption during partial symbol
1226 table construction by freeing stuff from this obstack more often
1227 --- say, after processing each compilation unit, or each die ---
1228 but it turns out that this saves almost nothing. For an
1229 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1230 on dwarf2_tmp_obstack. Some investigation showed:
1232 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1233 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1234 all fixed-length values not requiring dynamic allocation.
1236 2) 30% of the attributes used the form DW_FORM_string. For
1237 DW_FORM_string, read_attribute simply hands back a pointer to
1238 the null-terminated string in dwarf_info_buffer, so no dynamic
1239 allocation is needed there either.
1241 3) The remaining 1% of the attributes all used DW_FORM_block1.
1242 75% of those were DW_AT_frame_base location lists for
1243 functions; the rest were DW_AT_location attributes, probably
1244 for the global variables.
1246 Anyway, what this all means is that the memory the dwarf2
1247 reader uses as temporary space reading partial symbols is about
1248 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1250 obstack_init (&dwarf2_tmp_obstack
);
1251 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1253 /* Since the objects we're extracting from dwarf_info_buffer vary in
1254 length, only the individual functions to extract them (like
1255 read_comp_unit_head and read_partial_die) can really know whether
1256 the buffer is large enough to hold another complete object.
1258 At the moment, they don't actually check that. If
1259 dwarf_info_buffer holds just one extra byte after the last
1260 compilation unit's dies, then read_comp_unit_head will happily
1261 read off the end of the buffer. read_partial_die is similarly
1262 casual. Those functions should be fixed.
1264 For this loop condition, simply checking whether there's any data
1265 left at all should be sufficient. */
1266 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1268 struct comp_unit_head cu_header
;
1269 beg_of_comp_unit
= info_ptr
;
1270 info_ptr
= read_comp_unit_head (&cu_header
, info_ptr
, abfd
);
1272 if (cu_header
.version
!= 2)
1274 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
));
1277 if (cu_header
.abbrev_offset
>= dwarf_abbrev_size
)
1279 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1280 (long) cu_header
.abbrev_offset
,
1281 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1282 bfd_get_filename (abfd
));
1285 if (beg_of_comp_unit
+ cu_header
.length
+ cu_header
.initial_length_size
1286 > dwarf_info_buffer
+ dwarf_info_size
)
1288 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1289 (long) cu_header
.length
,
1290 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1291 bfd_get_filename (abfd
));
1294 /* Complete the cu_header */
1295 cu_header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1296 cu_header
.first_die_ptr
= info_ptr
;
1297 cu_header
.cu_head_ptr
= beg_of_comp_unit
;
1299 /* Read the abbrevs for this compilation unit into a table */
1300 dwarf2_read_abbrevs (abfd
, &cu_header
);
1301 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1303 /* Read the compilation unit die */
1304 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1307 /* Set the language we're debugging */
1308 set_cu_language (comp_unit_die
.language
);
1310 /* Allocate a new partial symbol table structure */
1311 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1312 comp_unit_die
.name
? comp_unit_die
.name
: "",
1313 comp_unit_die
.lowpc
,
1314 objfile
->global_psymbols
.next
,
1315 objfile
->static_psymbols
.next
);
1317 pst
->read_symtab_private
= (char *)
1318 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1319 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1320 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1321 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1322 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1323 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1324 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1325 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1326 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1327 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1328 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1329 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1330 DWARF_RANGES_BUFFER (pst
) = dwarf_ranges_buffer
;
1331 DWARF_RANGES_SIZE (pst
) = dwarf_ranges_size
;
1332 DWARF_LOC_BUFFER (pst
) = dwarf_loc_buffer
;
1333 DWARF_LOC_SIZE (pst
) = dwarf_loc_size
;
1334 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1336 /* Store the function that reads in the rest of the symbol table */
1337 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1339 /* Check if comp unit has_children.
1340 If so, read the rest of the partial symbols from this comp unit.
1341 If not, there's no more debug_info for this comp unit. */
1342 if (comp_unit_die
.has_children
)
1344 lowpc
= ((CORE_ADDR
) -1);
1345 highpc
= ((CORE_ADDR
) 0);
1347 info_ptr
= scan_partial_symbols (info_ptr
, objfile
, &lowpc
, &highpc
,
1350 /* If we didn't find a lowpc, set it to highpc to avoid
1351 complaints from `maint check'. */
1352 if (lowpc
== ((CORE_ADDR
) -1))
1355 /* If the compilation unit didn't have an explicit address range,
1356 then use the information extracted from its child dies. */
1357 if (! comp_unit_die
.has_pc_info
)
1359 comp_unit_die
.lowpc
= lowpc
;
1360 comp_unit_die
.highpc
= highpc
;
1363 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1364 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1366 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1367 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1368 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1369 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1370 sort_pst_symbols (pst
);
1372 /* If there is already a psymtab or symtab for a file of this
1373 name, remove it. (If there is a symtab, more drastic things
1374 also happen.) This happens in VxWorks. */
1375 free_named_symtabs (pst
->filename
);
1377 info_ptr
= beg_of_comp_unit
+ cu_header
.length
1378 + cu_header
.initial_length_size
;
1380 do_cleanups (back_to
);
1383 /* Read in all interesting dies to the end of the compilation unit or
1384 to the end of the current namespace. NAMESPACE is NULL if we
1385 haven't yet encountered any DW_TAG_namespace entries; otherwise,
1386 it's the name of the current namespace. In particular, it's the
1387 empty string if we're currently in the global namespace but have
1388 previously encountered a DW_TAG_namespace. */
1391 scan_partial_symbols (char *info_ptr
, struct objfile
*objfile
,
1392 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1393 const struct comp_unit_head
*cu_header
,
1394 const char *namespace)
1396 bfd
*abfd
= objfile
->obfd
;
1397 struct partial_die_info pdi
;
1399 /* Now, march along the PDI's, descending into ones which have
1400 interesting children but skipping the children of the other ones,
1401 until we reach the end of the compilation unit. */
1405 /* This flag tells whether or not info_ptr has gotten updated
1407 int info_ptr_updated
= 0;
1409 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1411 /* Anonymous namespaces have no name but have interesting
1412 children, so we need to look at them. Ditto for anonymous
1415 if (pdi
.name
!= NULL
|| pdi
.tag
== DW_TAG_namespace
1416 || pdi
.tag
== DW_TAG_enumeration_type
)
1420 case DW_TAG_subprogram
:
1421 if (pdi
.has_pc_info
)
1423 if (pdi
.lowpc
< *lowpc
)
1427 if (pdi
.highpc
> *highpc
)
1429 *highpc
= pdi
.highpc
;
1431 if (!pdi
.is_declaration
)
1433 add_partial_symbol (&pdi
, objfile
, cu_header
, namespace);
1437 case DW_TAG_variable
:
1438 case DW_TAG_typedef
:
1439 case DW_TAG_union_type
:
1440 case DW_TAG_class_type
:
1441 case DW_TAG_structure_type
:
1442 if (!pdi
.is_declaration
)
1444 add_partial_symbol (&pdi
, objfile
, cu_header
, namespace);
1447 case DW_TAG_enumeration_type
:
1448 if (!pdi
.is_declaration
)
1450 info_ptr
= add_partial_enumeration (&pdi
, info_ptr
,
1453 info_ptr_updated
= 1;
1456 case DW_TAG_base_type
:
1457 /* File scope base type definitions are added to the partial
1459 add_partial_symbol (&pdi
, objfile
, cu_header
, namespace);
1461 case DW_TAG_namespace
:
1462 /* We've hit a DW_TAG_namespace entry, so we know this
1463 file has been compiled using a compiler that
1464 generates them; update NAMESPACE to reflect that. */
1465 if (namespace == NULL
)
1467 info_ptr
= add_partial_namespace (&pdi
, info_ptr
, objfile
,
1468 lowpc
, highpc
, cu_header
,
1470 info_ptr_updated
= 1;
1480 /* If the die has a sibling, skip to the sibling, unless another
1481 function has already updated info_ptr for us. */
1483 /* NOTE: carlton/2003-06-16: This is a bit hackish, but whether
1484 or not we want to update this depends on enough stuff (not
1485 only pdi.tag but also whether or not pdi.name is NULL) that
1486 this seems like the easiest way to handle the issue. */
1488 if (!info_ptr_updated
)
1489 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu_header
);
1496 add_partial_symbol (struct partial_die_info
*pdi
, struct objfile
*objfile
,
1497 const struct comp_unit_head
*cu_header
,
1498 const char *namespace)
1501 const struct partial_symbol
*psym
= NULL
;
1505 case DW_TAG_subprogram
:
1506 if (pdi
->is_external
)
1508 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1509 mst_text, objfile); */
1510 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1511 VAR_DOMAIN
, LOC_BLOCK
,
1512 &objfile
->global_psymbols
,
1513 0, pdi
->lowpc
+ baseaddr
,
1514 cu_language
, objfile
);
1518 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1519 mst_file_text, objfile); */
1520 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1521 VAR_DOMAIN
, LOC_BLOCK
,
1522 &objfile
->static_psymbols
,
1523 0, pdi
->lowpc
+ baseaddr
,
1524 cu_language
, objfile
);
1527 case DW_TAG_variable
:
1528 if (pdi
->is_external
)
1531 Don't enter into the minimal symbol tables as there is
1532 a minimal symbol table entry from the ELF symbols already.
1533 Enter into partial symbol table if it has a location
1534 descriptor or a type.
1535 If the location descriptor is missing, new_symbol will create
1536 a LOC_UNRESOLVED symbol, the address of the variable will then
1537 be determined from the minimal symbol table whenever the variable
1539 The address for the partial symbol table entry is not
1540 used by GDB, but it comes in handy for debugging partial symbol
1544 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1545 if (pdi
->locdesc
|| pdi
->has_type
)
1546 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1547 VAR_DOMAIN
, LOC_STATIC
,
1548 &objfile
->global_psymbols
,
1550 cu_language
, objfile
);
1554 /* Static Variable. Skip symbols without location descriptors. */
1555 if (pdi
->locdesc
== NULL
)
1557 addr
= decode_locdesc (pdi
->locdesc
, objfile
, cu_header
);
1558 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1559 mst_file_data, objfile); */
1560 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1561 VAR_DOMAIN
, LOC_STATIC
,
1562 &objfile
->static_psymbols
,
1564 cu_language
, objfile
);
1567 case DW_TAG_typedef
:
1568 case DW_TAG_base_type
:
1569 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1570 VAR_DOMAIN
, LOC_TYPEDEF
,
1571 &objfile
->static_psymbols
,
1572 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1574 case DW_TAG_class_type
:
1575 case DW_TAG_structure_type
:
1576 case DW_TAG_union_type
:
1577 case DW_TAG_enumeration_type
:
1578 /* Skip aggregate types without children, these are external
1580 if (pdi
->has_children
== 0)
1582 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1583 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1584 &objfile
->static_psymbols
,
1585 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1587 if (cu_language
== language_cplus
)
1589 /* For C++, these implicitly act as typedefs as well. */
1590 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1591 VAR_DOMAIN
, LOC_TYPEDEF
,
1592 &objfile
->static_psymbols
,
1593 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1596 case DW_TAG_enumerator
:
1597 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1598 VAR_DOMAIN
, LOC_CONST
,
1599 &objfile
->static_psymbols
,
1600 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1606 /* Check to see if we should scan the name for possible namespace
1607 info. Only do this if this is C++, if we don't have namespace
1608 debugging info in the file, if the psym is of an appropriate type
1609 (otherwise we'll have psym == NULL), and if we actually had a
1610 mangled name to begin with. */
1612 if (cu_language
== language_cplus
1613 && namespace == NULL
1615 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
1616 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
1620 /* Read a partial die corresponding to a namespace; also, add a symbol
1621 corresponding to that namespace to the symbol table. NAMESPACE is
1622 the name of the enclosing namespace. */
1625 add_partial_namespace (struct partial_die_info
*pdi
, char *info_ptr
,
1626 struct objfile
*objfile
,
1627 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1628 const struct comp_unit_head
*cu_header
,
1629 const char *namespace)
1631 /* Calculate the full name of the namespace that we just entered. */
1633 const char *new_name
= pdi
->name
;
1636 if (new_name
== NULL
)
1637 new_name
= "(anonymous namespace)";
1638 full_name
= alloca (strlen (namespace) + 2 + strlen (new_name
) + 1);
1639 strcpy (full_name
, namespace);
1640 if (*namespace != '\0')
1641 strcat (full_name
, "::");
1642 strcat (full_name
, new_name
);
1644 /* FIXME: carlton/2003-06-27: Once we build qualified names for more
1645 symbols than just namespaces, we should replace this by a call to
1646 add_partial_symbol. */
1648 add_psymbol_to_list (full_name
, strlen (full_name
),
1649 VAR_DOMAIN
, LOC_TYPEDEF
,
1650 &objfile
->global_psymbols
,
1651 0, 0, cu_language
, objfile
);
1653 /* Now scan partial symbols in that namespace. */
1655 if (pdi
->has_children
)
1656 info_ptr
= scan_partial_symbols (info_ptr
, objfile
,
1658 cu_header
, full_name
);
1663 /* Read a partial die corresponding to an enumeration type. */
1666 add_partial_enumeration (struct partial_die_info
*enum_pdi
, char *info_ptr
,
1667 struct objfile
*objfile
,
1668 const struct comp_unit_head
*cu_header
,
1669 const char *namespace)
1671 bfd
*abfd
= objfile
->obfd
;
1672 struct partial_die_info pdi
;
1674 if (enum_pdi
->name
!= NULL
)
1675 add_partial_symbol (enum_pdi
, objfile
, cu_header
, namespace);
1679 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1682 if (pdi
.tag
!= DW_TAG_enumerator
|| pdi
.name
== NULL
)
1683 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
1685 add_partial_symbol (&pdi
, objfile
, cu_header
, namespace);
1691 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the next DIE
1695 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
1696 bfd
*abfd
, const struct comp_unit_head
*cu_header
)
1698 /* Do we know the sibling already? */
1700 if (orig_pdi
->sibling
)
1701 return orig_pdi
->sibling
;
1703 /* Are there any children to deal with? */
1705 if (!orig_pdi
->has_children
)
1708 /* Okay, we don't know the sibling, but we have children that we
1709 want to skip. So read children until we run into one without a
1710 tag; return whatever follows it. */
1714 struct partial_die_info pdi
;
1716 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu_header
);
1721 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu_header
);
1725 /* Expand this partial symbol table into a full symbol table. */
1728 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1730 /* FIXME: This is barely more than a stub. */
1735 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1741 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1742 gdb_flush (gdb_stdout
);
1745 psymtab_to_symtab_1 (pst
);
1747 /* Finish up the debug error message. */
1749 printf_filtered ("done.\n");
1755 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1757 struct objfile
*objfile
= pst
->objfile
;
1758 bfd
*abfd
= objfile
->obfd
;
1759 struct comp_unit_head cu_header
;
1760 struct die_info
*dies
;
1761 unsigned long offset
;
1762 CORE_ADDR lowpc
, highpc
;
1763 struct die_info
*child_die
;
1765 struct symtab
*symtab
;
1766 struct cleanup
*back_to
;
1767 struct attribute
*attr
;
1769 /* Set local variables from the partial symbol table info. */
1770 offset
= DWARF_INFO_OFFSET (pst
);
1771 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1772 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1773 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1774 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1775 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1776 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1777 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1778 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1779 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1780 dwarf_ranges_buffer
= DWARF_RANGES_BUFFER (pst
);
1781 dwarf_ranges_size
= DWARF_RANGES_SIZE (pst
);
1782 dwarf_loc_buffer
= DWARF_LOC_BUFFER (pst
);
1783 dwarf_loc_size
= DWARF_LOC_SIZE (pst
);
1784 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1785 cu_header_offset
= offset
;
1786 info_ptr
= dwarf_info_buffer
+ offset
;
1788 obstack_init (&dwarf2_tmp_obstack
);
1789 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1792 make_cleanup (really_free_pendings
, NULL
);
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_header
);
1799 make_cleanup (dwarf2_empty_abbrev_table
, cu_header
.dwarf2_abbrevs
);
1801 dies
= read_comp_unit (info_ptr
, abfd
, &cu_header
);
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
, objfile
, &cu_header
);
1833 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, objfile
, &cu_header
))
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
->has_children
)
1841 child_die
= dies
->next
;
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
,
1849 objfile
, &cu_header
))
1851 highpc
= max (highpc
, high
);
1854 child_die
= sibling_die (child_die
);
1858 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1860 /* Set symtab language to language from DW_AT_language.
1861 If the compilation is from a C file generated by language preprocessors,
1862 do not set the language if it was already deduced by start_subfile. */
1864 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1866 symtab
->language
= cu_language
;
1868 pst
->symtab
= symtab
;
1871 do_cleanups (back_to
);
1874 /* Process a die and its children. */
1877 process_die (struct die_info
*die
, struct objfile
*objfile
,
1878 const struct comp_unit_head
*cu_header
)
1882 case DW_TAG_padding
:
1884 case DW_TAG_compile_unit
:
1885 read_file_scope (die
, objfile
, cu_header
);
1887 case DW_TAG_subprogram
:
1888 read_subroutine_type (die
, objfile
, cu_header
);
1889 read_func_scope (die
, objfile
, cu_header
);
1891 case DW_TAG_inlined_subroutine
:
1892 /* FIXME: These are ignored for now.
1893 They could be used to set breakpoints on all inlined instances
1894 of a function and make GDB `next' properly over inlined functions. */
1896 case DW_TAG_lexical_block
:
1897 case DW_TAG_try_block
:
1898 case DW_TAG_catch_block
:
1899 read_lexical_block_scope (die
, objfile
, cu_header
);
1901 case DW_TAG_class_type
:
1902 case DW_TAG_structure_type
:
1903 case DW_TAG_union_type
:
1904 read_structure_scope (die
, objfile
, cu_header
);
1906 case DW_TAG_enumeration_type
:
1907 read_enumeration (die
, objfile
, cu_header
);
1909 case DW_TAG_subroutine_type
:
1910 read_subroutine_type (die
, objfile
, cu_header
);
1912 case DW_TAG_array_type
:
1913 read_array_type (die
, objfile
, cu_header
);
1915 case DW_TAG_pointer_type
:
1916 read_tag_pointer_type (die
, objfile
, cu_header
);
1918 case DW_TAG_ptr_to_member_type
:
1919 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
1921 case DW_TAG_reference_type
:
1922 read_tag_reference_type (die
, objfile
, cu_header
);
1924 case DW_TAG_string_type
:
1925 read_tag_string_type (die
, objfile
);
1927 case DW_TAG_base_type
:
1928 read_base_type (die
, objfile
);
1929 if (dwarf_attr (die
, DW_AT_name
))
1931 /* Add a typedef symbol for the base type definition. */
1932 new_symbol (die
, die
->type
, objfile
, cu_header
);
1935 case DW_TAG_common_block
:
1936 read_common_block (die
, objfile
, cu_header
);
1938 case DW_TAG_common_inclusion
:
1940 case DW_TAG_namespace
:
1941 if (!processing_has_namespace_info
)
1943 processing_has_namespace_info
= 1;
1944 processing_current_namespace
= "";
1946 read_namespace (die
, objfile
, cu_header
);
1948 case DW_TAG_imported_declaration
:
1949 case DW_TAG_imported_module
:
1950 /* FIXME: carlton/2002-10-16: Eventually, we should use the
1951 information contained in these. DW_TAG_imported_declaration
1952 dies shouldn't have children; DW_TAG_imported_module dies
1953 shouldn't in the C++ case, but conceivably could in the
1954 Fortran case, so we'll have to replace this gdb_assert if
1955 Fortran compilers start generating that info. */
1956 if (!processing_has_namespace_info
)
1958 processing_has_namespace_info
= 1;
1959 processing_current_namespace
= "";
1961 gdb_assert (!die
->has_children
);
1964 new_symbol (die
, NULL
, objfile
, cu_header
);
1970 initialize_cu_func_list (void)
1972 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1976 read_file_scope (struct die_info
*die
, struct objfile
*objfile
,
1977 const struct comp_unit_head
*cu_header
)
1979 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1980 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1981 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1982 struct attribute
*attr
;
1983 char *name
= "<unknown>";
1984 char *comp_dir
= NULL
;
1985 struct die_info
*child_die
;
1986 bfd
*abfd
= objfile
->obfd
;
1987 struct line_header
*line_header
= 0;
1989 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
, cu_header
))
1991 if (die
->has_children
)
1993 child_die
= die
->next
;
1994 while (child_die
&& child_die
->tag
)
1996 if (child_die
->tag
== DW_TAG_subprogram
)
1998 CORE_ADDR low
, high
;
2000 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
,
2001 objfile
, cu_header
))
2003 lowpc
= min (lowpc
, low
);
2004 highpc
= max (highpc
, high
);
2007 child_die
= sibling_die (child_die
);
2012 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2013 from finish_block. */
2014 if (lowpc
== ((CORE_ADDR
) -1))
2019 attr
= dwarf_attr (die
, DW_AT_name
);
2022 name
= DW_STRING (attr
);
2024 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
2027 comp_dir
= DW_STRING (attr
);
2030 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2031 directory, get rid of it. */
2032 char *cp
= strchr (comp_dir
, ':');
2034 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2039 if (objfile
->ei
.entry_point
>= lowpc
&&
2040 objfile
->ei
.entry_point
< highpc
)
2042 objfile
->ei
.deprecated_entry_file_lowpc
= lowpc
;
2043 objfile
->ei
.deprecated_entry_file_highpc
= highpc
;
2046 attr
= dwarf_attr (die
, DW_AT_language
);
2049 set_cu_language (DW_UNSND (attr
));
2052 /* We assume that we're processing GCC output. */
2053 processing_gcc_compilation
= 2;
2055 /* FIXME:Do something here. */
2056 if (dip
->at_producer
!= NULL
)
2058 handle_producer (dip
->at_producer
);
2062 /* The compilation unit may be in a different language or objfile,
2063 zero out all remembered fundamental types. */
2064 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2066 start_symtab (name
, comp_dir
, lowpc
);
2067 record_debugformat ("DWARF 2");
2069 initialize_cu_func_list ();
2071 /* Process all dies in compilation unit. */
2072 if (die
->has_children
)
2074 child_die
= die
->next
;
2075 while (child_die
&& child_die
->tag
)
2077 process_die (child_die
, objfile
, cu_header
);
2078 child_die
= sibling_die (child_die
);
2082 /* Decode line number information if present. */
2083 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
2086 unsigned int line_offset
= DW_UNSND (attr
);
2087 line_header
= dwarf_decode_line_header (line_offset
,
2091 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2092 (void *) line_header
);
2093 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu_header
);
2097 /* Decode macro information, if present. Dwarf 2 macro information
2098 refers to information in the line number info statement program
2099 header, so we can only read it if we've read the header
2101 attr
= dwarf_attr (die
, DW_AT_macro_info
);
2102 if (attr
&& line_header
)
2104 unsigned int macro_offset
= DW_UNSND (attr
);
2105 dwarf_decode_macros (line_header
, macro_offset
,
2106 comp_dir
, abfd
, cu_header
, objfile
);
2108 do_cleanups (back_to
);
2112 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
2114 struct function_range
*thisfn
;
2116 thisfn
= (struct function_range
*)
2117 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
2118 thisfn
->name
= name
;
2119 thisfn
->lowpc
= lowpc
;
2120 thisfn
->highpc
= highpc
;
2121 thisfn
->seen_line
= 0;
2122 thisfn
->next
= NULL
;
2124 if (cu_last_fn
== NULL
)
2125 cu_first_fn
= thisfn
;
2127 cu_last_fn
->next
= thisfn
;
2129 cu_last_fn
= thisfn
;
2133 read_func_scope (struct die_info
*die
, struct objfile
*objfile
,
2134 const struct comp_unit_head
*cu_header
)
2136 struct context_stack
*new;
2139 struct die_info
*child_die
;
2140 struct attribute
*attr
;
2143 name
= dwarf2_linkage_name (die
);
2145 /* Ignore functions with missing or empty names and functions with
2146 missing or invalid low and high pc attributes. */
2147 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
, cu_header
))
2153 /* Record the function range for dwarf_decode_lines. */
2154 add_to_cu_func_list (name
, lowpc
, highpc
);
2156 if (objfile
->ei
.entry_point
>= lowpc
&&
2157 objfile
->ei
.entry_point
< highpc
)
2159 objfile
->ei
.entry_func_lowpc
= lowpc
;
2160 objfile
->ei
.entry_func_highpc
= highpc
;
2163 /* Decode DW_AT_frame_base location descriptor if present, keep result
2164 for DW_OP_fbreg operands in decode_locdesc. */
2165 frame_base_reg
= -1;
2166 frame_base_offset
= 0;
2167 attr
= dwarf_attr (die
, DW_AT_frame_base
);
2172 /* Support the .debug_loc offsets */
2173 if (attr_form_is_block (attr
))
2175 addr
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
2177 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2179 dwarf2_complex_location_expr_complaint ();
2184 dwarf2_invalid_attrib_class_complaint ("DW_AT_frame_base", name
);
2189 dwarf2_unsupported_at_frame_base_complaint (name
);
2191 frame_base_reg
= addr
;
2194 frame_base_reg
= basereg
;
2195 frame_base_offset
= addr
;
2198 dwarf2_unsupported_at_frame_base_complaint (name
);
2201 new = push_context (0, lowpc
);
2202 new->name
= new_symbol (die
, die
->type
, objfile
, cu_header
);
2204 /* If there was a location expression for DW_AT_frame_base above,
2205 record it. We still need to decode it above because not all
2206 symbols use location expressions exclusively. */
2208 dwarf2_symbol_mark_computed (attr
, new->name
, cu_header
, objfile
);
2210 list_in_scope
= &local_symbols
;
2212 if (die
->has_children
)
2214 child_die
= die
->next
;
2215 while (child_die
&& child_die
->tag
)
2217 process_die (child_die
, objfile
, cu_header
);
2218 child_die
= sibling_die (child_die
);
2222 new = pop_context ();
2223 /* Make a block for the local symbols within. */
2224 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2225 lowpc
, highpc
, objfile
);
2227 /* In C++, we can have functions nested inside functions (e.g., when
2228 a function declares a class that has methods). This means that
2229 when we finish processing a function scope, we may need to go
2230 back to building a containing block's symbol lists. */
2231 local_symbols
= new->locals
;
2232 param_symbols
= new->params
;
2234 /* If we've finished processing a top-level function, subsequent
2235 symbols go in the file symbol list. */
2236 if (outermost_context_p ())
2237 list_in_scope
= &file_symbols
;
2240 /* Process all the DIES contained within a lexical block scope. Start
2241 a new scope, process the dies, and then close the scope. */
2244 read_lexical_block_scope (struct die_info
*die
, struct objfile
*objfile
,
2245 const struct comp_unit_head
*cu_header
)
2247 struct context_stack
*new;
2248 CORE_ADDR lowpc
, highpc
;
2249 struct die_info
*child_die
;
2251 /* Ignore blocks with missing or invalid low and high pc attributes. */
2252 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2253 as multiple lexical blocks? Handling children in a sane way would
2254 be nasty. Might be easier to properly extend generic blocks to
2256 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, objfile
, cu_header
))
2261 push_context (0, lowpc
);
2262 if (die
->has_children
)
2264 child_die
= die
->next
;
2265 while (child_die
&& child_die
->tag
)
2267 process_die (child_die
, objfile
, cu_header
);
2268 child_die
= sibling_die (child_die
);
2271 new = pop_context ();
2273 if (local_symbols
!= NULL
)
2275 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2278 local_symbols
= new->locals
;
2281 /* Get low and high pc attributes from a die. Return 1 if the attributes
2282 are present and valid, otherwise, return 0. Return -1 if the range is
2283 discontinuous, i.e. derived from DW_AT_ranges information. */
2285 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
2286 CORE_ADDR
*highpc
, struct objfile
*objfile
,
2287 const struct comp_unit_head
*cu_header
)
2289 struct attribute
*attr
;
2290 bfd
*obfd
= objfile
->obfd
;
2295 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2298 high
= DW_ADDR (attr
);
2299 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2301 low
= DW_ADDR (attr
);
2303 /* Found high w/o low attribute. */
2306 /* Found consecutive range of addresses. */
2311 attr
= dwarf_attr (die
, DW_AT_ranges
);
2314 unsigned int addr_size
= cu_header
->addr_size
;
2315 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2316 /* Value of the DW_AT_ranges attribute is the offset in the
2317 .debug_ranges section. */
2318 unsigned int offset
= DW_UNSND (attr
);
2319 /* Base address selection entry. */
2328 found_base
= cu_header
->base_known
;
2329 base
= cu_header
->base_address
;
2331 if (offset
>= dwarf_ranges_size
)
2333 complaint (&symfile_complaints
,
2334 "Offset %d out of bounds for DW_AT_ranges attribute",
2338 buffer
= dwarf_ranges_buffer
+ offset
;
2340 /* Read in the largest possible address. */
2341 marker
= read_address (obfd
, buffer
, cu_header
, &dummy
);
2342 if ((marker
& mask
) == mask
)
2344 /* If we found the largest possible address, then
2345 read the base address. */
2346 base
= read_address (obfd
, buffer
+ addr_size
,
2348 buffer
+= 2 * addr_size
;
2349 offset
+= 2 * addr_size
;
2357 CORE_ADDR range_beginning
, range_end
;
2359 range_beginning
= read_address (obfd
, buffer
,
2361 buffer
+= addr_size
;
2362 range_end
= read_address (obfd
, buffer
, cu_header
, &dummy
);
2363 buffer
+= addr_size
;
2364 offset
+= 2 * addr_size
;
2366 /* An end of list marker is a pair of zero addresses. */
2367 if (range_beginning
== 0 && range_end
== 0)
2368 /* Found the end of list entry. */
2371 /* Each base address selection entry is a pair of 2 values.
2372 The first is the largest possible address, the second is
2373 the base address. Check for a base address here. */
2374 if ((range_beginning
& mask
) == mask
)
2376 /* If we found the largest possible address, then
2377 read the base address. */
2378 base
= read_address (obfd
, buffer
+ addr_size
,
2386 /* We have no valid base address for the ranges
2388 complaint (&symfile_complaints
,
2389 "Invalid .debug_ranges data (no base address)");
2393 range_beginning
+= base
;
2396 /* FIXME: This is recording everything as a low-high
2397 segment of consecutive addresses. We should have a
2398 data structure for discontiguous block ranges
2402 low
= range_beginning
;
2408 if (range_beginning
< low
)
2409 low
= range_beginning
;
2410 if (range_end
> high
)
2416 /* If the first entry is an end-of-list marker, the range
2417 describes an empty scope, i.e. no instructions. */
2427 /* When using the GNU linker, .gnu.linkonce. sections are used to
2428 eliminate duplicate copies of functions and vtables and such.
2429 The linker will arbitrarily choose one and discard the others.
2430 The AT_*_pc values for such functions refer to local labels in
2431 these sections. If the section from that file was discarded, the
2432 labels are not in the output, so the relocs get a value of 0.
2433 If this is a discarded function, mark the pc bounds as invalid,
2434 so that GDB will ignore it. */
2435 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
2443 /* Add an aggregate field to the field list. */
2446 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2447 struct objfile
*objfile
,
2448 const struct comp_unit_head
*cu_header
)
2450 struct nextfield
*new_field
;
2451 struct attribute
*attr
;
2453 char *fieldname
= "";
2455 /* Allocate a new field list entry and link it in. */
2456 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2457 make_cleanup (xfree
, new_field
);
2458 memset (new_field
, 0, sizeof (struct nextfield
));
2459 new_field
->next
= fip
->fields
;
2460 fip
->fields
= new_field
;
2463 /* Handle accessibility and virtuality of field.
2464 The default accessibility for members is public, the default
2465 accessibility for inheritance is private. */
2466 if (die
->tag
!= DW_TAG_inheritance
)
2467 new_field
->accessibility
= DW_ACCESS_public
;
2469 new_field
->accessibility
= DW_ACCESS_private
;
2470 new_field
->virtuality
= DW_VIRTUALITY_none
;
2472 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2474 new_field
->accessibility
= DW_UNSND (attr
);
2475 if (new_field
->accessibility
!= DW_ACCESS_public
)
2476 fip
->non_public_fields
= 1;
2477 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2479 new_field
->virtuality
= DW_UNSND (attr
);
2481 fp
= &new_field
->field
;
2483 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
))
2485 /* Data member other than a C++ static data member. */
2487 /* Get type of field. */
2488 fp
->type
= die_type (die
, objfile
, cu_header
);
2490 FIELD_STATIC_KIND (*fp
) = 0;
2492 /* Get bit size of field (zero if none). */
2493 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2496 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2500 FIELD_BITSIZE (*fp
) = 0;
2503 /* Get bit offset of field. */
2504 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2507 FIELD_BITPOS (*fp
) =
2508 decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) * bits_per_byte
;
2511 FIELD_BITPOS (*fp
) = 0;
2512 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2515 if (BITS_BIG_ENDIAN
)
2517 /* For big endian bits, the DW_AT_bit_offset gives the
2518 additional bit offset from the MSB of the containing
2519 anonymous object to the MSB of the field. We don't
2520 have to do anything special since we don't need to
2521 know the size of the anonymous object. */
2522 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2526 /* For little endian bits, compute the bit offset to the
2527 MSB of the anonymous object, subtract off the number of
2528 bits from the MSB of the field to the MSB of the
2529 object, and then subtract off the number of bits of
2530 the field itself. The result is the bit offset of
2531 the LSB of the field. */
2533 int bit_offset
= DW_UNSND (attr
);
2535 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2538 /* The size of the anonymous object containing
2539 the bit field is explicit, so use the
2540 indicated size (in bytes). */
2541 anonymous_size
= DW_UNSND (attr
);
2545 /* The size of the anonymous object containing
2546 the bit field must be inferred from the type
2547 attribute of the data member containing the
2549 anonymous_size
= TYPE_LENGTH (fp
->type
);
2551 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2552 - bit_offset
- FIELD_BITSIZE (*fp
);
2556 /* Get name of field. */
2557 attr
= dwarf_attr (die
, DW_AT_name
);
2558 if (attr
&& DW_STRING (attr
))
2559 fieldname
= DW_STRING (attr
);
2560 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2561 &objfile
->type_obstack
);
2563 /* Change accessibility for artificial fields (e.g. virtual table
2564 pointer or virtual base class pointer) to private. */
2565 if (dwarf_attr (die
, DW_AT_artificial
))
2567 new_field
->accessibility
= DW_ACCESS_private
;
2568 fip
->non_public_fields
= 1;
2571 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
2573 /* C++ static member. */
2575 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2576 is a declaration, but all versions of G++ as of this writing
2577 (so through at least 3.2.1) incorrectly generate
2578 DW_TAG_variable tags. */
2582 /* Get name of field. */
2583 attr
= dwarf_attr (die
, DW_AT_name
);
2584 if (attr
&& DW_STRING (attr
))
2585 fieldname
= DW_STRING (attr
);
2589 /* Get physical name. */
2590 physname
= dwarf2_linkage_name (die
);
2592 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2593 &objfile
->type_obstack
));
2594 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2595 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2596 &objfile
->type_obstack
);
2598 else if (die
->tag
== DW_TAG_inheritance
)
2600 /* C++ base class field. */
2601 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2603 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
)
2605 FIELD_BITSIZE (*fp
) = 0;
2606 FIELD_STATIC_KIND (*fp
) = 0;
2607 FIELD_TYPE (*fp
) = die_type (die
, objfile
, cu_header
);
2608 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2609 fip
->nbaseclasses
++;
2613 /* Create the vector of fields, and attach it to the type. */
2616 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2617 struct objfile
*objfile
)
2619 int nfields
= fip
->nfields
;
2621 /* Record the field count, allocate space for the array of fields,
2622 and create blank accessibility bitfields if necessary. */
2623 TYPE_NFIELDS (type
) = nfields
;
2624 TYPE_FIELDS (type
) = (struct field
*)
2625 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2626 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2628 if (fip
->non_public_fields
)
2630 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2632 TYPE_FIELD_PRIVATE_BITS (type
) =
2633 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2634 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2636 TYPE_FIELD_PROTECTED_BITS (type
) =
2637 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2638 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2640 TYPE_FIELD_IGNORE_BITS (type
) =
2641 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2642 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2645 /* If the type has baseclasses, allocate and clear a bit vector for
2646 TYPE_FIELD_VIRTUAL_BITS. */
2647 if (fip
->nbaseclasses
)
2649 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2652 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2653 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2654 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2655 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2656 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2659 /* Copy the saved-up fields into the field vector. Start from the head
2660 of the list, adding to the tail of the field array, so that they end
2661 up in the same order in the array in which they were added to the list. */
2662 while (nfields
-- > 0)
2664 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2665 switch (fip
->fields
->accessibility
)
2667 case DW_ACCESS_private
:
2668 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2671 case DW_ACCESS_protected
:
2672 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2675 case DW_ACCESS_public
:
2679 /* Unknown accessibility. Complain and treat it as public. */
2681 complaint (&symfile_complaints
, "unsupported accessibility %d",
2682 fip
->fields
->accessibility
);
2686 if (nfields
< fip
->nbaseclasses
)
2688 switch (fip
->fields
->virtuality
)
2690 case DW_VIRTUALITY_virtual
:
2691 case DW_VIRTUALITY_pure_virtual
:
2692 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2696 fip
->fields
= fip
->fields
->next
;
2700 /* Add a member function to the proper fieldlist. */
2703 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2704 struct type
*type
, struct objfile
*objfile
,
2705 const struct comp_unit_head
*cu_header
)
2707 struct attribute
*attr
;
2708 struct fnfieldlist
*flp
;
2710 struct fn_field
*fnp
;
2713 struct nextfnfield
*new_fnfield
;
2715 /* Get name of member function. */
2716 attr
= dwarf_attr (die
, DW_AT_name
);
2717 if (attr
&& DW_STRING (attr
))
2718 fieldname
= DW_STRING (attr
);
2722 /* Get the mangled name. */
2723 physname
= dwarf2_linkage_name (die
);
2725 /* Look up member function name in fieldlist. */
2726 for (i
= 0; i
< fip
->nfnfields
; i
++)
2728 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2732 /* Create new list element if necessary. */
2733 if (i
< fip
->nfnfields
)
2734 flp
= &fip
->fnfieldlists
[i
];
2737 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2739 fip
->fnfieldlists
= (struct fnfieldlist
*)
2740 xrealloc (fip
->fnfieldlists
,
2741 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2742 * sizeof (struct fnfieldlist
));
2743 if (fip
->nfnfields
== 0)
2744 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2746 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2747 flp
->name
= fieldname
;
2753 /* Create a new member function field and chain it to the field list
2755 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2756 make_cleanup (xfree
, new_fnfield
);
2757 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2758 new_fnfield
->next
= flp
->head
;
2759 flp
->head
= new_fnfield
;
2762 /* Fill in the member function field info. */
2763 fnp
= &new_fnfield
->fnfield
;
2764 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2765 &objfile
->type_obstack
);
2766 fnp
->type
= alloc_type (objfile
);
2767 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2769 struct type
*return_type
= TYPE_TARGET_TYPE (die
->type
);
2770 int nparams
= TYPE_NFIELDS (die
->type
);
2772 /* TYPE is the domain of this method, and DIE->TYPE is the type
2773 of the method itself (TYPE_CODE_METHOD). */
2774 smash_to_method_type (fnp
->type
, type
,
2775 TYPE_TARGET_TYPE (die
->type
),
2776 TYPE_FIELDS (die
->type
),
2777 TYPE_NFIELDS (die
->type
),
2778 TYPE_VARARGS (die
->type
));
2780 /* Handle static member functions.
2781 Dwarf2 has no clean way to discern C++ static and non-static
2782 member functions. G++ helps GDB by marking the first
2783 parameter for non-static member functions (which is the
2784 this pointer) as artificial. We obtain this information
2785 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2786 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2787 fnp
->voffset
= VOFFSET_STATIC
;
2790 complaint (&symfile_complaints
, "member function type missing for '%s'",
2793 /* Get fcontext from DW_AT_containing_type if present. */
2794 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2795 fnp
->fcontext
= die_containing_type (die
, objfile
, cu_header
);
2797 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2798 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2800 /* Get accessibility. */
2801 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2804 switch (DW_UNSND (attr
))
2806 case DW_ACCESS_private
:
2807 fnp
->is_private
= 1;
2809 case DW_ACCESS_protected
:
2810 fnp
->is_protected
= 1;
2815 /* Check for artificial methods. */
2816 attr
= dwarf_attr (die
, DW_AT_artificial
);
2817 if (attr
&& DW_UNSND (attr
) != 0)
2818 fnp
->is_artificial
= 1;
2820 /* Get index in virtual function table if it is a virtual member function. */
2821 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2824 /* Support the .debug_loc offsets */
2825 if (attr_form_is_block (attr
))
2827 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
) + 2;
2829 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2831 dwarf2_complex_location_expr_complaint ();
2835 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2841 /* Create the vector of member function fields, and attach it to the type. */
2844 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2845 struct objfile
*objfile
)
2847 struct fnfieldlist
*flp
;
2848 int total_length
= 0;
2851 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2852 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2853 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2855 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2857 struct nextfnfield
*nfp
= flp
->head
;
2858 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2861 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2862 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2863 fn_flp
->fn_fields
= (struct fn_field
*)
2864 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2865 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2866 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2868 total_length
+= flp
->length
;
2871 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2872 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2875 /* Called when we find the DIE that starts a structure or union scope
2876 (definition) to process all dies that define the members of the
2879 NOTE: we need to call struct_type regardless of whether or not the
2880 DIE has an at_name attribute, since it might be an anonymous
2881 structure or union. This gets the type entered into our set of
2884 However, if the structure is incomplete (an opaque struct/union)
2885 then suppress creating a symbol table entry for it since gdb only
2886 wants to find the one with the complete definition. Note that if
2887 it is complete, we just call new_symbol, which does it's own
2888 checking about whether the struct/union is anonymous or not (and
2889 suppresses creating a symbol table entry itself). */
2892 read_structure_scope (struct die_info
*die
, struct objfile
*objfile
,
2893 const struct comp_unit_head
*cu_header
)
2896 struct attribute
*attr
;
2898 type
= alloc_type (objfile
);
2900 INIT_CPLUS_SPECIFIC (type
);
2901 attr
= dwarf_attr (die
, DW_AT_name
);
2902 if (attr
&& DW_STRING (attr
))
2904 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2905 strlen (DW_STRING (attr
)),
2906 &objfile
->type_obstack
);
2909 if (die
->tag
== DW_TAG_structure_type
)
2911 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2913 else if (die
->tag
== DW_TAG_union_type
)
2915 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2919 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2921 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2924 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2927 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2931 TYPE_LENGTH (type
) = 0;
2934 /* We need to add the type field to the die immediately so we don't
2935 infinitely recurse when dealing with pointers to the structure
2936 type within the structure itself. */
2939 if (die
->has_children
&& ! die_is_declaration (die
))
2941 struct field_info fi
;
2942 struct die_info
*child_die
;
2943 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2945 memset (&fi
, 0, sizeof (struct field_info
));
2947 child_die
= die
->next
;
2949 while (child_die
&& child_die
->tag
)
2951 if (child_die
->tag
== DW_TAG_member
2952 || child_die
->tag
== DW_TAG_variable
)
2954 /* NOTE: carlton/2002-11-05: A C++ static data member
2955 should be a DW_TAG_member that is a declaration, but
2956 all versions of G++ as of this writing (so through at
2957 least 3.2.1) incorrectly generate DW_TAG_variable
2958 tags for them instead. */
2959 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2961 else if (child_die
->tag
== DW_TAG_subprogram
)
2963 /* C++ member function. */
2964 process_die (child_die
, objfile
, cu_header
);
2965 dwarf2_add_member_fn (&fi
, child_die
, type
, objfile
, cu_header
);
2967 else if (child_die
->tag
== DW_TAG_inheritance
)
2969 /* C++ base class field. */
2970 dwarf2_add_field (&fi
, child_die
, objfile
, cu_header
);
2974 process_die (child_die
, objfile
, cu_header
);
2976 child_die
= sibling_die (child_die
);
2979 /* Attach fields and member functions to the type. */
2981 dwarf2_attach_fields_to_type (&fi
, type
, objfile
);
2984 dwarf2_attach_fn_fields_to_type (&fi
, type
, objfile
);
2986 /* Get the type which refers to the base class (possibly this
2987 class itself) which contains the vtable pointer for the current
2988 class from the DW_AT_containing_type attribute. */
2990 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2992 struct type
*t
= die_containing_type (die
, objfile
, cu_header
);
2994 TYPE_VPTR_BASETYPE (type
) = t
;
2997 static const char vptr_name
[] =
2998 {'_', 'v', 'p', 't', 'r', '\0'};
3001 /* Our own class provides vtbl ptr. */
3002 for (i
= TYPE_NFIELDS (t
) - 1;
3003 i
>= TYPE_N_BASECLASSES (t
);
3006 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3008 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
3009 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
3011 TYPE_VPTR_FIELDNO (type
) = i
;
3016 /* Complain if virtual function table field not found. */
3017 if (i
< TYPE_N_BASECLASSES (t
))
3018 complaint (&symfile_complaints
,
3019 "virtual function table pointer not found when defining class '%s'",
3020 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3025 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3030 new_symbol (die
, type
, objfile
, cu_header
);
3032 do_cleanups (back_to
);
3036 /* No children, must be stub. */
3037 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3041 /* Given a pointer to a die which begins an enumeration, process all
3042 the dies that define the members of the enumeration.
3044 This will be much nicer in draft 6 of the DWARF spec when our
3045 members will be dies instead squished into the DW_AT_element_list
3048 NOTE: We reverse the order of the element list. */
3051 read_enumeration (struct die_info
*die
, struct objfile
*objfile
,
3052 const struct comp_unit_head
*cu_header
)
3054 struct die_info
*child_die
;
3056 struct field
*fields
;
3057 struct attribute
*attr
;
3060 int unsigned_enum
= 1;
3062 type
= alloc_type (objfile
);
3064 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3065 attr
= dwarf_attr (die
, DW_AT_name
);
3066 if (attr
&& DW_STRING (attr
))
3068 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
3069 strlen (DW_STRING (attr
)),
3070 &objfile
->type_obstack
);
3073 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3076 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3080 TYPE_LENGTH (type
) = 0;
3085 if (die
->has_children
)
3087 child_die
= die
->next
;
3088 while (child_die
&& child_die
->tag
)
3090 if (child_die
->tag
!= DW_TAG_enumerator
)
3092 process_die (child_die
, objfile
, cu_header
);
3096 attr
= dwarf_attr (child_die
, DW_AT_name
);
3099 sym
= new_symbol (child_die
, type
, objfile
, cu_header
);
3100 if (SYMBOL_VALUE (sym
) < 0)
3103 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3105 fields
= (struct field
*)
3107 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
3108 * sizeof (struct field
));
3111 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
3112 FIELD_TYPE (fields
[num_fields
]) = NULL
;
3113 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
3114 FIELD_BITSIZE (fields
[num_fields
]) = 0;
3115 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
3121 child_die
= sibling_die (child_die
);
3126 TYPE_NFIELDS (type
) = num_fields
;
3127 TYPE_FIELDS (type
) = (struct field
*)
3128 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
3129 memcpy (TYPE_FIELDS (type
), fields
,
3130 sizeof (struct field
) * num_fields
);
3134 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
3137 new_symbol (die
, type
, objfile
, cu_header
);
3140 /* Extract all information from a DW_TAG_array_type DIE and put it in
3141 the DIE's type field. For now, this only handles one dimensional
3145 read_array_type (struct die_info
*die
, struct objfile
*objfile
,
3146 const struct comp_unit_head
*cu_header
)
3148 struct die_info
*child_die
;
3149 struct type
*type
= NULL
;
3150 struct type
*element_type
, *range_type
, *index_type
;
3151 struct type
**range_types
= NULL
;
3152 struct attribute
*attr
;
3154 struct cleanup
*back_to
;
3156 /* Return if we've already decoded this type. */
3162 element_type
= die_type (die
, objfile
, cu_header
);
3164 /* Irix 6.2 native cc creates array types without children for
3165 arrays with unspecified length. */
3166 if (die
->has_children
== 0)
3168 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3169 range_type
= create_range_type (NULL
, index_type
, 0, -1);
3170 die
->type
= create_array_type (NULL
, element_type
, range_type
);
3174 back_to
= make_cleanup (null_cleanup
, NULL
);
3175 child_die
= die
->next
;
3176 while (child_die
&& child_die
->tag
)
3178 if (child_die
->tag
== DW_TAG_subrange_type
)
3180 unsigned int low
, high
;
3182 /* Default bounds to an array with unspecified length. */
3185 if (cu_language
== language_fortran
)
3187 /* FORTRAN implies a lower bound of 1, if not given. */
3191 index_type
= die_type (child_die
, objfile
, cu_header
);
3192 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
3195 if (attr
->form
== DW_FORM_sdata
)
3197 low
= DW_SND (attr
);
3199 else if (attr
->form
== DW_FORM_udata
3200 || attr
->form
== DW_FORM_data1
3201 || attr
->form
== DW_FORM_data2
3202 || attr
->form
== DW_FORM_data4
3203 || attr
->form
== DW_FORM_data8
)
3205 low
= DW_UNSND (attr
);
3209 dwarf2_non_const_array_bound_ignored_complaint
3210 (dwarf_form_name (attr
->form
));
3212 die
->type
= lookup_pointer_type (element_type
);
3219 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
3222 if (attr
->form
== DW_FORM_sdata
)
3224 high
= DW_SND (attr
);
3226 else if (attr
->form
== DW_FORM_udata
3227 || attr
->form
== DW_FORM_data1
3228 || attr
->form
== DW_FORM_data2
3229 || attr
->form
== DW_FORM_data4
3230 || attr
->form
== DW_FORM_data8
)
3232 high
= DW_UNSND (attr
);
3234 else if (attr
->form
== DW_FORM_block1
)
3236 /* GCC encodes arrays with unspecified or dynamic length
3237 with a DW_FORM_block1 attribute.
3238 FIXME: GDB does not yet know how to handle dynamic
3239 arrays properly, treat them as arrays with unspecified
3242 FIXME: jimb/2003-09-22: GDB does not really know
3243 how to handle arrays of unspecified length
3244 either; we just represent them as zero-length
3245 arrays. Choose an appropriate upper bound given
3246 the lower bound we've computed above. */
3251 dwarf2_non_const_array_bound_ignored_complaint
3252 (dwarf_form_name (attr
->form
));
3254 die
->type
= lookup_pointer_type (element_type
);
3262 /* Create a range type and save it for array type creation. */
3263 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
3265 range_types
= (struct type
**)
3266 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
3267 * sizeof (struct type
*));
3269 make_cleanup (free_current_contents
, &range_types
);
3271 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
3273 child_die
= sibling_die (child_die
);
3276 /* Dwarf2 dimensions are output from left to right, create the
3277 necessary array types in backwards order. */
3278 type
= element_type
;
3280 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
3282 /* Understand Dwarf2 support for vector types (like they occur on
3283 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3284 array type. This is not part of the Dwarf2/3 standard yet, but a
3285 custom vendor extension. The main difference between a regular
3286 array and the vector variant is that vectors are passed by value
3288 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
3290 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
3292 do_cleanups (back_to
);
3294 /* Install the type in the die. */
3298 /* First cut: install each common block member as a global variable. */
3301 read_common_block (struct die_info
*die
, struct objfile
*objfile
,
3302 const struct comp_unit_head
*cu_header
)
3304 struct die_info
*child_die
;
3305 struct attribute
*attr
;
3307 CORE_ADDR base
= (CORE_ADDR
) 0;
3309 attr
= dwarf_attr (die
, DW_AT_location
);
3312 /* Support the .debug_loc offsets */
3313 if (attr_form_is_block (attr
))
3315 base
= decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
3317 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3319 dwarf2_complex_location_expr_complaint ();
3323 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3324 "common block member");
3327 if (die
->has_children
)
3329 child_die
= die
->next
;
3330 while (child_die
&& child_die
->tag
)
3332 sym
= new_symbol (child_die
, NULL
, objfile
, cu_header
);
3333 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
3336 SYMBOL_VALUE_ADDRESS (sym
) =
3337 base
+ decode_locdesc (DW_BLOCK (attr
), objfile
, cu_header
);
3338 add_symbol_to_list (sym
, &global_symbols
);
3340 child_die
= sibling_die (child_die
);
3345 /* Read a C++ namespace. */
3348 read_namespace (struct die_info
*die
, struct objfile
*objfile
,
3349 const struct comp_unit_head
*cu_header
)
3351 const char *previous_namespace
= processing_current_namespace
;
3352 const char *name
= NULL
;
3354 struct die_info
*current_die
;
3356 /* Loop through the extensions until we find a name. */
3358 for (current_die
= die
;
3359 current_die
!= NULL
;
3360 current_die
= dwarf2_extension (die
))
3362 name
= dwarf2_name (current_die
);
3367 /* Is it an anonymous namespace? */
3369 is_anonymous
= (name
== NULL
);
3371 name
= "(anonymous namespace)";
3373 /* Now build the name of the current namespace. */
3375 if (previous_namespace
[0] == '\0')
3377 processing_current_namespace
= name
;
3381 /* We need temp_name around because processing_current_namespace
3382 is a const char *. */
3383 char *temp_name
= alloca (strlen (previous_namespace
)
3384 + 2 + strlen(name
) + 1);
3385 strcpy (temp_name
, previous_namespace
);
3386 strcat (temp_name
, "::");
3387 strcat (temp_name
, name
);
3389 processing_current_namespace
= temp_name
;
3392 /* Add a symbol associated to this if we haven't seen the namespace
3393 before. Also, add a using directive if it's an anonymous
3396 if (dwarf2_extension (die
) == NULL
)
3400 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3401 this cast will hopefully become unnecessary. */
3402 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
3403 (char *) processing_current_namespace
,
3405 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
3407 new_symbol (die
, type
, objfile
, cu_header
);
3410 cp_add_using_directive (processing_current_namespace
,
3411 strlen (previous_namespace
),
3412 strlen (processing_current_namespace
));
3415 if (die
->has_children
)
3417 struct die_info
*child_die
= die
->next
;
3419 while (child_die
&& child_die
->tag
)
3421 process_die (child_die
, objfile
, cu_header
);
3422 child_die
= sibling_die (child_die
);
3426 processing_current_namespace
= previous_namespace
;
3429 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3430 the user defined type vector. */
3433 read_tag_pointer_type (struct die_info
*die
, struct objfile
*objfile
,
3434 const struct comp_unit_head
*cu_header
)
3437 struct attribute
*attr_byte_size
;
3438 struct attribute
*attr_address_class
;
3439 int byte_size
, addr_class
;
3446 type
= lookup_pointer_type (die_type (die
, objfile
, cu_header
));
3448 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
3450 byte_size
= DW_UNSND (attr_byte_size
);
3452 byte_size
= cu_header
->addr_size
;
3454 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
3455 if (attr_address_class
)
3456 addr_class
= DW_UNSND (attr_address_class
);
3458 addr_class
= DW_ADDR_none
;
3460 /* If the pointer size or address class is different than the
3461 default, create a type variant marked as such and set the
3462 length accordingly. */
3463 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3465 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3469 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3470 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3471 type
= make_type_with_address_space (type
, type_flags
);
3473 else if (TYPE_LENGTH (type
) != byte_size
)
3475 complaint (&symfile_complaints
, "invalid pointer size %d", byte_size
);
3478 /* Should we also complain about unhandled address classes? */
3482 TYPE_LENGTH (type
) = byte_size
;
3486 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3487 the user defined type vector. */
3490 read_tag_ptr_to_member_type (struct die_info
*die
, struct objfile
*objfile
,
3491 const struct comp_unit_head
*cu_header
)
3494 struct type
*to_type
;
3495 struct type
*domain
;
3502 type
= alloc_type (objfile
);
3503 to_type
= die_type (die
, objfile
, cu_header
);
3504 domain
= die_containing_type (die
, objfile
, cu_header
);
3505 smash_to_member_type (type
, domain
, to_type
);
3510 /* Extract all information from a DW_TAG_reference_type DIE and add to
3511 the user defined type vector. */
3514 read_tag_reference_type (struct die_info
*die
, struct objfile
*objfile
,
3515 const struct comp_unit_head
*cu_header
)
3518 struct attribute
*attr
;
3525 type
= lookup_reference_type (die_type (die
, objfile
, cu_header
));
3526 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3529 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3533 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3539 read_tag_const_type (struct die_info
*die
, struct objfile
*objfile
,
3540 const struct comp_unit_head
*cu_header
)
3542 struct type
*base_type
;
3549 base_type
= die_type (die
, objfile
, cu_header
);
3550 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3554 read_tag_volatile_type (struct die_info
*die
, struct objfile
*objfile
,
3555 const struct comp_unit_head
*cu_header
)
3557 struct type
*base_type
;
3564 base_type
= die_type (die
, objfile
, cu_header
);
3565 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3568 /* Extract all information from a DW_TAG_string_type DIE and add to
3569 the user defined type vector. It isn't really a user defined type,
3570 but it behaves like one, with other DIE's using an AT_user_def_type
3571 attribute to reference it. */
3574 read_tag_string_type (struct die_info
*die
, struct objfile
*objfile
)
3576 struct type
*type
, *range_type
, *index_type
, *char_type
;
3577 struct attribute
*attr
;
3578 unsigned int length
;
3585 attr
= dwarf_attr (die
, DW_AT_string_length
);
3588 length
= DW_UNSND (attr
);
3592 /* check for the DW_AT_byte_size attribute */
3593 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3596 length
= DW_UNSND (attr
);
3603 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3604 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3605 if (cu_language
== language_fortran
)
3607 /* Need to create a unique string type for bounds
3609 type
= create_string_type (0, range_type
);
3613 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3614 type
= create_string_type (char_type
, range_type
);
3619 /* Handle DIES due to C code like:
3623 int (*funcp)(int a, long l);
3627 ('funcp' generates a DW_TAG_subroutine_type DIE)
3631 read_subroutine_type (struct die_info
*die
, struct objfile
*objfile
,
3632 const struct comp_unit_head
*cu_header
)
3634 struct type
*type
; /* Type that this function returns */
3635 struct type
*ftype
; /* Function that returns above type */
3636 struct attribute
*attr
;
3638 /* Decode the type that this subroutine returns */
3643 type
= die_type (die
, objfile
, cu_header
);
3644 ftype
= lookup_function_type (type
);
3646 /* All functions in C++ have prototypes. */
3647 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3648 if ((attr
&& (DW_UNSND (attr
) != 0))
3649 || cu_language
== language_cplus
)
3650 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3652 if (die
->has_children
)
3654 struct die_info
*child_die
;
3658 /* Count the number of parameters.
3659 FIXME: GDB currently ignores vararg functions, but knows about
3660 vararg member functions. */
3661 child_die
= die
->next
;
3662 while (child_die
&& child_die
->tag
)
3664 if (child_die
->tag
== DW_TAG_formal_parameter
)
3666 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3667 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3668 child_die
= sibling_die (child_die
);
3671 /* Allocate storage for parameters and fill them in. */
3672 TYPE_NFIELDS (ftype
) = nparams
;
3673 TYPE_FIELDS (ftype
) = (struct field
*)
3674 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3676 child_die
= die
->next
;
3677 while (child_die
&& child_die
->tag
)
3679 if (child_die
->tag
== DW_TAG_formal_parameter
)
3681 /* Dwarf2 has no clean way to discern C++ static and non-static
3682 member functions. G++ helps GDB by marking the first
3683 parameter for non-static member functions (which is the
3684 this pointer) as artificial. We pass this information
3685 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3686 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3688 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3690 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3691 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, objfile
,
3695 child_die
= sibling_die (child_die
);
3703 read_typedef (struct die_info
*die
, struct objfile
*objfile
,
3704 const struct comp_unit_head
*cu_header
)
3706 struct attribute
*attr
;
3711 attr
= dwarf_attr (die
, DW_AT_name
);
3712 if (attr
&& DW_STRING (attr
))
3714 name
= DW_STRING (attr
);
3716 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3717 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, objfile
, cu_header
);
3721 /* Find a representation of a given base type and install
3722 it in the TYPE field of the die. */
3725 read_base_type (struct die_info
*die
, struct objfile
*objfile
)
3728 struct attribute
*attr
;
3729 int encoding
= 0, size
= 0;
3731 /* If we've already decoded this die, this is a no-op. */
3737 attr
= dwarf_attr (die
, DW_AT_encoding
);
3740 encoding
= DW_UNSND (attr
);
3742 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3745 size
= DW_UNSND (attr
);
3747 attr
= dwarf_attr (die
, DW_AT_name
);
3748 if (attr
&& DW_STRING (attr
))
3750 enum type_code code
= TYPE_CODE_INT
;
3755 case DW_ATE_address
:
3756 /* Turn DW_ATE_address into a void * pointer. */
3757 code
= TYPE_CODE_PTR
;
3758 type_flags
|= TYPE_FLAG_UNSIGNED
;
3760 case DW_ATE_boolean
:
3761 code
= TYPE_CODE_BOOL
;
3762 type_flags
|= TYPE_FLAG_UNSIGNED
;
3764 case DW_ATE_complex_float
:
3765 code
= TYPE_CODE_COMPLEX
;
3768 code
= TYPE_CODE_FLT
;
3771 case DW_ATE_signed_char
:
3773 case DW_ATE_unsigned
:
3774 case DW_ATE_unsigned_char
:
3775 type_flags
|= TYPE_FLAG_UNSIGNED
;
3778 complaint (&symfile_complaints
, "unsupported DW_AT_encoding: '%s'",
3779 dwarf_type_encoding_name (encoding
));
3782 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3783 if (encoding
== DW_ATE_address
)
3784 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3785 else if (encoding
== DW_ATE_complex_float
)
3788 TYPE_TARGET_TYPE (type
)
3789 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3790 else if (size
== 16)
3791 TYPE_TARGET_TYPE (type
)
3792 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3794 TYPE_TARGET_TYPE (type
)
3795 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3800 type
= dwarf_base_type (encoding
, size
, objfile
);
3805 /* Read a whole compilation unit into a linked list of dies. */
3807 static struct die_info
*
3808 read_comp_unit (char *info_ptr
, bfd
*abfd
,
3809 const struct comp_unit_head
*cu_header
)
3811 struct die_info
*first_die
, *last_die
, *die
;
3815 /* Reset die reference table; we are
3816 building new ones now. */
3817 dwarf2_empty_hash_tables ();
3821 first_die
= last_die
= NULL
;
3824 cur_ptr
= read_full_die (&die
, abfd
, cur_ptr
, cu_header
);
3825 if (die
->has_children
)
3836 /* Enter die in reference hash table */
3837 store_in_ref_table (die
->offset
, die
);
3841 first_die
= last_die
= die
;
3845 last_die
->next
= die
;
3849 while (nesting_level
> 0);
3853 /* Free a linked list of dies. */
3856 free_die_list (struct die_info
*dies
)
3858 struct die_info
*die
, *next
;
3871 do_free_die_list_cleanup (void *dies
)
3873 free_die_list (dies
);
3876 static struct cleanup
*
3877 make_cleanup_free_die_list (struct die_info
*dies
)
3879 return make_cleanup (do_free_die_list_cleanup
, dies
);
3883 /* Read the contents of the section at OFFSET and of size SIZE from the
3884 object file specified by OBJFILE into the psymbol_obstack and return it. */
3887 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3888 unsigned int size
, asection
*sectp
)
3890 bfd
*abfd
= objfile
->obfd
;
3896 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3898 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
3902 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3903 (bfd_bread (buf
, size
, abfd
) != size
))
3906 error ("Dwarf Error: Can't read DWARF data from '%s'",
3907 bfd_get_filename (abfd
));
3912 /* In DWARF version 2, the description of the debugging information is
3913 stored in a separate .debug_abbrev section. Before we read any
3914 dies from a section we read in all abbreviations and install them
3918 dwarf2_read_abbrevs (bfd
*abfd
, struct comp_unit_head
*cu_header
)
3921 struct abbrev_info
*cur_abbrev
;
3922 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3923 unsigned int abbrev_form
, hash_number
;
3925 /* Initialize dwarf2 abbrevs */
3926 memset (cu_header
->dwarf2_abbrevs
, 0,
3927 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
3929 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
3930 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3931 abbrev_ptr
+= bytes_read
;
3933 /* loop until we reach an abbrev number of 0 */
3934 while (abbrev_number
)
3936 cur_abbrev
= dwarf_alloc_abbrev ();
3938 /* read in abbrev header */
3939 cur_abbrev
->number
= abbrev_number
;
3940 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3941 abbrev_ptr
+= bytes_read
;
3942 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3945 /* now read in declarations */
3946 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3947 abbrev_ptr
+= bytes_read
;
3948 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3949 abbrev_ptr
+= bytes_read
;
3952 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3954 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3955 xrealloc (cur_abbrev
->attrs
,
3956 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3957 * sizeof (struct attr_abbrev
));
3959 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3960 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3961 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3962 abbrev_ptr
+= bytes_read
;
3963 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3964 abbrev_ptr
+= bytes_read
;
3967 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3968 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
3969 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3971 /* Get next abbreviation.
3972 Under Irix6 the abbreviations for a compilation unit are not
3973 always properly terminated with an abbrev number of 0.
3974 Exit loop if we encounter an abbreviation which we have
3975 already read (which means we are about to read the abbreviations
3976 for the next compile unit) or if the end of the abbreviation
3977 table is reached. */
3978 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
3979 >= dwarf_abbrev_size
)
3981 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3982 abbrev_ptr
+= bytes_read
;
3983 if (dwarf2_lookup_abbrev (abbrev_number
, cu_header
) != NULL
)
3988 /* Empty the abbrev table for a new compilation unit. */
3991 dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table
)
3994 struct abbrev_info
*abbrev
, *next
;
3995 struct abbrev_info
**abbrevs
;
3997 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
3999 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
4002 abbrev
= abbrevs
[i
];
4005 next
= abbrev
->next
;
4006 xfree (abbrev
->attrs
);
4014 /* Lookup an abbrev_info structure in the abbrev hash table. */
4016 static struct abbrev_info
*
4017 dwarf2_lookup_abbrev (unsigned int number
, const struct comp_unit_head
*cu_header
)
4019 unsigned int hash_number
;
4020 struct abbrev_info
*abbrev
;
4022 hash_number
= number
% ABBREV_HASH_SIZE
;
4023 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
4027 if (abbrev
->number
== number
)
4030 abbrev
= abbrev
->next
;
4035 /* Read a minimal amount of information into the minimal die structure. */
4038 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
4039 char *info_ptr
, const struct comp_unit_head
*cu_header
)
4041 unsigned int abbrev_number
, bytes_read
, i
;
4042 struct abbrev_info
*abbrev
;
4043 struct attribute attr
;
4044 struct attribute spec_attr
;
4045 int found_spec_attr
= 0;
4046 int has_low_pc_attr
= 0;
4047 int has_high_pc_attr
= 0;
4049 *part_die
= zeroed_partial_die
;
4050 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4051 info_ptr
+= bytes_read
;
4055 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
4058 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number
,
4059 bfd_get_filename (abfd
));
4061 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
4062 part_die
->tag
= abbrev
->tag
;
4063 part_die
->has_children
= abbrev
->has_children
;
4064 part_die
->abbrev
= abbrev_number
;
4066 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4068 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
,
4069 info_ptr
, cu_header
);
4071 /* Store the data if it is of an attribute we want to keep in a
4072 partial symbol table. */
4077 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
4078 if (part_die
->name
== NULL
)
4079 part_die
->name
= DW_STRING (&attr
);
4081 case DW_AT_MIPS_linkage_name
:
4082 part_die
->name
= DW_STRING (&attr
);
4085 has_low_pc_attr
= 1;
4086 part_die
->lowpc
= DW_ADDR (&attr
);
4089 has_high_pc_attr
= 1;
4090 part_die
->highpc
= DW_ADDR (&attr
);
4092 case DW_AT_location
:
4093 /* Support the .debug_loc offsets */
4094 if (attr_form_is_block (&attr
))
4096 part_die
->locdesc
= DW_BLOCK (&attr
);
4098 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
4100 dwarf2_complex_location_expr_complaint ();
4104 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4105 "partial symbol information");
4108 case DW_AT_language
:
4109 part_die
->language
= DW_UNSND (&attr
);
4111 case DW_AT_external
:
4112 part_die
->is_external
= DW_UNSND (&attr
);
4114 case DW_AT_declaration
:
4115 part_die
->is_declaration
= DW_UNSND (&attr
);
4118 part_die
->has_type
= 1;
4120 case DW_AT_abstract_origin
:
4121 case DW_AT_specification
:
4122 found_spec_attr
= 1;
4126 /* Ignore absolute siblings, they might point outside of
4127 the current compile unit. */
4128 if (attr
.form
== DW_FORM_ref_addr
)
4129 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
4132 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
4139 /* If we found a reference attribute and the die has no name, try
4140 to find a name in the referred to die. */
4142 if (found_spec_attr
&& part_die
->name
== NULL
)
4144 struct partial_die_info spec_die
;
4148 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
4149 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu_header
);
4152 part_die
->name
= spec_die
.name
;
4154 /* Copy DW_AT_external attribute if it is set. */
4155 if (spec_die
.is_external
)
4156 part_die
->is_external
= spec_die
.is_external
;
4160 /* When using the GNU linker, .gnu.linkonce. sections are used to
4161 eliminate duplicate copies of functions and vtables and such.
4162 The linker will arbitrarily choose one and discard the others.
4163 The AT_*_pc values for such functions refer to local labels in
4164 these sections. If the section from that file was discarded, the
4165 labels are not in the output, so the relocs get a value of 0.
4166 If this is a discarded function, mark the pc bounds as invalid,
4167 so that GDB will ignore it. */
4168 if (has_low_pc_attr
&& has_high_pc_attr
4169 && part_die
->lowpc
< part_die
->highpc
4170 && (part_die
->lowpc
!= 0
4171 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
4172 part_die
->has_pc_info
= 1;
4176 /* Read the die from the .debug_info section buffer. And set diep to
4177 point to a newly allocated die with its information. */
4180 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
4181 const struct comp_unit_head
*cu_header
)
4183 unsigned int abbrev_number
, bytes_read
, i
, offset
;
4184 struct abbrev_info
*abbrev
;
4185 struct die_info
*die
;
4187 offset
= info_ptr
- dwarf_info_buffer
;
4188 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4189 info_ptr
+= bytes_read
;
4192 die
= dwarf_alloc_die ();
4194 die
->abbrev
= abbrev_number
;
4200 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu_header
);
4203 error ("Dwarf Error: could not find abbrev number %d [in module %s]", abbrev_number
,
4204 bfd_get_filename (abfd
));
4206 die
= dwarf_alloc_die ();
4207 die
->offset
= offset
;
4208 die
->tag
= abbrev
->tag
;
4209 die
->has_children
= abbrev
->has_children
;
4210 die
->abbrev
= abbrev_number
;
4213 die
->num_attrs
= abbrev
->num_attrs
;
4214 die
->attrs
= (struct attribute
*)
4215 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
4217 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4219 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
4220 abfd
, info_ptr
, cu_header
);
4227 /* Read an attribute value described by an attribute form. */
4230 read_attribute_value (struct attribute
*attr
, unsigned form
,
4231 bfd
*abfd
, char *info_ptr
,
4232 const struct comp_unit_head
*cu_header
)
4234 unsigned int bytes_read
;
4235 struct dwarf_block
*blk
;
4241 case DW_FORM_ref_addr
:
4242 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu_header
, &bytes_read
);
4243 info_ptr
+= bytes_read
;
4245 case DW_FORM_block2
:
4246 blk
= dwarf_alloc_block ();
4247 blk
->size
= read_2_bytes (abfd
, info_ptr
);
4249 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4250 info_ptr
+= blk
->size
;
4251 DW_BLOCK (attr
) = blk
;
4253 case DW_FORM_block4
:
4254 blk
= dwarf_alloc_block ();
4255 blk
->size
= read_4_bytes (abfd
, info_ptr
);
4257 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4258 info_ptr
+= blk
->size
;
4259 DW_BLOCK (attr
) = blk
;
4262 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4266 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4270 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4273 case DW_FORM_string
:
4274 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
4275 info_ptr
+= bytes_read
;
4278 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
4280 info_ptr
+= bytes_read
;
4283 blk
= dwarf_alloc_block ();
4284 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4285 info_ptr
+= bytes_read
;
4286 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4287 info_ptr
+= blk
->size
;
4288 DW_BLOCK (attr
) = blk
;
4290 case DW_FORM_block1
:
4291 blk
= dwarf_alloc_block ();
4292 blk
->size
= read_1_byte (abfd
, info_ptr
);
4294 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4295 info_ptr
+= blk
->size
;
4296 DW_BLOCK (attr
) = blk
;
4299 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4303 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4307 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
4308 info_ptr
+= bytes_read
;
4311 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4312 info_ptr
+= bytes_read
;
4315 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4319 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4323 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4327 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4330 case DW_FORM_ref_udata
:
4331 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4332 info_ptr
+= bytes_read
;
4334 case DW_FORM_indirect
:
4335 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4336 info_ptr
+= bytes_read
;
4337 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu_header
);
4340 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4341 dwarf_form_name (form
),
4342 bfd_get_filename (abfd
));
4347 /* Read an attribute described by an abbreviated attribute. */
4350 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
4351 bfd
*abfd
, char *info_ptr
,
4352 const struct comp_unit_head
*cu_header
)
4354 attr
->name
= abbrev
->name
;
4355 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu_header
);
4358 /* read dwarf information from a buffer */
4361 read_1_byte (bfd
*abfd
, char *buf
)
4363 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4367 read_1_signed_byte (bfd
*abfd
, char *buf
)
4369 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
4373 read_2_bytes (bfd
*abfd
, char *buf
)
4375 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4379 read_2_signed_bytes (bfd
*abfd
, char *buf
)
4381 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4385 read_4_bytes (bfd
*abfd
, char *buf
)
4387 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4391 read_4_signed_bytes (bfd
*abfd
, char *buf
)
4393 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4396 static unsigned long
4397 read_8_bytes (bfd
*abfd
, char *buf
)
4399 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4403 read_address (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4406 CORE_ADDR retval
= 0;
4408 if (cu_header
->signed_addr_p
)
4410 switch (cu_header
->addr_size
)
4413 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4416 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4419 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
4422 internal_error (__FILE__
, __LINE__
,
4423 "read_address: bad switch, signed [in module %s]",
4424 bfd_get_filename (abfd
));
4429 switch (cu_header
->addr_size
)
4432 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4435 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4438 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4441 internal_error (__FILE__
, __LINE__
,
4442 "read_address: bad switch, unsigned [in module %s]",
4443 bfd_get_filename (abfd
));
4447 *bytes_read
= cu_header
->addr_size
;
4451 /* Read the initial length from a section. The (draft) DWARF 3
4452 specification allows the initial length to take up either 4 bytes
4453 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4454 bytes describe the length and all offsets will be 8 bytes in length
4457 An older, non-standard 64-bit format is also handled by this
4458 function. The older format in question stores the initial length
4459 as an 8-byte quantity without an escape value. Lengths greater
4460 than 2^32 aren't very common which means that the initial 4 bytes
4461 is almost always zero. Since a length value of zero doesn't make
4462 sense for the 32-bit format, this initial zero can be considered to
4463 be an escape value which indicates the presence of the older 64-bit
4464 format. As written, the code can't detect (old format) lengths
4465 greater than 4GB. If it becomes necessary to handle lengths somewhat
4466 larger than 4GB, we could allow other small values (such as the
4467 non-sensical values of 1, 2, and 3) to also be used as escape values
4468 indicating the presence of the old format.
4470 The value returned via bytes_read should be used to increment
4471 the relevant pointer after calling read_initial_length().
4473 As a side effect, this function sets the fields initial_length_size
4474 and offset_size in cu_header to the values appropriate for the
4475 length field. (The format of the initial length field determines
4476 the width of file offsets to be fetched later with fetch_offset().)
4478 [ Note: read_initial_length() and read_offset() are based on the
4479 document entitled "DWARF Debugging Information Format", revision
4480 3, draft 8, dated November 19, 2001. This document was obtained
4483 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4485 This document is only a draft and is subject to change. (So beware.)
4487 Details regarding the older, non-standard 64-bit format were
4488 determined empirically by examining 64-bit ELF files produced
4489 by the SGI toolchain on an IRIX 6.5 machine.
4491 - Kevin, July 16, 2002
4495 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4500 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4502 if (retval
== 0xffffffff)
4504 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4506 if (cu_header
!= NULL
)
4508 cu_header
->initial_length_size
= 12;
4509 cu_header
->offset_size
= 8;
4512 else if (retval
== 0)
4514 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4516 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4518 if (cu_header
!= NULL
)
4520 cu_header
->initial_length_size
= 8;
4521 cu_header
->offset_size
= 8;
4527 if (cu_header
!= NULL
)
4529 cu_header
->initial_length_size
= 4;
4530 cu_header
->offset_size
= 4;
4537 /* Read an offset from the data stream. The size of the offset is
4538 given by cu_header->offset_size. */
4541 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4546 switch (cu_header
->offset_size
)
4549 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4553 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4557 internal_error (__FILE__
, __LINE__
,
4558 "read_offset: bad switch [in module %s]",
4559 bfd_get_filename (abfd
));
4566 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4568 /* If the size of a host char is 8 bits, we can return a pointer
4569 to the buffer, otherwise we have to copy the data to a buffer
4570 allocated on the temporary obstack. */
4571 gdb_assert (HOST_CHAR_BIT
== 8);
4576 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4578 /* If the size of a host char is 8 bits, we can return a pointer
4579 to the string, otherwise we have to copy the string to a buffer
4580 allocated on the temporary obstack. */
4581 gdb_assert (HOST_CHAR_BIT
== 8);
4584 *bytes_read_ptr
= 1;
4587 *bytes_read_ptr
= strlen (buf
) + 1;
4592 read_indirect_string (bfd
*abfd
, char *buf
,
4593 const struct comp_unit_head
*cu_header
,
4594 unsigned int *bytes_read_ptr
)
4596 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4597 (int *) bytes_read_ptr
);
4599 if (dwarf_str_buffer
== NULL
)
4601 error ("DW_FORM_strp used without .debug_str section [in module %s]",
4602 bfd_get_filename (abfd
));
4605 if (str_offset
>= dwarf_str_size
)
4607 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4608 bfd_get_filename (abfd
));
4611 gdb_assert (HOST_CHAR_BIT
== 8);
4612 if (dwarf_str_buffer
[str_offset
] == '\0')
4614 return dwarf_str_buffer
+ str_offset
;
4617 static unsigned long
4618 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4620 unsigned long result
;
4621 unsigned int num_read
;
4631 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4634 result
|= ((unsigned long)(byte
& 127) << shift
);
4635 if ((byte
& 128) == 0)
4641 *bytes_read_ptr
= num_read
;
4646 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4649 int i
, shift
, size
, num_read
;
4659 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4662 result
|= ((long)(byte
& 127) << shift
);
4664 if ((byte
& 128) == 0)
4669 if ((shift
< size
) && (byte
& 0x40))
4671 result
|= -(1 << shift
);
4673 *bytes_read_ptr
= num_read
;
4678 set_cu_language (unsigned int lang
)
4684 cu_language
= language_c
;
4686 case DW_LANG_C_plus_plus
:
4687 cu_language
= language_cplus
;
4689 case DW_LANG_Fortran77
:
4690 case DW_LANG_Fortran90
:
4691 case DW_LANG_Fortran95
:
4692 cu_language
= language_fortran
;
4694 case DW_LANG_Mips_Assembler
:
4695 cu_language
= language_asm
;
4698 cu_language
= language_java
;
4702 case DW_LANG_Cobol74
:
4703 case DW_LANG_Cobol85
:
4704 case DW_LANG_Pascal83
:
4705 case DW_LANG_Modula2
:
4707 cu_language
= language_minimal
;
4710 cu_language_defn
= language_def (cu_language
);
4713 /* Return the named attribute or NULL if not there. */
4715 static struct attribute
*
4716 dwarf_attr (struct die_info
*die
, unsigned int name
)
4719 struct attribute
*spec
= NULL
;
4721 for (i
= 0; i
< die
->num_attrs
; ++i
)
4723 if (die
->attrs
[i
].name
== name
)
4725 return &die
->attrs
[i
];
4727 if (die
->attrs
[i
].name
== DW_AT_specification
4728 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4729 spec
= &die
->attrs
[i
];
4733 struct die_info
*ref_die
=
4734 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4737 return dwarf_attr (ref_die
, name
);
4744 die_is_declaration (struct die_info
*die
)
4746 return (dwarf_attr (die
, DW_AT_declaration
)
4747 && ! dwarf_attr (die
, DW_AT_specification
));
4751 /* Free the line_header structure *LH, and any arrays and strings it
4754 free_line_header (struct line_header
*lh
)
4756 if (lh
->standard_opcode_lengths
)
4757 xfree (lh
->standard_opcode_lengths
);
4759 /* Remember that all the lh->file_names[i].name pointers are
4760 pointers into debug_line_buffer, and don't need to be freed. */
4762 xfree (lh
->file_names
);
4764 /* Similarly for the include directory names. */
4765 if (lh
->include_dirs
)
4766 xfree (lh
->include_dirs
);
4772 /* Add an entry to LH's include directory table. */
4774 add_include_dir (struct line_header
*lh
, char *include_dir
)
4776 /* Grow the array if necessary. */
4777 if (lh
->include_dirs_size
== 0)
4779 lh
->include_dirs_size
= 1; /* for testing */
4780 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4781 * sizeof (*lh
->include_dirs
));
4783 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4785 lh
->include_dirs_size
*= 2;
4786 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4787 (lh
->include_dirs_size
4788 * sizeof (*lh
->include_dirs
)));
4791 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4795 /* Add an entry to LH's file name table. */
4797 add_file_name (struct line_header
*lh
,
4799 unsigned int dir_index
,
4800 unsigned int mod_time
,
4801 unsigned int length
)
4803 struct file_entry
*fe
;
4805 /* Grow the array if necessary. */
4806 if (lh
->file_names_size
== 0)
4808 lh
->file_names_size
= 1; /* for testing */
4809 lh
->file_names
= xmalloc (lh
->file_names_size
4810 * sizeof (*lh
->file_names
));
4812 else if (lh
->num_file_names
>= lh
->file_names_size
)
4814 lh
->file_names_size
*= 2;
4815 lh
->file_names
= xrealloc (lh
->file_names
,
4816 (lh
->file_names_size
4817 * sizeof (*lh
->file_names
)));
4820 fe
= &lh
->file_names
[lh
->num_file_names
++];
4822 fe
->dir_index
= dir_index
;
4823 fe
->mod_time
= mod_time
;
4824 fe
->length
= length
;
4828 /* Read the statement program header starting at OFFSET in
4829 dwarf_line_buffer, according to the endianness of ABFD. Return a
4830 pointer to a struct line_header, allocated using xmalloc.
4832 NOTE: the strings in the include directory and file name tables of
4833 the returned object point into debug_line_buffer, and must not be
4835 static struct line_header
*
4836 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4837 const struct comp_unit_head
*cu_header
)
4839 struct cleanup
*back_to
;
4840 struct line_header
*lh
;
4844 char *cur_dir
, *cur_file
;
4846 if (dwarf_line_buffer
== NULL
)
4848 complaint (&symfile_complaints
, "missing .debug_line section");
4852 /* Make sure that at least there's room for the total_length field. That
4853 could be 12 bytes long, but we're just going to fudge that. */
4854 if (offset
+ 4 >= dwarf_line_size
)
4856 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4860 lh
= xmalloc (sizeof (*lh
));
4861 memset (lh
, 0, sizeof (*lh
));
4862 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4865 line_ptr
= dwarf_line_buffer
+ offset
;
4867 /* read in the header */
4868 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4869 line_ptr
+= bytes_read
;
4870 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4872 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4875 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4876 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4878 lh
->header_length
= read_offset (abfd
, line_ptr
, cu_header
, &bytes_read
);
4879 line_ptr
+= bytes_read
;
4880 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4882 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4884 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4886 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4888 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4890 lh
->standard_opcode_lengths
4891 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4893 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4894 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4896 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4900 /* Read directory table */
4901 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4903 line_ptr
+= bytes_read
;
4904 add_include_dir (lh
, cur_dir
);
4906 line_ptr
+= bytes_read
;
4908 /* Read file name table */
4909 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4911 unsigned int dir_index
, mod_time
, length
;
4913 line_ptr
+= bytes_read
;
4914 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4915 line_ptr
+= bytes_read
;
4916 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4917 line_ptr
+= bytes_read
;
4918 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4919 line_ptr
+= bytes_read
;
4921 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4923 line_ptr
+= bytes_read
;
4924 lh
->statement_program_start
= line_ptr
;
4926 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4927 complaint (&symfile_complaints
,
4928 "line number info header doesn't fit in `.debug_line' section");
4930 discard_cleanups (back_to
);
4934 /* This function exists to work around a bug in certain compilers
4935 (particularly GCC 2.95), in which the first line number marker of a
4936 function does not show up until after the prologue, right before
4937 the second line number marker. This function shifts ADDRESS down
4938 to the beginning of the function if necessary, and is called on
4939 addresses passed to record_line. */
4942 check_cu_functions (CORE_ADDR address
)
4944 struct function_range
*fn
;
4946 /* Find the function_range containing address. */
4951 cu_cached_fn
= cu_first_fn
;
4955 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4961 while (fn
&& fn
!= cu_cached_fn
)
4962 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4972 if (address
!= fn
->lowpc
)
4973 complaint (&symfile_complaints
,
4974 "misplaced first line number at 0x%lx for '%s'",
4975 (unsigned long) address
, fn
->name
);
4980 /* Decode the line number information for the compilation unit whose
4981 line number info is at OFFSET in the .debug_line section.
4982 The compilation directory of the file is passed in COMP_DIR. */
4985 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
4986 const struct comp_unit_head
*cu_header
)
4990 unsigned int i
, bytes_read
;
4992 unsigned char op_code
, extended_op
, adj_opcode
;
4994 line_ptr
= lh
->statement_program_start
;
4995 line_end
= lh
->statement_program_end
;
4997 /* Read the statement sequences until there's nothing left. */
4998 while (line_ptr
< line_end
)
5000 /* state machine registers */
5001 CORE_ADDR address
= 0;
5002 unsigned int file
= 1;
5003 unsigned int line
= 1;
5004 unsigned int column
= 0;
5005 int is_stmt
= lh
->default_is_stmt
;
5006 int basic_block
= 0;
5007 int end_sequence
= 0;
5009 /* Start a subfile for the current file of the state machine. */
5010 if (lh
->num_file_names
>= file
)
5012 /* lh->include_dirs and lh->file_names are 0-based, but the
5013 directory and file name numbers in the statement program
5015 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
5018 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5021 dwarf2_start_subfile (fe
->name
, dir
);
5024 /* Decode the table. */
5025 while (!end_sequence
)
5027 op_code
= read_1_byte (abfd
, line_ptr
);
5030 if (op_code
>= lh
->opcode_base
)
5031 { /* Special operand. */
5032 adj_opcode
= op_code
- lh
->opcode_base
;
5033 address
+= (adj_opcode
/ lh
->line_range
)
5034 * lh
->minimum_instruction_length
;
5035 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
5036 /* append row to matrix using current values */
5037 record_line (current_subfile
, line
,
5038 check_cu_functions (address
));
5041 else switch (op_code
)
5043 case DW_LNS_extended_op
:
5044 line_ptr
+= 1; /* ignore length */
5045 extended_op
= read_1_byte (abfd
, line_ptr
);
5047 switch (extended_op
)
5049 case DW_LNE_end_sequence
:
5051 record_line (current_subfile
, 0, address
);
5053 case DW_LNE_set_address
:
5054 address
= read_address (abfd
, line_ptr
, cu_header
, &bytes_read
);
5055 line_ptr
+= bytes_read
;
5056 address
+= baseaddr
;
5058 case DW_LNE_define_file
:
5061 unsigned int dir_index
, mod_time
, length
;
5063 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
5064 line_ptr
+= bytes_read
;
5066 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5067 line_ptr
+= bytes_read
;
5069 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5070 line_ptr
+= bytes_read
;
5072 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5073 line_ptr
+= bytes_read
;
5074 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5078 complaint (&symfile_complaints
,
5079 "mangled .debug_line section");
5084 record_line (current_subfile
, line
,
5085 check_cu_functions (address
));
5088 case DW_LNS_advance_pc
:
5089 address
+= lh
->minimum_instruction_length
5090 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5091 line_ptr
+= bytes_read
;
5093 case DW_LNS_advance_line
:
5094 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
5095 line_ptr
+= bytes_read
;
5097 case DW_LNS_set_file
:
5099 /* lh->include_dirs and lh->file_names are 0-based,
5100 but the directory and file name numbers in the
5101 statement program are 1-based. */
5102 struct file_entry
*fe
;
5104 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5105 line_ptr
+= bytes_read
;
5106 fe
= &lh
->file_names
[file
- 1];
5108 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5111 dwarf2_start_subfile (fe
->name
, dir
);
5114 case DW_LNS_set_column
:
5115 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5116 line_ptr
+= bytes_read
;
5118 case DW_LNS_negate_stmt
:
5119 is_stmt
= (!is_stmt
);
5121 case DW_LNS_set_basic_block
:
5124 /* Add to the address register of the state machine the
5125 address increment value corresponding to special opcode
5126 255. Ie, this value is scaled by the minimum instruction
5127 length since special opcode 255 would have scaled the
5129 case DW_LNS_const_add_pc
:
5130 address
+= (lh
->minimum_instruction_length
5131 * ((255 - lh
->opcode_base
) / lh
->line_range
));
5133 case DW_LNS_fixed_advance_pc
:
5134 address
+= read_2_bytes (abfd
, line_ptr
);
5138 { /* Unknown standard opcode, ignore it. */
5140 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
5142 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5143 line_ptr
+= bytes_read
;
5151 /* Start a subfile for DWARF. FILENAME is the name of the file and
5152 DIRNAME the name of the source directory which contains FILENAME
5153 or NULL if not known.
5154 This routine tries to keep line numbers from identical absolute and
5155 relative file names in a common subfile.
5157 Using the `list' example from the GDB testsuite, which resides in
5158 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
5159 of /srcdir/list0.c yields the following debugging information for list0.c:
5161 DW_AT_name: /srcdir/list0.c
5162 DW_AT_comp_dir: /compdir
5163 files.files[0].name: list0.h
5164 files.files[0].dir: /srcdir
5165 files.files[1].name: list0.c
5166 files.files[1].dir: /srcdir
5168 The line number information for list0.c has to end up in a single
5169 subfile, so that `break /srcdir/list0.c:1' works as expected. */
5172 dwarf2_start_subfile (char *filename
, char *dirname
)
5174 /* If the filename isn't absolute, try to match an existing subfile
5175 with the full pathname. */
5177 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
5179 struct subfile
*subfile
;
5180 char *fullname
= concat (dirname
, "/", filename
, NULL
);
5182 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
5184 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
5186 current_subfile
= subfile
;
5193 start_subfile (filename
, dirname
);
5197 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
5198 struct objfile
*objfile
,
5199 const struct comp_unit_head
*cu_header
)
5201 /* NOTE drow/2003-01-30: There used to be a comment and some special
5202 code here to turn a symbol with DW_AT_external and a
5203 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
5204 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
5205 with some versions of binutils) where shared libraries could have
5206 relocations against symbols in their debug information - the
5207 minimal symbol would have the right address, but the debug info
5208 would not. It's no longer necessary, because we will explicitly
5209 apply relocations when we read in the debug information now. */
5211 /* A DW_AT_location attribute with no contents indicates that a
5212 variable has been optimized away. */
5213 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
5215 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
5219 /* Handle one degenerate form of location expression specially, to
5220 preserve GDB's previous behavior when section offsets are
5221 specified. If this is just a DW_OP_addr then mark this symbol
5224 if (attr_form_is_block (attr
)
5225 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
5226 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
5230 SYMBOL_VALUE_ADDRESS (sym
) =
5231 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu_header
,
5233 fixup_symbol_section (sym
, objfile
);
5234 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
5235 SYMBOL_SECTION (sym
));
5236 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5240 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
5241 expression evaluator, and use LOC_COMPUTED only when necessary
5242 (i.e. when the value of a register or memory location is
5243 referenced, or a thread-local block, etc.). Then again, it might
5244 not be worthwhile. I'm assuming that it isn't unless performance
5245 or memory numbers show me otherwise. */
5247 dwarf2_symbol_mark_computed (attr
, sym
, cu_header
, objfile
);
5248 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
5251 /* Given a pointer to a DWARF information entry, figure out if we need
5252 to make a symbol table entry for it, and if so, create a new entry
5253 and return a pointer to it.
5254 If TYPE is NULL, determine symbol type from the die, otherwise
5255 used the passed type. */
5257 static struct symbol
*
5258 new_symbol (struct die_info
*die
, struct type
*type
, struct objfile
*objfile
,
5259 const struct comp_unit_head
*cu_header
)
5261 struct symbol
*sym
= NULL
;
5263 struct attribute
*attr
= NULL
;
5264 struct attribute
*attr2
= NULL
;
5267 if (die
->tag
!= DW_TAG_namespace
)
5268 name
= dwarf2_linkage_name (die
);
5270 name
= TYPE_NAME (type
);
5274 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
5275 sizeof (struct symbol
));
5276 OBJSTAT (objfile
, n_syms
++);
5277 memset (sym
, 0, sizeof (struct symbol
));
5279 /* Cache this symbol's name and the name's demangled form (if any). */
5280 SYMBOL_LANGUAGE (sym
) = cu_language
;
5281 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
5283 /* Default assumptions.
5284 Use the passed type or decode it from the die. */
5285 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5286 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5288 SYMBOL_TYPE (sym
) = type
;
5290 SYMBOL_TYPE (sym
) = die_type (die
, objfile
, cu_header
);
5291 attr
= dwarf_attr (die
, DW_AT_decl_line
);
5294 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
5299 attr
= dwarf_attr (die
, DW_AT_low_pc
);
5302 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
5304 SYMBOL_CLASS (sym
) = LOC_LABEL
;
5306 case DW_TAG_subprogram
:
5307 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
5309 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5310 attr2
= dwarf_attr (die
, DW_AT_external
);
5311 if (attr2
&& (DW_UNSND (attr2
) != 0))
5313 add_symbol_to_list (sym
, &global_symbols
);
5317 add_symbol_to_list (sym
, list_in_scope
);
5320 case DW_TAG_variable
:
5321 /* Compilation with minimal debug info may result in variables
5322 with missing type entries. Change the misleading `void' type
5323 to something sensible. */
5324 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
5325 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
5326 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
5327 "<variable, no debug info>",
5329 attr
= dwarf_attr (die
, DW_AT_const_value
);
5332 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5333 attr2
= dwarf_attr (die
, DW_AT_external
);
5334 if (attr2
&& (DW_UNSND (attr2
) != 0))
5335 add_symbol_to_list (sym
, &global_symbols
);
5337 add_symbol_to_list (sym
, list_in_scope
);
5340 attr
= dwarf_attr (die
, DW_AT_location
);
5343 var_decode_location (attr
, sym
, objfile
, cu_header
);
5344 attr2
= dwarf_attr (die
, DW_AT_external
);
5345 if (attr2
&& (DW_UNSND (attr2
) != 0))
5346 add_symbol_to_list (sym
, &global_symbols
);
5348 add_symbol_to_list (sym
, list_in_scope
);
5352 /* We do not know the address of this symbol.
5353 If it is an external symbol and we have type information
5354 for it, enter the symbol as a LOC_UNRESOLVED symbol.
5355 The address of the variable will then be determined from
5356 the minimal symbol table whenever the variable is
5358 attr2
= dwarf_attr (die
, DW_AT_external
);
5359 if (attr2
&& (DW_UNSND (attr2
) != 0)
5360 && dwarf_attr (die
, DW_AT_type
) != NULL
)
5362 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
5363 add_symbol_to_list (sym
, &global_symbols
);
5367 case DW_TAG_formal_parameter
:
5368 attr
= dwarf_attr (die
, DW_AT_location
);
5371 var_decode_location (attr
, sym
, objfile
, cu_header
);
5372 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
5373 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
5374 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
5376 attr
= dwarf_attr (die
, DW_AT_const_value
);
5379 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5381 add_symbol_to_list (sym
, list_in_scope
);
5383 case DW_TAG_unspecified_parameters
:
5384 /* From varargs functions; gdb doesn't seem to have any
5385 interest in this information, so just ignore it for now.
5388 case DW_TAG_class_type
:
5389 case DW_TAG_structure_type
:
5390 case DW_TAG_union_type
:
5391 case DW_TAG_enumeration_type
:
5392 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5393 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
5394 add_symbol_to_list (sym
, list_in_scope
);
5396 /* The semantics of C++ state that "struct foo { ... }" also
5397 defines a typedef for "foo". Synthesize a typedef symbol so
5398 that "ptype foo" works as expected. */
5399 if (cu_language
== language_cplus
)
5401 struct symbol
*typedef_sym
= (struct symbol
*)
5402 obstack_alloc (&objfile
->symbol_obstack
,
5403 sizeof (struct symbol
));
5404 *typedef_sym
= *sym
;
5405 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
5406 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5407 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5408 obsavestring (DEPRECATED_SYMBOL_NAME (sym
),
5409 strlen (DEPRECATED_SYMBOL_NAME (sym
)),
5410 &objfile
->type_obstack
);
5411 add_symbol_to_list (typedef_sym
, list_in_scope
);
5414 case DW_TAG_typedef
:
5415 case DW_TAG_base_type
:
5416 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5417 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5418 add_symbol_to_list (sym
, list_in_scope
);
5420 case DW_TAG_enumerator
:
5421 attr
= dwarf_attr (die
, DW_AT_const_value
);
5424 dwarf2_const_value (attr
, sym
, objfile
, cu_header
);
5426 add_symbol_to_list (sym
, list_in_scope
);
5428 case DW_TAG_namespace
:
5429 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5430 add_symbol_to_list (sym
, &global_symbols
);
5433 /* Not a tag we recognize. Hopefully we aren't processing
5434 trash data, but since we must specifically ignore things
5435 we don't recognize, there is nothing else we should do at
5437 complaint (&symfile_complaints
, "unsupported tag: '%s'",
5438 dwarf_tag_name (die
->tag
));
5445 /* Copy constant value from an attribute to a symbol. */
5448 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5449 struct objfile
*objfile
,
5450 const struct comp_unit_head
*cu_header
)
5452 struct dwarf_block
*blk
;
5457 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5458 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5459 cu_header
->addr_size
,
5460 TYPE_LENGTH (SYMBOL_TYPE
5462 SYMBOL_VALUE_BYTES (sym
) = (char *)
5463 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5464 /* NOTE: cagney/2003-05-09: In-lined store_address call with
5465 it's body - store_unsigned_integer. */
5466 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5468 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5470 case DW_FORM_block1
:
5471 case DW_FORM_block2
:
5472 case DW_FORM_block4
:
5474 blk
= DW_BLOCK (attr
);
5475 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5476 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5478 TYPE_LENGTH (SYMBOL_TYPE
5480 SYMBOL_VALUE_BYTES (sym
) = (char *)
5481 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5482 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5483 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5486 /* The DW_AT_const_value attributes are supposed to carry the
5487 symbol's value "represented as it would be on the target
5488 architecture." By the time we get here, it's already been
5489 converted to host endianness, so we just need to sign- or
5490 zero-extend it as appropriate. */
5492 dwarf2_const_value_data (attr
, sym
, 8);
5495 dwarf2_const_value_data (attr
, sym
, 16);
5498 dwarf2_const_value_data (attr
, sym
, 32);
5501 dwarf2_const_value_data (attr
, sym
, 64);
5505 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5506 SYMBOL_CLASS (sym
) = LOC_CONST
;
5510 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5511 SYMBOL_CLASS (sym
) = LOC_CONST
;
5515 complaint (&symfile_complaints
,
5516 "unsupported const value attribute form: '%s'",
5517 dwarf_form_name (attr
->form
));
5518 SYMBOL_VALUE (sym
) = 0;
5519 SYMBOL_CLASS (sym
) = LOC_CONST
;
5525 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5526 or zero-extend it as appropriate for the symbol's type. */
5528 dwarf2_const_value_data (struct attribute
*attr
,
5532 LONGEST l
= DW_UNSND (attr
);
5534 if (bits
< sizeof (l
) * 8)
5536 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5537 l
&= ((LONGEST
) 1 << bits
) - 1;
5539 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5542 SYMBOL_VALUE (sym
) = l
;
5543 SYMBOL_CLASS (sym
) = LOC_CONST
;
5547 /* Return the type of the die in question using its DW_AT_type attribute. */
5549 static struct type
*
5550 die_type (struct die_info
*die
, struct objfile
*objfile
,
5551 const struct comp_unit_head
*cu_header
)
5554 struct attribute
*type_attr
;
5555 struct die_info
*type_die
;
5558 type_attr
= dwarf_attr (die
, DW_AT_type
);
5561 /* A missing DW_AT_type represents a void type. */
5562 return dwarf2_fundamental_type (objfile
, FT_VOID
);
5566 ref
= dwarf2_get_ref_die_offset (type_attr
);
5567 type_die
= follow_die_ref (ref
);
5570 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5571 ref
, objfile
->name
);
5575 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5578 dump_die (type_die
);
5579 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5585 /* Return the containing type of the die in question using its
5586 DW_AT_containing_type attribute. */
5588 static struct type
*
5589 die_containing_type (struct die_info
*die
, struct objfile
*objfile
,
5590 const struct comp_unit_head
*cu_header
)
5592 struct type
*type
= NULL
;
5593 struct attribute
*type_attr
;
5594 struct die_info
*type_die
= NULL
;
5597 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5600 ref
= dwarf2_get_ref_die_offset (type_attr
);
5601 type_die
= follow_die_ref (ref
);
5604 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref
,
5608 type
= tag_type_to_type (type_die
, objfile
, cu_header
);
5613 dump_die (type_die
);
5614 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
5621 static struct type
*
5622 type_at_offset (unsigned int offset
, struct objfile
*objfile
)
5624 struct die_info
*die
;
5627 die
= follow_die_ref (offset
);
5630 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5633 type
= tag_type_to_type (die
, objfile
);
5638 static struct type
*
5639 tag_type_to_type (struct die_info
*die
, struct objfile
*objfile
,
5640 const struct comp_unit_head
*cu_header
)
5648 read_type_die (die
, objfile
, cu_header
);
5652 error ("Dwarf Error: Cannot find type of die [in module %s]",
5660 read_type_die (struct die_info
*die
, struct objfile
*objfile
,
5661 const struct comp_unit_head
*cu_header
)
5665 case DW_TAG_class_type
:
5666 case DW_TAG_structure_type
:
5667 case DW_TAG_union_type
:
5668 read_structure_scope (die
, objfile
, cu_header
);
5670 case DW_TAG_enumeration_type
:
5671 read_enumeration (die
, objfile
, cu_header
);
5673 case DW_TAG_subprogram
:
5674 case DW_TAG_subroutine_type
:
5675 read_subroutine_type (die
, objfile
, cu_header
);
5677 case DW_TAG_array_type
:
5678 read_array_type (die
, objfile
, cu_header
);
5680 case DW_TAG_pointer_type
:
5681 read_tag_pointer_type (die
, objfile
, cu_header
);
5683 case DW_TAG_ptr_to_member_type
:
5684 read_tag_ptr_to_member_type (die
, objfile
, cu_header
);
5686 case DW_TAG_reference_type
:
5687 read_tag_reference_type (die
, objfile
, cu_header
);
5689 case DW_TAG_const_type
:
5690 read_tag_const_type (die
, objfile
, cu_header
);
5692 case DW_TAG_volatile_type
:
5693 read_tag_volatile_type (die
, objfile
, cu_header
);
5695 case DW_TAG_string_type
:
5696 read_tag_string_type (die
, objfile
);
5698 case DW_TAG_typedef
:
5699 read_typedef (die
, objfile
, cu_header
);
5701 case DW_TAG_base_type
:
5702 read_base_type (die
, objfile
);
5705 complaint (&symfile_complaints
, "unexepected tag in read_type_die: '%s'",
5706 dwarf_tag_name (die
->tag
));
5711 static struct type
*
5712 dwarf_base_type (int encoding
, int size
, struct objfile
*objfile
)
5714 /* FIXME - this should not produce a new (struct type *)
5715 every time. It should cache base types. */
5719 case DW_ATE_address
:
5720 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5722 case DW_ATE_boolean
:
5723 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5725 case DW_ATE_complex_float
:
5728 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5732 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5738 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5742 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5749 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5752 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5756 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5760 case DW_ATE_signed_char
:
5761 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5763 case DW_ATE_unsigned
:
5767 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5770 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5774 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5778 case DW_ATE_unsigned_char
:
5779 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5782 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5789 copy_die (struct die_info
*old_die
)
5791 struct die_info
*new_die
;
5794 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5795 memset (new_die
, 0, sizeof (struct die_info
));
5797 new_die
->tag
= old_die
->tag
;
5798 new_die
->has_children
= old_die
->has_children
;
5799 new_die
->abbrev
= old_die
->abbrev
;
5800 new_die
->offset
= old_die
->offset
;
5801 new_die
->type
= NULL
;
5803 num_attrs
= old_die
->num_attrs
;
5804 new_die
->num_attrs
= num_attrs
;
5805 new_die
->attrs
= (struct attribute
*)
5806 xmalloc (num_attrs
* sizeof (struct attribute
));
5808 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5810 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5811 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5812 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5815 new_die
->next
= NULL
;
5820 /* Return sibling of die, NULL if no sibling. */
5822 static struct die_info
*
5823 sibling_die (struct die_info
*die
)
5825 int nesting_level
= 0;
5827 if (!die
->has_children
)
5829 if (die
->next
&& (die
->next
->tag
== 0))
5842 if (die
->has_children
)
5852 while (nesting_level
);
5853 if (die
&& (die
->tag
== 0))
5864 /* Get linkage name of a die, return NULL if not found. */
5867 dwarf2_linkage_name (struct die_info
*die
)
5869 struct attribute
*attr
;
5871 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5872 if (attr
&& DW_STRING (attr
))
5873 return DW_STRING (attr
);
5874 attr
= dwarf_attr (die
, DW_AT_name
);
5875 if (attr
&& DW_STRING (attr
))
5876 return DW_STRING (attr
);
5880 /* Get name of a die, return NULL if not found. */
5883 dwarf2_name (struct die_info
*die
)
5885 struct attribute
*attr
;
5887 attr
= dwarf_attr (die
, DW_AT_name
);
5888 if (attr
&& DW_STRING (attr
))
5889 return DW_STRING (attr
);
5893 /* Return the die that this die in an extension of, or NULL if there
5896 static struct die_info
*
5897 dwarf2_extension (struct die_info
*die
)
5899 struct attribute
*attr
;
5900 struct die_info
*extension_die
;
5903 attr
= dwarf_attr (die
, DW_AT_extension
);
5907 ref
= dwarf2_get_ref_die_offset (attr
);
5908 extension_die
= follow_die_ref (ref
);
5911 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5914 return extension_die
;
5917 /* Convert a DIE tag into its string name. */
5920 dwarf_tag_name (unsigned tag
)
5924 case DW_TAG_padding
:
5925 return "DW_TAG_padding";
5926 case DW_TAG_array_type
:
5927 return "DW_TAG_array_type";
5928 case DW_TAG_class_type
:
5929 return "DW_TAG_class_type";
5930 case DW_TAG_entry_point
:
5931 return "DW_TAG_entry_point";
5932 case DW_TAG_enumeration_type
:
5933 return "DW_TAG_enumeration_type";
5934 case DW_TAG_formal_parameter
:
5935 return "DW_TAG_formal_parameter";
5936 case DW_TAG_imported_declaration
:
5937 return "DW_TAG_imported_declaration";
5939 return "DW_TAG_label";
5940 case DW_TAG_lexical_block
:
5941 return "DW_TAG_lexical_block";
5943 return "DW_TAG_member";
5944 case DW_TAG_pointer_type
:
5945 return "DW_TAG_pointer_type";
5946 case DW_TAG_reference_type
:
5947 return "DW_TAG_reference_type";
5948 case DW_TAG_compile_unit
:
5949 return "DW_TAG_compile_unit";
5950 case DW_TAG_string_type
:
5951 return "DW_TAG_string_type";
5952 case DW_TAG_structure_type
:
5953 return "DW_TAG_structure_type";
5954 case DW_TAG_subroutine_type
:
5955 return "DW_TAG_subroutine_type";
5956 case DW_TAG_typedef
:
5957 return "DW_TAG_typedef";
5958 case DW_TAG_union_type
:
5959 return "DW_TAG_union_type";
5960 case DW_TAG_unspecified_parameters
:
5961 return "DW_TAG_unspecified_parameters";
5962 case DW_TAG_variant
:
5963 return "DW_TAG_variant";
5964 case DW_TAG_common_block
:
5965 return "DW_TAG_common_block";
5966 case DW_TAG_common_inclusion
:
5967 return "DW_TAG_common_inclusion";
5968 case DW_TAG_inheritance
:
5969 return "DW_TAG_inheritance";
5970 case DW_TAG_inlined_subroutine
:
5971 return "DW_TAG_inlined_subroutine";
5973 return "DW_TAG_module";
5974 case DW_TAG_ptr_to_member_type
:
5975 return "DW_TAG_ptr_to_member_type";
5976 case DW_TAG_set_type
:
5977 return "DW_TAG_set_type";
5978 case DW_TAG_subrange_type
:
5979 return "DW_TAG_subrange_type";
5980 case DW_TAG_with_stmt
:
5981 return "DW_TAG_with_stmt";
5982 case DW_TAG_access_declaration
:
5983 return "DW_TAG_access_declaration";
5984 case DW_TAG_base_type
:
5985 return "DW_TAG_base_type";
5986 case DW_TAG_catch_block
:
5987 return "DW_TAG_catch_block";
5988 case DW_TAG_const_type
:
5989 return "DW_TAG_const_type";
5990 case DW_TAG_constant
:
5991 return "DW_TAG_constant";
5992 case DW_TAG_enumerator
:
5993 return "DW_TAG_enumerator";
5994 case DW_TAG_file_type
:
5995 return "DW_TAG_file_type";
5997 return "DW_TAG_friend";
5998 case DW_TAG_namelist
:
5999 return "DW_TAG_namelist";
6000 case DW_TAG_namelist_item
:
6001 return "DW_TAG_namelist_item";
6002 case DW_TAG_packed_type
:
6003 return "DW_TAG_packed_type";
6004 case DW_TAG_subprogram
:
6005 return "DW_TAG_subprogram";
6006 case DW_TAG_template_type_param
:
6007 return "DW_TAG_template_type_param";
6008 case DW_TAG_template_value_param
:
6009 return "DW_TAG_template_value_param";
6010 case DW_TAG_thrown_type
:
6011 return "DW_TAG_thrown_type";
6012 case DW_TAG_try_block
:
6013 return "DW_TAG_try_block";
6014 case DW_TAG_variant_part
:
6015 return "DW_TAG_variant_part";
6016 case DW_TAG_variable
:
6017 return "DW_TAG_variable";
6018 case DW_TAG_volatile_type
:
6019 return "DW_TAG_volatile_type";
6020 case DW_TAG_dwarf_procedure
:
6021 return "DW_TAG_dwarf_procedure";
6022 case DW_TAG_restrict_type
:
6023 return "DW_TAG_restrict_type";
6024 case DW_TAG_interface_type
:
6025 return "DW_TAG_interface_type";
6026 case DW_TAG_namespace
:
6027 return "DW_TAG_namespace";
6028 case DW_TAG_imported_module
:
6029 return "DW_TAG_imported_module";
6030 case DW_TAG_unspecified_type
:
6031 return "DW_TAG_unspecified_type";
6032 case DW_TAG_partial_unit
:
6033 return "DW_TAG_partial_unit";
6034 case DW_TAG_imported_unit
:
6035 return "DW_TAG_imported_unit";
6036 case DW_TAG_MIPS_loop
:
6037 return "DW_TAG_MIPS_loop";
6038 case DW_TAG_format_label
:
6039 return "DW_TAG_format_label";
6040 case DW_TAG_function_template
:
6041 return "DW_TAG_function_template";
6042 case DW_TAG_class_template
:
6043 return "DW_TAG_class_template";
6045 return "DW_TAG_<unknown>";
6049 /* Convert a DWARF attribute code into its string name. */
6052 dwarf_attr_name (unsigned attr
)
6057 return "DW_AT_sibling";
6058 case DW_AT_location
:
6059 return "DW_AT_location";
6061 return "DW_AT_name";
6062 case DW_AT_ordering
:
6063 return "DW_AT_ordering";
6064 case DW_AT_subscr_data
:
6065 return "DW_AT_subscr_data";
6066 case DW_AT_byte_size
:
6067 return "DW_AT_byte_size";
6068 case DW_AT_bit_offset
:
6069 return "DW_AT_bit_offset";
6070 case DW_AT_bit_size
:
6071 return "DW_AT_bit_size";
6072 case DW_AT_element_list
:
6073 return "DW_AT_element_list";
6074 case DW_AT_stmt_list
:
6075 return "DW_AT_stmt_list";
6077 return "DW_AT_low_pc";
6079 return "DW_AT_high_pc";
6080 case DW_AT_language
:
6081 return "DW_AT_language";
6083 return "DW_AT_member";
6085 return "DW_AT_discr";
6086 case DW_AT_discr_value
:
6087 return "DW_AT_discr_value";
6088 case DW_AT_visibility
:
6089 return "DW_AT_visibility";
6091 return "DW_AT_import";
6092 case DW_AT_string_length
:
6093 return "DW_AT_string_length";
6094 case DW_AT_common_reference
:
6095 return "DW_AT_common_reference";
6096 case DW_AT_comp_dir
:
6097 return "DW_AT_comp_dir";
6098 case DW_AT_const_value
:
6099 return "DW_AT_const_value";
6100 case DW_AT_containing_type
:
6101 return "DW_AT_containing_type";
6102 case DW_AT_default_value
:
6103 return "DW_AT_default_value";
6105 return "DW_AT_inline";
6106 case DW_AT_is_optional
:
6107 return "DW_AT_is_optional";
6108 case DW_AT_lower_bound
:
6109 return "DW_AT_lower_bound";
6110 case DW_AT_producer
:
6111 return "DW_AT_producer";
6112 case DW_AT_prototyped
:
6113 return "DW_AT_prototyped";
6114 case DW_AT_return_addr
:
6115 return "DW_AT_return_addr";
6116 case DW_AT_start_scope
:
6117 return "DW_AT_start_scope";
6118 case DW_AT_stride_size
:
6119 return "DW_AT_stride_size";
6120 case DW_AT_upper_bound
:
6121 return "DW_AT_upper_bound";
6122 case DW_AT_abstract_origin
:
6123 return "DW_AT_abstract_origin";
6124 case DW_AT_accessibility
:
6125 return "DW_AT_accessibility";
6126 case DW_AT_address_class
:
6127 return "DW_AT_address_class";
6128 case DW_AT_artificial
:
6129 return "DW_AT_artificial";
6130 case DW_AT_base_types
:
6131 return "DW_AT_base_types";
6132 case DW_AT_calling_convention
:
6133 return "DW_AT_calling_convention";
6135 return "DW_AT_count";
6136 case DW_AT_data_member_location
:
6137 return "DW_AT_data_member_location";
6138 case DW_AT_decl_column
:
6139 return "DW_AT_decl_column";
6140 case DW_AT_decl_file
:
6141 return "DW_AT_decl_file";
6142 case DW_AT_decl_line
:
6143 return "DW_AT_decl_line";
6144 case DW_AT_declaration
:
6145 return "DW_AT_declaration";
6146 case DW_AT_discr_list
:
6147 return "DW_AT_discr_list";
6148 case DW_AT_encoding
:
6149 return "DW_AT_encoding";
6150 case DW_AT_external
:
6151 return "DW_AT_external";
6152 case DW_AT_frame_base
:
6153 return "DW_AT_frame_base";
6155 return "DW_AT_friend";
6156 case DW_AT_identifier_case
:
6157 return "DW_AT_identifier_case";
6158 case DW_AT_macro_info
:
6159 return "DW_AT_macro_info";
6160 case DW_AT_namelist_items
:
6161 return "DW_AT_namelist_items";
6162 case DW_AT_priority
:
6163 return "DW_AT_priority";
6165 return "DW_AT_segment";
6166 case DW_AT_specification
:
6167 return "DW_AT_specification";
6168 case DW_AT_static_link
:
6169 return "DW_AT_static_link";
6171 return "DW_AT_type";
6172 case DW_AT_use_location
:
6173 return "DW_AT_use_location";
6174 case DW_AT_variable_parameter
:
6175 return "DW_AT_variable_parameter";
6176 case DW_AT_virtuality
:
6177 return "DW_AT_virtuality";
6178 case DW_AT_vtable_elem_location
:
6179 return "DW_AT_vtable_elem_location";
6180 case DW_AT_allocated
:
6181 return "DW_AT_allocated";
6182 case DW_AT_associated
:
6183 return "DW_AT_associated";
6184 case DW_AT_data_location
:
6185 return "DW_AT_data_location";
6187 return "DW_AT_stride";
6188 case DW_AT_entry_pc
:
6189 return "DW_AT_entry_pc";
6190 case DW_AT_use_UTF8
:
6191 return "DW_AT_use_UTF8";
6192 case DW_AT_extension
:
6193 return "DW_AT_extension";
6195 return "DW_AT_ranges";
6196 case DW_AT_trampoline
:
6197 return "DW_AT_trampoline";
6198 case DW_AT_call_column
:
6199 return "DW_AT_call_column";
6200 case DW_AT_call_file
:
6201 return "DW_AT_call_file";
6202 case DW_AT_call_line
:
6203 return "DW_AT_call_line";
6205 case DW_AT_MIPS_fde
:
6206 return "DW_AT_MIPS_fde";
6207 case DW_AT_MIPS_loop_begin
:
6208 return "DW_AT_MIPS_loop_begin";
6209 case DW_AT_MIPS_tail_loop_begin
:
6210 return "DW_AT_MIPS_tail_loop_begin";
6211 case DW_AT_MIPS_epilog_begin
:
6212 return "DW_AT_MIPS_epilog_begin";
6213 case DW_AT_MIPS_loop_unroll_factor
:
6214 return "DW_AT_MIPS_loop_unroll_factor";
6215 case DW_AT_MIPS_software_pipeline_depth
:
6216 return "DW_AT_MIPS_software_pipeline_depth";
6218 case DW_AT_MIPS_linkage_name
:
6219 return "DW_AT_MIPS_linkage_name";
6221 case DW_AT_sf_names
:
6222 return "DW_AT_sf_names";
6223 case DW_AT_src_info
:
6224 return "DW_AT_src_info";
6225 case DW_AT_mac_info
:
6226 return "DW_AT_mac_info";
6227 case DW_AT_src_coords
:
6228 return "DW_AT_src_coords";
6229 case DW_AT_body_begin
:
6230 return "DW_AT_body_begin";
6231 case DW_AT_body_end
:
6232 return "DW_AT_body_end";
6233 case DW_AT_GNU_vector
:
6234 return "DW_AT_GNU_vector";
6236 return "DW_AT_<unknown>";
6240 /* Convert a DWARF value form code into its string name. */
6243 dwarf_form_name (unsigned form
)
6248 return "DW_FORM_addr";
6249 case DW_FORM_block2
:
6250 return "DW_FORM_block2";
6251 case DW_FORM_block4
:
6252 return "DW_FORM_block4";
6254 return "DW_FORM_data2";
6256 return "DW_FORM_data4";
6258 return "DW_FORM_data8";
6259 case DW_FORM_string
:
6260 return "DW_FORM_string";
6262 return "DW_FORM_block";
6263 case DW_FORM_block1
:
6264 return "DW_FORM_block1";
6266 return "DW_FORM_data1";
6268 return "DW_FORM_flag";
6270 return "DW_FORM_sdata";
6272 return "DW_FORM_strp";
6274 return "DW_FORM_udata";
6275 case DW_FORM_ref_addr
:
6276 return "DW_FORM_ref_addr";
6278 return "DW_FORM_ref1";
6280 return "DW_FORM_ref2";
6282 return "DW_FORM_ref4";
6284 return "DW_FORM_ref8";
6285 case DW_FORM_ref_udata
:
6286 return "DW_FORM_ref_udata";
6287 case DW_FORM_indirect
:
6288 return "DW_FORM_indirect";
6290 return "DW_FORM_<unknown>";
6294 /* Convert a DWARF stack opcode into its string name. */
6297 dwarf_stack_op_name (unsigned op
)
6302 return "DW_OP_addr";
6304 return "DW_OP_deref";
6306 return "DW_OP_const1u";
6308 return "DW_OP_const1s";
6310 return "DW_OP_const2u";
6312 return "DW_OP_const2s";
6314 return "DW_OP_const4u";
6316 return "DW_OP_const4s";
6318 return "DW_OP_const8u";
6320 return "DW_OP_const8s";
6322 return "DW_OP_constu";
6324 return "DW_OP_consts";
6328 return "DW_OP_drop";
6330 return "DW_OP_over";
6332 return "DW_OP_pick";
6334 return "DW_OP_swap";
6338 return "DW_OP_xderef";
6346 return "DW_OP_minus";
6358 return "DW_OP_plus";
6359 case DW_OP_plus_uconst
:
6360 return "DW_OP_plus_uconst";
6366 return "DW_OP_shra";
6384 return "DW_OP_skip";
6386 return "DW_OP_lit0";
6388 return "DW_OP_lit1";
6390 return "DW_OP_lit2";
6392 return "DW_OP_lit3";
6394 return "DW_OP_lit4";
6396 return "DW_OP_lit5";
6398 return "DW_OP_lit6";
6400 return "DW_OP_lit7";
6402 return "DW_OP_lit8";
6404 return "DW_OP_lit9";
6406 return "DW_OP_lit10";
6408 return "DW_OP_lit11";
6410 return "DW_OP_lit12";
6412 return "DW_OP_lit13";
6414 return "DW_OP_lit14";
6416 return "DW_OP_lit15";
6418 return "DW_OP_lit16";
6420 return "DW_OP_lit17";
6422 return "DW_OP_lit18";
6424 return "DW_OP_lit19";
6426 return "DW_OP_lit20";
6428 return "DW_OP_lit21";
6430 return "DW_OP_lit22";
6432 return "DW_OP_lit23";
6434 return "DW_OP_lit24";
6436 return "DW_OP_lit25";
6438 return "DW_OP_lit26";
6440 return "DW_OP_lit27";
6442 return "DW_OP_lit28";
6444 return "DW_OP_lit29";
6446 return "DW_OP_lit30";
6448 return "DW_OP_lit31";
6450 return "DW_OP_reg0";
6452 return "DW_OP_reg1";
6454 return "DW_OP_reg2";
6456 return "DW_OP_reg3";
6458 return "DW_OP_reg4";
6460 return "DW_OP_reg5";
6462 return "DW_OP_reg6";
6464 return "DW_OP_reg7";
6466 return "DW_OP_reg8";
6468 return "DW_OP_reg9";
6470 return "DW_OP_reg10";
6472 return "DW_OP_reg11";
6474 return "DW_OP_reg12";
6476 return "DW_OP_reg13";
6478 return "DW_OP_reg14";
6480 return "DW_OP_reg15";
6482 return "DW_OP_reg16";
6484 return "DW_OP_reg17";
6486 return "DW_OP_reg18";
6488 return "DW_OP_reg19";
6490 return "DW_OP_reg20";
6492 return "DW_OP_reg21";
6494 return "DW_OP_reg22";
6496 return "DW_OP_reg23";
6498 return "DW_OP_reg24";
6500 return "DW_OP_reg25";
6502 return "DW_OP_reg26";
6504 return "DW_OP_reg27";
6506 return "DW_OP_reg28";
6508 return "DW_OP_reg29";
6510 return "DW_OP_reg30";
6512 return "DW_OP_reg31";
6514 return "DW_OP_breg0";
6516 return "DW_OP_breg1";
6518 return "DW_OP_breg2";
6520 return "DW_OP_breg3";
6522 return "DW_OP_breg4";
6524 return "DW_OP_breg5";
6526 return "DW_OP_breg6";
6528 return "DW_OP_breg7";
6530 return "DW_OP_breg8";
6532 return "DW_OP_breg9";
6534 return "DW_OP_breg10";
6536 return "DW_OP_breg11";
6538 return "DW_OP_breg12";
6540 return "DW_OP_breg13";
6542 return "DW_OP_breg14";
6544 return "DW_OP_breg15";
6546 return "DW_OP_breg16";
6548 return "DW_OP_breg17";
6550 return "DW_OP_breg18";
6552 return "DW_OP_breg19";
6554 return "DW_OP_breg20";
6556 return "DW_OP_breg21";
6558 return "DW_OP_breg22";
6560 return "DW_OP_breg23";
6562 return "DW_OP_breg24";
6564 return "DW_OP_breg25";
6566 return "DW_OP_breg26";
6568 return "DW_OP_breg27";
6570 return "DW_OP_breg28";
6572 return "DW_OP_breg29";
6574 return "DW_OP_breg30";
6576 return "DW_OP_breg31";
6578 return "DW_OP_regx";
6580 return "DW_OP_fbreg";
6582 return "DW_OP_bregx";
6584 return "DW_OP_piece";
6585 case DW_OP_deref_size
:
6586 return "DW_OP_deref_size";
6587 case DW_OP_xderef_size
:
6588 return "DW_OP_xderef_size";
6591 /* DWARF 3 extensions. */
6592 case DW_OP_push_object_address
:
6593 return "DW_OP_push_object_address";
6595 return "DW_OP_call2";
6597 return "DW_OP_call4";
6598 case DW_OP_call_ref
:
6599 return "DW_OP_call_ref";
6600 /* GNU extensions. */
6601 case DW_OP_GNU_push_tls_address
:
6602 return "DW_OP_GNU_push_tls_address";
6604 return "OP_<unknown>";
6609 dwarf_bool_name (unsigned mybool
)
6617 /* Convert a DWARF type code into its string name. */
6620 dwarf_type_encoding_name (unsigned enc
)
6624 case DW_ATE_address
:
6625 return "DW_ATE_address";
6626 case DW_ATE_boolean
:
6627 return "DW_ATE_boolean";
6628 case DW_ATE_complex_float
:
6629 return "DW_ATE_complex_float";
6631 return "DW_ATE_float";
6633 return "DW_ATE_signed";
6634 case DW_ATE_signed_char
:
6635 return "DW_ATE_signed_char";
6636 case DW_ATE_unsigned
:
6637 return "DW_ATE_unsigned";
6638 case DW_ATE_unsigned_char
:
6639 return "DW_ATE_unsigned_char";
6640 case DW_ATE_imaginary_float
:
6641 return "DW_ATE_imaginary_float";
6643 return "DW_ATE_<unknown>";
6647 /* Convert a DWARF call frame info operation to its string name. */
6651 dwarf_cfi_name (unsigned cfi_opc
)
6655 case DW_CFA_advance_loc
:
6656 return "DW_CFA_advance_loc";
6658 return "DW_CFA_offset";
6659 case DW_CFA_restore
:
6660 return "DW_CFA_restore";
6662 return "DW_CFA_nop";
6663 case DW_CFA_set_loc
:
6664 return "DW_CFA_set_loc";
6665 case DW_CFA_advance_loc1
:
6666 return "DW_CFA_advance_loc1";
6667 case DW_CFA_advance_loc2
:
6668 return "DW_CFA_advance_loc2";
6669 case DW_CFA_advance_loc4
:
6670 return "DW_CFA_advance_loc4";
6671 case DW_CFA_offset_extended
:
6672 return "DW_CFA_offset_extended";
6673 case DW_CFA_restore_extended
:
6674 return "DW_CFA_restore_extended";
6675 case DW_CFA_undefined
:
6676 return "DW_CFA_undefined";
6677 case DW_CFA_same_value
:
6678 return "DW_CFA_same_value";
6679 case DW_CFA_register
:
6680 return "DW_CFA_register";
6681 case DW_CFA_remember_state
:
6682 return "DW_CFA_remember_state";
6683 case DW_CFA_restore_state
:
6684 return "DW_CFA_restore_state";
6685 case DW_CFA_def_cfa
:
6686 return "DW_CFA_def_cfa";
6687 case DW_CFA_def_cfa_register
:
6688 return "DW_CFA_def_cfa_register";
6689 case DW_CFA_def_cfa_offset
:
6690 return "DW_CFA_def_cfa_offset";
6693 case DW_CFA_def_cfa_expression
:
6694 return "DW_CFA_def_cfa_expression";
6695 case DW_CFA_expression
:
6696 return "DW_CFA_expression";
6697 case DW_CFA_offset_extended_sf
:
6698 return "DW_CFA_offset_extended_sf";
6699 case DW_CFA_def_cfa_sf
:
6700 return "DW_CFA_def_cfa_sf";
6701 case DW_CFA_def_cfa_offset_sf
:
6702 return "DW_CFA_def_cfa_offset_sf";
6704 /* SGI/MIPS specific */
6705 case DW_CFA_MIPS_advance_loc8
:
6706 return "DW_CFA_MIPS_advance_loc8";
6708 /* GNU extensions */
6709 case DW_CFA_GNU_window_save
:
6710 return "DW_CFA_GNU_window_save";
6711 case DW_CFA_GNU_args_size
:
6712 return "DW_CFA_GNU_args_size";
6713 case DW_CFA_GNU_negative_offset_extended
:
6714 return "DW_CFA_GNU_negative_offset_extended";
6717 return "DW_CFA_<unknown>";
6723 dump_die (struct die_info
*die
)
6727 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6728 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6729 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6730 dwarf_bool_name (die
->has_children
));
6732 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6733 for (i
= 0; i
< die
->num_attrs
; ++i
)
6735 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6736 dwarf_attr_name (die
->attrs
[i
].name
),
6737 dwarf_form_name (die
->attrs
[i
].form
));
6738 switch (die
->attrs
[i
].form
)
6740 case DW_FORM_ref_addr
:
6742 fprintf_unfiltered (gdb_stderr
, "address: ");
6743 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6745 case DW_FORM_block2
:
6746 case DW_FORM_block4
:
6748 case DW_FORM_block1
:
6749 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6760 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6762 case DW_FORM_string
:
6764 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6765 DW_STRING (&die
->attrs
[i
])
6766 ? DW_STRING (&die
->attrs
[i
]) : "");
6769 if (DW_UNSND (&die
->attrs
[i
]))
6770 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6772 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6774 case DW_FORM_indirect
:
6775 /* the reader will have reduced the indirect form to
6776 the "base form" so this form should not occur */
6777 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6780 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6781 die
->attrs
[i
].form
);
6783 fprintf_unfiltered (gdb_stderr
, "\n");
6788 dump_die_list (struct die_info
*die
)
6798 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6801 struct die_info
*old
;
6803 h
= (offset
% REF_HASH_SIZE
);
6804 old
= die_ref_table
[h
];
6805 die
->next_ref
= old
;
6806 die_ref_table
[h
] = die
;
6811 dwarf2_empty_hash_tables (void)
6813 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6817 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6819 unsigned int result
= 0;
6823 case DW_FORM_ref_addr
:
6824 result
= DW_ADDR (attr
);
6830 case DW_FORM_ref_udata
:
6831 result
= cu_header_offset
+ DW_UNSND (attr
);
6834 complaint (&symfile_complaints
,
6835 "unsupported die ref attribute form: '%s'",
6836 dwarf_form_name (attr
->form
));
6841 static struct die_info
*
6842 follow_die_ref (unsigned int offset
)
6844 struct die_info
*die
;
6847 h
= (offset
% REF_HASH_SIZE
);
6848 die
= die_ref_table
[h
];
6851 if (die
->offset
== offset
)
6855 die
= die
->next_ref
;
6860 static struct type
*
6861 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6863 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6865 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
6866 typeid, objfile
->name
);
6869 /* Look for this particular type in the fundamental type vector. If
6870 one is not found, create and install one appropriate for the
6871 current language and the current target machine. */
6873 if (ftypes
[typeid] == NULL
)
6875 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6878 return (ftypes
[typeid]);
6881 /* Decode simple location descriptions.
6882 Given a pointer to a dwarf block that defines a location, compute
6883 the location and return the value.
6885 FIXME: This is a kludge until we figure out a better
6886 way to handle the location descriptions.
6887 Gdb's design does not mesh well with the DWARF2 notion of a location
6888 computing interpreter, which is a shame because the flexibility goes unused.
6889 FIXME: Implement more operations as necessary.
6891 A location description containing no operations indicates that the
6892 object is optimized out. The global optimized_out flag is set for
6893 those, the return value is meaningless.
6895 When the result is a register number, the global isreg flag is set,
6896 otherwise it is cleared.
6898 When the result is a base register offset, the global offreg flag is set
6899 and the register number is returned in basereg, otherwise it is cleared.
6901 When the DW_OP_fbreg operation is encountered without a corresponding
6902 DW_AT_frame_base attribute, the global islocal flag is set.
6903 Hopefully the machine dependent code knows how to set up a virtual
6904 frame pointer for the local references.
6906 Note that stack[0] is unused except as a default error return.
6907 Note that stack overflow is not yet handled. */
6910 decode_locdesc (struct dwarf_block
*blk
, struct objfile
*objfile
,
6911 const struct comp_unit_head
*cu_header
)
6914 int size
= blk
->size
;
6915 char *data
= blk
->data
;
6916 CORE_ADDR stack
[64];
6918 unsigned int bytes_read
, unsnd
;
6968 stack
[++stacki
] = op
- DW_OP_lit0
;
7004 stack
[++stacki
] = op
- DW_OP_reg0
;
7009 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7011 stack
[++stacki
] = unsnd
;
7047 basereg
= op
- DW_OP_breg0
;
7048 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7054 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7056 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7061 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7063 if (frame_base_reg
>= 0)
7066 basereg
= frame_base_reg
;
7067 stack
[stacki
] += frame_base_offset
;
7071 complaint (&symfile_complaints
,
7072 "DW_AT_frame_base missing for DW_OP_fbreg");
7078 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
7079 cu_header
, &bytes_read
);
7084 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
7089 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
7094 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
7099 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
7104 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
7109 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
7114 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
7120 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7125 stack
[stacki
+ 1] = stack
[stacki
];
7130 stack
[stacki
- 1] += stack
[stacki
];
7134 case DW_OP_plus_uconst
:
7135 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7140 stack
[stacki
- 1] -= stack
[stacki
];
7146 /* If we're not the last op, then we definitely can't encode
7147 this using GDB's address_class enum. */
7149 dwarf2_complex_location_expr_complaint ();
7152 case DW_OP_GNU_push_tls_address
:
7153 /* The top of the stack has the offset from the beginning
7154 of the thread control block at which the variable is located. */
7155 /* Nothing should follow this operator, so the top of stack would
7158 dwarf2_complex_location_expr_complaint ();
7162 complaint (&symfile_complaints
, "unsupported stack op: '%s'",
7163 dwarf_stack_op_name (op
));
7164 return (stack
[stacki
]);
7167 return (stack
[stacki
]);
7170 /* memory allocation interface */
7173 dwarf2_free_tmp_obstack (void *ignore
)
7175 obstack_free (&dwarf2_tmp_obstack
, NULL
);
7178 static struct dwarf_block
*
7179 dwarf_alloc_block (void)
7181 struct dwarf_block
*blk
;
7183 blk
= (struct dwarf_block
*)
7184 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
7188 static struct abbrev_info
*
7189 dwarf_alloc_abbrev (void)
7191 struct abbrev_info
*abbrev
;
7193 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
7194 memset (abbrev
, 0, sizeof (struct abbrev_info
));
7198 static struct die_info
*
7199 dwarf_alloc_die (void)
7201 struct die_info
*die
;
7203 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7204 memset (die
, 0, sizeof (struct die_info
));
7209 /* Macro support. */
7212 /* Return the full name of file number I in *LH's file name table.
7213 Use COMP_DIR as the name of the current directory of the
7214 compilation. The result is allocated using xmalloc; the caller is
7215 responsible for freeing it. */
7217 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
7219 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
7221 if (IS_ABSOLUTE_PATH (fe
->name
))
7222 return xstrdup (fe
->name
);
7230 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7236 dir_len
= strlen (dir
);
7237 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
7238 strcpy (full_name
, dir
);
7239 full_name
[dir_len
] = '/';
7240 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
7244 return xstrdup (fe
->name
);
7249 static struct macro_source_file
*
7250 macro_start_file (int file
, int line
,
7251 struct macro_source_file
*current_file
,
7252 const char *comp_dir
,
7253 struct line_header
*lh
, struct objfile
*objfile
)
7255 /* The full name of this source file. */
7256 char *full_name
= file_full_name (file
, lh
, comp_dir
);
7258 /* We don't create a macro table for this compilation unit
7259 at all until we actually get a filename. */
7260 if (! pending_macros
)
7261 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
7262 objfile
->macro_cache
);
7265 /* If we have no current file, then this must be the start_file
7266 directive for the compilation unit's main source file. */
7267 current_file
= macro_set_main (pending_macros
, full_name
);
7269 current_file
= macro_include (current_file
, line
, full_name
);
7273 return current_file
;
7277 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7278 followed by a null byte. */
7280 copy_string (const char *buf
, int len
)
7282 char *s
= xmalloc (len
+ 1);
7283 memcpy (s
, buf
, len
);
7291 consume_improper_spaces (const char *p
, const char *body
)
7295 complaint (&symfile_complaints
,
7296 "macro definition contains spaces in formal argument list:\n`%s'",
7308 parse_macro_definition (struct macro_source_file
*file
, int line
,
7313 /* The body string takes one of two forms. For object-like macro
7314 definitions, it should be:
7316 <macro name> " " <definition>
7318 For function-like macro definitions, it should be:
7320 <macro name> "() " <definition>
7322 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7324 Spaces may appear only where explicitly indicated, and in the
7327 The Dwarf 2 spec says that an object-like macro's name is always
7328 followed by a space, but versions of GCC around March 2002 omit
7329 the space when the macro's definition is the empty string.
7331 The Dwarf 2 spec says that there should be no spaces between the
7332 formal arguments in a function-like macro's formal argument list,
7333 but versions of GCC around March 2002 include spaces after the
7337 /* Find the extent of the macro name. The macro name is terminated
7338 by either a space or null character (for an object-like macro) or
7339 an opening paren (for a function-like macro). */
7340 for (p
= body
; *p
; p
++)
7341 if (*p
== ' ' || *p
== '(')
7344 if (*p
== ' ' || *p
== '\0')
7346 /* It's an object-like macro. */
7347 int name_len
= p
- body
;
7348 char *name
= copy_string (body
, name_len
);
7349 const char *replacement
;
7352 replacement
= body
+ name_len
+ 1;
7355 dwarf2_macro_malformed_definition_complaint (body
);
7356 replacement
= body
+ name_len
;
7359 macro_define_object (file
, line
, name
, replacement
);
7365 /* It's a function-like macro. */
7366 char *name
= copy_string (body
, p
- body
);
7369 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
7373 p
= consume_improper_spaces (p
, body
);
7375 /* Parse the formal argument list. */
7376 while (*p
&& *p
!= ')')
7378 /* Find the extent of the current argument name. */
7379 const char *arg_start
= p
;
7381 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
7384 if (! *p
|| p
== arg_start
)
7385 dwarf2_macro_malformed_definition_complaint (body
);
7388 /* Make sure argv has room for the new argument. */
7389 if (argc
>= argv_size
)
7392 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
7395 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
7398 p
= consume_improper_spaces (p
, body
);
7400 /* Consume the comma, if present. */
7405 p
= consume_improper_spaces (p
, body
);
7414 /* Perfectly formed definition, no complaints. */
7415 macro_define_function (file
, line
, name
,
7416 argc
, (const char **) argv
,
7418 else if (*p
== '\0')
7420 /* Complain, but do define it. */
7421 dwarf2_macro_malformed_definition_complaint (body
);
7422 macro_define_function (file
, line
, name
,
7423 argc
, (const char **) argv
,
7427 /* Just complain. */
7428 dwarf2_macro_malformed_definition_complaint (body
);
7431 /* Just complain. */
7432 dwarf2_macro_malformed_definition_complaint (body
);
7438 for (i
= 0; i
< argc
; i
++)
7444 dwarf2_macro_malformed_definition_complaint (body
);
7449 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7450 char *comp_dir
, bfd
*abfd
,
7451 const struct comp_unit_head
*cu_header
,
7452 struct objfile
*objfile
)
7454 char *mac_ptr
, *mac_end
;
7455 struct macro_source_file
*current_file
= 0;
7457 if (dwarf_macinfo_buffer
== NULL
)
7459 complaint (&symfile_complaints
, "missing .debug_macinfo section");
7463 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7464 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7468 enum dwarf_macinfo_record_type macinfo_type
;
7470 /* Do we at least have room for a macinfo type byte? */
7471 if (mac_ptr
>= mac_end
)
7473 dwarf2_macros_too_long_complaint ();
7477 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7480 switch (macinfo_type
)
7482 /* A zero macinfo type indicates the end of the macro
7487 case DW_MACINFO_define
:
7488 case DW_MACINFO_undef
:
7494 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7495 mac_ptr
+= bytes_read
;
7496 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7497 mac_ptr
+= bytes_read
;
7500 complaint (&symfile_complaints
,
7501 "debug info gives macro %s outside of any file: %s",
7503 DW_MACINFO_define
? "definition" : macinfo_type
==
7504 DW_MACINFO_undef
? "undefinition" :
7505 "something-or-other", body
);
7508 if (macinfo_type
== DW_MACINFO_define
)
7509 parse_macro_definition (current_file
, line
, body
);
7510 else if (macinfo_type
== DW_MACINFO_undef
)
7511 macro_undef (current_file
, line
, body
);
7516 case DW_MACINFO_start_file
:
7521 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7522 mac_ptr
+= bytes_read
;
7523 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7524 mac_ptr
+= bytes_read
;
7526 current_file
= macro_start_file (file
, line
,
7527 current_file
, comp_dir
,
7532 case DW_MACINFO_end_file
:
7534 complaint (&symfile_complaints
,
7535 "macro debug info has an unmatched `close_file' directive");
7538 current_file
= current_file
->included_by
;
7541 enum dwarf_macinfo_record_type next_type
;
7543 /* GCC circa March 2002 doesn't produce the zero
7544 type byte marking the end of the compilation
7545 unit. Complain if it's not there, but exit no
7548 /* Do we at least have room for a macinfo type byte? */
7549 if (mac_ptr
>= mac_end
)
7551 dwarf2_macros_too_long_complaint ();
7555 /* We don't increment mac_ptr here, so this is just
7557 next_type
= read_1_byte (abfd
, mac_ptr
);
7559 complaint (&symfile_complaints
,
7560 "no terminating 0-type entry for macros in `.debug_macinfo' section");
7567 case DW_MACINFO_vendor_ext
:
7573 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7574 mac_ptr
+= bytes_read
;
7575 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7576 mac_ptr
+= bytes_read
;
7578 /* We don't recognize any vendor extensions. */
7585 /* Check if the attribute's form is a DW_FORM_block*
7586 if so return true else false. */
7588 attr_form_is_block (struct attribute
*attr
)
7590 return (attr
== NULL
? 0 :
7591 attr
->form
== DW_FORM_block1
7592 || attr
->form
== DW_FORM_block2
7593 || attr
->form
== DW_FORM_block4
7594 || attr
->form
== DW_FORM_block
);
7598 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
7599 const struct comp_unit_head
*cu_header
,
7600 struct objfile
*objfile
)
7602 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
7604 struct dwarf2_loclist_baton
*baton
;
7606 baton
= obstack_alloc (&objfile
->symbol_obstack
,
7607 sizeof (struct dwarf2_loclist_baton
));
7608 baton
->objfile
= objfile
;
7610 /* We don't know how long the location list is, but make sure we
7611 don't run off the edge of the section. */
7612 baton
->size
= dwarf_loc_size
- DW_UNSND (attr
);
7613 baton
->data
= dwarf_loc_buffer
+ DW_UNSND (attr
);
7614 baton
->base_address
= cu_header
->base_address
;
7615 if (cu_header
->base_known
== 0)
7616 complaint (&symfile_complaints
,
7617 "Location list used without specifying the CU base address.");
7619 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_loclist_funcs
;
7620 SYMBOL_LOCATION_BATON (sym
) = baton
;
7624 struct dwarf2_locexpr_baton
*baton
;
7626 baton
= obstack_alloc (&objfile
->symbol_obstack
,
7627 sizeof (struct dwarf2_locexpr_baton
));
7628 baton
->objfile
= objfile
;
7630 if (attr_form_is_block (attr
))
7632 /* Note that we're just copying the block's data pointer
7633 here, not the actual data. We're still pointing into the
7634 dwarf_info_buffer for SYM's objfile; right now we never
7635 release that buffer, but when we do clean up properly
7636 this may need to change. */
7637 baton
->size
= DW_BLOCK (attr
)->size
;
7638 baton
->data
= DW_BLOCK (attr
)->data
;
7642 dwarf2_invalid_attrib_class_complaint ("location description",
7643 SYMBOL_NATURAL_NAME (sym
));
7648 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_locexpr_funcs
;
7649 SYMBOL_LOCATION_BATON (sym
) = baton
;