1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
10 support in dwarfread.c
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or (at
17 your option) any later version.
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330,
27 Boston, MA 02111-1307, USA. */
35 #include "elf/dwarf2.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
42 #include "complaints.h"
44 #include "dwarf2expr.h"
45 #include "dwarf2loc.h"
46 #include "cp-support.h"
49 #include "gdb_string.h"
50 #include "gdb_assert.h"
51 #include <sys/types.h>
53 #ifndef DWARF2_REG_TO_REGNUM
54 #define DWARF2_REG_TO_REGNUM(REG) (REG)
58 /* .debug_info header for a compilation unit
59 Because of alignment constraints, this structure has padding and cannot
60 be mapped directly onto the beginning of the .debug_info section. */
61 typedef struct comp_unit_header
63 unsigned int length
; /* length of the .debug_info
65 unsigned short version
; /* version number -- 2 for DWARF
67 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
68 unsigned char addr_size
; /* byte size of an address -- 4 */
71 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
74 /* .debug_pubnames header
75 Because of alignment constraints, this structure has padding and cannot
76 be mapped directly onto the beginning of the .debug_info section. */
77 typedef struct pubnames_header
79 unsigned int length
; /* length of the .debug_pubnames
81 unsigned char version
; /* version number -- 2 for DWARF
83 unsigned int info_offset
; /* offset into .debug_info section */
84 unsigned int info_size
; /* byte size of .debug_info section
88 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
90 /* .debug_pubnames header
91 Because of alignment constraints, this structure has padding and cannot
92 be mapped directly onto the beginning of the .debug_info section. */
93 typedef struct aranges_header
95 unsigned int length
; /* byte len of the .debug_aranges
97 unsigned short version
; /* version number -- 2 for DWARF
99 unsigned int info_offset
; /* offset into .debug_info section */
100 unsigned char addr_size
; /* byte size of an address */
101 unsigned char seg_size
; /* byte size of segment descriptor */
104 #define _ACTUAL_ARANGES_HEADER_SIZE 12
106 /* .debug_line statement program prologue
107 Because of alignment constraints, this structure has padding and cannot
108 be mapped directly onto the beginning of the .debug_info section. */
109 typedef struct statement_prologue
111 unsigned int total_length
; /* byte length of the statement
113 unsigned short version
; /* version number -- 2 for DWARF
115 unsigned int prologue_length
; /* # bytes between prologue &
117 unsigned char minimum_instruction_length
; /* byte size of
119 unsigned char default_is_stmt
; /* initial value of is_stmt
122 unsigned char line_range
;
123 unsigned char opcode_base
; /* number assigned to first special
125 unsigned char *standard_opcode_lengths
;
129 /* offsets and sizes of debugging sections */
131 static file_ptr dwarf_info_offset
;
132 static file_ptr dwarf_abbrev_offset
;
133 static file_ptr dwarf_line_offset
;
134 static file_ptr dwarf_pubnames_offset
;
135 static file_ptr dwarf_aranges_offset
;
136 static file_ptr dwarf_loc_offset
;
137 static file_ptr dwarf_macinfo_offset
;
138 static file_ptr dwarf_str_offset
;
139 static file_ptr dwarf_ranges_offset
;
140 file_ptr dwarf_frame_offset
;
141 file_ptr dwarf_eh_frame_offset
;
143 static unsigned int dwarf_info_size
;
144 static unsigned int dwarf_abbrev_size
;
145 static unsigned int dwarf_line_size
;
146 static unsigned int dwarf_pubnames_size
;
147 static unsigned int dwarf_aranges_size
;
148 static unsigned int dwarf_loc_size
;
149 static unsigned int dwarf_macinfo_size
;
150 static unsigned int dwarf_str_size
;
151 static unsigned int dwarf_ranges_size
;
152 unsigned int dwarf_frame_size
;
153 unsigned int dwarf_eh_frame_size
;
155 static asection
*dwarf_info_section
;
156 static asection
*dwarf_abbrev_section
;
157 static asection
*dwarf_line_section
;
158 static asection
*dwarf_pubnames_section
;
159 static asection
*dwarf_aranges_section
;
160 static asection
*dwarf_loc_section
;
161 static asection
*dwarf_macinfo_section
;
162 static asection
*dwarf_str_section
;
163 static asection
*dwarf_ranges_section
;
164 asection
*dwarf_frame_section
;
165 asection
*dwarf_eh_frame_section
;
167 /* names of the debugging sections */
169 #define INFO_SECTION ".debug_info"
170 #define ABBREV_SECTION ".debug_abbrev"
171 #define LINE_SECTION ".debug_line"
172 #define PUBNAMES_SECTION ".debug_pubnames"
173 #define ARANGES_SECTION ".debug_aranges"
174 #define LOC_SECTION ".debug_loc"
175 #define MACINFO_SECTION ".debug_macinfo"
176 #define STR_SECTION ".debug_str"
177 #define RANGES_SECTION ".debug_ranges"
178 #define FRAME_SECTION ".debug_frame"
179 #define EH_FRAME_SECTION ".eh_frame"
181 /* local data types */
183 /* We hold several abbreviation tables in memory at the same time. */
184 #ifndef ABBREV_HASH_SIZE
185 #define ABBREV_HASH_SIZE 121
188 /* The data in a compilation unit header, after target2host
189 translation, looks like this. */
190 struct comp_unit_head
192 unsigned long length
;
194 unsigned int abbrev_offset
;
195 unsigned char addr_size
;
196 unsigned char signed_addr_p
;
197 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
198 unsigned int initial_length_size
; /* size of the length field; either
201 /* Offset to the first byte of this compilation unit header in the
202 * .debug_info section, for resolving relative reference dies. */
206 /* Pointer to this compilation unit header in the .debug_info
211 /* Pointer to the first die of this compilatio unit. This will
212 * be the first byte following the compilation unit header. */
216 /* Pointer to the next compilation unit header in the program. */
218 struct comp_unit_head
*next
;
220 /* DWARF abbreviation table associated with this compilation unit */
222 struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
224 /* Base address of this compilation unit. */
226 CORE_ADDR base_address
;
228 /* Non-zero if base_address has been set. */
233 /* Internal state when decoding a particular compilation unit. */
236 /* The objfile containing this compilation unit. */
237 struct objfile
*objfile
;
239 /* The header of the compilation unit.
241 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
242 should be moved to the dwarf2_cu structure; for instance the abbrevs
244 struct comp_unit_head header
;
247 /* The line number information for a compilation unit (found in the
248 .debug_line section) begins with a "statement program header",
249 which contains the following information. */
252 unsigned int total_length
;
253 unsigned short version
;
254 unsigned int header_length
;
255 unsigned char minimum_instruction_length
;
256 unsigned char default_is_stmt
;
258 unsigned char line_range
;
259 unsigned char opcode_base
;
261 /* standard_opcode_lengths[i] is the number of operands for the
262 standard opcode whose value is i. This means that
263 standard_opcode_lengths[0] is unused, and the last meaningful
264 element is standard_opcode_lengths[opcode_base - 1]. */
265 unsigned char *standard_opcode_lengths
;
267 /* The include_directories table. NOTE! These strings are not
268 allocated with xmalloc; instead, they are pointers into
269 debug_line_buffer. If you try to free them, `free' will get
271 unsigned int num_include_dirs
, include_dirs_size
;
274 /* The file_names table. NOTE! These strings are not allocated
275 with xmalloc; instead, they are pointers into debug_line_buffer.
276 Don't try to free them directly. */
277 unsigned int num_file_names
, file_names_size
;
281 unsigned int dir_index
;
282 unsigned int mod_time
;
286 /* The start and end of the statement program following this
287 header. These point into dwarf_line_buffer. */
288 char *statement_program_start
, *statement_program_end
;
291 /* When we construct a partial symbol table entry we only
292 need this much information. */
293 struct partial_die_info
296 unsigned char has_children
;
297 unsigned char is_external
;
298 unsigned char is_declaration
;
299 unsigned char has_type
;
306 struct dwarf_block
*locdesc
;
307 unsigned int language
;
311 /* This data structure holds the information of an abbrev. */
314 unsigned int number
; /* number identifying abbrev */
315 enum dwarf_tag tag
; /* dwarf tag */
316 int has_children
; /* boolean */
317 unsigned int num_attrs
; /* number of attributes */
318 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
319 struct abbrev_info
*next
; /* next in chain */
324 enum dwarf_attribute name
;
325 enum dwarf_form form
;
328 /* This data structure holds a complete die structure. */
331 enum dwarf_tag tag
; /* Tag indicating type of die */
332 unsigned int abbrev
; /* Abbrev number */
333 unsigned int offset
; /* Offset in .debug_info section */
334 unsigned int num_attrs
; /* Number of attributes */
335 struct attribute
*attrs
; /* An array of attributes */
336 struct die_info
*next_ref
; /* Next die in ref hash table */
338 /* The dies in a compilation unit form an n-ary tree. PARENT
339 points to this die's parent; CHILD points to the first child of
340 this node; and all the children of a given node are chained
341 together via their SIBLING fields, terminated by a die whose
343 struct die_info
*child
; /* Its first child, if any. */
344 struct die_info
*sibling
; /* Its next sibling, if any. */
345 struct die_info
*parent
; /* Its parent, if any. */
347 struct type
*type
; /* Cached type information */
350 /* Attributes have a name and a value */
353 enum dwarf_attribute name
;
354 enum dwarf_form form
;
358 struct dwarf_block
*blk
;
366 struct function_range
369 CORE_ADDR lowpc
, highpc
;
371 struct function_range
*next
;
374 static struct function_range
*cu_first_fn
, *cu_last_fn
, *cu_cached_fn
;
376 /* Get at parts of an attribute structure */
378 #define DW_STRING(attr) ((attr)->u.str)
379 #define DW_UNSND(attr) ((attr)->u.unsnd)
380 #define DW_BLOCK(attr) ((attr)->u.blk)
381 #define DW_SND(attr) ((attr)->u.snd)
382 #define DW_ADDR(attr) ((attr)->u.addr)
384 /* Blocks are a bunch of untyped bytes. */
391 #ifndef ATTR_ALLOC_CHUNK
392 #define ATTR_ALLOC_CHUNK 4
395 /* A hash table of die offsets for following references. */
396 #ifndef REF_HASH_SIZE
397 #define REF_HASH_SIZE 1021
400 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
402 /* Obstack for allocating temporary storage used during symbol reading. */
403 static struct obstack dwarf2_tmp_obstack
;
405 /* Offset to the first byte of the current compilation unit header,
406 for resolving relative reference dies. */
407 static unsigned int cu_header_offset
;
409 /* Allocate fields for structs, unions and enums in this size. */
410 #ifndef DW_FIELD_ALLOC_CHUNK
411 #define DW_FIELD_ALLOC_CHUNK 4
414 /* The language we are debugging. */
415 static enum language cu_language
;
416 static const struct language_defn
*cu_language_defn
;
418 /* Actually data from the sections. */
419 static char *dwarf_info_buffer
;
420 static char *dwarf_abbrev_buffer
;
421 static char *dwarf_line_buffer
;
422 static char *dwarf_str_buffer
;
423 static char *dwarf_macinfo_buffer
;
424 static char *dwarf_ranges_buffer
;
425 static char *dwarf_loc_buffer
;
427 /* A zeroed version of a partial die for initialization purposes. */
428 static struct partial_die_info zeroed_partial_die
;
430 /* The generic symbol table building routines have separate lists for
431 file scope symbols and all all other scopes (local scopes). So
432 we need to select the right one to pass to add_symbol_to_list().
433 We do it by keeping a pointer to the correct list in list_in_scope.
435 FIXME: The original dwarf code just treated the file scope as the first
436 local scope, and all other local scopes as nested local scopes, and worked
437 fine. Check to see if we really need to distinguish these
439 static struct pending
**list_in_scope
= &file_symbols
;
441 /* FIXME: decode_locdesc sets these variables to describe the location
442 to the caller. These ought to be a structure or something. If
443 none of the flags are set, the object lives at the address returned
444 by decode_locdesc. */
446 static int isreg
; /* Object lives in register.
447 decode_locdesc's return value is
448 the register number. */
449 static int offreg
; /* Object's address is the sum of the
450 register specified by basereg, plus
451 the offset returned. */
452 static int basereg
; /* See `offreg'. */
453 static int isderef
; /* Value described by flags above is
454 the address of a pointer to the object. */
456 /* DW_AT_frame_base values for the current function.
457 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
458 contains the register number for the frame register.
459 frame_base_offset is the offset from the frame register to the
460 virtual stack frame. */
461 static int frame_base_reg
;
462 static CORE_ADDR frame_base_offset
;
464 /* This value is added to each symbol value. FIXME: Generalize to
465 the section_offsets structure used by dbxread (once this is done,
466 pass the appropriate section number to end_symtab). */
467 static CORE_ADDR baseaddr
; /* Add to each symbol value */
469 /* We put a pointer to this structure in the read_symtab_private field
471 The complete dwarf information for an objfile is kept in the
472 psymbol_obstack, so that absolute die references can be handled.
473 Most of the information in this structure is related to an entire
474 object file and could be passed via the sym_private field of the objfile.
475 It is however conceivable that dwarf2 might not be the only type
476 of symbols read from an object file. */
480 /* Pointer to start of dwarf info buffer for the objfile. */
482 char *dwarf_info_buffer
;
484 /* Offset in dwarf_info_buffer for this compilation unit. */
486 unsigned long dwarf_info_offset
;
488 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
490 char *dwarf_abbrev_buffer
;
492 /* Size of dwarf abbreviation section for the objfile. */
494 unsigned int dwarf_abbrev_size
;
496 /* Pointer to start of dwarf line buffer for the objfile. */
498 char *dwarf_line_buffer
;
500 /* Size of dwarf_line_buffer, in bytes. */
502 unsigned int dwarf_line_size
;
504 /* Pointer to start of dwarf string buffer for the objfile. */
506 char *dwarf_str_buffer
;
508 /* Size of dwarf string section for the objfile. */
510 unsigned int dwarf_str_size
;
512 /* Pointer to start of dwarf macro buffer for the objfile. */
514 char *dwarf_macinfo_buffer
;
516 /* Size of dwarf macinfo section for the objfile. */
518 unsigned int dwarf_macinfo_size
;
520 /* Pointer to start of dwarf ranges buffer for the objfile. */
522 char *dwarf_ranges_buffer
;
524 /* Size of dwarf ranges buffer for the objfile. */
526 unsigned int dwarf_ranges_size
;
528 /* Pointer to start of dwarf locations buffer for the objfile. */
530 char *dwarf_loc_buffer
;
532 /* Size of dwarf locations buffer for the objfile. */
534 unsigned int dwarf_loc_size
;
537 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
538 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
539 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
540 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
541 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
542 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
543 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
544 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
545 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
546 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
547 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
548 #define DWARF_RANGES_BUFFER(p) (PST_PRIVATE(p)->dwarf_ranges_buffer)
549 #define DWARF_RANGES_SIZE(p) (PST_PRIVATE(p)->dwarf_ranges_size)
550 #define DWARF_LOC_BUFFER(p) (PST_PRIVATE(p)->dwarf_loc_buffer)
551 #define DWARF_LOC_SIZE(p) (PST_PRIVATE(p)->dwarf_loc_size)
553 /* Maintain an array of referenced fundamental types for the current
554 compilation unit being read. For DWARF version 1, we have to construct
555 the fundamental types on the fly, since no information about the
556 fundamental types is supplied. Each such fundamental type is created by
557 calling a language dependent routine to create the type, and then a
558 pointer to that type is then placed in the array at the index specified
559 by it's FT_<TYPENAME> value. The array has a fixed size set by the
560 FT_NUM_MEMBERS compile time constant, which is the number of predefined
561 fundamental types gdb knows how to construct. */
562 static struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
564 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
565 but this would require a corresponding change in unpack_field_as_long
567 static int bits_per_byte
= 8;
569 /* The routines that read and process dies for a C struct or C++ class
570 pass lists of data member fields and lists of member function fields
571 in an instance of a field_info structure, as defined below. */
574 /* List of data member and baseclasses fields. */
577 struct nextfield
*next
;
584 /* Number of fields. */
587 /* Number of baseclasses. */
590 /* Set if the accesibility of one of the fields is not public. */
591 int non_public_fields
;
593 /* Member function fields array, entries are allocated in the order they
594 are encountered in the object file. */
597 struct nextfnfield
*next
;
598 struct fn_field fnfield
;
602 /* Member function fieldlist array, contains name of possibly overloaded
603 member function, number of overloaded member functions and a pointer
604 to the head of the member function field chain. */
609 struct nextfnfield
*head
;
613 /* Number of entries in the fnfieldlists array. */
617 /* Various complaints about symbol reading that don't abort the process */
620 dwarf2_non_const_array_bound_ignored_complaint (const char *arg1
)
622 complaint (&symfile_complaints
, "non-constant array bounds form '%s' ignored",
627 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
629 complaint (&symfile_complaints
,
630 "statement list doesn't fit in .debug_line section");
634 dwarf2_complex_location_expr_complaint (void)
636 complaint (&symfile_complaints
, "location expression too complex");
640 dwarf2_unsupported_at_frame_base_complaint (const char *arg1
)
642 complaint (&symfile_complaints
,
643 "unsupported DW_AT_frame_base for function '%s'", arg1
);
647 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
650 complaint (&symfile_complaints
,
651 "const value length mismatch for '%s', got %d, expected %d", arg1
,
656 dwarf2_macros_too_long_complaint (void)
658 complaint (&symfile_complaints
,
659 "macro info runs off end of `.debug_macinfo' section");
663 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
665 complaint (&symfile_complaints
,
666 "macro debug info contains a malformed macro definition:\n`%s'",
671 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
673 complaint (&symfile_complaints
,
674 "invalid attribute class or form for '%s' in '%s'", arg1
, arg2
);
677 /* local function prototypes */
679 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
682 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
685 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
687 static char *scan_partial_symbols (char *, CORE_ADDR
*, CORE_ADDR
*,
689 const char *namespace);
691 static void add_partial_symbol (struct partial_die_info
*, struct dwarf2_cu
*,
692 const char *namespace);
694 static char *add_partial_namespace (struct partial_die_info
*pdi
,
696 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
697 struct dwarf2_cu
*cu
,
698 const char *namespace);
700 static char *add_partial_enumeration (struct partial_die_info
*enum_pdi
,
702 struct dwarf2_cu
*cu
,
703 const char *namespace);
705 static char *locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
708 struct dwarf2_cu
*cu
);
710 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
712 static void psymtab_to_symtab_1 (struct partial_symtab
*);
714 char *dwarf2_read_section (struct objfile
*, file_ptr
, unsigned int,
717 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
719 static void dwarf2_empty_abbrev_table (void *);
721 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
724 static char *read_partial_die (struct partial_die_info
*,
725 bfd
*, char *, struct dwarf2_cu
*);
727 static char *read_full_die (struct die_info
**, bfd
*, char *,
728 struct dwarf2_cu
*, int *);
730 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
731 bfd
*, char *, struct dwarf2_cu
*);
733 static char *read_attribute_value (struct attribute
*, unsigned,
734 bfd
*, char *, struct dwarf2_cu
*);
736 static unsigned int read_1_byte (bfd
*, char *);
738 static int read_1_signed_byte (bfd
*, char *);
740 static unsigned int read_2_bytes (bfd
*, char *);
742 static unsigned int read_4_bytes (bfd
*, char *);
744 static unsigned long read_8_bytes (bfd
*, char *);
746 static CORE_ADDR
read_address (bfd
*, char *ptr
, struct dwarf2_cu
*,
749 static LONGEST
read_initial_length (bfd
*, char *,
750 struct comp_unit_head
*, int *bytes_read
);
752 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
755 static char *read_n_bytes (bfd
*, char *, unsigned int);
757 static char *read_string (bfd
*, char *, unsigned int *);
759 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
762 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
764 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
766 static void set_cu_language (unsigned int);
768 static struct attribute
*dwarf_attr (struct die_info
*, unsigned int);
770 static int die_is_declaration (struct die_info
*);
772 static void free_line_header (struct line_header
*lh
);
774 static struct line_header
*(dwarf_decode_line_header
775 (unsigned int offset
,
776 bfd
*abfd
, struct dwarf2_cu
*cu
));
778 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
781 static void dwarf2_start_subfile (char *, char *);
783 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
786 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
789 static void dwarf2_const_value_data (struct attribute
*attr
,
793 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
795 static struct type
*die_containing_type (struct die_info
*,
799 static struct type
*type_at_offset (unsigned int, struct objfile
*);
802 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
804 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
806 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
808 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
810 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
812 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
814 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
816 static int dwarf2_get_pc_bounds (struct die_info
*,
817 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
819 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
822 static void dwarf2_attach_fields_to_type (struct field_info
*,
823 struct type
*, struct dwarf2_cu
*);
825 static void dwarf2_add_member_fn (struct field_info
*,
826 struct die_info
*, struct type
*,
829 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
830 struct type
*, struct dwarf2_cu
*);
832 static void read_structure_scope (struct die_info
*, struct dwarf2_cu
*);
834 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
836 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
838 static void read_enumeration (struct die_info
*, struct dwarf2_cu
*);
840 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
842 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
844 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
846 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
848 static void read_tag_ptr_to_member_type (struct die_info
*,
851 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
853 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
855 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
857 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
859 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
861 static struct die_info
*read_comp_unit (char *, bfd
*, struct dwarf2_cu
*);
863 static struct die_info
*read_die_and_children (char *info_ptr
, bfd
*abfd
,
866 struct die_info
*parent
);
868 static struct die_info
*read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
871 struct die_info
*parent
);
873 static void free_die_list (struct die_info
*);
875 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
877 static void process_die (struct die_info
*, struct dwarf2_cu
*);
879 static char *dwarf2_linkage_name (struct die_info
*);
881 static char *dwarf2_name (struct die_info
*die
);
883 static struct die_info
*dwarf2_extension (struct die_info
*die
);
885 static char *dwarf_tag_name (unsigned int);
887 static char *dwarf_attr_name (unsigned int);
889 static char *dwarf_form_name (unsigned int);
891 static char *dwarf_stack_op_name (unsigned int);
893 static char *dwarf_bool_name (unsigned int);
895 static char *dwarf_type_encoding_name (unsigned int);
898 static char *dwarf_cfi_name (unsigned int);
900 struct die_info
*copy_die (struct die_info
*);
903 static struct die_info
*sibling_die (struct die_info
*);
905 static void dump_die (struct die_info
*);
907 static void dump_die_list (struct die_info
*);
909 static void store_in_ref_table (unsigned int, struct die_info
*);
911 static void dwarf2_empty_hash_tables (void);
913 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
915 static struct die_info
*follow_die_ref (unsigned int);
917 static struct type
*dwarf2_fundamental_type (struct objfile
*, int);
919 /* memory allocation interface */
921 static void dwarf2_free_tmp_obstack (void *);
923 static struct dwarf_block
*dwarf_alloc_block (void);
925 static struct abbrev_info
*dwarf_alloc_abbrev (void);
927 static struct die_info
*dwarf_alloc_die (void);
929 static void initialize_cu_func_list (void);
931 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
);
933 static void dwarf_decode_macros (struct line_header
*, unsigned int,
934 char *, bfd
*, struct dwarf2_cu
*);
936 static int attr_form_is_block (struct attribute
*);
939 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
940 struct dwarf2_cu
*cu
);
942 /* Try to locate the sections we need for DWARF 2 debugging
943 information and return true if we have enough to do something. */
946 dwarf2_has_info (bfd
*abfd
)
948 dwarf_info_offset
= 0;
949 dwarf_abbrev_offset
= 0;
950 dwarf_line_offset
= 0;
951 dwarf_str_offset
= 0;
952 dwarf_macinfo_offset
= 0;
953 dwarf_frame_offset
= 0;
954 dwarf_eh_frame_offset
= 0;
955 dwarf_ranges_offset
= 0;
956 dwarf_loc_offset
= 0;
958 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
959 if (dwarf_info_offset
&& dwarf_abbrev_offset
)
969 /* This function is mapped across the sections and remembers the
970 offset and size of each of the debugging sections we are interested
974 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
976 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
978 dwarf_info_offset
= sectp
->filepos
;
979 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
980 dwarf_info_section
= sectp
;
982 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
984 dwarf_abbrev_offset
= sectp
->filepos
;
985 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
986 dwarf_abbrev_section
= sectp
;
988 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
990 dwarf_line_offset
= sectp
->filepos
;
991 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
992 dwarf_line_section
= sectp
;
994 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
996 dwarf_pubnames_offset
= sectp
->filepos
;
997 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
998 dwarf_pubnames_section
= sectp
;
1000 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1002 dwarf_aranges_offset
= sectp
->filepos
;
1003 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
1004 dwarf_aranges_section
= sectp
;
1006 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1008 dwarf_loc_offset
= sectp
->filepos
;
1009 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
1010 dwarf_loc_section
= sectp
;
1012 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1014 dwarf_macinfo_offset
= sectp
->filepos
;
1015 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
1016 dwarf_macinfo_section
= sectp
;
1018 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1020 dwarf_str_offset
= sectp
->filepos
;
1021 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
1022 dwarf_str_section
= sectp
;
1024 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1026 dwarf_frame_offset
= sectp
->filepos
;
1027 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1028 dwarf_frame_section
= sectp
;
1030 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1032 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1033 if (aflag
& SEC_HAS_CONTENTS
)
1035 dwarf_eh_frame_offset
= sectp
->filepos
;
1036 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1037 dwarf_eh_frame_section
= sectp
;
1040 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1042 dwarf_ranges_offset
= sectp
->filepos
;
1043 dwarf_ranges_size
= bfd_get_section_size_before_reloc (sectp
);
1044 dwarf_ranges_section
= sectp
;
1048 /* Build a partial symbol table. */
1051 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1054 /* We definitely need the .debug_info and .debug_abbrev sections */
1056 dwarf_info_buffer
= dwarf2_read_section (objfile
,
1059 dwarf_info_section
);
1060 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
,
1061 dwarf_abbrev_offset
,
1063 dwarf_abbrev_section
);
1065 if (dwarf_line_offset
)
1066 dwarf_line_buffer
= dwarf2_read_section (objfile
,
1069 dwarf_line_section
);
1071 dwarf_line_buffer
= NULL
;
1073 if (dwarf_str_offset
)
1074 dwarf_str_buffer
= dwarf2_read_section (objfile
,
1079 dwarf_str_buffer
= NULL
;
1081 if (dwarf_macinfo_offset
)
1082 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1083 dwarf_macinfo_offset
,
1085 dwarf_macinfo_section
);
1087 dwarf_macinfo_buffer
= NULL
;
1089 if (dwarf_ranges_offset
)
1090 dwarf_ranges_buffer
= dwarf2_read_section (objfile
,
1091 dwarf_ranges_offset
,
1093 dwarf_ranges_section
);
1095 dwarf_ranges_buffer
= NULL
;
1097 if (dwarf_loc_offset
)
1098 dwarf_loc_buffer
= dwarf2_read_section (objfile
,
1103 dwarf_loc_buffer
= NULL
;
1106 || (objfile
->global_psymbols
.size
== 0
1107 && objfile
->static_psymbols
.size
== 0))
1109 init_psymbol_list (objfile
, 1024);
1113 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1115 /* Things are significantly easier if we have .debug_aranges and
1116 .debug_pubnames sections */
1118 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1122 /* only test this case for now */
1124 /* In this case we have to work a bit harder */
1125 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1130 /* Build the partial symbol table from the information in the
1131 .debug_pubnames and .debug_aranges sections. */
1134 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1136 bfd
*abfd
= objfile
->obfd
;
1137 char *aranges_buffer
, *pubnames_buffer
;
1138 char *aranges_ptr
, *pubnames_ptr
;
1139 unsigned int entry_length
, version
, info_offset
, info_size
;
1141 pubnames_buffer
= dwarf2_read_section (objfile
,
1142 dwarf_pubnames_offset
,
1143 dwarf_pubnames_size
,
1144 dwarf_pubnames_section
);
1145 pubnames_ptr
= pubnames_buffer
;
1146 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1148 struct comp_unit_head cu_header
;
1151 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1153 pubnames_ptr
+= bytes_read
;
1154 version
= read_1_byte (abfd
, pubnames_ptr
);
1156 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1158 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1162 aranges_buffer
= dwarf2_read_section (objfile
,
1163 dwarf_aranges_offset
,
1165 dwarf_aranges_section
);
1170 /* Read in the comp unit header information from the debug_info at
1174 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1175 char *info_ptr
, bfd
*abfd
)
1179 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1181 info_ptr
+= bytes_read
;
1182 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1184 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1186 info_ptr
+= bytes_read
;
1187 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1189 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1190 if (signed_addr
< 0)
1191 internal_error (__FILE__
, __LINE__
,
1192 "read_comp_unit_head: dwarf from non elf file");
1193 cu_header
->signed_addr_p
= signed_addr
;
1197 /* Build the partial symbol table by doing a quick pass through the
1198 .debug_info and .debug_abbrev sections. */
1201 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1203 /* Instead of reading this into a big buffer, we should probably use
1204 mmap() on architectures that support it. (FIXME) */
1205 bfd
*abfd
= objfile
->obfd
;
1206 char *info_ptr
, *abbrev_ptr
;
1207 char *beg_of_comp_unit
;
1208 struct partial_die_info comp_unit_die
;
1209 struct partial_symtab
*pst
;
1210 struct cleanup
*back_to
;
1211 CORE_ADDR lowpc
, highpc
;
1213 info_ptr
= dwarf_info_buffer
;
1214 abbrev_ptr
= dwarf_abbrev_buffer
;
1216 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1217 the partial symbol scan, like attribute values.
1219 We could reduce our peak memory consumption during partial symbol
1220 table construction by freeing stuff from this obstack more often
1221 --- say, after processing each compilation unit, or each die ---
1222 but it turns out that this saves almost nothing. For an
1223 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1224 on dwarf2_tmp_obstack. Some investigation showed:
1226 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1227 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1228 all fixed-length values not requiring dynamic allocation.
1230 2) 30% of the attributes used the form DW_FORM_string. For
1231 DW_FORM_string, read_attribute simply hands back a pointer to
1232 the null-terminated string in dwarf_info_buffer, so no dynamic
1233 allocation is needed there either.
1235 3) The remaining 1% of the attributes all used DW_FORM_block1.
1236 75% of those were DW_AT_frame_base location lists for
1237 functions; the rest were DW_AT_location attributes, probably
1238 for the global variables.
1240 Anyway, what this all means is that the memory the dwarf2
1241 reader uses as temporary space reading partial symbols is about
1242 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1244 obstack_init (&dwarf2_tmp_obstack
);
1245 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1247 /* Since the objects we're extracting from dwarf_info_buffer vary in
1248 length, only the individual functions to extract them (like
1249 read_comp_unit_head and read_partial_die) can really know whether
1250 the buffer is large enough to hold another complete object.
1252 At the moment, they don't actually check that. If
1253 dwarf_info_buffer holds just one extra byte after the last
1254 compilation unit's dies, then read_comp_unit_head will happily
1255 read off the end of the buffer. read_partial_die is similarly
1256 casual. Those functions should be fixed.
1258 For this loop condition, simply checking whether there's any data
1259 left at all should be sufficient. */
1260 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1262 struct dwarf2_cu cu
;
1263 beg_of_comp_unit
= info_ptr
;
1265 cu
.objfile
= objfile
;
1266 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1268 if (cu
.header
.version
!= 2)
1270 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
));
1273 if (cu
.header
.abbrev_offset
>= dwarf_abbrev_size
)
1275 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1276 (long) cu
.header
.abbrev_offset
,
1277 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1278 bfd_get_filename (abfd
));
1281 if (beg_of_comp_unit
+ cu
.header
.length
+ cu
.header
.initial_length_size
1282 > dwarf_info_buffer
+ dwarf_info_size
)
1284 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1285 (long) cu
.header
.length
,
1286 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1287 bfd_get_filename (abfd
));
1290 /* Complete the cu_header */
1291 cu
.header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1292 cu
.header
.first_die_ptr
= info_ptr
;
1293 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1295 /* Read the abbrevs for this compilation unit into a table */
1296 dwarf2_read_abbrevs (abfd
, &cu
);
1297 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1299 /* Read the compilation unit die */
1300 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1303 /* Set the language we're debugging */
1304 set_cu_language (comp_unit_die
.language
);
1306 /* Allocate a new partial symbol table structure */
1307 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1308 comp_unit_die
.name
? comp_unit_die
.name
: "",
1309 comp_unit_die
.lowpc
,
1310 objfile
->global_psymbols
.next
,
1311 objfile
->static_psymbols
.next
);
1313 pst
->read_symtab_private
= (char *)
1314 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct dwarf2_pinfo
));
1315 cu_header_offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1316 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1317 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1318 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1319 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1320 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1321 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1322 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1323 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1324 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1325 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1326 DWARF_RANGES_BUFFER (pst
) = dwarf_ranges_buffer
;
1327 DWARF_RANGES_SIZE (pst
) = dwarf_ranges_size
;
1328 DWARF_LOC_BUFFER (pst
) = dwarf_loc_buffer
;
1329 DWARF_LOC_SIZE (pst
) = dwarf_loc_size
;
1330 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1332 /* Store the function that reads in the rest of the symbol table */
1333 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1335 /* Check if comp unit has_children.
1336 If so, read the rest of the partial symbols from this comp unit.
1337 If not, there's no more debug_info for this comp unit. */
1338 if (comp_unit_die
.has_children
)
1340 lowpc
= ((CORE_ADDR
) -1);
1341 highpc
= ((CORE_ADDR
) 0);
1343 info_ptr
= scan_partial_symbols (info_ptr
, &lowpc
, &highpc
,
1346 /* If we didn't find a lowpc, set it to highpc to avoid
1347 complaints from `maint check'. */
1348 if (lowpc
== ((CORE_ADDR
) -1))
1351 /* If the compilation unit didn't have an explicit address range,
1352 then use the information extracted from its child dies. */
1353 if (! comp_unit_die
.has_pc_info
)
1355 comp_unit_die
.lowpc
= lowpc
;
1356 comp_unit_die
.highpc
= highpc
;
1359 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1360 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1362 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1363 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1364 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1365 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1366 sort_pst_symbols (pst
);
1368 /* If there is already a psymtab or symtab for a file of this
1369 name, remove it. (If there is a symtab, more drastic things
1370 also happen.) This happens in VxWorks. */
1371 free_named_symtabs (pst
->filename
);
1373 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1374 + cu
.header
.initial_length_size
;
1376 do_cleanups (back_to
);
1379 /* Read in all interesting dies to the end of the compilation unit or
1380 to the end of the current namespace. NAMESPACE is NULL if we
1381 haven't yet encountered any DW_TAG_namespace entries; otherwise,
1382 it's the name of the current namespace. In particular, it's the
1383 empty string if we're currently in the global namespace but have
1384 previously encountered a DW_TAG_namespace. */
1387 scan_partial_symbols (char *info_ptr
, CORE_ADDR
*lowpc
,
1388 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
1389 const char *namespace)
1391 struct objfile
*objfile
= cu
->objfile
;
1392 bfd
*abfd
= objfile
->obfd
;
1393 struct partial_die_info pdi
;
1395 /* Now, march along the PDI's, descending into ones which have
1396 interesting children but skipping the children of the other ones,
1397 until we reach the end of the compilation unit. */
1401 /* This flag tells whether or not info_ptr has gotten updated
1403 int info_ptr_updated
= 0;
1405 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1407 /* Anonymous namespaces have no name but have interesting
1408 children, so we need to look at them. Ditto for anonymous
1411 if (pdi
.name
!= NULL
|| pdi
.tag
== DW_TAG_namespace
1412 || pdi
.tag
== DW_TAG_enumeration_type
)
1416 case DW_TAG_subprogram
:
1417 if (pdi
.has_pc_info
)
1419 if (pdi
.lowpc
< *lowpc
)
1423 if (pdi
.highpc
> *highpc
)
1425 *highpc
= pdi
.highpc
;
1427 if (!pdi
.is_declaration
)
1429 add_partial_symbol (&pdi
, cu
, namespace);
1433 case DW_TAG_variable
:
1434 case DW_TAG_typedef
:
1435 case DW_TAG_union_type
:
1436 case DW_TAG_class_type
:
1437 case DW_TAG_structure_type
:
1438 if (!pdi
.is_declaration
)
1440 add_partial_symbol (&pdi
, cu
, namespace);
1443 case DW_TAG_enumeration_type
:
1444 if (!pdi
.is_declaration
)
1446 info_ptr
= add_partial_enumeration (&pdi
, info_ptr
, cu
,
1448 info_ptr_updated
= 1;
1451 case DW_TAG_base_type
:
1452 /* File scope base type definitions are added to the partial
1454 add_partial_symbol (&pdi
, cu
, namespace);
1456 case DW_TAG_namespace
:
1457 /* We've hit a DW_TAG_namespace entry, so we know this
1458 file has been compiled using a compiler that
1459 generates them; update NAMESPACE to reflect that. */
1460 if (namespace == NULL
)
1462 info_ptr
= add_partial_namespace (&pdi
, info_ptr
, lowpc
, highpc
,
1464 info_ptr_updated
= 1;
1474 /* If the die has a sibling, skip to the sibling, unless another
1475 function has already updated info_ptr for us. */
1477 /* NOTE: carlton/2003-06-16: This is a bit hackish, but whether
1478 or not we want to update this depends on enough stuff (not
1479 only pdi.tag but also whether or not pdi.name is NULL) that
1480 this seems like the easiest way to handle the issue. */
1482 if (!info_ptr_updated
)
1483 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1490 add_partial_symbol (struct partial_die_info
*pdi
,
1491 struct dwarf2_cu
*cu
, const char *namespace)
1493 struct objfile
*objfile
= cu
->objfile
;
1495 const struct partial_symbol
*psym
= NULL
;
1499 case DW_TAG_subprogram
:
1500 if (pdi
->is_external
)
1502 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1503 mst_text, objfile); */
1504 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1505 VAR_DOMAIN
, LOC_BLOCK
,
1506 &objfile
->global_psymbols
,
1507 0, pdi
->lowpc
+ baseaddr
,
1508 cu_language
, objfile
);
1512 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1513 mst_file_text, objfile); */
1514 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1515 VAR_DOMAIN
, LOC_BLOCK
,
1516 &objfile
->static_psymbols
,
1517 0, pdi
->lowpc
+ baseaddr
,
1518 cu_language
, objfile
);
1521 case DW_TAG_variable
:
1522 if (pdi
->is_external
)
1525 Don't enter into the minimal symbol tables as there is
1526 a minimal symbol table entry from the ELF symbols already.
1527 Enter into partial symbol table if it has a location
1528 descriptor or a type.
1529 If the location descriptor is missing, new_symbol will create
1530 a LOC_UNRESOLVED symbol, the address of the variable will then
1531 be determined from the minimal symbol table whenever the variable
1533 The address for the partial symbol table entry is not
1534 used by GDB, but it comes in handy for debugging partial symbol
1538 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1539 if (pdi
->locdesc
|| pdi
->has_type
)
1540 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1541 VAR_DOMAIN
, LOC_STATIC
,
1542 &objfile
->global_psymbols
,
1544 cu_language
, objfile
);
1548 /* Static Variable. Skip symbols without location descriptors. */
1549 if (pdi
->locdesc
== NULL
)
1551 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1552 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1553 mst_file_data, objfile); */
1554 psym
= add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1555 VAR_DOMAIN
, LOC_STATIC
,
1556 &objfile
->static_psymbols
,
1558 cu_language
, objfile
);
1561 case DW_TAG_typedef
:
1562 case DW_TAG_base_type
:
1563 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1564 VAR_DOMAIN
, LOC_TYPEDEF
,
1565 &objfile
->static_psymbols
,
1566 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1568 case DW_TAG_class_type
:
1569 case DW_TAG_structure_type
:
1570 case DW_TAG_union_type
:
1571 case DW_TAG_enumeration_type
:
1572 /* Skip aggregate types without children, these are external
1574 if (pdi
->has_children
== 0)
1576 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1577 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1578 &objfile
->static_psymbols
,
1579 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1581 if (cu_language
== language_cplus
)
1583 /* For C++, these implicitly act as typedefs as well. */
1584 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1585 VAR_DOMAIN
, LOC_TYPEDEF
,
1586 &objfile
->static_psymbols
,
1587 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1590 case DW_TAG_enumerator
:
1591 add_psymbol_to_list (pdi
->name
, strlen (pdi
->name
),
1592 VAR_DOMAIN
, LOC_CONST
,
1593 &objfile
->static_psymbols
,
1594 0, (CORE_ADDR
) 0, cu_language
, objfile
);
1600 /* Check to see if we should scan the name for possible namespace
1601 info. Only do this if this is C++, if we don't have namespace
1602 debugging info in the file, if the psym is of an appropriate type
1603 (otherwise we'll have psym == NULL), and if we actually had a
1604 mangled name to begin with. */
1606 if (cu_language
== language_cplus
1607 && namespace == NULL
1609 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
1610 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
1614 /* Read a partial die corresponding to a namespace; also, add a symbol
1615 corresponding to that namespace to the symbol table. NAMESPACE is
1616 the name of the enclosing namespace. */
1619 add_partial_namespace (struct partial_die_info
*pdi
, char *info_ptr
,
1620 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1621 struct dwarf2_cu
*cu
, const char *namespace)
1623 struct objfile
*objfile
= cu
->objfile
;
1624 const char *new_name
= pdi
->name
;
1627 /* Calculate the full name of the namespace that we just entered. */
1629 if (new_name
== NULL
)
1630 new_name
= "(anonymous namespace)";
1631 full_name
= alloca (strlen (namespace) + 2 + strlen (new_name
) + 1);
1632 strcpy (full_name
, namespace);
1633 if (*namespace != '\0')
1634 strcat (full_name
, "::");
1635 strcat (full_name
, new_name
);
1637 /* FIXME: carlton/2003-06-27: Once we build qualified names for more
1638 symbols than just namespaces, we should replace this by a call to
1639 add_partial_symbol. */
1641 add_psymbol_to_list (full_name
, strlen (full_name
),
1642 VAR_DOMAIN
, LOC_TYPEDEF
,
1643 &objfile
->global_psymbols
,
1644 0, 0, cu_language
, objfile
);
1646 /* Now scan partial symbols in that namespace. */
1648 if (pdi
->has_children
)
1649 info_ptr
= scan_partial_symbols (info_ptr
, lowpc
, highpc
, cu
, full_name
);
1654 /* Read a partial die corresponding to an enumeration type. */
1657 add_partial_enumeration (struct partial_die_info
*enum_pdi
, char *info_ptr
,
1658 struct dwarf2_cu
*cu
, const char *namespace)
1660 struct objfile
*objfile
= cu
->objfile
;
1661 bfd
*abfd
= objfile
->obfd
;
1662 struct partial_die_info pdi
;
1664 if (enum_pdi
->name
!= NULL
)
1665 add_partial_symbol (enum_pdi
, cu
, namespace);
1669 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1672 if (pdi
.tag
!= DW_TAG_enumerator
|| pdi
.name
== NULL
)
1673 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
1675 add_partial_symbol (&pdi
, cu
, namespace);
1681 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the next DIE
1685 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
1686 bfd
*abfd
, struct dwarf2_cu
*cu
)
1688 /* Do we know the sibling already? */
1690 if (orig_pdi
->sibling
)
1691 return orig_pdi
->sibling
;
1693 /* Are there any children to deal with? */
1695 if (!orig_pdi
->has_children
)
1698 /* Okay, we don't know the sibling, but we have children that we
1699 want to skip. So read children until we run into one without a
1700 tag; return whatever follows it. */
1704 struct partial_die_info pdi
;
1706 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1711 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1715 /* Expand this partial symbol table into a full symbol table. */
1718 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1720 /* FIXME: This is barely more than a stub. */
1725 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1731 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1732 gdb_flush (gdb_stdout
);
1735 psymtab_to_symtab_1 (pst
);
1737 /* Finish up the debug error message. */
1739 printf_filtered ("done.\n");
1745 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1747 struct objfile
*objfile
= pst
->objfile
;
1748 bfd
*abfd
= objfile
->obfd
;
1749 struct dwarf2_cu cu
;
1750 struct die_info
*dies
;
1751 unsigned long offset
;
1752 CORE_ADDR lowpc
, highpc
;
1753 struct die_info
*child_die
;
1755 struct symtab
*symtab
;
1756 struct cleanup
*back_to
;
1757 struct attribute
*attr
;
1759 /* Set local variables from the partial symbol table info. */
1760 offset
= DWARF_INFO_OFFSET (pst
);
1761 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1762 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1763 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1764 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1765 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1766 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1767 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1768 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1769 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1770 dwarf_ranges_buffer
= DWARF_RANGES_BUFFER (pst
);
1771 dwarf_ranges_size
= DWARF_RANGES_SIZE (pst
);
1772 dwarf_loc_buffer
= DWARF_LOC_BUFFER (pst
);
1773 dwarf_loc_size
= DWARF_LOC_SIZE (pst
);
1774 baseaddr
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
1775 cu_header_offset
= offset
;
1776 info_ptr
= dwarf_info_buffer
+ offset
;
1778 obstack_init (&dwarf2_tmp_obstack
);
1779 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1782 make_cleanup (really_free_pendings
, NULL
);
1784 cu
.objfile
= objfile
;
1786 /* read in the comp_unit header */
1787 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1789 /* Read the abbrevs for this compilation unit */
1790 dwarf2_read_abbrevs (abfd
, &cu
);
1791 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1793 dies
= read_comp_unit (info_ptr
, abfd
, &cu
);
1795 make_cleanup_free_die_list (dies
);
1797 /* Find the base address of the compilation unit for range lists and
1798 location lists. It will normally be specified by DW_AT_low_pc.
1799 In DWARF-3 draft 4, the base address could be overridden by
1800 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1801 compilation units with discontinuous ranges. */
1803 cu
.header
.base_known
= 0;
1804 cu
.header
.base_address
= 0;
1806 attr
= dwarf_attr (dies
, DW_AT_entry_pc
);
1809 cu
.header
.base_address
= DW_ADDR (attr
);
1810 cu
.header
.base_known
= 1;
1814 attr
= dwarf_attr (dies
, DW_AT_low_pc
);
1817 cu
.header
.base_address
= DW_ADDR (attr
);
1818 cu
.header
.base_known
= 1;
1822 /* Do line number decoding in read_file_scope () */
1823 process_die (dies
, &cu
);
1825 if (!dwarf2_get_pc_bounds (dies
, &lowpc
, &highpc
, &cu
))
1827 /* Some compilers don't define a DW_AT_high_pc attribute for
1828 the compilation unit. If the DW_AT_high_pc is missing,
1829 synthesize it, by scanning the DIE's below the compilation unit. */
1831 if (dies
->child
!= NULL
)
1833 child_die
= dies
->child
;
1834 while (child_die
&& child_die
->tag
)
1836 if (child_die
->tag
== DW_TAG_subprogram
)
1838 CORE_ADDR low
, high
;
1840 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, &cu
))
1842 highpc
= max (highpc
, high
);
1845 child_die
= sibling_die (child_die
);
1849 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1851 /* Set symtab language to language from DW_AT_language.
1852 If the compilation is from a C file generated by language preprocessors,
1853 do not set the language if it was already deduced by start_subfile. */
1855 && !(cu_language
== language_c
&& symtab
->language
!= language_c
))
1857 symtab
->language
= cu_language
;
1859 pst
->symtab
= symtab
;
1862 do_cleanups (back_to
);
1865 /* Process a die and its children. */
1868 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
1872 case DW_TAG_padding
:
1874 case DW_TAG_compile_unit
:
1875 read_file_scope (die
, cu
);
1877 case DW_TAG_subprogram
:
1878 read_subroutine_type (die
, cu
);
1879 read_func_scope (die
, cu
);
1881 case DW_TAG_inlined_subroutine
:
1882 /* FIXME: These are ignored for now.
1883 They could be used to set breakpoints on all inlined instances
1884 of a function and make GDB `next' properly over inlined functions. */
1886 case DW_TAG_lexical_block
:
1887 case DW_TAG_try_block
:
1888 case DW_TAG_catch_block
:
1889 read_lexical_block_scope (die
, cu
);
1891 case DW_TAG_class_type
:
1892 case DW_TAG_structure_type
:
1893 case DW_TAG_union_type
:
1894 read_structure_scope (die
, cu
);
1896 case DW_TAG_enumeration_type
:
1897 read_enumeration (die
, cu
);
1899 case DW_TAG_subroutine_type
:
1900 read_subroutine_type (die
, cu
);
1902 case DW_TAG_array_type
:
1903 read_array_type (die
, cu
);
1905 case DW_TAG_pointer_type
:
1906 read_tag_pointer_type (die
, cu
);
1908 case DW_TAG_ptr_to_member_type
:
1909 read_tag_ptr_to_member_type (die
, cu
);
1911 case DW_TAG_reference_type
:
1912 read_tag_reference_type (die
, cu
);
1914 case DW_TAG_string_type
:
1915 read_tag_string_type (die
, cu
);
1917 case DW_TAG_base_type
:
1918 read_base_type (die
, cu
);
1919 if (dwarf_attr (die
, DW_AT_name
))
1921 /* Add a typedef symbol for the base type definition. */
1922 new_symbol (die
, die
->type
, cu
);
1925 case DW_TAG_common_block
:
1926 read_common_block (die
, cu
);
1928 case DW_TAG_common_inclusion
:
1930 case DW_TAG_namespace
:
1931 if (!processing_has_namespace_info
)
1933 processing_has_namespace_info
= 1;
1934 processing_current_namespace
= "";
1936 read_namespace (die
, cu
);
1938 case DW_TAG_imported_declaration
:
1939 case DW_TAG_imported_module
:
1940 /* FIXME: carlton/2002-10-16: Eventually, we should use the
1941 information contained in these. DW_TAG_imported_declaration
1942 dies shouldn't have children; DW_TAG_imported_module dies
1943 shouldn't in the C++ case, but conceivably could in the
1944 Fortran case, so we'll have to replace this gdb_assert if
1945 Fortran compilers start generating that info. */
1946 if (!processing_has_namespace_info
)
1948 processing_has_namespace_info
= 1;
1949 processing_current_namespace
= "";
1951 gdb_assert (die
->child
== NULL
);
1954 new_symbol (die
, NULL
, cu
);
1960 initialize_cu_func_list (void)
1962 cu_first_fn
= cu_last_fn
= cu_cached_fn
= NULL
;
1966 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
1968 struct objfile
*objfile
= cu
->objfile
;
1969 struct comp_unit_head
*cu_header
= &cu
->header
;
1970 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1971 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
1972 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
1973 struct attribute
*attr
;
1974 char *name
= "<unknown>";
1975 char *comp_dir
= NULL
;
1976 struct die_info
*child_die
;
1977 bfd
*abfd
= objfile
->obfd
;
1978 struct line_header
*line_header
= 0;
1980 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
1982 if (die
->child
!= NULL
)
1984 child_die
= die
->child
;
1985 while (child_die
&& child_die
->tag
)
1987 if (child_die
->tag
== DW_TAG_subprogram
)
1989 CORE_ADDR low
, high
;
1991 if (dwarf2_get_pc_bounds (child_die
, &low
, &high
, cu
))
1993 lowpc
= min (lowpc
, low
);
1994 highpc
= max (highpc
, high
);
1997 child_die
= sibling_die (child_die
);
2002 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2003 from finish_block. */
2004 if (lowpc
== ((CORE_ADDR
) -1))
2009 attr
= dwarf_attr (die
, DW_AT_name
);
2012 name
= DW_STRING (attr
);
2014 attr
= dwarf_attr (die
, DW_AT_comp_dir
);
2017 comp_dir
= DW_STRING (attr
);
2020 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2021 directory, get rid of it. */
2022 char *cp
= strchr (comp_dir
, ':');
2024 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2029 if (objfile
->ei
.entry_point
>= lowpc
&&
2030 objfile
->ei
.entry_point
< highpc
)
2032 objfile
->ei
.deprecated_entry_file_lowpc
= lowpc
;
2033 objfile
->ei
.deprecated_entry_file_highpc
= highpc
;
2036 attr
= dwarf_attr (die
, DW_AT_language
);
2039 set_cu_language (DW_UNSND (attr
));
2042 /* We assume that we're processing GCC output. */
2043 processing_gcc_compilation
= 2;
2045 /* FIXME:Do something here. */
2046 if (dip
->at_producer
!= NULL
)
2048 handle_producer (dip
->at_producer
);
2052 /* The compilation unit may be in a different language or objfile,
2053 zero out all remembered fundamental types. */
2054 memset (ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2056 start_symtab (name
, comp_dir
, lowpc
);
2057 record_debugformat ("DWARF 2");
2059 initialize_cu_func_list ();
2061 /* Process all dies in compilation unit. */
2062 if (die
->child
!= NULL
)
2064 child_die
= die
->child
;
2065 while (child_die
&& child_die
->tag
)
2067 process_die (child_die
, cu
);
2068 child_die
= sibling_die (child_die
);
2072 /* Decode line number information if present. */
2073 attr
= dwarf_attr (die
, DW_AT_stmt_list
);
2076 unsigned int line_offset
= DW_UNSND (attr
);
2077 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2080 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2081 (void *) line_header
);
2082 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
);
2086 /* Decode macro information, if present. Dwarf 2 macro information
2087 refers to information in the line number info statement program
2088 header, so we can only read it if we've read the header
2090 attr
= dwarf_attr (die
, DW_AT_macro_info
);
2091 if (attr
&& line_header
)
2093 unsigned int macro_offset
= DW_UNSND (attr
);
2094 dwarf_decode_macros (line_header
, macro_offset
,
2095 comp_dir
, abfd
, cu
);
2097 do_cleanups (back_to
);
2101 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
)
2103 struct function_range
*thisfn
;
2105 thisfn
= (struct function_range
*)
2106 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
2107 thisfn
->name
= name
;
2108 thisfn
->lowpc
= lowpc
;
2109 thisfn
->highpc
= highpc
;
2110 thisfn
->seen_line
= 0;
2111 thisfn
->next
= NULL
;
2113 if (cu_last_fn
== NULL
)
2114 cu_first_fn
= thisfn
;
2116 cu_last_fn
->next
= thisfn
;
2118 cu_last_fn
= thisfn
;
2122 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2124 struct objfile
*objfile
= cu
->objfile
;
2125 struct context_stack
*new;
2128 struct die_info
*child_die
;
2129 struct attribute
*attr
;
2132 name
= dwarf2_linkage_name (die
);
2134 /* Ignore functions with missing or empty names and functions with
2135 missing or invalid low and high pc attributes. */
2136 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2142 /* Record the function range for dwarf_decode_lines. */
2143 add_to_cu_func_list (name
, lowpc
, highpc
);
2145 if (objfile
->ei
.entry_point
>= lowpc
&&
2146 objfile
->ei
.entry_point
< highpc
)
2148 objfile
->ei
.entry_func_lowpc
= lowpc
;
2149 objfile
->ei
.entry_func_highpc
= highpc
;
2152 /* Decode DW_AT_frame_base location descriptor if present, keep result
2153 for DW_OP_fbreg operands in decode_locdesc. */
2154 frame_base_reg
= -1;
2155 frame_base_offset
= 0;
2156 attr
= dwarf_attr (die
, DW_AT_frame_base
);
2161 /* Support the .debug_loc offsets */
2162 if (attr_form_is_block (attr
))
2164 addr
= decode_locdesc (DW_BLOCK (attr
), cu
);
2166 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2168 dwarf2_complex_location_expr_complaint ();
2173 dwarf2_invalid_attrib_class_complaint ("DW_AT_frame_base", name
);
2178 dwarf2_unsupported_at_frame_base_complaint (name
);
2180 frame_base_reg
= addr
;
2183 frame_base_reg
= basereg
;
2184 frame_base_offset
= addr
;
2187 dwarf2_unsupported_at_frame_base_complaint (name
);
2190 new = push_context (0, lowpc
);
2191 new->name
= new_symbol (die
, die
->type
, cu
);
2193 /* If there was a location expression for DW_AT_frame_base above,
2194 record it. We still need to decode it above because not all
2195 symbols use location expressions exclusively. */
2197 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2199 list_in_scope
= &local_symbols
;
2201 if (die
->child
!= NULL
)
2203 child_die
= die
->child
;
2204 while (child_die
&& child_die
->tag
)
2206 process_die (child_die
, cu
);
2207 child_die
= sibling_die (child_die
);
2211 new = pop_context ();
2212 /* Make a block for the local symbols within. */
2213 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2214 lowpc
, highpc
, objfile
);
2216 /* In C++, we can have functions nested inside functions (e.g., when
2217 a function declares a class that has methods). This means that
2218 when we finish processing a function scope, we may need to go
2219 back to building a containing block's symbol lists. */
2220 local_symbols
= new->locals
;
2221 param_symbols
= new->params
;
2223 /* If we've finished processing a top-level function, subsequent
2224 symbols go in the file symbol list. */
2225 if (outermost_context_p ())
2226 list_in_scope
= &file_symbols
;
2229 /* Process all the DIES contained within a lexical block scope. Start
2230 a new scope, process the dies, and then close the scope. */
2233 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2235 struct objfile
*objfile
= cu
->objfile
;
2236 struct context_stack
*new;
2237 CORE_ADDR lowpc
, highpc
;
2238 struct die_info
*child_die
;
2240 /* Ignore blocks with missing or invalid low and high pc attributes. */
2241 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2242 as multiple lexical blocks? Handling children in a sane way would
2243 be nasty. Might be easier to properly extend generic blocks to
2245 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2250 push_context (0, lowpc
);
2251 if (die
->child
!= NULL
)
2253 child_die
= die
->child
;
2254 while (child_die
&& child_die
->tag
)
2256 process_die (child_die
, cu
);
2257 child_die
= sibling_die (child_die
);
2260 new = pop_context ();
2262 if (local_symbols
!= NULL
)
2264 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2267 local_symbols
= new->locals
;
2270 /* Get low and high pc attributes from a die. Return 1 if the attributes
2271 are present and valid, otherwise, return 0. Return -1 if the range is
2272 discontinuous, i.e. derived from DW_AT_ranges information. */
2274 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
2275 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
2277 struct objfile
*objfile
= cu
->objfile
;
2278 struct comp_unit_head
*cu_header
= &cu
->header
;
2279 struct attribute
*attr
;
2280 bfd
*obfd
= objfile
->obfd
;
2285 attr
= dwarf_attr (die
, DW_AT_high_pc
);
2288 high
= DW_ADDR (attr
);
2289 attr
= dwarf_attr (die
, DW_AT_low_pc
);
2291 low
= DW_ADDR (attr
);
2293 /* Found high w/o low attribute. */
2296 /* Found consecutive range of addresses. */
2301 attr
= dwarf_attr (die
, DW_AT_ranges
);
2304 unsigned int addr_size
= cu_header
->addr_size
;
2305 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2306 /* Value of the DW_AT_ranges attribute is the offset in the
2307 .debug_ranges section. */
2308 unsigned int offset
= DW_UNSND (attr
);
2309 /* Base address selection entry. */
2317 found_base
= cu_header
->base_known
;
2318 base
= cu_header
->base_address
;
2320 if (offset
>= dwarf_ranges_size
)
2322 complaint (&symfile_complaints
,
2323 "Offset %d out of bounds for DW_AT_ranges attribute",
2327 buffer
= dwarf_ranges_buffer
+ offset
;
2329 /* Read in the largest possible address. */
2330 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
2331 if ((marker
& mask
) == mask
)
2333 /* If we found the largest possible address, then
2334 read the base address. */
2335 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2336 buffer
+= 2 * addr_size
;
2337 offset
+= 2 * addr_size
;
2345 CORE_ADDR range_beginning
, range_end
;
2347 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
2348 buffer
+= addr_size
;
2349 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
2350 buffer
+= addr_size
;
2351 offset
+= 2 * addr_size
;
2353 /* An end of list marker is a pair of zero addresses. */
2354 if (range_beginning
== 0 && range_end
== 0)
2355 /* Found the end of list entry. */
2358 /* Each base address selection entry is a pair of 2 values.
2359 The first is the largest possible address, the second is
2360 the base address. Check for a base address here. */
2361 if ((range_beginning
& mask
) == mask
)
2363 /* If we found the largest possible address, then
2364 read the base address. */
2365 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2372 /* We have no valid base address for the ranges
2374 complaint (&symfile_complaints
,
2375 "Invalid .debug_ranges data (no base address)");
2379 range_beginning
+= base
;
2382 /* FIXME: This is recording everything as a low-high
2383 segment of consecutive addresses. We should have a
2384 data structure for discontiguous block ranges
2388 low
= range_beginning
;
2394 if (range_beginning
< low
)
2395 low
= range_beginning
;
2396 if (range_end
> high
)
2402 /* If the first entry is an end-of-list marker, the range
2403 describes an empty scope, i.e. no instructions. */
2413 /* When using the GNU linker, .gnu.linkonce. sections are used to
2414 eliminate duplicate copies of functions and vtables and such.
2415 The linker will arbitrarily choose one and discard the others.
2416 The AT_*_pc values for such functions refer to local labels in
2417 these sections. If the section from that file was discarded, the
2418 labels are not in the output, so the relocs get a value of 0.
2419 If this is a discarded function, mark the pc bounds as invalid,
2420 so that GDB will ignore it. */
2421 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
2429 /* Add an aggregate field to the field list. */
2432 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2433 struct dwarf2_cu
*cu
)
2435 struct objfile
*objfile
= cu
->objfile
;
2436 struct nextfield
*new_field
;
2437 struct attribute
*attr
;
2439 char *fieldname
= "";
2441 /* Allocate a new field list entry and link it in. */
2442 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2443 make_cleanup (xfree
, new_field
);
2444 memset (new_field
, 0, sizeof (struct nextfield
));
2445 new_field
->next
= fip
->fields
;
2446 fip
->fields
= new_field
;
2449 /* Handle accessibility and virtuality of field.
2450 The default accessibility for members is public, the default
2451 accessibility for inheritance is private. */
2452 if (die
->tag
!= DW_TAG_inheritance
)
2453 new_field
->accessibility
= DW_ACCESS_public
;
2455 new_field
->accessibility
= DW_ACCESS_private
;
2456 new_field
->virtuality
= DW_VIRTUALITY_none
;
2458 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2460 new_field
->accessibility
= DW_UNSND (attr
);
2461 if (new_field
->accessibility
!= DW_ACCESS_public
)
2462 fip
->non_public_fields
= 1;
2463 attr
= dwarf_attr (die
, DW_AT_virtuality
);
2465 new_field
->virtuality
= DW_UNSND (attr
);
2467 fp
= &new_field
->field
;
2469 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
))
2471 /* Data member other than a C++ static data member. */
2473 /* Get type of field. */
2474 fp
->type
= die_type (die
, cu
);
2476 FIELD_STATIC_KIND (*fp
) = 0;
2478 /* Get bit size of field (zero if none). */
2479 attr
= dwarf_attr (die
, DW_AT_bit_size
);
2482 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2486 FIELD_BITSIZE (*fp
) = 0;
2489 /* Get bit offset of field. */
2490 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2493 FIELD_BITPOS (*fp
) =
2494 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
2497 FIELD_BITPOS (*fp
) = 0;
2498 attr
= dwarf_attr (die
, DW_AT_bit_offset
);
2501 if (BITS_BIG_ENDIAN
)
2503 /* For big endian bits, the DW_AT_bit_offset gives the
2504 additional bit offset from the MSB of the containing
2505 anonymous object to the MSB of the field. We don't
2506 have to do anything special since we don't need to
2507 know the size of the anonymous object. */
2508 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2512 /* For little endian bits, compute the bit offset to the
2513 MSB of the anonymous object, subtract off the number of
2514 bits from the MSB of the field to the MSB of the
2515 object, and then subtract off the number of bits of
2516 the field itself. The result is the bit offset of
2517 the LSB of the field. */
2519 int bit_offset
= DW_UNSND (attr
);
2521 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2524 /* The size of the anonymous object containing
2525 the bit field is explicit, so use the
2526 indicated size (in bytes). */
2527 anonymous_size
= DW_UNSND (attr
);
2531 /* The size of the anonymous object containing
2532 the bit field must be inferred from the type
2533 attribute of the data member containing the
2535 anonymous_size
= TYPE_LENGTH (fp
->type
);
2537 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2538 - bit_offset
- FIELD_BITSIZE (*fp
);
2542 /* Get name of field. */
2543 attr
= dwarf_attr (die
, DW_AT_name
);
2544 if (attr
&& DW_STRING (attr
))
2545 fieldname
= DW_STRING (attr
);
2546 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2547 &objfile
->type_obstack
);
2549 /* Change accessibility for artificial fields (e.g. virtual table
2550 pointer or virtual base class pointer) to private. */
2551 if (dwarf_attr (die
, DW_AT_artificial
))
2553 new_field
->accessibility
= DW_ACCESS_private
;
2554 fip
->non_public_fields
= 1;
2557 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
2559 /* C++ static member. */
2561 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2562 is a declaration, but all versions of G++ as of this writing
2563 (so through at least 3.2.1) incorrectly generate
2564 DW_TAG_variable tags. */
2568 /* Get name of field. */
2569 attr
= dwarf_attr (die
, DW_AT_name
);
2570 if (attr
&& DW_STRING (attr
))
2571 fieldname
= DW_STRING (attr
);
2575 /* Get physical name. */
2576 physname
= dwarf2_linkage_name (die
);
2578 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2579 &objfile
->type_obstack
));
2580 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2581 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2582 &objfile
->type_obstack
);
2584 else if (die
->tag
== DW_TAG_inheritance
)
2586 /* C++ base class field. */
2587 attr
= dwarf_attr (die
, DW_AT_data_member_location
);
2589 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
2591 FIELD_BITSIZE (*fp
) = 0;
2592 FIELD_STATIC_KIND (*fp
) = 0;
2593 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2594 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2595 fip
->nbaseclasses
++;
2599 /* Create the vector of fields, and attach it to the type. */
2602 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2603 struct dwarf2_cu
*cu
)
2605 int nfields
= fip
->nfields
;
2607 /* Record the field count, allocate space for the array of fields,
2608 and create blank accessibility bitfields if necessary. */
2609 TYPE_NFIELDS (type
) = nfields
;
2610 TYPE_FIELDS (type
) = (struct field
*)
2611 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2612 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2614 if (fip
->non_public_fields
)
2616 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2618 TYPE_FIELD_PRIVATE_BITS (type
) =
2619 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2620 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2622 TYPE_FIELD_PROTECTED_BITS (type
) =
2623 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2624 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2626 TYPE_FIELD_IGNORE_BITS (type
) =
2627 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2628 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2631 /* If the type has baseclasses, allocate and clear a bit vector for
2632 TYPE_FIELD_VIRTUAL_BITS. */
2633 if (fip
->nbaseclasses
)
2635 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2638 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2639 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2640 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2641 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2642 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2645 /* Copy the saved-up fields into the field vector. Start from the head
2646 of the list, adding to the tail of the field array, so that they end
2647 up in the same order in the array in which they were added to the list. */
2648 while (nfields
-- > 0)
2650 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2651 switch (fip
->fields
->accessibility
)
2653 case DW_ACCESS_private
:
2654 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2657 case DW_ACCESS_protected
:
2658 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2661 case DW_ACCESS_public
:
2665 /* Unknown accessibility. Complain and treat it as public. */
2667 complaint (&symfile_complaints
, "unsupported accessibility %d",
2668 fip
->fields
->accessibility
);
2672 if (nfields
< fip
->nbaseclasses
)
2674 switch (fip
->fields
->virtuality
)
2676 case DW_VIRTUALITY_virtual
:
2677 case DW_VIRTUALITY_pure_virtual
:
2678 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2682 fip
->fields
= fip
->fields
->next
;
2686 /* Add a member function to the proper fieldlist. */
2689 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2690 struct type
*type
, struct dwarf2_cu
*cu
)
2692 struct objfile
*objfile
= cu
->objfile
;
2693 struct attribute
*attr
;
2694 struct fnfieldlist
*flp
;
2696 struct fn_field
*fnp
;
2699 struct nextfnfield
*new_fnfield
;
2701 /* Get name of member function. */
2702 attr
= dwarf_attr (die
, DW_AT_name
);
2703 if (attr
&& DW_STRING (attr
))
2704 fieldname
= DW_STRING (attr
);
2708 /* Get the mangled name. */
2709 physname
= dwarf2_linkage_name (die
);
2711 /* Look up member function name in fieldlist. */
2712 for (i
= 0; i
< fip
->nfnfields
; i
++)
2714 if (STREQ (fip
->fnfieldlists
[i
].name
, fieldname
))
2718 /* Create new list element if necessary. */
2719 if (i
< fip
->nfnfields
)
2720 flp
= &fip
->fnfieldlists
[i
];
2723 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2725 fip
->fnfieldlists
= (struct fnfieldlist
*)
2726 xrealloc (fip
->fnfieldlists
,
2727 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2728 * sizeof (struct fnfieldlist
));
2729 if (fip
->nfnfields
== 0)
2730 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2732 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2733 flp
->name
= fieldname
;
2739 /* Create a new member function field and chain it to the field list
2741 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2742 make_cleanup (xfree
, new_fnfield
);
2743 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2744 new_fnfield
->next
= flp
->head
;
2745 flp
->head
= new_fnfield
;
2748 /* Fill in the member function field info. */
2749 fnp
= &new_fnfield
->fnfield
;
2750 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2751 &objfile
->type_obstack
);
2752 fnp
->type
= alloc_type (objfile
);
2753 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2755 int nparams
= TYPE_NFIELDS (die
->type
);
2757 /* TYPE is the domain of this method, and DIE->TYPE is the type
2758 of the method itself (TYPE_CODE_METHOD). */
2759 smash_to_method_type (fnp
->type
, type
,
2760 TYPE_TARGET_TYPE (die
->type
),
2761 TYPE_FIELDS (die
->type
),
2762 TYPE_NFIELDS (die
->type
),
2763 TYPE_VARARGS (die
->type
));
2765 /* Handle static member functions.
2766 Dwarf2 has no clean way to discern C++ static and non-static
2767 member functions. G++ helps GDB by marking the first
2768 parameter for non-static member functions (which is the
2769 this pointer) as artificial. We obtain this information
2770 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2771 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2772 fnp
->voffset
= VOFFSET_STATIC
;
2775 complaint (&symfile_complaints
, "member function type missing for '%s'",
2778 /* Get fcontext from DW_AT_containing_type if present. */
2779 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2780 fnp
->fcontext
= die_containing_type (die
, cu
);
2782 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2783 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2785 /* Get accessibility. */
2786 attr
= dwarf_attr (die
, DW_AT_accessibility
);
2789 switch (DW_UNSND (attr
))
2791 case DW_ACCESS_private
:
2792 fnp
->is_private
= 1;
2794 case DW_ACCESS_protected
:
2795 fnp
->is_protected
= 1;
2800 /* Check for artificial methods. */
2801 attr
= dwarf_attr (die
, DW_AT_artificial
);
2802 if (attr
&& DW_UNSND (attr
) != 0)
2803 fnp
->is_artificial
= 1;
2805 /* Get index in virtual function table if it is a virtual member function. */
2806 attr
= dwarf_attr (die
, DW_AT_vtable_elem_location
);
2809 /* Support the .debug_loc offsets */
2810 if (attr_form_is_block (attr
))
2812 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
2814 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2816 dwarf2_complex_location_expr_complaint ();
2820 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2826 /* Create the vector of member function fields, and attach it to the type. */
2829 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2830 struct dwarf2_cu
*cu
)
2832 struct fnfieldlist
*flp
;
2833 int total_length
= 0;
2836 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2837 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2838 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2840 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2842 struct nextfnfield
*nfp
= flp
->head
;
2843 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2846 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2847 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2848 fn_flp
->fn_fields
= (struct fn_field
*)
2849 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2850 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2851 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2853 total_length
+= flp
->length
;
2856 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2857 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2860 /* Called when we find the DIE that starts a structure or union scope
2861 (definition) to process all dies that define the members of the
2864 NOTE: we need to call struct_type regardless of whether or not the
2865 DIE has an at_name attribute, since it might be an anonymous
2866 structure or union. This gets the type entered into our set of
2869 However, if the structure is incomplete (an opaque struct/union)
2870 then suppress creating a symbol table entry for it since gdb only
2871 wants to find the one with the complete definition. Note that if
2872 it is complete, we just call new_symbol, which does it's own
2873 checking about whether the struct/union is anonymous or not (and
2874 suppresses creating a symbol table entry itself). */
2877 read_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2879 struct objfile
*objfile
= cu
->objfile
;
2881 struct attribute
*attr
;
2883 type
= alloc_type (objfile
);
2885 INIT_CPLUS_SPECIFIC (type
);
2886 attr
= dwarf_attr (die
, DW_AT_name
);
2887 if (attr
&& DW_STRING (attr
))
2889 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
2890 strlen (DW_STRING (attr
)),
2891 &objfile
->type_obstack
);
2894 if (die
->tag
== DW_TAG_structure_type
)
2896 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2898 else if (die
->tag
== DW_TAG_union_type
)
2900 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2904 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2906 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
2909 attr
= dwarf_attr (die
, DW_AT_byte_size
);
2912 TYPE_LENGTH (type
) = DW_UNSND (attr
);
2916 TYPE_LENGTH (type
) = 0;
2919 /* We need to add the type field to the die immediately so we don't
2920 infinitely recurse when dealing with pointers to the structure
2921 type within the structure itself. */
2924 if (die
->child
!= NULL
&& ! die_is_declaration (die
))
2926 struct field_info fi
;
2927 struct die_info
*child_die
;
2928 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2930 memset (&fi
, 0, sizeof (struct field_info
));
2932 child_die
= die
->child
;
2934 while (child_die
&& child_die
->tag
)
2936 if (child_die
->tag
== DW_TAG_member
2937 || child_die
->tag
== DW_TAG_variable
)
2939 /* NOTE: carlton/2002-11-05: A C++ static data member
2940 should be a DW_TAG_member that is a declaration, but
2941 all versions of G++ as of this writing (so through at
2942 least 3.2.1) incorrectly generate DW_TAG_variable
2943 tags for them instead. */
2944 dwarf2_add_field (&fi
, child_die
, cu
);
2946 else if (child_die
->tag
== DW_TAG_subprogram
)
2948 /* C++ member function. */
2949 process_die (child_die
, cu
);
2950 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
2952 else if (child_die
->tag
== DW_TAG_inheritance
)
2954 /* C++ base class field. */
2955 dwarf2_add_field (&fi
, child_die
, cu
);
2959 process_die (child_die
, cu
);
2961 child_die
= sibling_die (child_die
);
2964 /* Attach fields and member functions to the type. */
2966 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
2969 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
2971 /* Get the type which refers to the base class (possibly this
2972 class itself) which contains the vtable pointer for the current
2973 class from the DW_AT_containing_type attribute. */
2975 if (dwarf_attr (die
, DW_AT_containing_type
) != NULL
)
2977 struct type
*t
= die_containing_type (die
, cu
);
2979 TYPE_VPTR_BASETYPE (type
) = t
;
2982 static const char vptr_name
[] =
2983 {'_', 'v', 'p', 't', 'r', '\0'};
2986 /* Our own class provides vtbl ptr. */
2987 for (i
= TYPE_NFIELDS (t
) - 1;
2988 i
>= TYPE_N_BASECLASSES (t
);
2991 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
2993 if (STREQN (fieldname
, vptr_name
, strlen (vptr_name
) - 1)
2994 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
2996 TYPE_VPTR_FIELDNO (type
) = i
;
3001 /* Complain if virtual function table field not found. */
3002 if (i
< TYPE_N_BASECLASSES (t
))
3003 complaint (&symfile_complaints
,
3004 "virtual function table pointer not found when defining class '%s'",
3005 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3010 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3015 new_symbol (die
, type
, cu
);
3017 do_cleanups (back_to
);
3021 /* No children, must be stub. */
3022 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3026 /* Given a pointer to a die which begins an enumeration, process all
3027 the dies that define the members of the enumeration.
3029 This will be much nicer in draft 6 of the DWARF spec when our
3030 members will be dies instead squished into the DW_AT_element_list
3033 NOTE: We reverse the order of the element list. */
3036 read_enumeration (struct die_info
*die
, struct dwarf2_cu
*cu
)
3038 struct objfile
*objfile
= cu
->objfile
;
3039 struct die_info
*child_die
;
3041 struct field
*fields
;
3042 struct attribute
*attr
;
3045 int unsigned_enum
= 1;
3047 type
= alloc_type (objfile
);
3049 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3050 attr
= dwarf_attr (die
, DW_AT_name
);
3051 if (attr
&& DW_STRING (attr
))
3053 TYPE_TAG_NAME (type
) = obsavestring (DW_STRING (attr
),
3054 strlen (DW_STRING (attr
)),
3055 &objfile
->type_obstack
);
3058 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3061 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3065 TYPE_LENGTH (type
) = 0;
3070 if (die
->child
!= NULL
)
3072 child_die
= die
->child
;
3073 while (child_die
&& child_die
->tag
)
3075 if (child_die
->tag
!= DW_TAG_enumerator
)
3077 process_die (child_die
, cu
);
3081 attr
= dwarf_attr (child_die
, DW_AT_name
);
3084 sym
= new_symbol (child_die
, type
, cu
);
3085 if (SYMBOL_VALUE (sym
) < 0)
3088 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3090 fields
= (struct field
*)
3092 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
3093 * sizeof (struct field
));
3096 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
3097 FIELD_TYPE (fields
[num_fields
]) = NULL
;
3098 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
3099 FIELD_BITSIZE (fields
[num_fields
]) = 0;
3100 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
3106 child_die
= sibling_die (child_die
);
3111 TYPE_NFIELDS (type
) = num_fields
;
3112 TYPE_FIELDS (type
) = (struct field
*)
3113 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
3114 memcpy (TYPE_FIELDS (type
), fields
,
3115 sizeof (struct field
) * num_fields
);
3119 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
3122 new_symbol (die
, type
, cu
);
3125 /* Extract all information from a DW_TAG_array_type DIE and put it in
3126 the DIE's type field. For now, this only handles one dimensional
3130 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3132 struct objfile
*objfile
= cu
->objfile
;
3133 struct die_info
*child_die
;
3134 struct type
*type
= NULL
;
3135 struct type
*element_type
, *range_type
, *index_type
;
3136 struct type
**range_types
= NULL
;
3137 struct attribute
*attr
;
3139 struct cleanup
*back_to
;
3141 /* Return if we've already decoded this type. */
3147 element_type
= die_type (die
, cu
);
3149 /* Irix 6.2 native cc creates array types without children for
3150 arrays with unspecified length. */
3151 if (die
->child
== NULL
)
3153 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3154 range_type
= create_range_type (NULL
, index_type
, 0, -1);
3155 die
->type
= create_array_type (NULL
, element_type
, range_type
);
3159 back_to
= make_cleanup (null_cleanup
, NULL
);
3160 child_die
= die
->child
;
3161 while (child_die
&& child_die
->tag
)
3163 if (child_die
->tag
== DW_TAG_subrange_type
)
3165 unsigned int low
, high
;
3167 /* Default bounds to an array with unspecified length. */
3170 if (cu_language
== language_fortran
)
3172 /* FORTRAN implies a lower bound of 1, if not given. */
3176 index_type
= die_type (child_die
, cu
);
3177 attr
= dwarf_attr (child_die
, DW_AT_lower_bound
);
3180 if (attr
->form
== DW_FORM_sdata
)
3182 low
= DW_SND (attr
);
3184 else if (attr
->form
== DW_FORM_udata
3185 || attr
->form
== DW_FORM_data1
3186 || attr
->form
== DW_FORM_data2
3187 || attr
->form
== DW_FORM_data4
3188 || attr
->form
== DW_FORM_data8
)
3190 low
= DW_UNSND (attr
);
3194 dwarf2_non_const_array_bound_ignored_complaint
3195 (dwarf_form_name (attr
->form
));
3197 die
->type
= lookup_pointer_type (element_type
);
3204 attr
= dwarf_attr (child_die
, DW_AT_upper_bound
);
3207 if (attr
->form
== DW_FORM_sdata
)
3209 high
= DW_SND (attr
);
3211 else if (attr
->form
== DW_FORM_udata
3212 || attr
->form
== DW_FORM_data1
3213 || attr
->form
== DW_FORM_data2
3214 || attr
->form
== DW_FORM_data4
3215 || attr
->form
== DW_FORM_data8
)
3217 high
= DW_UNSND (attr
);
3219 else if (attr
->form
== DW_FORM_block1
)
3221 /* GCC encodes arrays with unspecified or dynamic length
3222 with a DW_FORM_block1 attribute.
3223 FIXME: GDB does not yet know how to handle dynamic
3224 arrays properly, treat them as arrays with unspecified
3227 FIXME: jimb/2003-09-22: GDB does not really know
3228 how to handle arrays of unspecified length
3229 either; we just represent them as zero-length
3230 arrays. Choose an appropriate upper bound given
3231 the lower bound we've computed above. */
3236 dwarf2_non_const_array_bound_ignored_complaint
3237 (dwarf_form_name (attr
->form
));
3239 die
->type
= lookup_pointer_type (element_type
);
3247 /* Create a range type and save it for array type creation. */
3248 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
3250 range_types
= (struct type
**)
3251 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
3252 * sizeof (struct type
*));
3254 make_cleanup (free_current_contents
, &range_types
);
3256 range_types
[ndim
++] = create_range_type (NULL
, index_type
, low
, high
);
3258 child_die
= sibling_die (child_die
);
3261 /* Dwarf2 dimensions are output from left to right, create the
3262 necessary array types in backwards order. */
3263 type
= element_type
;
3265 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
3267 /* Understand Dwarf2 support for vector types (like they occur on
3268 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3269 array type. This is not part of the Dwarf2/3 standard yet, but a
3270 custom vendor extension. The main difference between a regular
3271 array and the vector variant is that vectors are passed by value
3273 attr
= dwarf_attr (die
, DW_AT_GNU_vector
);
3275 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
3277 do_cleanups (back_to
);
3279 /* Install the type in the die. */
3283 /* First cut: install each common block member as a global variable. */
3286 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
3288 struct die_info
*child_die
;
3289 struct attribute
*attr
;
3291 CORE_ADDR base
= (CORE_ADDR
) 0;
3293 attr
= dwarf_attr (die
, DW_AT_location
);
3296 /* Support the .debug_loc offsets */
3297 if (attr_form_is_block (attr
))
3299 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
3301 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3303 dwarf2_complex_location_expr_complaint ();
3307 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3308 "common block member");
3311 if (die
->child
!= NULL
)
3313 child_die
= die
->child
;
3314 while (child_die
&& child_die
->tag
)
3316 sym
= new_symbol (child_die
, NULL
, cu
);
3317 attr
= dwarf_attr (child_die
, DW_AT_data_member_location
);
3320 SYMBOL_VALUE_ADDRESS (sym
) =
3321 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
3322 add_symbol_to_list (sym
, &global_symbols
);
3324 child_die
= sibling_die (child_die
);
3329 /* Read a C++ namespace. */
3332 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
3334 struct objfile
*objfile
= cu
->objfile
;
3335 const char *previous_namespace
= processing_current_namespace
;
3336 const char *name
= NULL
;
3338 struct die_info
*current_die
;
3340 /* Loop through the extensions until we find a name. */
3342 for (current_die
= die
;
3343 current_die
!= NULL
;
3344 current_die
= dwarf2_extension (die
))
3346 name
= dwarf2_name (current_die
);
3351 /* Is it an anonymous namespace? */
3353 is_anonymous
= (name
== NULL
);
3355 name
= "(anonymous namespace)";
3357 /* Now build the name of the current namespace. */
3359 if (previous_namespace
[0] == '\0')
3361 processing_current_namespace
= name
;
3365 /* We need temp_name around because processing_current_namespace
3366 is a const char *. */
3367 char *temp_name
= alloca (strlen (previous_namespace
)
3368 + 2 + strlen(name
) + 1);
3369 strcpy (temp_name
, previous_namespace
);
3370 strcat (temp_name
, "::");
3371 strcat (temp_name
, name
);
3373 processing_current_namespace
= temp_name
;
3376 /* Add a symbol associated to this if we haven't seen the namespace
3377 before. Also, add a using directive if it's an anonymous
3380 if (dwarf2_extension (die
) == NULL
)
3384 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3385 this cast will hopefully become unnecessary. */
3386 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
3387 (char *) processing_current_namespace
,
3389 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
3391 new_symbol (die
, type
, cu
);
3394 cp_add_using_directive (processing_current_namespace
,
3395 strlen (previous_namespace
),
3396 strlen (processing_current_namespace
));
3399 if (die
->child
!= NULL
)
3401 struct die_info
*child_die
= die
->child
;
3403 while (child_die
&& child_die
->tag
)
3405 process_die (child_die
, cu
);
3406 child_die
= sibling_die (child_die
);
3410 processing_current_namespace
= previous_namespace
;
3413 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3414 the user defined type vector. */
3417 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3419 struct comp_unit_head
*cu_header
= &cu
->header
;
3421 struct attribute
*attr_byte_size
;
3422 struct attribute
*attr_address_class
;
3423 int byte_size
, addr_class
;
3430 type
= lookup_pointer_type (die_type (die
, cu
));
3432 attr_byte_size
= dwarf_attr (die
, DW_AT_byte_size
);
3434 byte_size
= DW_UNSND (attr_byte_size
);
3436 byte_size
= cu_header
->addr_size
;
3438 attr_address_class
= dwarf_attr (die
, DW_AT_address_class
);
3439 if (attr_address_class
)
3440 addr_class
= DW_UNSND (attr_address_class
);
3442 addr_class
= DW_ADDR_none
;
3444 /* If the pointer size or address class is different than the
3445 default, create a type variant marked as such and set the
3446 length accordingly. */
3447 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3449 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3453 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3454 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3455 type
= make_type_with_address_space (type
, type_flags
);
3457 else if (TYPE_LENGTH (type
) != byte_size
)
3459 complaint (&symfile_complaints
, "invalid pointer size %d", byte_size
);
3462 /* Should we also complain about unhandled address classes? */
3466 TYPE_LENGTH (type
) = byte_size
;
3470 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3471 the user defined type vector. */
3474 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3476 struct objfile
*objfile
= cu
->objfile
;
3478 struct type
*to_type
;
3479 struct type
*domain
;
3486 type
= alloc_type (objfile
);
3487 to_type
= die_type (die
, cu
);
3488 domain
= die_containing_type (die
, cu
);
3489 smash_to_member_type (type
, domain
, to_type
);
3494 /* Extract all information from a DW_TAG_reference_type DIE and add to
3495 the user defined type vector. */
3498 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3500 struct comp_unit_head
*cu_header
= &cu
->header
;
3502 struct attribute
*attr
;
3509 type
= lookup_reference_type (die_type (die
, cu
));
3510 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3513 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3517 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3523 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3525 struct type
*base_type
;
3532 base_type
= die_type (die
, cu
);
3533 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3537 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3539 struct type
*base_type
;
3546 base_type
= die_type (die
, cu
);
3547 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3550 /* Extract all information from a DW_TAG_string_type DIE and add to
3551 the user defined type vector. It isn't really a user defined type,
3552 but it behaves like one, with other DIE's using an AT_user_def_type
3553 attribute to reference it. */
3556 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3558 struct objfile
*objfile
= cu
->objfile
;
3559 struct type
*type
, *range_type
, *index_type
, *char_type
;
3560 struct attribute
*attr
;
3561 unsigned int length
;
3568 attr
= dwarf_attr (die
, DW_AT_string_length
);
3571 length
= DW_UNSND (attr
);
3575 /* check for the DW_AT_byte_size attribute */
3576 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3579 length
= DW_UNSND (attr
);
3586 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
);
3587 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3588 if (cu_language
== language_fortran
)
3590 /* Need to create a unique string type for bounds
3592 type
= create_string_type (0, range_type
);
3596 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
);
3597 type
= create_string_type (char_type
, range_type
);
3602 /* Handle DIES due to C code like:
3606 int (*funcp)(int a, long l);
3610 ('funcp' generates a DW_TAG_subroutine_type DIE)
3614 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3616 struct type
*type
; /* Type that this function returns */
3617 struct type
*ftype
; /* Function that returns above type */
3618 struct attribute
*attr
;
3620 /* Decode the type that this subroutine returns */
3625 type
= die_type (die
, cu
);
3626 ftype
= lookup_function_type (type
);
3628 /* All functions in C++ have prototypes. */
3629 attr
= dwarf_attr (die
, DW_AT_prototyped
);
3630 if ((attr
&& (DW_UNSND (attr
) != 0))
3631 || cu_language
== language_cplus
)
3632 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3634 if (die
->child
!= NULL
)
3636 struct die_info
*child_die
;
3640 /* Count the number of parameters.
3641 FIXME: GDB currently ignores vararg functions, but knows about
3642 vararg member functions. */
3643 child_die
= die
->child
;
3644 while (child_die
&& child_die
->tag
)
3646 if (child_die
->tag
== DW_TAG_formal_parameter
)
3648 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3649 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3650 child_die
= sibling_die (child_die
);
3653 /* Allocate storage for parameters and fill them in. */
3654 TYPE_NFIELDS (ftype
) = nparams
;
3655 TYPE_FIELDS (ftype
) = (struct field
*)
3656 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3658 child_die
= die
->child
;
3659 while (child_die
&& child_die
->tag
)
3661 if (child_die
->tag
== DW_TAG_formal_parameter
)
3663 /* Dwarf2 has no clean way to discern C++ static and non-static
3664 member functions. G++ helps GDB by marking the first
3665 parameter for non-static member functions (which is the
3666 this pointer) as artificial. We pass this information
3667 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3668 attr
= dwarf_attr (child_die
, DW_AT_artificial
);
3670 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3672 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3673 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
3676 child_die
= sibling_die (child_die
);
3684 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
3686 struct objfile
*objfile
= cu
->objfile
;
3687 struct attribute
*attr
;
3692 attr
= dwarf_attr (die
, DW_AT_name
);
3693 if (attr
&& DW_STRING (attr
))
3695 name
= DW_STRING (attr
);
3697 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3698 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
3702 /* Find a representation of a given base type and install
3703 it in the TYPE field of the die. */
3706 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3708 struct objfile
*objfile
= cu
->objfile
;
3710 struct attribute
*attr
;
3711 int encoding
= 0, size
= 0;
3713 /* If we've already decoded this die, this is a no-op. */
3719 attr
= dwarf_attr (die
, DW_AT_encoding
);
3722 encoding
= DW_UNSND (attr
);
3724 attr
= dwarf_attr (die
, DW_AT_byte_size
);
3727 size
= DW_UNSND (attr
);
3729 attr
= dwarf_attr (die
, DW_AT_name
);
3730 if (attr
&& DW_STRING (attr
))
3732 enum type_code code
= TYPE_CODE_INT
;
3737 case DW_ATE_address
:
3738 /* Turn DW_ATE_address into a void * pointer. */
3739 code
= TYPE_CODE_PTR
;
3740 type_flags
|= TYPE_FLAG_UNSIGNED
;
3742 case DW_ATE_boolean
:
3743 code
= TYPE_CODE_BOOL
;
3744 type_flags
|= TYPE_FLAG_UNSIGNED
;
3746 case DW_ATE_complex_float
:
3747 code
= TYPE_CODE_COMPLEX
;
3750 code
= TYPE_CODE_FLT
;
3753 case DW_ATE_signed_char
:
3755 case DW_ATE_unsigned
:
3756 case DW_ATE_unsigned_char
:
3757 type_flags
|= TYPE_FLAG_UNSIGNED
;
3760 complaint (&symfile_complaints
, "unsupported DW_AT_encoding: '%s'",
3761 dwarf_type_encoding_name (encoding
));
3764 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3765 if (encoding
== DW_ATE_address
)
3766 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
);
3767 else if (encoding
== DW_ATE_complex_float
)
3770 TYPE_TARGET_TYPE (type
)
3771 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
3772 else if (size
== 16)
3773 TYPE_TARGET_TYPE (type
)
3774 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
3776 TYPE_TARGET_TYPE (type
)
3777 = dwarf2_fundamental_type (objfile
, FT_FLOAT
);
3782 type
= dwarf_base_type (encoding
, size
, cu
);
3787 /* Read a whole compilation unit into a linked list of dies. */
3789 static struct die_info
*
3790 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
3792 /* Reset die reference table; we are
3793 building new ones now. */
3794 dwarf2_empty_hash_tables ();
3796 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
3799 /* Read a single die and all its descendents. Set the die's sibling
3800 field to NULL; set other fields in the die correctly, and set all
3801 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
3802 location of the info_ptr after reading all of those dies. PARENT
3803 is the parent of the die in question. */
3805 static struct die_info
*
3806 read_die_and_children (char *info_ptr
, bfd
*abfd
,
3807 struct dwarf2_cu
*cu
,
3808 char **new_info_ptr
,
3809 struct die_info
*parent
)
3811 struct die_info
*die
;
3815 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
3816 store_in_ref_table (die
->offset
, die
);
3820 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
3826 *new_info_ptr
= cur_ptr
;
3829 die
->sibling
= NULL
;
3830 die
->parent
= parent
;
3834 /* Read a die, all of its descendents, and all of its siblings; set
3835 all of the fields of all of the dies correctly. Arguments are as
3836 in read_die_and_children. */
3838 static struct die_info
*
3839 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
3840 struct dwarf2_cu
*cu
,
3841 char **new_info_ptr
,
3842 struct die_info
*parent
)
3844 struct die_info
*first_die
, *last_sibling
;
3848 first_die
= last_sibling
= NULL
;
3852 struct die_info
*die
3853 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
3861 last_sibling
->sibling
= die
;
3866 *new_info_ptr
= cur_ptr
;
3876 /* Free a linked list of dies. */
3879 free_die_list (struct die_info
*dies
)
3881 struct die_info
*die
, *next
;
3886 if (die
->child
!= NULL
)
3887 free_die_list (die
->child
);
3888 next
= die
->sibling
;
3896 do_free_die_list_cleanup (void *dies
)
3898 free_die_list (dies
);
3901 static struct cleanup
*
3902 make_cleanup_free_die_list (struct die_info
*dies
)
3904 return make_cleanup (do_free_die_list_cleanup
, dies
);
3908 /* Read the contents of the section at OFFSET and of size SIZE from the
3909 object file specified by OBJFILE into the psymbol_obstack and return it. */
3912 dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
3913 unsigned int size
, asection
*sectp
)
3915 bfd
*abfd
= objfile
->obfd
;
3921 buf
= (char *) obstack_alloc (&objfile
->psymbol_obstack
, size
);
3923 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
3927 if ((bfd_seek (abfd
, offset
, SEEK_SET
) != 0) ||
3928 (bfd_bread (buf
, size
, abfd
) != size
))
3931 error ("Dwarf Error: Can't read DWARF data from '%s'",
3932 bfd_get_filename (abfd
));
3937 /* In DWARF version 2, the description of the debugging information is
3938 stored in a separate .debug_abbrev section. Before we read any
3939 dies from a section we read in all abbreviations and install them
3943 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
3945 struct comp_unit_head
*cu_header
= &cu
->header
;
3947 struct abbrev_info
*cur_abbrev
;
3948 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
3949 unsigned int abbrev_form
, hash_number
;
3951 /* Initialize dwarf2 abbrevs */
3952 memset (cu_header
->dwarf2_abbrevs
, 0,
3953 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
3955 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
3956 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3957 abbrev_ptr
+= bytes_read
;
3959 /* loop until we reach an abbrev number of 0 */
3960 while (abbrev_number
)
3962 cur_abbrev
= dwarf_alloc_abbrev ();
3964 /* read in abbrev header */
3965 cur_abbrev
->number
= abbrev_number
;
3966 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3967 abbrev_ptr
+= bytes_read
;
3968 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
3971 /* now read in declarations */
3972 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3973 abbrev_ptr
+= bytes_read
;
3974 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3975 abbrev_ptr
+= bytes_read
;
3978 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
3980 cur_abbrev
->attrs
= (struct attr_abbrev
*)
3981 xrealloc (cur_abbrev
->attrs
,
3982 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
3983 * sizeof (struct attr_abbrev
));
3985 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
3986 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
3987 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3988 abbrev_ptr
+= bytes_read
;
3989 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
3990 abbrev_ptr
+= bytes_read
;
3993 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
3994 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
3995 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
3997 /* Get next abbreviation.
3998 Under Irix6 the abbreviations for a compilation unit are not
3999 always properly terminated with an abbrev number of 0.
4000 Exit loop if we encounter an abbreviation which we have
4001 already read (which means we are about to read the abbreviations
4002 for the next compile unit) or if the end of the abbreviation
4003 table is reached. */
4004 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
4005 >= dwarf_abbrev_size
)
4007 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4008 abbrev_ptr
+= bytes_read
;
4009 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
4014 /* Empty the abbrev table for a new compilation unit. */
4017 dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table
)
4020 struct abbrev_info
*abbrev
, *next
;
4021 struct abbrev_info
**abbrevs
;
4023 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
4025 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
4028 abbrev
= abbrevs
[i
];
4031 next
= abbrev
->next
;
4032 xfree (abbrev
->attrs
);
4040 /* Lookup an abbrev_info structure in the abbrev hash table. */
4042 static struct abbrev_info
*
4043 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
4045 struct comp_unit_head
*cu_header
= &cu
->header
;
4046 unsigned int hash_number
;
4047 struct abbrev_info
*abbrev
;
4049 hash_number
= number
% ABBREV_HASH_SIZE
;
4050 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
4054 if (abbrev
->number
== number
)
4057 abbrev
= abbrev
->next
;
4062 /* Read a minimal amount of information into the minimal die structure. */
4065 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
4066 char *info_ptr
, struct dwarf2_cu
*cu
)
4068 unsigned int abbrev_number
, bytes_read
, i
;
4069 struct abbrev_info
*abbrev
;
4070 struct attribute attr
;
4071 struct attribute spec_attr
;
4072 int found_spec_attr
= 0;
4073 int has_low_pc_attr
= 0;
4074 int has_high_pc_attr
= 0;
4076 *part_die
= zeroed_partial_die
;
4077 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4078 info_ptr
+= bytes_read
;
4082 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4085 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number
,
4086 bfd_get_filename (abfd
));
4088 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
4089 part_die
->tag
= abbrev
->tag
;
4090 part_die
->has_children
= abbrev
->has_children
;
4091 part_die
->abbrev
= abbrev_number
;
4093 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4095 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
4097 /* Store the data if it is of an attribute we want to keep in a
4098 partial symbol table. */
4103 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
4104 if (part_die
->name
== NULL
)
4105 part_die
->name
= DW_STRING (&attr
);
4107 case DW_AT_MIPS_linkage_name
:
4108 part_die
->name
= DW_STRING (&attr
);
4111 has_low_pc_attr
= 1;
4112 part_die
->lowpc
= DW_ADDR (&attr
);
4115 has_high_pc_attr
= 1;
4116 part_die
->highpc
= DW_ADDR (&attr
);
4118 case DW_AT_location
:
4119 /* Support the .debug_loc offsets */
4120 if (attr_form_is_block (&attr
))
4122 part_die
->locdesc
= DW_BLOCK (&attr
);
4124 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
4126 dwarf2_complex_location_expr_complaint ();
4130 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4131 "partial symbol information");
4134 case DW_AT_language
:
4135 part_die
->language
= DW_UNSND (&attr
);
4137 case DW_AT_external
:
4138 part_die
->is_external
= DW_UNSND (&attr
);
4140 case DW_AT_declaration
:
4141 part_die
->is_declaration
= DW_UNSND (&attr
);
4144 part_die
->has_type
= 1;
4146 case DW_AT_abstract_origin
:
4147 case DW_AT_specification
:
4148 found_spec_attr
= 1;
4152 /* Ignore absolute siblings, they might point outside of
4153 the current compile unit. */
4154 if (attr
.form
== DW_FORM_ref_addr
)
4155 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
4158 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
);
4165 /* If we found a reference attribute and the die has no name, try
4166 to find a name in the referred to die. */
4168 if (found_spec_attr
&& part_die
->name
== NULL
)
4170 struct partial_die_info spec_die
;
4173 spec_ptr
= dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&spec_attr
);
4174 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu
);
4177 part_die
->name
= spec_die
.name
;
4179 /* Copy DW_AT_external attribute if it is set. */
4180 if (spec_die
.is_external
)
4181 part_die
->is_external
= spec_die
.is_external
;
4185 /* When using the GNU linker, .gnu.linkonce. sections are used to
4186 eliminate duplicate copies of functions and vtables and such.
4187 The linker will arbitrarily choose one and discard the others.
4188 The AT_*_pc values for such functions refer to local labels in
4189 these sections. If the section from that file was discarded, the
4190 labels are not in the output, so the relocs get a value of 0.
4191 If this is a discarded function, mark the pc bounds as invalid,
4192 so that GDB will ignore it. */
4193 if (has_low_pc_attr
&& has_high_pc_attr
4194 && part_die
->lowpc
< part_die
->highpc
4195 && (part_die
->lowpc
!= 0
4196 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
4197 part_die
->has_pc_info
= 1;
4201 /* Read the die from the .debug_info section buffer. Set DIEP to
4202 point to a newly allocated die with its information, except for its
4203 child, sibling, and parent fields. Set HAS_CHILDREN to tell
4204 whether the die has children or not. */
4207 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
4208 struct dwarf2_cu
*cu
, int *has_children
)
4210 unsigned int abbrev_number
, bytes_read
, i
, offset
;
4211 struct abbrev_info
*abbrev
;
4212 struct die_info
*die
;
4214 offset
= info_ptr
- dwarf_info_buffer
;
4215 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4216 info_ptr
+= bytes_read
;
4219 die
= dwarf_alloc_die ();
4221 die
->abbrev
= abbrev_number
;
4228 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4231 error ("Dwarf Error: could not find abbrev number %d [in module %s]",
4233 bfd_get_filename (abfd
));
4235 die
= dwarf_alloc_die ();
4236 die
->offset
= offset
;
4237 die
->tag
= abbrev
->tag
;
4238 die
->abbrev
= abbrev_number
;
4241 die
->num_attrs
= abbrev
->num_attrs
;
4242 die
->attrs
= (struct attribute
*)
4243 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
4245 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4247 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
4248 abfd
, info_ptr
, cu
);
4252 *has_children
= abbrev
->has_children
;
4256 /* Read an attribute value described by an attribute form. */
4259 read_attribute_value (struct attribute
*attr
, unsigned form
,
4260 bfd
*abfd
, char *info_ptr
,
4261 struct dwarf2_cu
*cu
)
4263 struct comp_unit_head
*cu_header
= &cu
->header
;
4264 unsigned int bytes_read
;
4265 struct dwarf_block
*blk
;
4271 case DW_FORM_ref_addr
:
4272 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
4273 info_ptr
+= bytes_read
;
4275 case DW_FORM_block2
:
4276 blk
= dwarf_alloc_block ();
4277 blk
->size
= read_2_bytes (abfd
, info_ptr
);
4279 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4280 info_ptr
+= blk
->size
;
4281 DW_BLOCK (attr
) = blk
;
4283 case DW_FORM_block4
:
4284 blk
= dwarf_alloc_block ();
4285 blk
->size
= read_4_bytes (abfd
, info_ptr
);
4287 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4288 info_ptr
+= blk
->size
;
4289 DW_BLOCK (attr
) = blk
;
4292 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4296 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4300 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4303 case DW_FORM_string
:
4304 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
4305 info_ptr
+= bytes_read
;
4308 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
4310 info_ptr
+= bytes_read
;
4313 blk
= dwarf_alloc_block ();
4314 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4315 info_ptr
+= bytes_read
;
4316 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4317 info_ptr
+= blk
->size
;
4318 DW_BLOCK (attr
) = blk
;
4320 case DW_FORM_block1
:
4321 blk
= dwarf_alloc_block ();
4322 blk
->size
= read_1_byte (abfd
, info_ptr
);
4324 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4325 info_ptr
+= blk
->size
;
4326 DW_BLOCK (attr
) = blk
;
4329 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4333 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4337 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
4338 info_ptr
+= bytes_read
;
4341 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4342 info_ptr
+= bytes_read
;
4345 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4349 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4353 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4357 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4360 case DW_FORM_ref_udata
:
4361 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4362 info_ptr
+= bytes_read
;
4364 case DW_FORM_indirect
:
4365 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4366 info_ptr
+= bytes_read
;
4367 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
4370 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4371 dwarf_form_name (form
),
4372 bfd_get_filename (abfd
));
4377 /* Read an attribute described by an abbreviated attribute. */
4380 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
4381 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
4383 attr
->name
= abbrev
->name
;
4384 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
4387 /* read dwarf information from a buffer */
4390 read_1_byte (bfd
*abfd
, char *buf
)
4392 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4396 read_1_signed_byte (bfd
*abfd
, char *buf
)
4398 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
4402 read_2_bytes (bfd
*abfd
, char *buf
)
4404 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4408 read_2_signed_bytes (bfd
*abfd
, char *buf
)
4410 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4414 read_4_bytes (bfd
*abfd
, char *buf
)
4416 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4420 read_4_signed_bytes (bfd
*abfd
, char *buf
)
4422 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4425 static unsigned long
4426 read_8_bytes (bfd
*abfd
, char *buf
)
4428 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4432 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
4434 struct comp_unit_head
*cu_header
= &cu
->header
;
4435 CORE_ADDR retval
= 0;
4437 if (cu_header
->signed_addr_p
)
4439 switch (cu_header
->addr_size
)
4442 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4445 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4448 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
4451 internal_error (__FILE__
, __LINE__
,
4452 "read_address: bad switch, signed [in module %s]",
4453 bfd_get_filename (abfd
));
4458 switch (cu_header
->addr_size
)
4461 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4464 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4467 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4470 internal_error (__FILE__
, __LINE__
,
4471 "read_address: bad switch, unsigned [in module %s]",
4472 bfd_get_filename (abfd
));
4476 *bytes_read
= cu_header
->addr_size
;
4480 /* Read the initial length from a section. The (draft) DWARF 3
4481 specification allows the initial length to take up either 4 bytes
4482 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4483 bytes describe the length and all offsets will be 8 bytes in length
4486 An older, non-standard 64-bit format is also handled by this
4487 function. The older format in question stores the initial length
4488 as an 8-byte quantity without an escape value. Lengths greater
4489 than 2^32 aren't very common which means that the initial 4 bytes
4490 is almost always zero. Since a length value of zero doesn't make
4491 sense for the 32-bit format, this initial zero can be considered to
4492 be an escape value which indicates the presence of the older 64-bit
4493 format. As written, the code can't detect (old format) lengths
4494 greater than 4GB. If it becomes necessary to handle lengths somewhat
4495 larger than 4GB, we could allow other small values (such as the
4496 non-sensical values of 1, 2, and 3) to also be used as escape values
4497 indicating the presence of the old format.
4499 The value returned via bytes_read should be used to increment
4500 the relevant pointer after calling read_initial_length().
4502 As a side effect, this function sets the fields initial_length_size
4503 and offset_size in cu_header to the values appropriate for the
4504 length field. (The format of the initial length field determines
4505 the width of file offsets to be fetched later with fetch_offset().)
4507 [ Note: read_initial_length() and read_offset() are based on the
4508 document entitled "DWARF Debugging Information Format", revision
4509 3, draft 8, dated November 19, 2001. This document was obtained
4512 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4514 This document is only a draft and is subject to change. (So beware.)
4516 Details regarding the older, non-standard 64-bit format were
4517 determined empirically by examining 64-bit ELF files produced
4518 by the SGI toolchain on an IRIX 6.5 machine.
4520 - Kevin, July 16, 2002
4524 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4529 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4531 if (retval
== 0xffffffff)
4533 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4535 if (cu_header
!= NULL
)
4537 cu_header
->initial_length_size
= 12;
4538 cu_header
->offset_size
= 8;
4541 else if (retval
== 0)
4543 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4545 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4547 if (cu_header
!= NULL
)
4549 cu_header
->initial_length_size
= 8;
4550 cu_header
->offset_size
= 8;
4556 if (cu_header
!= NULL
)
4558 cu_header
->initial_length_size
= 4;
4559 cu_header
->offset_size
= 4;
4566 /* Read an offset from the data stream. The size of the offset is
4567 given by cu_header->offset_size. */
4570 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4575 switch (cu_header
->offset_size
)
4578 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4582 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4586 internal_error (__FILE__
, __LINE__
,
4587 "read_offset: bad switch [in module %s]",
4588 bfd_get_filename (abfd
));
4595 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4597 /* If the size of a host char is 8 bits, we can return a pointer
4598 to the buffer, otherwise we have to copy the data to a buffer
4599 allocated on the temporary obstack. */
4600 gdb_assert (HOST_CHAR_BIT
== 8);
4605 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4607 /* If the size of a host char is 8 bits, we can return a pointer
4608 to the string, otherwise we have to copy the string to a buffer
4609 allocated on the temporary obstack. */
4610 gdb_assert (HOST_CHAR_BIT
== 8);
4613 *bytes_read_ptr
= 1;
4616 *bytes_read_ptr
= strlen (buf
) + 1;
4621 read_indirect_string (bfd
*abfd
, char *buf
,
4622 const struct comp_unit_head
*cu_header
,
4623 unsigned int *bytes_read_ptr
)
4625 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4626 (int *) bytes_read_ptr
);
4628 if (dwarf_str_buffer
== NULL
)
4630 error ("DW_FORM_strp used without .debug_str section [in module %s]",
4631 bfd_get_filename (abfd
));
4634 if (str_offset
>= dwarf_str_size
)
4636 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4637 bfd_get_filename (abfd
));
4640 gdb_assert (HOST_CHAR_BIT
== 8);
4641 if (dwarf_str_buffer
[str_offset
] == '\0')
4643 return dwarf_str_buffer
+ str_offset
;
4646 static unsigned long
4647 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4649 unsigned long result
;
4650 unsigned int num_read
;
4660 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4663 result
|= ((unsigned long)(byte
& 127) << shift
);
4664 if ((byte
& 128) == 0)
4670 *bytes_read_ptr
= num_read
;
4675 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4678 int i
, shift
, size
, num_read
;
4688 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4691 result
|= ((long)(byte
& 127) << shift
);
4693 if ((byte
& 128) == 0)
4698 if ((shift
< size
) && (byte
& 0x40))
4700 result
|= -(1 << shift
);
4702 *bytes_read_ptr
= num_read
;
4707 set_cu_language (unsigned int lang
)
4713 cu_language
= language_c
;
4715 case DW_LANG_C_plus_plus
:
4716 cu_language
= language_cplus
;
4718 case DW_LANG_Fortran77
:
4719 case DW_LANG_Fortran90
:
4720 case DW_LANG_Fortran95
:
4721 cu_language
= language_fortran
;
4723 case DW_LANG_Mips_Assembler
:
4724 cu_language
= language_asm
;
4727 cu_language
= language_java
;
4731 case DW_LANG_Cobol74
:
4732 case DW_LANG_Cobol85
:
4733 case DW_LANG_Pascal83
:
4734 case DW_LANG_Modula2
:
4736 cu_language
= language_minimal
;
4739 cu_language_defn
= language_def (cu_language
);
4742 /* Return the named attribute or NULL if not there. */
4744 static struct attribute
*
4745 dwarf_attr (struct die_info
*die
, unsigned int name
)
4748 struct attribute
*spec
= NULL
;
4750 for (i
= 0; i
< die
->num_attrs
; ++i
)
4752 if (die
->attrs
[i
].name
== name
)
4754 return &die
->attrs
[i
];
4756 if (die
->attrs
[i
].name
== DW_AT_specification
4757 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4758 spec
= &die
->attrs
[i
];
4762 struct die_info
*ref_die
=
4763 follow_die_ref (dwarf2_get_ref_die_offset (spec
));
4766 return dwarf_attr (ref_die
, name
);
4773 die_is_declaration (struct die_info
*die
)
4775 return (dwarf_attr (die
, DW_AT_declaration
)
4776 && ! dwarf_attr (die
, DW_AT_specification
));
4780 /* Free the line_header structure *LH, and any arrays and strings it
4783 free_line_header (struct line_header
*lh
)
4785 if (lh
->standard_opcode_lengths
)
4786 xfree (lh
->standard_opcode_lengths
);
4788 /* Remember that all the lh->file_names[i].name pointers are
4789 pointers into debug_line_buffer, and don't need to be freed. */
4791 xfree (lh
->file_names
);
4793 /* Similarly for the include directory names. */
4794 if (lh
->include_dirs
)
4795 xfree (lh
->include_dirs
);
4801 /* Add an entry to LH's include directory table. */
4803 add_include_dir (struct line_header
*lh
, char *include_dir
)
4805 /* Grow the array if necessary. */
4806 if (lh
->include_dirs_size
== 0)
4808 lh
->include_dirs_size
= 1; /* for testing */
4809 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
4810 * sizeof (*lh
->include_dirs
));
4812 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
4814 lh
->include_dirs_size
*= 2;
4815 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
4816 (lh
->include_dirs_size
4817 * sizeof (*lh
->include_dirs
)));
4820 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
4824 /* Add an entry to LH's file name table. */
4826 add_file_name (struct line_header
*lh
,
4828 unsigned int dir_index
,
4829 unsigned int mod_time
,
4830 unsigned int length
)
4832 struct file_entry
*fe
;
4834 /* Grow the array if necessary. */
4835 if (lh
->file_names_size
== 0)
4837 lh
->file_names_size
= 1; /* for testing */
4838 lh
->file_names
= xmalloc (lh
->file_names_size
4839 * sizeof (*lh
->file_names
));
4841 else if (lh
->num_file_names
>= lh
->file_names_size
)
4843 lh
->file_names_size
*= 2;
4844 lh
->file_names
= xrealloc (lh
->file_names
,
4845 (lh
->file_names_size
4846 * sizeof (*lh
->file_names
)));
4849 fe
= &lh
->file_names
[lh
->num_file_names
++];
4851 fe
->dir_index
= dir_index
;
4852 fe
->mod_time
= mod_time
;
4853 fe
->length
= length
;
4857 /* Read the statement program header starting at OFFSET in
4858 dwarf_line_buffer, according to the endianness of ABFD. Return a
4859 pointer to a struct line_header, allocated using xmalloc.
4861 NOTE: the strings in the include directory and file name tables of
4862 the returned object point into debug_line_buffer, and must not be
4864 static struct line_header
*
4865 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
4866 struct dwarf2_cu
*cu
)
4868 struct cleanup
*back_to
;
4869 struct line_header
*lh
;
4873 char *cur_dir
, *cur_file
;
4875 if (dwarf_line_buffer
== NULL
)
4877 complaint (&symfile_complaints
, "missing .debug_line section");
4881 /* Make sure that at least there's room for the total_length field. That
4882 could be 12 bytes long, but we're just going to fudge that. */
4883 if (offset
+ 4 >= dwarf_line_size
)
4885 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4889 lh
= xmalloc (sizeof (*lh
));
4890 memset (lh
, 0, sizeof (*lh
));
4891 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
4894 line_ptr
= dwarf_line_buffer
+ offset
;
4896 /* read in the header */
4897 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
4898 line_ptr
+= bytes_read
;
4899 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
4901 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4904 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
4905 lh
->version
= read_2_bytes (abfd
, line_ptr
);
4907 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
4908 line_ptr
+= bytes_read
;
4909 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
4911 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
4913 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
4915 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
4917 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
4919 lh
->standard_opcode_lengths
4920 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
4922 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
4923 for (i
= 1; i
< lh
->opcode_base
; ++i
)
4925 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
4929 /* Read directory table */
4930 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4932 line_ptr
+= bytes_read
;
4933 add_include_dir (lh
, cur_dir
);
4935 line_ptr
+= bytes_read
;
4937 /* Read file name table */
4938 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
4940 unsigned int dir_index
, mod_time
, length
;
4942 line_ptr
+= bytes_read
;
4943 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4944 line_ptr
+= bytes_read
;
4945 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4946 line_ptr
+= bytes_read
;
4947 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
4948 line_ptr
+= bytes_read
;
4950 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
4952 line_ptr
+= bytes_read
;
4953 lh
->statement_program_start
= line_ptr
;
4955 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
4956 complaint (&symfile_complaints
,
4957 "line number info header doesn't fit in `.debug_line' section");
4959 discard_cleanups (back_to
);
4963 /* This function exists to work around a bug in certain compilers
4964 (particularly GCC 2.95), in which the first line number marker of a
4965 function does not show up until after the prologue, right before
4966 the second line number marker. This function shifts ADDRESS down
4967 to the beginning of the function if necessary, and is called on
4968 addresses passed to record_line. */
4971 check_cu_functions (CORE_ADDR address
)
4973 struct function_range
*fn
;
4975 /* Find the function_range containing address. */
4980 cu_cached_fn
= cu_first_fn
;
4984 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
4990 while (fn
&& fn
!= cu_cached_fn
)
4991 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5001 if (address
!= fn
->lowpc
)
5002 complaint (&symfile_complaints
,
5003 "misplaced first line number at 0x%lx for '%s'",
5004 (unsigned long) address
, fn
->name
);
5009 /* Decode the line number information for the compilation unit whose
5010 line number info is at OFFSET in the .debug_line section.
5011 The compilation directory of the file is passed in COMP_DIR. */
5014 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
5015 struct dwarf2_cu
*cu
)
5019 unsigned int bytes_read
;
5020 unsigned char op_code
, extended_op
, adj_opcode
;
5022 line_ptr
= lh
->statement_program_start
;
5023 line_end
= lh
->statement_program_end
;
5025 /* Read the statement sequences until there's nothing left. */
5026 while (line_ptr
< line_end
)
5028 /* state machine registers */
5029 CORE_ADDR address
= 0;
5030 unsigned int file
= 1;
5031 unsigned int line
= 1;
5032 unsigned int column
= 0;
5033 int is_stmt
= lh
->default_is_stmt
;
5034 int basic_block
= 0;
5035 int end_sequence
= 0;
5037 /* Start a subfile for the current file of the state machine. */
5038 if (lh
->num_file_names
>= file
)
5040 /* lh->include_dirs and lh->file_names are 0-based, but the
5041 directory and file name numbers in the statement program
5043 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
5046 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5049 dwarf2_start_subfile (fe
->name
, dir
);
5052 /* Decode the table. */
5053 while (!end_sequence
)
5055 op_code
= read_1_byte (abfd
, line_ptr
);
5058 if (op_code
>= lh
->opcode_base
)
5059 { /* Special operand. */
5060 adj_opcode
= op_code
- lh
->opcode_base
;
5061 address
+= (adj_opcode
/ lh
->line_range
)
5062 * lh
->minimum_instruction_length
;
5063 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
5064 /* append row to matrix using current values */
5065 record_line (current_subfile
, line
,
5066 check_cu_functions (address
));
5069 else switch (op_code
)
5071 case DW_LNS_extended_op
:
5072 line_ptr
+= 1; /* ignore length */
5073 extended_op
= read_1_byte (abfd
, line_ptr
);
5075 switch (extended_op
)
5077 case DW_LNE_end_sequence
:
5079 record_line (current_subfile
, 0, address
);
5081 case DW_LNE_set_address
:
5082 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
5083 line_ptr
+= bytes_read
;
5084 address
+= baseaddr
;
5086 case DW_LNE_define_file
:
5089 unsigned int dir_index
, mod_time
, length
;
5091 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
5092 line_ptr
+= bytes_read
;
5094 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5095 line_ptr
+= bytes_read
;
5097 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5098 line_ptr
+= bytes_read
;
5100 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5101 line_ptr
+= bytes_read
;
5102 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5106 complaint (&symfile_complaints
,
5107 "mangled .debug_line section");
5112 record_line (current_subfile
, line
,
5113 check_cu_functions (address
));
5116 case DW_LNS_advance_pc
:
5117 address
+= lh
->minimum_instruction_length
5118 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5119 line_ptr
+= bytes_read
;
5121 case DW_LNS_advance_line
:
5122 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
5123 line_ptr
+= bytes_read
;
5125 case DW_LNS_set_file
:
5127 /* lh->include_dirs and lh->file_names are 0-based,
5128 but the directory and file name numbers in the
5129 statement program are 1-based. */
5130 struct file_entry
*fe
;
5132 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5133 line_ptr
+= bytes_read
;
5134 fe
= &lh
->file_names
[file
- 1];
5136 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5139 dwarf2_start_subfile (fe
->name
, dir
);
5142 case DW_LNS_set_column
:
5143 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5144 line_ptr
+= bytes_read
;
5146 case DW_LNS_negate_stmt
:
5147 is_stmt
= (!is_stmt
);
5149 case DW_LNS_set_basic_block
:
5152 /* Add to the address register of the state machine the
5153 address increment value corresponding to special opcode
5154 255. Ie, this value is scaled by the minimum instruction
5155 length since special opcode 255 would have scaled the
5157 case DW_LNS_const_add_pc
:
5158 address
+= (lh
->minimum_instruction_length
5159 * ((255 - lh
->opcode_base
) / lh
->line_range
));
5161 case DW_LNS_fixed_advance_pc
:
5162 address
+= read_2_bytes (abfd
, line_ptr
);
5166 { /* Unknown standard opcode, ignore it. */
5168 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
5170 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5171 line_ptr
+= bytes_read
;
5179 /* Start a subfile for DWARF. FILENAME is the name of the file and
5180 DIRNAME the name of the source directory which contains FILENAME
5181 or NULL if not known.
5182 This routine tries to keep line numbers from identical absolute and
5183 relative file names in a common subfile.
5185 Using the `list' example from the GDB testsuite, which resides in
5186 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
5187 of /srcdir/list0.c yields the following debugging information for list0.c:
5189 DW_AT_name: /srcdir/list0.c
5190 DW_AT_comp_dir: /compdir
5191 files.files[0].name: list0.h
5192 files.files[0].dir: /srcdir
5193 files.files[1].name: list0.c
5194 files.files[1].dir: /srcdir
5196 The line number information for list0.c has to end up in a single
5197 subfile, so that `break /srcdir/list0.c:1' works as expected. */
5200 dwarf2_start_subfile (char *filename
, char *dirname
)
5202 /* If the filename isn't absolute, try to match an existing subfile
5203 with the full pathname. */
5205 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
5207 struct subfile
*subfile
;
5208 char *fullname
= concat (dirname
, "/", filename
, NULL
);
5210 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
5212 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
5214 current_subfile
= subfile
;
5221 start_subfile (filename
, dirname
);
5225 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
5226 struct dwarf2_cu
*cu
)
5228 struct objfile
*objfile
= cu
->objfile
;
5229 struct comp_unit_head
*cu_header
= &cu
->header
;
5231 /* NOTE drow/2003-01-30: There used to be a comment and some special
5232 code here to turn a symbol with DW_AT_external and a
5233 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
5234 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
5235 with some versions of binutils) where shared libraries could have
5236 relocations against symbols in their debug information - the
5237 minimal symbol would have the right address, but the debug info
5238 would not. It's no longer necessary, because we will explicitly
5239 apply relocations when we read in the debug information now. */
5241 /* A DW_AT_location attribute with no contents indicates that a
5242 variable has been optimized away. */
5243 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
5245 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
5249 /* Handle one degenerate form of location expression specially, to
5250 preserve GDB's previous behavior when section offsets are
5251 specified. If this is just a DW_OP_addr then mark this symbol
5254 if (attr_form_is_block (attr
)
5255 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
5256 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
5260 SYMBOL_VALUE_ADDRESS (sym
) =
5261 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
5262 fixup_symbol_section (sym
, objfile
);
5263 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
5264 SYMBOL_SECTION (sym
));
5265 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5269 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
5270 expression evaluator, and use LOC_COMPUTED only when necessary
5271 (i.e. when the value of a register or memory location is
5272 referenced, or a thread-local block, etc.). Then again, it might
5273 not be worthwhile. I'm assuming that it isn't unless performance
5274 or memory numbers show me otherwise. */
5276 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
5277 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
5280 /* Given a pointer to a DWARF information entry, figure out if we need
5281 to make a symbol table entry for it, and if so, create a new entry
5282 and return a pointer to it.
5283 If TYPE is NULL, determine symbol type from the die, otherwise
5284 used the passed type. */
5286 static struct symbol
*
5287 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
5289 struct objfile
*objfile
= cu
->objfile
;
5290 struct symbol
*sym
= NULL
;
5292 struct attribute
*attr
= NULL
;
5293 struct attribute
*attr2
= NULL
;
5295 if (die
->tag
!= DW_TAG_namespace
)
5296 name
= dwarf2_linkage_name (die
);
5298 name
= TYPE_NAME (type
);
5302 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
5303 sizeof (struct symbol
));
5304 OBJSTAT (objfile
, n_syms
++);
5305 memset (sym
, 0, sizeof (struct symbol
));
5307 /* Cache this symbol's name and the name's demangled form (if any). */
5308 SYMBOL_LANGUAGE (sym
) = cu_language
;
5309 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
5311 /* Default assumptions.
5312 Use the passed type or decode it from the die. */
5313 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5314 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5316 SYMBOL_TYPE (sym
) = type
;
5318 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
5319 attr
= dwarf_attr (die
, DW_AT_decl_line
);
5322 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
5327 attr
= dwarf_attr (die
, DW_AT_low_pc
);
5330 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
5332 SYMBOL_CLASS (sym
) = LOC_LABEL
;
5334 case DW_TAG_subprogram
:
5335 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
5337 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5338 attr2
= dwarf_attr (die
, DW_AT_external
);
5339 if (attr2
&& (DW_UNSND (attr2
) != 0))
5341 add_symbol_to_list (sym
, &global_symbols
);
5345 add_symbol_to_list (sym
, list_in_scope
);
5348 case DW_TAG_variable
:
5349 /* Compilation with minimal debug info may result in variables
5350 with missing type entries. Change the misleading `void' type
5351 to something sensible. */
5352 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
5353 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
5354 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
5355 "<variable, no debug info>",
5357 attr
= dwarf_attr (die
, DW_AT_const_value
);
5360 dwarf2_const_value (attr
, sym
, cu
);
5361 attr2
= dwarf_attr (die
, DW_AT_external
);
5362 if (attr2
&& (DW_UNSND (attr2
) != 0))
5363 add_symbol_to_list (sym
, &global_symbols
);
5365 add_symbol_to_list (sym
, list_in_scope
);
5368 attr
= dwarf_attr (die
, DW_AT_location
);
5371 var_decode_location (attr
, sym
, cu
);
5372 attr2
= dwarf_attr (die
, DW_AT_external
);
5373 if (attr2
&& (DW_UNSND (attr2
) != 0))
5374 add_symbol_to_list (sym
, &global_symbols
);
5376 add_symbol_to_list (sym
, list_in_scope
);
5380 /* We do not know the address of this symbol.
5381 If it is an external symbol and we have type information
5382 for it, enter the symbol as a LOC_UNRESOLVED symbol.
5383 The address of the variable will then be determined from
5384 the minimal symbol table whenever the variable is
5386 attr2
= dwarf_attr (die
, DW_AT_external
);
5387 if (attr2
&& (DW_UNSND (attr2
) != 0)
5388 && dwarf_attr (die
, DW_AT_type
) != NULL
)
5390 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
5391 add_symbol_to_list (sym
, &global_symbols
);
5395 case DW_TAG_formal_parameter
:
5396 attr
= dwarf_attr (die
, DW_AT_location
);
5399 var_decode_location (attr
, sym
, cu
);
5400 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
5401 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
5402 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
5404 attr
= dwarf_attr (die
, DW_AT_const_value
);
5407 dwarf2_const_value (attr
, sym
, cu
);
5409 add_symbol_to_list (sym
, list_in_scope
);
5411 case DW_TAG_unspecified_parameters
:
5412 /* From varargs functions; gdb doesn't seem to have any
5413 interest in this information, so just ignore it for now.
5416 case DW_TAG_class_type
:
5417 case DW_TAG_structure_type
:
5418 case DW_TAG_union_type
:
5419 case DW_TAG_enumeration_type
:
5420 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5421 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
5422 add_symbol_to_list (sym
, list_in_scope
);
5424 /* The semantics of C++ state that "struct foo { ... }" also
5425 defines a typedef for "foo". Synthesize a typedef symbol so
5426 that "ptype foo" works as expected. */
5427 if (cu_language
== language_cplus
)
5429 struct symbol
*typedef_sym
= (struct symbol
*)
5430 obstack_alloc (&objfile
->symbol_obstack
,
5431 sizeof (struct symbol
));
5432 *typedef_sym
= *sym
;
5433 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
5434 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5435 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5436 obsavestring (DEPRECATED_SYMBOL_NAME (sym
),
5437 strlen (DEPRECATED_SYMBOL_NAME (sym
)),
5438 &objfile
->type_obstack
);
5439 add_symbol_to_list (typedef_sym
, list_in_scope
);
5442 case DW_TAG_typedef
:
5443 case DW_TAG_base_type
:
5444 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5445 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5446 add_symbol_to_list (sym
, list_in_scope
);
5448 case DW_TAG_enumerator
:
5449 attr
= dwarf_attr (die
, DW_AT_const_value
);
5452 dwarf2_const_value (attr
, sym
, cu
);
5454 add_symbol_to_list (sym
, list_in_scope
);
5456 case DW_TAG_namespace
:
5457 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5458 add_symbol_to_list (sym
, &global_symbols
);
5461 /* Not a tag we recognize. Hopefully we aren't processing
5462 trash data, but since we must specifically ignore things
5463 we don't recognize, there is nothing else we should do at
5465 complaint (&symfile_complaints
, "unsupported tag: '%s'",
5466 dwarf_tag_name (die
->tag
));
5473 /* Copy constant value from an attribute to a symbol. */
5476 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5477 struct dwarf2_cu
*cu
)
5479 struct objfile
*objfile
= cu
->objfile
;
5480 struct comp_unit_head
*cu_header
= &cu
->header
;
5481 struct dwarf_block
*blk
;
5486 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5487 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5488 cu_header
->addr_size
,
5489 TYPE_LENGTH (SYMBOL_TYPE
5491 SYMBOL_VALUE_BYTES (sym
) = (char *)
5492 obstack_alloc (&objfile
->symbol_obstack
, cu_header
->addr_size
);
5493 /* NOTE: cagney/2003-05-09: In-lined store_address call with
5494 it's body - store_unsigned_integer. */
5495 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5497 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5499 case DW_FORM_block1
:
5500 case DW_FORM_block2
:
5501 case DW_FORM_block4
:
5503 blk
= DW_BLOCK (attr
);
5504 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5505 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5507 TYPE_LENGTH (SYMBOL_TYPE
5509 SYMBOL_VALUE_BYTES (sym
) = (char *)
5510 obstack_alloc (&objfile
->symbol_obstack
, blk
->size
);
5511 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5512 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5515 /* The DW_AT_const_value attributes are supposed to carry the
5516 symbol's value "represented as it would be on the target
5517 architecture." By the time we get here, it's already been
5518 converted to host endianness, so we just need to sign- or
5519 zero-extend it as appropriate. */
5521 dwarf2_const_value_data (attr
, sym
, 8);
5524 dwarf2_const_value_data (attr
, sym
, 16);
5527 dwarf2_const_value_data (attr
, sym
, 32);
5530 dwarf2_const_value_data (attr
, sym
, 64);
5534 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5535 SYMBOL_CLASS (sym
) = LOC_CONST
;
5539 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5540 SYMBOL_CLASS (sym
) = LOC_CONST
;
5544 complaint (&symfile_complaints
,
5545 "unsupported const value attribute form: '%s'",
5546 dwarf_form_name (attr
->form
));
5547 SYMBOL_VALUE (sym
) = 0;
5548 SYMBOL_CLASS (sym
) = LOC_CONST
;
5554 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5555 or zero-extend it as appropriate for the symbol's type. */
5557 dwarf2_const_value_data (struct attribute
*attr
,
5561 LONGEST l
= DW_UNSND (attr
);
5563 if (bits
< sizeof (l
) * 8)
5565 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5566 l
&= ((LONGEST
) 1 << bits
) - 1;
5568 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5571 SYMBOL_VALUE (sym
) = l
;
5572 SYMBOL_CLASS (sym
) = LOC_CONST
;
5576 /* Return the type of the die in question using its DW_AT_type attribute. */
5578 static struct type
*
5579 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5582 struct attribute
*type_attr
;
5583 struct die_info
*type_die
;
5586 type_attr
= dwarf_attr (die
, DW_AT_type
);
5589 /* A missing DW_AT_type represents a void type. */
5590 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
);
5594 ref
= dwarf2_get_ref_die_offset (type_attr
);
5595 type_die
= follow_die_ref (ref
);
5598 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5599 ref
, cu
->objfile
->name
);
5603 type
= tag_type_to_type (type_die
, cu
);
5606 dump_die (type_die
);
5607 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5613 /* Return the containing type of the die in question using its
5614 DW_AT_containing_type attribute. */
5616 static struct type
*
5617 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5619 struct type
*type
= NULL
;
5620 struct attribute
*type_attr
;
5621 struct die_info
*type_die
= NULL
;
5624 type_attr
= dwarf_attr (die
, DW_AT_containing_type
);
5627 ref
= dwarf2_get_ref_die_offset (type_attr
);
5628 type_die
= follow_die_ref (ref
);
5631 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref
,
5635 type
= tag_type_to_type (type_die
, cu
);
5640 dump_die (type_die
);
5641 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
5648 static struct type
*
5649 type_at_offset (unsigned int offset
, struct dwarf2_cu
*cu
)
5651 struct die_info
*die
;
5654 die
= follow_die_ref (offset
);
5657 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5660 type
= tag_type_to_type (die
, cu
);
5665 static struct type
*
5666 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5674 read_type_die (die
, cu
);
5678 error ("Dwarf Error: Cannot find type of die [in module %s]",
5686 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
5690 case DW_TAG_class_type
:
5691 case DW_TAG_structure_type
:
5692 case DW_TAG_union_type
:
5693 read_structure_scope (die
, cu
);
5695 case DW_TAG_enumeration_type
:
5696 read_enumeration (die
, cu
);
5698 case DW_TAG_subprogram
:
5699 case DW_TAG_subroutine_type
:
5700 read_subroutine_type (die
, cu
);
5702 case DW_TAG_array_type
:
5703 read_array_type (die
, cu
);
5705 case DW_TAG_pointer_type
:
5706 read_tag_pointer_type (die
, cu
);
5708 case DW_TAG_ptr_to_member_type
:
5709 read_tag_ptr_to_member_type (die
, cu
);
5711 case DW_TAG_reference_type
:
5712 read_tag_reference_type (die
, cu
);
5714 case DW_TAG_const_type
:
5715 read_tag_const_type (die
, cu
);
5717 case DW_TAG_volatile_type
:
5718 read_tag_volatile_type (die
, cu
);
5720 case DW_TAG_string_type
:
5721 read_tag_string_type (die
, cu
);
5723 case DW_TAG_typedef
:
5724 read_typedef (die
, cu
);
5726 case DW_TAG_base_type
:
5727 read_base_type (die
, cu
);
5730 complaint (&symfile_complaints
, "unexepected tag in read_type_die: '%s'",
5731 dwarf_tag_name (die
->tag
));
5736 static struct type
*
5737 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
5739 struct objfile
*objfile
= cu
->objfile
;
5741 /* FIXME - this should not produce a new (struct type *)
5742 every time. It should cache base types. */
5746 case DW_ATE_address
:
5747 type
= dwarf2_fundamental_type (objfile
, FT_VOID
);
5749 case DW_ATE_boolean
:
5750 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
);
5752 case DW_ATE_complex_float
:
5755 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
);
5759 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
);
5765 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
5769 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
);
5776 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5779 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
);
5783 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5787 case DW_ATE_signed_char
:
5788 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
);
5790 case DW_ATE_unsigned
:
5794 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5797 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
);
5801 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
5805 case DW_ATE_unsigned_char
:
5806 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
);
5809 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
);
5816 copy_die (struct die_info
*old_die
)
5818 struct die_info
*new_die
;
5821 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
5822 memset (new_die
, 0, sizeof (struct die_info
));
5824 new_die
->tag
= old_die
->tag
;
5825 new_die
->has_children
= old_die
->has_children
;
5826 new_die
->abbrev
= old_die
->abbrev
;
5827 new_die
->offset
= old_die
->offset
;
5828 new_die
->type
= NULL
;
5830 num_attrs
= old_die
->num_attrs
;
5831 new_die
->num_attrs
= num_attrs
;
5832 new_die
->attrs
= (struct attribute
*)
5833 xmalloc (num_attrs
* sizeof (struct attribute
));
5835 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
5837 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
5838 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
5839 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
5842 new_die
->next
= NULL
;
5847 /* Return sibling of die, NULL if no sibling. */
5849 static struct die_info
*
5850 sibling_die (struct die_info
*die
)
5852 return die
->sibling
;
5855 /* Get linkage name of a die, return NULL if not found. */
5858 dwarf2_linkage_name (struct die_info
*die
)
5860 struct attribute
*attr
;
5862 attr
= dwarf_attr (die
, DW_AT_MIPS_linkage_name
);
5863 if (attr
&& DW_STRING (attr
))
5864 return DW_STRING (attr
);
5865 attr
= dwarf_attr (die
, DW_AT_name
);
5866 if (attr
&& DW_STRING (attr
))
5867 return DW_STRING (attr
);
5871 /* Get name of a die, return NULL if not found. */
5874 dwarf2_name (struct die_info
*die
)
5876 struct attribute
*attr
;
5878 attr
= dwarf_attr (die
, DW_AT_name
);
5879 if (attr
&& DW_STRING (attr
))
5880 return DW_STRING (attr
);
5884 /* Return the die that this die in an extension of, or NULL if there
5887 static struct die_info
*
5888 dwarf2_extension (struct die_info
*die
)
5890 struct attribute
*attr
;
5891 struct die_info
*extension_die
;
5894 attr
= dwarf_attr (die
, DW_AT_extension
);
5898 ref
= dwarf2_get_ref_die_offset (attr
);
5899 extension_die
= follow_die_ref (ref
);
5902 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
5905 return extension_die
;
5908 /* Convert a DIE tag into its string name. */
5911 dwarf_tag_name (unsigned tag
)
5915 case DW_TAG_padding
:
5916 return "DW_TAG_padding";
5917 case DW_TAG_array_type
:
5918 return "DW_TAG_array_type";
5919 case DW_TAG_class_type
:
5920 return "DW_TAG_class_type";
5921 case DW_TAG_entry_point
:
5922 return "DW_TAG_entry_point";
5923 case DW_TAG_enumeration_type
:
5924 return "DW_TAG_enumeration_type";
5925 case DW_TAG_formal_parameter
:
5926 return "DW_TAG_formal_parameter";
5927 case DW_TAG_imported_declaration
:
5928 return "DW_TAG_imported_declaration";
5930 return "DW_TAG_label";
5931 case DW_TAG_lexical_block
:
5932 return "DW_TAG_lexical_block";
5934 return "DW_TAG_member";
5935 case DW_TAG_pointer_type
:
5936 return "DW_TAG_pointer_type";
5937 case DW_TAG_reference_type
:
5938 return "DW_TAG_reference_type";
5939 case DW_TAG_compile_unit
:
5940 return "DW_TAG_compile_unit";
5941 case DW_TAG_string_type
:
5942 return "DW_TAG_string_type";
5943 case DW_TAG_structure_type
:
5944 return "DW_TAG_structure_type";
5945 case DW_TAG_subroutine_type
:
5946 return "DW_TAG_subroutine_type";
5947 case DW_TAG_typedef
:
5948 return "DW_TAG_typedef";
5949 case DW_TAG_union_type
:
5950 return "DW_TAG_union_type";
5951 case DW_TAG_unspecified_parameters
:
5952 return "DW_TAG_unspecified_parameters";
5953 case DW_TAG_variant
:
5954 return "DW_TAG_variant";
5955 case DW_TAG_common_block
:
5956 return "DW_TAG_common_block";
5957 case DW_TAG_common_inclusion
:
5958 return "DW_TAG_common_inclusion";
5959 case DW_TAG_inheritance
:
5960 return "DW_TAG_inheritance";
5961 case DW_TAG_inlined_subroutine
:
5962 return "DW_TAG_inlined_subroutine";
5964 return "DW_TAG_module";
5965 case DW_TAG_ptr_to_member_type
:
5966 return "DW_TAG_ptr_to_member_type";
5967 case DW_TAG_set_type
:
5968 return "DW_TAG_set_type";
5969 case DW_TAG_subrange_type
:
5970 return "DW_TAG_subrange_type";
5971 case DW_TAG_with_stmt
:
5972 return "DW_TAG_with_stmt";
5973 case DW_TAG_access_declaration
:
5974 return "DW_TAG_access_declaration";
5975 case DW_TAG_base_type
:
5976 return "DW_TAG_base_type";
5977 case DW_TAG_catch_block
:
5978 return "DW_TAG_catch_block";
5979 case DW_TAG_const_type
:
5980 return "DW_TAG_const_type";
5981 case DW_TAG_constant
:
5982 return "DW_TAG_constant";
5983 case DW_TAG_enumerator
:
5984 return "DW_TAG_enumerator";
5985 case DW_TAG_file_type
:
5986 return "DW_TAG_file_type";
5988 return "DW_TAG_friend";
5989 case DW_TAG_namelist
:
5990 return "DW_TAG_namelist";
5991 case DW_TAG_namelist_item
:
5992 return "DW_TAG_namelist_item";
5993 case DW_TAG_packed_type
:
5994 return "DW_TAG_packed_type";
5995 case DW_TAG_subprogram
:
5996 return "DW_TAG_subprogram";
5997 case DW_TAG_template_type_param
:
5998 return "DW_TAG_template_type_param";
5999 case DW_TAG_template_value_param
:
6000 return "DW_TAG_template_value_param";
6001 case DW_TAG_thrown_type
:
6002 return "DW_TAG_thrown_type";
6003 case DW_TAG_try_block
:
6004 return "DW_TAG_try_block";
6005 case DW_TAG_variant_part
:
6006 return "DW_TAG_variant_part";
6007 case DW_TAG_variable
:
6008 return "DW_TAG_variable";
6009 case DW_TAG_volatile_type
:
6010 return "DW_TAG_volatile_type";
6011 case DW_TAG_dwarf_procedure
:
6012 return "DW_TAG_dwarf_procedure";
6013 case DW_TAG_restrict_type
:
6014 return "DW_TAG_restrict_type";
6015 case DW_TAG_interface_type
:
6016 return "DW_TAG_interface_type";
6017 case DW_TAG_namespace
:
6018 return "DW_TAG_namespace";
6019 case DW_TAG_imported_module
:
6020 return "DW_TAG_imported_module";
6021 case DW_TAG_unspecified_type
:
6022 return "DW_TAG_unspecified_type";
6023 case DW_TAG_partial_unit
:
6024 return "DW_TAG_partial_unit";
6025 case DW_TAG_imported_unit
:
6026 return "DW_TAG_imported_unit";
6027 case DW_TAG_MIPS_loop
:
6028 return "DW_TAG_MIPS_loop";
6029 case DW_TAG_format_label
:
6030 return "DW_TAG_format_label";
6031 case DW_TAG_function_template
:
6032 return "DW_TAG_function_template";
6033 case DW_TAG_class_template
:
6034 return "DW_TAG_class_template";
6036 return "DW_TAG_<unknown>";
6040 /* Convert a DWARF attribute code into its string name. */
6043 dwarf_attr_name (unsigned attr
)
6048 return "DW_AT_sibling";
6049 case DW_AT_location
:
6050 return "DW_AT_location";
6052 return "DW_AT_name";
6053 case DW_AT_ordering
:
6054 return "DW_AT_ordering";
6055 case DW_AT_subscr_data
:
6056 return "DW_AT_subscr_data";
6057 case DW_AT_byte_size
:
6058 return "DW_AT_byte_size";
6059 case DW_AT_bit_offset
:
6060 return "DW_AT_bit_offset";
6061 case DW_AT_bit_size
:
6062 return "DW_AT_bit_size";
6063 case DW_AT_element_list
:
6064 return "DW_AT_element_list";
6065 case DW_AT_stmt_list
:
6066 return "DW_AT_stmt_list";
6068 return "DW_AT_low_pc";
6070 return "DW_AT_high_pc";
6071 case DW_AT_language
:
6072 return "DW_AT_language";
6074 return "DW_AT_member";
6076 return "DW_AT_discr";
6077 case DW_AT_discr_value
:
6078 return "DW_AT_discr_value";
6079 case DW_AT_visibility
:
6080 return "DW_AT_visibility";
6082 return "DW_AT_import";
6083 case DW_AT_string_length
:
6084 return "DW_AT_string_length";
6085 case DW_AT_common_reference
:
6086 return "DW_AT_common_reference";
6087 case DW_AT_comp_dir
:
6088 return "DW_AT_comp_dir";
6089 case DW_AT_const_value
:
6090 return "DW_AT_const_value";
6091 case DW_AT_containing_type
:
6092 return "DW_AT_containing_type";
6093 case DW_AT_default_value
:
6094 return "DW_AT_default_value";
6096 return "DW_AT_inline";
6097 case DW_AT_is_optional
:
6098 return "DW_AT_is_optional";
6099 case DW_AT_lower_bound
:
6100 return "DW_AT_lower_bound";
6101 case DW_AT_producer
:
6102 return "DW_AT_producer";
6103 case DW_AT_prototyped
:
6104 return "DW_AT_prototyped";
6105 case DW_AT_return_addr
:
6106 return "DW_AT_return_addr";
6107 case DW_AT_start_scope
:
6108 return "DW_AT_start_scope";
6109 case DW_AT_stride_size
:
6110 return "DW_AT_stride_size";
6111 case DW_AT_upper_bound
:
6112 return "DW_AT_upper_bound";
6113 case DW_AT_abstract_origin
:
6114 return "DW_AT_abstract_origin";
6115 case DW_AT_accessibility
:
6116 return "DW_AT_accessibility";
6117 case DW_AT_address_class
:
6118 return "DW_AT_address_class";
6119 case DW_AT_artificial
:
6120 return "DW_AT_artificial";
6121 case DW_AT_base_types
:
6122 return "DW_AT_base_types";
6123 case DW_AT_calling_convention
:
6124 return "DW_AT_calling_convention";
6126 return "DW_AT_count";
6127 case DW_AT_data_member_location
:
6128 return "DW_AT_data_member_location";
6129 case DW_AT_decl_column
:
6130 return "DW_AT_decl_column";
6131 case DW_AT_decl_file
:
6132 return "DW_AT_decl_file";
6133 case DW_AT_decl_line
:
6134 return "DW_AT_decl_line";
6135 case DW_AT_declaration
:
6136 return "DW_AT_declaration";
6137 case DW_AT_discr_list
:
6138 return "DW_AT_discr_list";
6139 case DW_AT_encoding
:
6140 return "DW_AT_encoding";
6141 case DW_AT_external
:
6142 return "DW_AT_external";
6143 case DW_AT_frame_base
:
6144 return "DW_AT_frame_base";
6146 return "DW_AT_friend";
6147 case DW_AT_identifier_case
:
6148 return "DW_AT_identifier_case";
6149 case DW_AT_macro_info
:
6150 return "DW_AT_macro_info";
6151 case DW_AT_namelist_items
:
6152 return "DW_AT_namelist_items";
6153 case DW_AT_priority
:
6154 return "DW_AT_priority";
6156 return "DW_AT_segment";
6157 case DW_AT_specification
:
6158 return "DW_AT_specification";
6159 case DW_AT_static_link
:
6160 return "DW_AT_static_link";
6162 return "DW_AT_type";
6163 case DW_AT_use_location
:
6164 return "DW_AT_use_location";
6165 case DW_AT_variable_parameter
:
6166 return "DW_AT_variable_parameter";
6167 case DW_AT_virtuality
:
6168 return "DW_AT_virtuality";
6169 case DW_AT_vtable_elem_location
:
6170 return "DW_AT_vtable_elem_location";
6171 case DW_AT_allocated
:
6172 return "DW_AT_allocated";
6173 case DW_AT_associated
:
6174 return "DW_AT_associated";
6175 case DW_AT_data_location
:
6176 return "DW_AT_data_location";
6178 return "DW_AT_stride";
6179 case DW_AT_entry_pc
:
6180 return "DW_AT_entry_pc";
6181 case DW_AT_use_UTF8
:
6182 return "DW_AT_use_UTF8";
6183 case DW_AT_extension
:
6184 return "DW_AT_extension";
6186 return "DW_AT_ranges";
6187 case DW_AT_trampoline
:
6188 return "DW_AT_trampoline";
6189 case DW_AT_call_column
:
6190 return "DW_AT_call_column";
6191 case DW_AT_call_file
:
6192 return "DW_AT_call_file";
6193 case DW_AT_call_line
:
6194 return "DW_AT_call_line";
6196 case DW_AT_MIPS_fde
:
6197 return "DW_AT_MIPS_fde";
6198 case DW_AT_MIPS_loop_begin
:
6199 return "DW_AT_MIPS_loop_begin";
6200 case DW_AT_MIPS_tail_loop_begin
:
6201 return "DW_AT_MIPS_tail_loop_begin";
6202 case DW_AT_MIPS_epilog_begin
:
6203 return "DW_AT_MIPS_epilog_begin";
6204 case DW_AT_MIPS_loop_unroll_factor
:
6205 return "DW_AT_MIPS_loop_unroll_factor";
6206 case DW_AT_MIPS_software_pipeline_depth
:
6207 return "DW_AT_MIPS_software_pipeline_depth";
6209 case DW_AT_MIPS_linkage_name
:
6210 return "DW_AT_MIPS_linkage_name";
6212 case DW_AT_sf_names
:
6213 return "DW_AT_sf_names";
6214 case DW_AT_src_info
:
6215 return "DW_AT_src_info";
6216 case DW_AT_mac_info
:
6217 return "DW_AT_mac_info";
6218 case DW_AT_src_coords
:
6219 return "DW_AT_src_coords";
6220 case DW_AT_body_begin
:
6221 return "DW_AT_body_begin";
6222 case DW_AT_body_end
:
6223 return "DW_AT_body_end";
6224 case DW_AT_GNU_vector
:
6225 return "DW_AT_GNU_vector";
6227 return "DW_AT_<unknown>";
6231 /* Convert a DWARF value form code into its string name. */
6234 dwarf_form_name (unsigned form
)
6239 return "DW_FORM_addr";
6240 case DW_FORM_block2
:
6241 return "DW_FORM_block2";
6242 case DW_FORM_block4
:
6243 return "DW_FORM_block4";
6245 return "DW_FORM_data2";
6247 return "DW_FORM_data4";
6249 return "DW_FORM_data8";
6250 case DW_FORM_string
:
6251 return "DW_FORM_string";
6253 return "DW_FORM_block";
6254 case DW_FORM_block1
:
6255 return "DW_FORM_block1";
6257 return "DW_FORM_data1";
6259 return "DW_FORM_flag";
6261 return "DW_FORM_sdata";
6263 return "DW_FORM_strp";
6265 return "DW_FORM_udata";
6266 case DW_FORM_ref_addr
:
6267 return "DW_FORM_ref_addr";
6269 return "DW_FORM_ref1";
6271 return "DW_FORM_ref2";
6273 return "DW_FORM_ref4";
6275 return "DW_FORM_ref8";
6276 case DW_FORM_ref_udata
:
6277 return "DW_FORM_ref_udata";
6278 case DW_FORM_indirect
:
6279 return "DW_FORM_indirect";
6281 return "DW_FORM_<unknown>";
6285 /* Convert a DWARF stack opcode into its string name. */
6288 dwarf_stack_op_name (unsigned op
)
6293 return "DW_OP_addr";
6295 return "DW_OP_deref";
6297 return "DW_OP_const1u";
6299 return "DW_OP_const1s";
6301 return "DW_OP_const2u";
6303 return "DW_OP_const2s";
6305 return "DW_OP_const4u";
6307 return "DW_OP_const4s";
6309 return "DW_OP_const8u";
6311 return "DW_OP_const8s";
6313 return "DW_OP_constu";
6315 return "DW_OP_consts";
6319 return "DW_OP_drop";
6321 return "DW_OP_over";
6323 return "DW_OP_pick";
6325 return "DW_OP_swap";
6329 return "DW_OP_xderef";
6337 return "DW_OP_minus";
6349 return "DW_OP_plus";
6350 case DW_OP_plus_uconst
:
6351 return "DW_OP_plus_uconst";
6357 return "DW_OP_shra";
6375 return "DW_OP_skip";
6377 return "DW_OP_lit0";
6379 return "DW_OP_lit1";
6381 return "DW_OP_lit2";
6383 return "DW_OP_lit3";
6385 return "DW_OP_lit4";
6387 return "DW_OP_lit5";
6389 return "DW_OP_lit6";
6391 return "DW_OP_lit7";
6393 return "DW_OP_lit8";
6395 return "DW_OP_lit9";
6397 return "DW_OP_lit10";
6399 return "DW_OP_lit11";
6401 return "DW_OP_lit12";
6403 return "DW_OP_lit13";
6405 return "DW_OP_lit14";
6407 return "DW_OP_lit15";
6409 return "DW_OP_lit16";
6411 return "DW_OP_lit17";
6413 return "DW_OP_lit18";
6415 return "DW_OP_lit19";
6417 return "DW_OP_lit20";
6419 return "DW_OP_lit21";
6421 return "DW_OP_lit22";
6423 return "DW_OP_lit23";
6425 return "DW_OP_lit24";
6427 return "DW_OP_lit25";
6429 return "DW_OP_lit26";
6431 return "DW_OP_lit27";
6433 return "DW_OP_lit28";
6435 return "DW_OP_lit29";
6437 return "DW_OP_lit30";
6439 return "DW_OP_lit31";
6441 return "DW_OP_reg0";
6443 return "DW_OP_reg1";
6445 return "DW_OP_reg2";
6447 return "DW_OP_reg3";
6449 return "DW_OP_reg4";
6451 return "DW_OP_reg5";
6453 return "DW_OP_reg6";
6455 return "DW_OP_reg7";
6457 return "DW_OP_reg8";
6459 return "DW_OP_reg9";
6461 return "DW_OP_reg10";
6463 return "DW_OP_reg11";
6465 return "DW_OP_reg12";
6467 return "DW_OP_reg13";
6469 return "DW_OP_reg14";
6471 return "DW_OP_reg15";
6473 return "DW_OP_reg16";
6475 return "DW_OP_reg17";
6477 return "DW_OP_reg18";
6479 return "DW_OP_reg19";
6481 return "DW_OP_reg20";
6483 return "DW_OP_reg21";
6485 return "DW_OP_reg22";
6487 return "DW_OP_reg23";
6489 return "DW_OP_reg24";
6491 return "DW_OP_reg25";
6493 return "DW_OP_reg26";
6495 return "DW_OP_reg27";
6497 return "DW_OP_reg28";
6499 return "DW_OP_reg29";
6501 return "DW_OP_reg30";
6503 return "DW_OP_reg31";
6505 return "DW_OP_breg0";
6507 return "DW_OP_breg1";
6509 return "DW_OP_breg2";
6511 return "DW_OP_breg3";
6513 return "DW_OP_breg4";
6515 return "DW_OP_breg5";
6517 return "DW_OP_breg6";
6519 return "DW_OP_breg7";
6521 return "DW_OP_breg8";
6523 return "DW_OP_breg9";
6525 return "DW_OP_breg10";
6527 return "DW_OP_breg11";
6529 return "DW_OP_breg12";
6531 return "DW_OP_breg13";
6533 return "DW_OP_breg14";
6535 return "DW_OP_breg15";
6537 return "DW_OP_breg16";
6539 return "DW_OP_breg17";
6541 return "DW_OP_breg18";
6543 return "DW_OP_breg19";
6545 return "DW_OP_breg20";
6547 return "DW_OP_breg21";
6549 return "DW_OP_breg22";
6551 return "DW_OP_breg23";
6553 return "DW_OP_breg24";
6555 return "DW_OP_breg25";
6557 return "DW_OP_breg26";
6559 return "DW_OP_breg27";
6561 return "DW_OP_breg28";
6563 return "DW_OP_breg29";
6565 return "DW_OP_breg30";
6567 return "DW_OP_breg31";
6569 return "DW_OP_regx";
6571 return "DW_OP_fbreg";
6573 return "DW_OP_bregx";
6575 return "DW_OP_piece";
6576 case DW_OP_deref_size
:
6577 return "DW_OP_deref_size";
6578 case DW_OP_xderef_size
:
6579 return "DW_OP_xderef_size";
6582 /* DWARF 3 extensions. */
6583 case DW_OP_push_object_address
:
6584 return "DW_OP_push_object_address";
6586 return "DW_OP_call2";
6588 return "DW_OP_call4";
6589 case DW_OP_call_ref
:
6590 return "DW_OP_call_ref";
6591 /* GNU extensions. */
6592 case DW_OP_GNU_push_tls_address
:
6593 return "DW_OP_GNU_push_tls_address";
6595 return "OP_<unknown>";
6600 dwarf_bool_name (unsigned mybool
)
6608 /* Convert a DWARF type code into its string name. */
6611 dwarf_type_encoding_name (unsigned enc
)
6615 case DW_ATE_address
:
6616 return "DW_ATE_address";
6617 case DW_ATE_boolean
:
6618 return "DW_ATE_boolean";
6619 case DW_ATE_complex_float
:
6620 return "DW_ATE_complex_float";
6622 return "DW_ATE_float";
6624 return "DW_ATE_signed";
6625 case DW_ATE_signed_char
:
6626 return "DW_ATE_signed_char";
6627 case DW_ATE_unsigned
:
6628 return "DW_ATE_unsigned";
6629 case DW_ATE_unsigned_char
:
6630 return "DW_ATE_unsigned_char";
6631 case DW_ATE_imaginary_float
:
6632 return "DW_ATE_imaginary_float";
6634 return "DW_ATE_<unknown>";
6638 /* Convert a DWARF call frame info operation to its string name. */
6642 dwarf_cfi_name (unsigned cfi_opc
)
6646 case DW_CFA_advance_loc
:
6647 return "DW_CFA_advance_loc";
6649 return "DW_CFA_offset";
6650 case DW_CFA_restore
:
6651 return "DW_CFA_restore";
6653 return "DW_CFA_nop";
6654 case DW_CFA_set_loc
:
6655 return "DW_CFA_set_loc";
6656 case DW_CFA_advance_loc1
:
6657 return "DW_CFA_advance_loc1";
6658 case DW_CFA_advance_loc2
:
6659 return "DW_CFA_advance_loc2";
6660 case DW_CFA_advance_loc4
:
6661 return "DW_CFA_advance_loc4";
6662 case DW_CFA_offset_extended
:
6663 return "DW_CFA_offset_extended";
6664 case DW_CFA_restore_extended
:
6665 return "DW_CFA_restore_extended";
6666 case DW_CFA_undefined
:
6667 return "DW_CFA_undefined";
6668 case DW_CFA_same_value
:
6669 return "DW_CFA_same_value";
6670 case DW_CFA_register
:
6671 return "DW_CFA_register";
6672 case DW_CFA_remember_state
:
6673 return "DW_CFA_remember_state";
6674 case DW_CFA_restore_state
:
6675 return "DW_CFA_restore_state";
6676 case DW_CFA_def_cfa
:
6677 return "DW_CFA_def_cfa";
6678 case DW_CFA_def_cfa_register
:
6679 return "DW_CFA_def_cfa_register";
6680 case DW_CFA_def_cfa_offset
:
6681 return "DW_CFA_def_cfa_offset";
6684 case DW_CFA_def_cfa_expression
:
6685 return "DW_CFA_def_cfa_expression";
6686 case DW_CFA_expression
:
6687 return "DW_CFA_expression";
6688 case DW_CFA_offset_extended_sf
:
6689 return "DW_CFA_offset_extended_sf";
6690 case DW_CFA_def_cfa_sf
:
6691 return "DW_CFA_def_cfa_sf";
6692 case DW_CFA_def_cfa_offset_sf
:
6693 return "DW_CFA_def_cfa_offset_sf";
6695 /* SGI/MIPS specific */
6696 case DW_CFA_MIPS_advance_loc8
:
6697 return "DW_CFA_MIPS_advance_loc8";
6699 /* GNU extensions */
6700 case DW_CFA_GNU_window_save
:
6701 return "DW_CFA_GNU_window_save";
6702 case DW_CFA_GNU_args_size
:
6703 return "DW_CFA_GNU_args_size";
6704 case DW_CFA_GNU_negative_offset_extended
:
6705 return "DW_CFA_GNU_negative_offset_extended";
6708 return "DW_CFA_<unknown>";
6714 dump_die (struct die_info
*die
)
6718 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
6719 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
6720 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
6721 dwarf_bool_name (die
->child
!= NULL
));
6723 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
6724 for (i
= 0; i
< die
->num_attrs
; ++i
)
6726 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
6727 dwarf_attr_name (die
->attrs
[i
].name
),
6728 dwarf_form_name (die
->attrs
[i
].form
));
6729 switch (die
->attrs
[i
].form
)
6731 case DW_FORM_ref_addr
:
6733 fprintf_unfiltered (gdb_stderr
, "address: ");
6734 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
6736 case DW_FORM_block2
:
6737 case DW_FORM_block4
:
6739 case DW_FORM_block1
:
6740 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
6751 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
6753 case DW_FORM_string
:
6755 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
6756 DW_STRING (&die
->attrs
[i
])
6757 ? DW_STRING (&die
->attrs
[i
]) : "");
6760 if (DW_UNSND (&die
->attrs
[i
]))
6761 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
6763 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
6765 case DW_FORM_indirect
:
6766 /* the reader will have reduced the indirect form to
6767 the "base form" so this form should not occur */
6768 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
6771 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
6772 die
->attrs
[i
].form
);
6774 fprintf_unfiltered (gdb_stderr
, "\n");
6779 dump_die_list (struct die_info
*die
)
6784 if (die
->child
!= NULL
)
6785 dump_die_list (die
->child
);
6786 if (die
->sibling
!= NULL
)
6787 dump_die_list (die
->sibling
);
6792 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
6795 struct die_info
*old
;
6797 h
= (offset
% REF_HASH_SIZE
);
6798 old
= die_ref_table
[h
];
6799 die
->next_ref
= old
;
6800 die_ref_table
[h
] = die
;
6805 dwarf2_empty_hash_tables (void)
6807 memset (die_ref_table
, 0, sizeof (die_ref_table
));
6811 dwarf2_get_ref_die_offset (struct attribute
*attr
)
6813 unsigned int result
= 0;
6817 case DW_FORM_ref_addr
:
6818 result
= DW_ADDR (attr
);
6824 case DW_FORM_ref_udata
:
6825 result
= cu_header_offset
+ DW_UNSND (attr
);
6828 complaint (&symfile_complaints
,
6829 "unsupported die ref attribute form: '%s'",
6830 dwarf_form_name (attr
->form
));
6835 static struct die_info
*
6836 follow_die_ref (unsigned int offset
)
6838 struct die_info
*die
;
6841 h
= (offset
% REF_HASH_SIZE
);
6842 die
= die_ref_table
[h
];
6845 if (die
->offset
== offset
)
6849 die
= die
->next_ref
;
6854 static struct type
*
6855 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid)
6857 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
6859 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
6860 typeid, objfile
->name
);
6863 /* Look for this particular type in the fundamental type vector. If
6864 one is not found, create and install one appropriate for the
6865 current language and the current target machine. */
6867 if (ftypes
[typeid] == NULL
)
6869 ftypes
[typeid] = cu_language_defn
->la_fund_type (objfile
, typeid);
6872 return (ftypes
[typeid]);
6875 /* Decode simple location descriptions.
6876 Given a pointer to a dwarf block that defines a location, compute
6877 the location and return the value.
6879 FIXME: This is a kludge until we figure out a better
6880 way to handle the location descriptions.
6881 Gdb's design does not mesh well with the DWARF2 notion of a location
6882 computing interpreter, which is a shame because the flexibility goes unused.
6883 FIXME: Implement more operations as necessary.
6885 A location description containing no operations indicates that the
6886 object is optimized out. The return value is meaningless for that case.
6887 FIXME drow/2003-11-16: No callers check for this case any more; soon all
6888 callers will only want a very basic result and this can become a
6891 When the result is a register number, the global isreg flag is set,
6892 otherwise it is cleared.
6894 When the result is a base register offset, the global offreg flag is set
6895 and the register number is returned in basereg, otherwise it is cleared.
6897 When the DW_OP_fbreg operation is encountered without a corresponding
6898 DW_AT_frame_base attribute, we complain.
6900 Note that stack[0] is unused except as a default error return.
6901 Note that stack overflow is not yet handled. */
6904 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
6906 struct objfile
*objfile
= cu
->objfile
;
6907 struct comp_unit_head
*cu_header
= &cu
->header
;
6909 int size
= blk
->size
;
6910 char *data
= blk
->data
;
6911 CORE_ADDR stack
[64];
6913 unsigned int bytes_read
, unsnd
;
6960 stack
[++stacki
] = op
- DW_OP_lit0
;
6996 stack
[++stacki
] = op
- DW_OP_reg0
;
7001 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7003 stack
[++stacki
] = unsnd
;
7039 basereg
= op
- DW_OP_breg0
;
7040 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7046 basereg
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7048 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7053 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7055 if (frame_base_reg
>= 0)
7058 basereg
= frame_base_reg
;
7059 stack
[stacki
] += frame_base_offset
;
7063 complaint (&symfile_complaints
,
7064 "DW_AT_frame_base missing for DW_OP_fbreg");
7069 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
7075 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
7080 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
7085 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
7090 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
7095 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
7100 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
7105 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
7111 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7116 stack
[stacki
+ 1] = stack
[stacki
];
7121 stack
[stacki
- 1] += stack
[stacki
];
7125 case DW_OP_plus_uconst
:
7126 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7131 stack
[stacki
- 1] -= stack
[stacki
];
7137 /* If we're not the last op, then we definitely can't encode
7138 this using GDB's address_class enum. */
7140 dwarf2_complex_location_expr_complaint ();
7143 case DW_OP_GNU_push_tls_address
:
7144 /* The top of the stack has the offset from the beginning
7145 of the thread control block at which the variable is located. */
7146 /* Nothing should follow this operator, so the top of stack would
7149 dwarf2_complex_location_expr_complaint ();
7153 complaint (&symfile_complaints
, "unsupported stack op: '%s'",
7154 dwarf_stack_op_name (op
));
7155 return (stack
[stacki
]);
7158 return (stack
[stacki
]);
7161 /* memory allocation interface */
7164 dwarf2_free_tmp_obstack (void *ignore
)
7166 obstack_free (&dwarf2_tmp_obstack
, NULL
);
7169 static struct dwarf_block
*
7170 dwarf_alloc_block (void)
7172 struct dwarf_block
*blk
;
7174 blk
= (struct dwarf_block
*)
7175 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
7179 static struct abbrev_info
*
7180 dwarf_alloc_abbrev (void)
7182 struct abbrev_info
*abbrev
;
7184 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
7185 memset (abbrev
, 0, sizeof (struct abbrev_info
));
7189 static struct die_info
*
7190 dwarf_alloc_die (void)
7192 struct die_info
*die
;
7194 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7195 memset (die
, 0, sizeof (struct die_info
));
7200 /* Macro support. */
7203 /* Return the full name of file number I in *LH's file name table.
7204 Use COMP_DIR as the name of the current directory of the
7205 compilation. The result is allocated using xmalloc; the caller is
7206 responsible for freeing it. */
7208 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
7210 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
7212 if (IS_ABSOLUTE_PATH (fe
->name
))
7213 return xstrdup (fe
->name
);
7221 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7227 dir_len
= strlen (dir
);
7228 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
7229 strcpy (full_name
, dir
);
7230 full_name
[dir_len
] = '/';
7231 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
7235 return xstrdup (fe
->name
);
7240 static struct macro_source_file
*
7241 macro_start_file (int file
, int line
,
7242 struct macro_source_file
*current_file
,
7243 const char *comp_dir
,
7244 struct line_header
*lh
, struct objfile
*objfile
)
7246 /* The full name of this source file. */
7247 char *full_name
= file_full_name (file
, lh
, comp_dir
);
7249 /* We don't create a macro table for this compilation unit
7250 at all until we actually get a filename. */
7251 if (! pending_macros
)
7252 pending_macros
= new_macro_table (&objfile
->symbol_obstack
,
7253 objfile
->macro_cache
);
7256 /* If we have no current file, then this must be the start_file
7257 directive for the compilation unit's main source file. */
7258 current_file
= macro_set_main (pending_macros
, full_name
);
7260 current_file
= macro_include (current_file
, line
, full_name
);
7264 return current_file
;
7268 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7269 followed by a null byte. */
7271 copy_string (const char *buf
, int len
)
7273 char *s
= xmalloc (len
+ 1);
7274 memcpy (s
, buf
, len
);
7282 consume_improper_spaces (const char *p
, const char *body
)
7286 complaint (&symfile_complaints
,
7287 "macro definition contains spaces in formal argument list:\n`%s'",
7299 parse_macro_definition (struct macro_source_file
*file
, int line
,
7304 /* The body string takes one of two forms. For object-like macro
7305 definitions, it should be:
7307 <macro name> " " <definition>
7309 For function-like macro definitions, it should be:
7311 <macro name> "() " <definition>
7313 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7315 Spaces may appear only where explicitly indicated, and in the
7318 The Dwarf 2 spec says that an object-like macro's name is always
7319 followed by a space, but versions of GCC around March 2002 omit
7320 the space when the macro's definition is the empty string.
7322 The Dwarf 2 spec says that there should be no spaces between the
7323 formal arguments in a function-like macro's formal argument list,
7324 but versions of GCC around March 2002 include spaces after the
7328 /* Find the extent of the macro name. The macro name is terminated
7329 by either a space or null character (for an object-like macro) or
7330 an opening paren (for a function-like macro). */
7331 for (p
= body
; *p
; p
++)
7332 if (*p
== ' ' || *p
== '(')
7335 if (*p
== ' ' || *p
== '\0')
7337 /* It's an object-like macro. */
7338 int name_len
= p
- body
;
7339 char *name
= copy_string (body
, name_len
);
7340 const char *replacement
;
7343 replacement
= body
+ name_len
+ 1;
7346 dwarf2_macro_malformed_definition_complaint (body
);
7347 replacement
= body
+ name_len
;
7350 macro_define_object (file
, line
, name
, replacement
);
7356 /* It's a function-like macro. */
7357 char *name
= copy_string (body
, p
- body
);
7360 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
7364 p
= consume_improper_spaces (p
, body
);
7366 /* Parse the formal argument list. */
7367 while (*p
&& *p
!= ')')
7369 /* Find the extent of the current argument name. */
7370 const char *arg_start
= p
;
7372 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
7375 if (! *p
|| p
== arg_start
)
7376 dwarf2_macro_malformed_definition_complaint (body
);
7379 /* Make sure argv has room for the new argument. */
7380 if (argc
>= argv_size
)
7383 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
7386 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
7389 p
= consume_improper_spaces (p
, body
);
7391 /* Consume the comma, if present. */
7396 p
= consume_improper_spaces (p
, body
);
7405 /* Perfectly formed definition, no complaints. */
7406 macro_define_function (file
, line
, name
,
7407 argc
, (const char **) argv
,
7409 else if (*p
== '\0')
7411 /* Complain, but do define it. */
7412 dwarf2_macro_malformed_definition_complaint (body
);
7413 macro_define_function (file
, line
, name
,
7414 argc
, (const char **) argv
,
7418 /* Just complain. */
7419 dwarf2_macro_malformed_definition_complaint (body
);
7422 /* Just complain. */
7423 dwarf2_macro_malformed_definition_complaint (body
);
7429 for (i
= 0; i
< argc
; i
++)
7435 dwarf2_macro_malformed_definition_complaint (body
);
7440 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7441 char *comp_dir
, bfd
*abfd
,
7442 struct dwarf2_cu
*cu
)
7444 char *mac_ptr
, *mac_end
;
7445 struct macro_source_file
*current_file
= 0;
7447 if (dwarf_macinfo_buffer
== NULL
)
7449 complaint (&symfile_complaints
, "missing .debug_macinfo section");
7453 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7454 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7458 enum dwarf_macinfo_record_type macinfo_type
;
7460 /* Do we at least have room for a macinfo type byte? */
7461 if (mac_ptr
>= mac_end
)
7463 dwarf2_macros_too_long_complaint ();
7467 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7470 switch (macinfo_type
)
7472 /* A zero macinfo type indicates the end of the macro
7477 case DW_MACINFO_define
:
7478 case DW_MACINFO_undef
:
7484 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7485 mac_ptr
+= bytes_read
;
7486 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7487 mac_ptr
+= bytes_read
;
7490 complaint (&symfile_complaints
,
7491 "debug info gives macro %s outside of any file: %s",
7493 DW_MACINFO_define
? "definition" : macinfo_type
==
7494 DW_MACINFO_undef
? "undefinition" :
7495 "something-or-other", body
);
7498 if (macinfo_type
== DW_MACINFO_define
)
7499 parse_macro_definition (current_file
, line
, body
);
7500 else if (macinfo_type
== DW_MACINFO_undef
)
7501 macro_undef (current_file
, line
, body
);
7506 case DW_MACINFO_start_file
:
7511 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7512 mac_ptr
+= bytes_read
;
7513 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7514 mac_ptr
+= bytes_read
;
7516 current_file
= macro_start_file (file
, line
,
7517 current_file
, comp_dir
,
7522 case DW_MACINFO_end_file
:
7524 complaint (&symfile_complaints
,
7525 "macro debug info has an unmatched `close_file' directive");
7528 current_file
= current_file
->included_by
;
7531 enum dwarf_macinfo_record_type next_type
;
7533 /* GCC circa March 2002 doesn't produce the zero
7534 type byte marking the end of the compilation
7535 unit. Complain if it's not there, but exit no
7538 /* Do we at least have room for a macinfo type byte? */
7539 if (mac_ptr
>= mac_end
)
7541 dwarf2_macros_too_long_complaint ();
7545 /* We don't increment mac_ptr here, so this is just
7547 next_type
= read_1_byte (abfd
, mac_ptr
);
7549 complaint (&symfile_complaints
,
7550 "no terminating 0-type entry for macros in `.debug_macinfo' section");
7557 case DW_MACINFO_vendor_ext
:
7563 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7564 mac_ptr
+= bytes_read
;
7565 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7566 mac_ptr
+= bytes_read
;
7568 /* We don't recognize any vendor extensions. */
7575 /* Check if the attribute's form is a DW_FORM_block*
7576 if so return true else false. */
7578 attr_form_is_block (struct attribute
*attr
)
7580 return (attr
== NULL
? 0 :
7581 attr
->form
== DW_FORM_block1
7582 || attr
->form
== DW_FORM_block2
7583 || attr
->form
== DW_FORM_block4
7584 || attr
->form
== DW_FORM_block
);
7588 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
7589 struct dwarf2_cu
*cu
)
7591 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
7593 struct dwarf2_loclist_baton
*baton
;
7595 baton
= obstack_alloc (&cu
->objfile
->symbol_obstack
,
7596 sizeof (struct dwarf2_loclist_baton
));
7597 baton
->objfile
= cu
->objfile
;
7599 /* We don't know how long the location list is, but make sure we
7600 don't run off the edge of the section. */
7601 baton
->size
= dwarf_loc_size
- DW_UNSND (attr
);
7602 baton
->data
= dwarf_loc_buffer
+ DW_UNSND (attr
);
7603 baton
->base_address
= cu
->header
.base_address
;
7604 if (cu
->header
.base_known
== 0)
7605 complaint (&symfile_complaints
,
7606 "Location list used without specifying the CU base address.");
7608 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_loclist_funcs
;
7609 SYMBOL_LOCATION_BATON (sym
) = baton
;
7613 struct dwarf2_locexpr_baton
*baton
;
7615 baton
= obstack_alloc (&cu
->objfile
->symbol_obstack
,
7616 sizeof (struct dwarf2_locexpr_baton
));
7617 baton
->objfile
= cu
->objfile
;
7619 if (attr_form_is_block (attr
))
7621 /* Note that we're just copying the block's data pointer
7622 here, not the actual data. We're still pointing into the
7623 dwarf_info_buffer for SYM's objfile; right now we never
7624 release that buffer, but when we do clean up properly
7625 this may need to change. */
7626 baton
->size
= DW_BLOCK (attr
)->size
;
7627 baton
->data
= DW_BLOCK (attr
)->data
;
7631 dwarf2_invalid_attrib_class_complaint ("location description",
7632 SYMBOL_NATURAL_NAME (sym
));
7637 SYMBOL_LOCATION_FUNCS (sym
) = &dwarf2_locexpr_funcs
;
7638 SYMBOL_LOCATION_BATON (sym
) = baton
;