1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 Free Software Foundation, Inc.
6 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
7 Inc. with support from Florida State University (under contract
8 with the Ada Joint Program Office), and Silicon Graphics, Inc.
9 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
10 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
11 support in dwarfread.c
13 This file is part of GDB.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or (at
18 your option) any later version.
20 This program is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 59 Temple Place - Suite 330,
28 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 unsigned int dwarf_info_size
;
132 static unsigned int dwarf_abbrev_size
;
133 static unsigned int dwarf_line_size
;
134 static unsigned int dwarf_pubnames_size
;
135 static unsigned int dwarf_aranges_size
;
136 static unsigned int dwarf_loc_size
;
137 static unsigned int dwarf_macinfo_size
;
138 static unsigned int dwarf_str_size
;
139 static unsigned int dwarf_ranges_size
;
140 unsigned int dwarf_frame_size
;
141 unsigned int dwarf_eh_frame_size
;
143 static asection
*dwarf_info_section
;
144 static asection
*dwarf_abbrev_section
;
145 static asection
*dwarf_line_section
;
146 static asection
*dwarf_pubnames_section
;
147 static asection
*dwarf_aranges_section
;
148 static asection
*dwarf_loc_section
;
149 static asection
*dwarf_macinfo_section
;
150 static asection
*dwarf_str_section
;
151 static asection
*dwarf_ranges_section
;
152 asection
*dwarf_frame_section
;
153 asection
*dwarf_eh_frame_section
;
155 /* names of the debugging sections */
157 #define INFO_SECTION ".debug_info"
158 #define ABBREV_SECTION ".debug_abbrev"
159 #define LINE_SECTION ".debug_line"
160 #define PUBNAMES_SECTION ".debug_pubnames"
161 #define ARANGES_SECTION ".debug_aranges"
162 #define LOC_SECTION ".debug_loc"
163 #define MACINFO_SECTION ".debug_macinfo"
164 #define STR_SECTION ".debug_str"
165 #define RANGES_SECTION ".debug_ranges"
166 #define FRAME_SECTION ".debug_frame"
167 #define EH_FRAME_SECTION ".eh_frame"
169 /* local data types */
171 /* We hold several abbreviation tables in memory at the same time. */
172 #ifndef ABBREV_HASH_SIZE
173 #define ABBREV_HASH_SIZE 121
176 /* The data in a compilation unit header, after target2host
177 translation, looks like this. */
178 struct comp_unit_head
180 unsigned long length
;
182 unsigned int abbrev_offset
;
183 unsigned char addr_size
;
184 unsigned char signed_addr_p
;
185 unsigned int offset_size
; /* size of file offsets; either 4 or 8 */
186 unsigned int initial_length_size
; /* size of the length field; either
189 /* Offset to the first byte of this compilation unit header in the
190 * .debug_info section, for resolving relative reference dies. */
194 /* Pointer to this compilation unit header in the .debug_info
199 /* Pointer to the first die of this compilatio unit. This will
200 * be the first byte following the compilation unit header. */
204 /* Pointer to the next compilation unit header in the program. */
206 struct comp_unit_head
*next
;
208 /* DWARF abbreviation table associated with this compilation unit */
210 struct abbrev_info
*dwarf2_abbrevs
[ABBREV_HASH_SIZE
];
212 /* Base address of this compilation unit. */
214 CORE_ADDR base_address
;
216 /* Non-zero if base_address has been set. */
221 /* Internal state when decoding a particular compilation unit. */
224 /* The objfile containing this compilation unit. */
225 struct objfile
*objfile
;
227 /* The header of the compilation unit.
229 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
230 should be moved to the dwarf2_cu structure; for instance the abbrevs
232 struct comp_unit_head header
;
234 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
236 /* The language we are debugging. */
237 enum language language
;
238 const struct language_defn
*language_defn
;
240 /* The generic symbol table building routines have separate lists for
241 file scope symbols and all all other scopes (local scopes). So
242 we need to select the right one to pass to add_symbol_to_list().
243 We do it by keeping a pointer to the correct list in list_in_scope.
245 FIXME: The original dwarf code just treated the file scope as the
246 first local scope, and all other local scopes as nested local
247 scopes, and worked fine. Check to see if we really need to
248 distinguish these in buildsym.c. */
249 struct pending
**list_in_scope
;
251 /* Maintain an array of referenced fundamental types for the current
252 compilation unit being read. For DWARF version 1, we have to construct
253 the fundamental types on the fly, since no information about the
254 fundamental types is supplied. Each such fundamental type is created by
255 calling a language dependent routine to create the type, and then a
256 pointer to that type is then placed in the array at the index specified
257 by it's FT_<TYPENAME> value. The array has a fixed size set by the
258 FT_NUM_MEMBERS compile time constant, which is the number of predefined
259 fundamental types gdb knows how to construct. */
260 struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
263 /* The line number information for a compilation unit (found in the
264 .debug_line section) begins with a "statement program header",
265 which contains the following information. */
268 unsigned int total_length
;
269 unsigned short version
;
270 unsigned int header_length
;
271 unsigned char minimum_instruction_length
;
272 unsigned char default_is_stmt
;
274 unsigned char line_range
;
275 unsigned char opcode_base
;
277 /* standard_opcode_lengths[i] is the number of operands for the
278 standard opcode whose value is i. This means that
279 standard_opcode_lengths[0] is unused, and the last meaningful
280 element is standard_opcode_lengths[opcode_base - 1]. */
281 unsigned char *standard_opcode_lengths
;
283 /* The include_directories table. NOTE! These strings are not
284 allocated with xmalloc; instead, they are pointers into
285 debug_line_buffer. If you try to free them, `free' will get
287 unsigned int num_include_dirs
, include_dirs_size
;
290 /* The file_names table. NOTE! These strings are not allocated
291 with xmalloc; instead, they are pointers into debug_line_buffer.
292 Don't try to free them directly. */
293 unsigned int num_file_names
, file_names_size
;
297 unsigned int dir_index
;
298 unsigned int mod_time
;
302 /* The start and end of the statement program following this
303 header. These point into dwarf_line_buffer. */
304 char *statement_program_start
, *statement_program_end
;
307 /* When we construct a partial symbol table entry we only
308 need this much information. */
309 struct partial_die_info
312 unsigned char has_children
;
313 unsigned char is_external
;
314 unsigned char is_declaration
;
315 unsigned char has_type
;
322 struct dwarf_block
*locdesc
;
323 unsigned int language
;
327 /* This data structure holds the information of an abbrev. */
330 unsigned int number
; /* number identifying abbrev */
331 enum dwarf_tag tag
; /* dwarf tag */
332 int has_children
; /* boolean */
333 unsigned int num_attrs
; /* number of attributes */
334 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
335 struct abbrev_info
*next
; /* next in chain */
340 enum dwarf_attribute name
;
341 enum dwarf_form form
;
344 /* This data structure holds a complete die structure. */
347 enum dwarf_tag tag
; /* Tag indicating type of die */
348 unsigned int abbrev
; /* Abbrev number */
349 unsigned int offset
; /* Offset in .debug_info section */
350 unsigned int num_attrs
; /* Number of attributes */
351 struct attribute
*attrs
; /* An array of attributes */
352 struct die_info
*next_ref
; /* Next die in ref hash table */
354 /* The dies in a compilation unit form an n-ary tree. PARENT
355 points to this die's parent; CHILD points to the first child of
356 this node; and all the children of a given node are chained
357 together via their SIBLING fields, terminated by a die whose
359 struct die_info
*child
; /* Its first child, if any. */
360 struct die_info
*sibling
; /* Its next sibling, if any. */
361 struct die_info
*parent
; /* Its parent, if any. */
363 struct type
*type
; /* Cached type information */
366 /* Attributes have a name and a value */
369 enum dwarf_attribute name
;
370 enum dwarf_form form
;
374 struct dwarf_block
*blk
;
382 struct function_range
385 CORE_ADDR lowpc
, highpc
;
387 struct function_range
*next
;
390 /* Get at parts of an attribute structure */
392 #define DW_STRING(attr) ((attr)->u.str)
393 #define DW_UNSND(attr) ((attr)->u.unsnd)
394 #define DW_BLOCK(attr) ((attr)->u.blk)
395 #define DW_SND(attr) ((attr)->u.snd)
396 #define DW_ADDR(attr) ((attr)->u.addr)
398 /* Blocks are a bunch of untyped bytes. */
405 #ifndef ATTR_ALLOC_CHUNK
406 #define ATTR_ALLOC_CHUNK 4
409 /* A hash table of die offsets for following references. */
410 #ifndef REF_HASH_SIZE
411 #define REF_HASH_SIZE 1021
414 static struct die_info
*die_ref_table
[REF_HASH_SIZE
];
416 /* Obstack for allocating temporary storage used during symbol reading. */
417 static struct obstack dwarf2_tmp_obstack
;
419 /* Allocate fields for structs, unions and enums in this size. */
420 #ifndef DW_FIELD_ALLOC_CHUNK
421 #define DW_FIELD_ALLOC_CHUNK 4
424 /* Actually data from the sections. */
425 static char *dwarf_info_buffer
;
426 static char *dwarf_abbrev_buffer
;
427 static char *dwarf_line_buffer
;
428 static char *dwarf_str_buffer
;
429 static char *dwarf_macinfo_buffer
;
430 static char *dwarf_ranges_buffer
;
431 static char *dwarf_loc_buffer
;
433 /* A zeroed version of a partial die for initialization purposes. */
434 static struct partial_die_info zeroed_partial_die
;
436 /* FIXME: decode_locdesc sets these variables to describe the location
437 to the caller. These ought to be a structure or something. If
438 none of the flags are set, the object lives at the address returned
439 by decode_locdesc. */
441 static int isreg
; /* Object lives in register.
442 decode_locdesc's return value is
443 the register number. */
445 /* We put a pointer to this structure in the read_symtab_private field
447 The complete dwarf information for an objfile is kept in the
448 objfile_obstack, so that absolute die references can be handled.
449 Most of the information in this structure is related to an entire
450 object file and could be passed via the sym_private field of the objfile.
451 It is however conceivable that dwarf2 might not be the only type
452 of symbols read from an object file. */
456 /* Pointer to start of dwarf info buffer for the objfile. */
458 char *dwarf_info_buffer
;
460 /* Offset in dwarf_info_buffer for this compilation unit. */
462 unsigned long dwarf_info_offset
;
464 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
466 char *dwarf_abbrev_buffer
;
468 /* Size of dwarf abbreviation section for the objfile. */
470 unsigned int dwarf_abbrev_size
;
472 /* Pointer to start of dwarf line buffer for the objfile. */
474 char *dwarf_line_buffer
;
476 /* Size of dwarf_line_buffer, in bytes. */
478 unsigned int dwarf_line_size
;
480 /* Pointer to start of dwarf string buffer for the objfile. */
482 char *dwarf_str_buffer
;
484 /* Size of dwarf string section for the objfile. */
486 unsigned int dwarf_str_size
;
488 /* Pointer to start of dwarf macro buffer for the objfile. */
490 char *dwarf_macinfo_buffer
;
492 /* Size of dwarf macinfo section for the objfile. */
494 unsigned int dwarf_macinfo_size
;
496 /* Pointer to start of dwarf ranges buffer for the objfile. */
498 char *dwarf_ranges_buffer
;
500 /* Size of dwarf ranges buffer for the objfile. */
502 unsigned int dwarf_ranges_size
;
504 /* Pointer to start of dwarf locations buffer for the objfile. */
506 char *dwarf_loc_buffer
;
508 /* Size of dwarf locations buffer for the objfile. */
510 unsigned int dwarf_loc_size
;
513 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
514 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
515 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
516 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
517 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
518 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
519 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
520 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
521 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
522 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
523 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
524 #define DWARF_RANGES_BUFFER(p) (PST_PRIVATE(p)->dwarf_ranges_buffer)
525 #define DWARF_RANGES_SIZE(p) (PST_PRIVATE(p)->dwarf_ranges_size)
526 #define DWARF_LOC_BUFFER(p) (PST_PRIVATE(p)->dwarf_loc_buffer)
527 #define DWARF_LOC_SIZE(p) (PST_PRIVATE(p)->dwarf_loc_size)
529 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
530 but this would require a corresponding change in unpack_field_as_long
532 static int bits_per_byte
= 8;
534 /* The routines that read and process dies for a C struct or C++ class
535 pass lists of data member fields and lists of member function fields
536 in an instance of a field_info structure, as defined below. */
539 /* List of data member and baseclasses fields. */
542 struct nextfield
*next
;
549 /* Number of fields. */
552 /* Number of baseclasses. */
555 /* Set if the accesibility of one of the fields is not public. */
556 int non_public_fields
;
558 /* Member function fields array, entries are allocated in the order they
559 are encountered in the object file. */
562 struct nextfnfield
*next
;
563 struct fn_field fnfield
;
567 /* Member function fieldlist array, contains name of possibly overloaded
568 member function, number of overloaded member functions and a pointer
569 to the head of the member function field chain. */
574 struct nextfnfield
*head
;
578 /* Number of entries in the fnfieldlists array. */
582 /* Various complaints about symbol reading that don't abort the process */
585 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
587 complaint (&symfile_complaints
,
588 "statement list doesn't fit in .debug_line section");
592 dwarf2_complex_location_expr_complaint (void)
594 complaint (&symfile_complaints
, "location expression too complex");
598 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
601 complaint (&symfile_complaints
,
602 "const value length mismatch for '%s', got %d, expected %d", arg1
,
607 dwarf2_macros_too_long_complaint (void)
609 complaint (&symfile_complaints
,
610 "macro info runs off end of `.debug_macinfo' section");
614 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
616 complaint (&symfile_complaints
,
617 "macro debug info contains a malformed macro definition:\n`%s'",
622 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
624 complaint (&symfile_complaints
,
625 "invalid attribute class or form for '%s' in '%s'", arg1
, arg2
);
628 /* local function prototypes */
630 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
633 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
636 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
638 static char *scan_partial_symbols (char *, CORE_ADDR
*, CORE_ADDR
*,
640 const char *namespace);
642 static void add_partial_symbol (struct partial_die_info
*, struct dwarf2_cu
*,
643 const char *namespace);
645 static int pdi_needs_namespace (enum dwarf_tag tag
, const char *namespace);
647 static char *add_partial_namespace (struct partial_die_info
*pdi
,
649 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
650 struct dwarf2_cu
*cu
,
651 const char *namespace);
653 static char *add_partial_structure (struct partial_die_info
*struct_pdi
,
655 struct dwarf2_cu
*cu
,
656 const char *namespace);
658 static char *add_partial_enumeration (struct partial_die_info
*enum_pdi
,
660 struct dwarf2_cu
*cu
,
661 const char *namespace);
663 static char *locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
666 struct dwarf2_cu
*cu
);
668 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
670 static void psymtab_to_symtab_1 (struct partial_symtab
*);
672 char *dwarf2_read_section (struct objfile
*, asection
*);
674 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
676 static void dwarf2_empty_abbrev_table (void *);
678 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
681 static char *read_partial_die (struct partial_die_info
*,
682 bfd
*, char *, struct dwarf2_cu
*);
684 static char *read_full_die (struct die_info
**, bfd
*, char *,
685 struct dwarf2_cu
*, int *);
687 static char *read_attribute (struct attribute
*, struct attr_abbrev
*,
688 bfd
*, char *, struct dwarf2_cu
*);
690 static char *read_attribute_value (struct attribute
*, unsigned,
691 bfd
*, char *, struct dwarf2_cu
*);
693 static unsigned int read_1_byte (bfd
*, char *);
695 static int read_1_signed_byte (bfd
*, char *);
697 static unsigned int read_2_bytes (bfd
*, char *);
699 static unsigned int read_4_bytes (bfd
*, char *);
701 static unsigned long read_8_bytes (bfd
*, char *);
703 static CORE_ADDR
read_address (bfd
*, char *ptr
, struct dwarf2_cu
*,
706 static LONGEST
read_initial_length (bfd
*, char *,
707 struct comp_unit_head
*, int *bytes_read
);
709 static LONGEST
read_offset (bfd
*, char *, const struct comp_unit_head
*,
712 static char *read_n_bytes (bfd
*, char *, unsigned int);
714 static char *read_string (bfd
*, char *, unsigned int *);
716 static char *read_indirect_string (bfd
*, char *, const struct comp_unit_head
*,
719 static unsigned long read_unsigned_leb128 (bfd
*, char *, unsigned int *);
721 static long read_signed_leb128 (bfd
*, char *, unsigned int *);
723 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
725 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
728 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
730 static struct die_info
*die_specification (struct die_info
*die
,
733 static void free_line_header (struct line_header
*lh
);
735 static struct line_header
*(dwarf_decode_line_header
736 (unsigned int offset
,
737 bfd
*abfd
, struct dwarf2_cu
*cu
));
739 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
742 static void dwarf2_start_subfile (char *, char *);
744 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
747 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
750 static void dwarf2_const_value_data (struct attribute
*attr
,
754 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
756 static struct type
*die_containing_type (struct die_info
*,
760 static struct type
*type_at_offset (unsigned int, struct objfile
*);
763 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
765 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
767 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
769 static char *determine_prefix_aux (struct die_info
*die
, struct dwarf2_cu
*);
771 static char *typename_concat (const char *prefix
, const char *suffix
);
773 static char *class_name (struct die_info
*die
, struct dwarf2_cu
*);
775 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
777 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
779 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
781 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
783 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
785 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
787 static int dwarf2_get_pc_bounds (struct die_info
*,
788 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
790 static void get_scope_pc_bounds (struct die_info
*,
791 CORE_ADDR
*, CORE_ADDR
*,
794 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
797 static void dwarf2_attach_fields_to_type (struct field_info
*,
798 struct type
*, struct dwarf2_cu
*);
800 static void dwarf2_add_member_fn (struct field_info
*,
801 struct die_info
*, struct type
*,
804 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
805 struct type
*, struct dwarf2_cu
*);
807 static void read_structure_scope (struct die_info
*, struct dwarf2_cu
*);
809 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
811 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
813 static const char *namespace_name (struct die_info
*die
,
814 int *is_anonymous
, struct dwarf2_cu
*);
816 static void read_enumeration (struct die_info
*, struct dwarf2_cu
*);
818 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
820 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
822 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
824 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
826 static void read_tag_ptr_to_member_type (struct die_info
*,
829 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
831 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
833 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
835 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
837 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
839 static struct die_info
*read_comp_unit (char *, bfd
*, struct dwarf2_cu
*);
841 static struct die_info
*read_die_and_children (char *info_ptr
, bfd
*abfd
,
844 struct die_info
*parent
);
846 static struct die_info
*read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
849 struct die_info
*parent
);
851 static void free_die_list (struct die_info
*);
853 static struct cleanup
*make_cleanup_free_die_list (struct die_info
*);
855 static void process_die (struct die_info
*, struct dwarf2_cu
*);
857 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
859 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
861 static struct die_info
*dwarf2_extension (struct die_info
*die
,
864 static char *dwarf_tag_name (unsigned int);
866 static char *dwarf_attr_name (unsigned int);
868 static char *dwarf_form_name (unsigned int);
870 static char *dwarf_stack_op_name (unsigned int);
872 static char *dwarf_bool_name (unsigned int);
874 static char *dwarf_type_encoding_name (unsigned int);
877 static char *dwarf_cfi_name (unsigned int);
879 struct die_info
*copy_die (struct die_info
*);
882 static struct die_info
*sibling_die (struct die_info
*);
884 static void dump_die (struct die_info
*);
886 static void dump_die_list (struct die_info
*);
888 static void store_in_ref_table (unsigned int, struct die_info
*);
890 static void dwarf2_empty_hash_tables (void);
892 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
895 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
897 static struct die_info
*follow_die_ref (unsigned int);
899 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
902 /* memory allocation interface */
904 static void dwarf2_free_tmp_obstack (void *);
906 static struct dwarf_block
*dwarf_alloc_block (void);
908 static struct abbrev_info
*dwarf_alloc_abbrev (void);
910 static struct die_info
*dwarf_alloc_die (void);
912 static void initialize_cu_func_list (struct dwarf2_cu
*);
914 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
917 static void dwarf_decode_macros (struct line_header
*, unsigned int,
918 char *, bfd
*, struct dwarf2_cu
*);
920 static int attr_form_is_block (struct attribute
*);
923 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
924 struct dwarf2_cu
*cu
);
926 /* Try to locate the sections we need for DWARF 2 debugging
927 information and return true if we have enough to do something. */
930 dwarf2_has_info (bfd
*abfd
)
932 dwarf_info_section
= 0;
933 dwarf_abbrev_section
= 0;
934 dwarf_line_section
= 0;
935 dwarf_str_section
= 0;
936 dwarf_macinfo_section
= 0;
937 dwarf_frame_section
= 0;
938 dwarf_eh_frame_section
= 0;
939 dwarf_ranges_section
= 0;
940 dwarf_loc_section
= 0;
942 bfd_map_over_sections (abfd
, dwarf2_locate_sections
, NULL
);
943 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
946 /* This function is mapped across the sections and remembers the
947 offset and size of each of the debugging sections we are interested
951 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
953 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
955 dwarf_info_size
= bfd_get_section_size_before_reloc (sectp
);
956 dwarf_info_section
= sectp
;
958 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
960 dwarf_abbrev_size
= bfd_get_section_size_before_reloc (sectp
);
961 dwarf_abbrev_section
= sectp
;
963 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
965 dwarf_line_size
= bfd_get_section_size_before_reloc (sectp
);
966 dwarf_line_section
= sectp
;
968 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
970 dwarf_pubnames_size
= bfd_get_section_size_before_reloc (sectp
);
971 dwarf_pubnames_section
= sectp
;
973 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
975 dwarf_aranges_size
= bfd_get_section_size_before_reloc (sectp
);
976 dwarf_aranges_section
= sectp
;
978 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
980 dwarf_loc_size
= bfd_get_section_size_before_reloc (sectp
);
981 dwarf_loc_section
= sectp
;
983 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
985 dwarf_macinfo_size
= bfd_get_section_size_before_reloc (sectp
);
986 dwarf_macinfo_section
= sectp
;
988 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
990 dwarf_str_size
= bfd_get_section_size_before_reloc (sectp
);
991 dwarf_str_section
= sectp
;
993 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
995 dwarf_frame_size
= bfd_get_section_size_before_reloc (sectp
);
996 dwarf_frame_section
= sectp
;
998 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1000 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1001 if (aflag
& SEC_HAS_CONTENTS
)
1003 dwarf_eh_frame_size
= bfd_get_section_size_before_reloc (sectp
);
1004 dwarf_eh_frame_section
= sectp
;
1007 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1009 dwarf_ranges_size
= bfd_get_section_size_before_reloc (sectp
);
1010 dwarf_ranges_section
= sectp
;
1014 /* Build a partial symbol table. */
1017 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1020 /* We definitely need the .debug_info and .debug_abbrev sections */
1022 dwarf_info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1023 dwarf_abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1025 if (dwarf_line_section
)
1026 dwarf_line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1028 dwarf_line_buffer
= NULL
;
1030 if (dwarf_str_section
)
1031 dwarf_str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1033 dwarf_str_buffer
= NULL
;
1035 if (dwarf_macinfo_section
)
1036 dwarf_macinfo_buffer
= dwarf2_read_section (objfile
,
1037 dwarf_macinfo_section
);
1039 dwarf_macinfo_buffer
= NULL
;
1041 if (dwarf_ranges_section
)
1042 dwarf_ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1044 dwarf_ranges_buffer
= NULL
;
1046 if (dwarf_loc_section
)
1047 dwarf_loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1049 dwarf_loc_buffer
= NULL
;
1052 || (objfile
->global_psymbols
.size
== 0
1053 && objfile
->static_psymbols
.size
== 0))
1055 init_psymbol_list (objfile
, 1024);
1059 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1061 /* Things are significantly easier if we have .debug_aranges and
1062 .debug_pubnames sections */
1064 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1068 /* only test this case for now */
1070 /* In this case we have to work a bit harder */
1071 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1076 /* Build the partial symbol table from the information in the
1077 .debug_pubnames and .debug_aranges sections. */
1080 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1082 bfd
*abfd
= objfile
->obfd
;
1083 char *aranges_buffer
, *pubnames_buffer
;
1084 char *aranges_ptr
, *pubnames_ptr
;
1085 unsigned int entry_length
, version
, info_offset
, info_size
;
1087 pubnames_buffer
= dwarf2_read_section (objfile
,
1088 dwarf_pubnames_section
);
1089 pubnames_ptr
= pubnames_buffer
;
1090 while ((pubnames_ptr
- pubnames_buffer
) < dwarf_pubnames_size
)
1092 struct comp_unit_head cu_header
;
1095 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1097 pubnames_ptr
+= bytes_read
;
1098 version
= read_1_byte (abfd
, pubnames_ptr
);
1100 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1102 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1106 aranges_buffer
= dwarf2_read_section (objfile
,
1107 dwarf_aranges_section
);
1112 /* Read in the comp unit header information from the debug_info at
1116 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1117 char *info_ptr
, bfd
*abfd
)
1121 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1123 info_ptr
+= bytes_read
;
1124 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1126 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1128 info_ptr
+= bytes_read
;
1129 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1131 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1132 if (signed_addr
< 0)
1133 internal_error (__FILE__
, __LINE__
,
1134 "read_comp_unit_head: dwarf from non elf file");
1135 cu_header
->signed_addr_p
= signed_addr
;
1139 /* Build the partial symbol table by doing a quick pass through the
1140 .debug_info and .debug_abbrev sections. */
1143 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1145 /* Instead of reading this into a big buffer, we should probably use
1146 mmap() on architectures that support it. (FIXME) */
1147 bfd
*abfd
= objfile
->obfd
;
1148 char *info_ptr
, *abbrev_ptr
;
1149 char *beg_of_comp_unit
;
1150 struct partial_die_info comp_unit_die
;
1151 struct partial_symtab
*pst
;
1152 struct cleanup
*back_to
;
1153 CORE_ADDR lowpc
, highpc
, baseaddr
;
1155 info_ptr
= dwarf_info_buffer
;
1156 abbrev_ptr
= dwarf_abbrev_buffer
;
1158 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1159 the partial symbol scan, like attribute values.
1161 We could reduce our peak memory consumption during partial symbol
1162 table construction by freeing stuff from this obstack more often
1163 --- say, after processing each compilation unit, or each die ---
1164 but it turns out that this saves almost nothing. For an
1165 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1166 on dwarf2_tmp_obstack. Some investigation showed:
1168 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1169 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1170 all fixed-length values not requiring dynamic allocation.
1172 2) 30% of the attributes used the form DW_FORM_string. For
1173 DW_FORM_string, read_attribute simply hands back a pointer to
1174 the null-terminated string in dwarf_info_buffer, so no dynamic
1175 allocation is needed there either.
1177 3) The remaining 1% of the attributes all used DW_FORM_block1.
1178 75% of those were DW_AT_frame_base location lists for
1179 functions; the rest were DW_AT_location attributes, probably
1180 for the global variables.
1182 Anyway, what this all means is that the memory the dwarf2
1183 reader uses as temporary space reading partial symbols is about
1184 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1186 obstack_init (&dwarf2_tmp_obstack
);
1187 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1189 /* Since the objects we're extracting from dwarf_info_buffer vary in
1190 length, only the individual functions to extract them (like
1191 read_comp_unit_head and read_partial_die) can really know whether
1192 the buffer is large enough to hold another complete object.
1194 At the moment, they don't actually check that. If
1195 dwarf_info_buffer holds just one extra byte after the last
1196 compilation unit's dies, then read_comp_unit_head will happily
1197 read off the end of the buffer. read_partial_die is similarly
1198 casual. Those functions should be fixed.
1200 For this loop condition, simply checking whether there's any data
1201 left at all should be sufficient. */
1202 while (info_ptr
< dwarf_info_buffer
+ dwarf_info_size
)
1204 struct dwarf2_cu cu
;
1205 beg_of_comp_unit
= info_ptr
;
1207 cu
.objfile
= objfile
;
1208 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1210 if (cu
.header
.version
!= 2)
1212 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
));
1215 if (cu
.header
.abbrev_offset
>= dwarf_abbrev_size
)
1217 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1218 (long) cu
.header
.abbrev_offset
,
1219 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1220 bfd_get_filename (abfd
));
1223 if (beg_of_comp_unit
+ cu
.header
.length
+ cu
.header
.initial_length_size
1224 > dwarf_info_buffer
+ dwarf_info_size
)
1226 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1227 (long) cu
.header
.length
,
1228 (long) (beg_of_comp_unit
- dwarf_info_buffer
),
1229 bfd_get_filename (abfd
));
1232 /* Complete the cu_header */
1233 cu
.header
.offset
= beg_of_comp_unit
- dwarf_info_buffer
;
1234 cu
.header
.first_die_ptr
= info_ptr
;
1235 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1237 cu
.list_in_scope
= &file_symbols
;
1239 /* Read the abbrevs for this compilation unit into a table */
1240 dwarf2_read_abbrevs (abfd
, &cu
);
1241 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1243 /* Read the compilation unit die */
1244 info_ptr
= read_partial_die (&comp_unit_die
, abfd
, info_ptr
,
1247 /* Set the language we're debugging */
1248 set_cu_language (comp_unit_die
.language
, &cu
);
1250 /* Allocate a new partial symbol table structure */
1251 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1252 comp_unit_die
.name
? comp_unit_die
.name
: "",
1253 comp_unit_die
.lowpc
,
1254 objfile
->global_psymbols
.next
,
1255 objfile
->static_psymbols
.next
);
1257 pst
->read_symtab_private
= (char *)
1258 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct dwarf2_pinfo
));
1259 DWARF_INFO_BUFFER (pst
) = dwarf_info_buffer
;
1260 DWARF_INFO_OFFSET (pst
) = beg_of_comp_unit
- dwarf_info_buffer
;
1261 DWARF_ABBREV_BUFFER (pst
) = dwarf_abbrev_buffer
;
1262 DWARF_ABBREV_SIZE (pst
) = dwarf_abbrev_size
;
1263 DWARF_LINE_BUFFER (pst
) = dwarf_line_buffer
;
1264 DWARF_LINE_SIZE (pst
) = dwarf_line_size
;
1265 DWARF_STR_BUFFER (pst
) = dwarf_str_buffer
;
1266 DWARF_STR_SIZE (pst
) = dwarf_str_size
;
1267 DWARF_MACINFO_BUFFER (pst
) = dwarf_macinfo_buffer
;
1268 DWARF_MACINFO_SIZE (pst
) = dwarf_macinfo_size
;
1269 DWARF_RANGES_BUFFER (pst
) = dwarf_ranges_buffer
;
1270 DWARF_RANGES_SIZE (pst
) = dwarf_ranges_size
;
1271 DWARF_LOC_BUFFER (pst
) = dwarf_loc_buffer
;
1272 DWARF_LOC_SIZE (pst
) = dwarf_loc_size
;
1273 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1275 /* Store the function that reads in the rest of the symbol table */
1276 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1278 /* Check if comp unit has_children.
1279 If so, read the rest of the partial symbols from this comp unit.
1280 If not, there's no more debug_info for this comp unit. */
1281 if (comp_unit_die
.has_children
)
1283 lowpc
= ((CORE_ADDR
) -1);
1284 highpc
= ((CORE_ADDR
) 0);
1286 info_ptr
= scan_partial_symbols (info_ptr
, &lowpc
, &highpc
,
1289 /* If we didn't find a lowpc, set it to highpc to avoid
1290 complaints from `maint check'. */
1291 if (lowpc
== ((CORE_ADDR
) -1))
1294 /* If the compilation unit didn't have an explicit address range,
1295 then use the information extracted from its child dies. */
1296 if (! comp_unit_die
.has_pc_info
)
1298 comp_unit_die
.lowpc
= lowpc
;
1299 comp_unit_die
.highpc
= highpc
;
1302 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1303 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1305 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1306 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1307 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1308 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1309 sort_pst_symbols (pst
);
1311 /* If there is already a psymtab or symtab for a file of this
1312 name, remove it. (If there is a symtab, more drastic things
1313 also happen.) This happens in VxWorks. */
1314 free_named_symtabs (pst
->filename
);
1316 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1317 + cu
.header
.initial_length_size
;
1319 do_cleanups (back_to
);
1322 /* Read in all interesting dies to the end of the compilation unit or
1323 to the end of the current namespace. NAMESPACE is NULL if we
1324 haven't yet encountered any DW_TAG_namespace entries; otherwise,
1325 it's the name of the current namespace. In particular, it's the
1326 empty string if we're currently in the global namespace but have
1327 previously encountered a DW_TAG_namespace. */
1330 scan_partial_symbols (char *info_ptr
, CORE_ADDR
*lowpc
,
1331 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
1332 const char *namespace)
1334 struct objfile
*objfile
= cu
->objfile
;
1335 bfd
*abfd
= objfile
->obfd
;
1336 struct partial_die_info pdi
;
1338 /* Now, march along the PDI's, descending into ones which have
1339 interesting children but skipping the children of the other ones,
1340 until we reach the end of the compilation unit. */
1344 /* This flag tells whether or not info_ptr has gotten updated
1346 int info_ptr_updated
= 0;
1348 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1350 /* Anonymous namespaces have no name but have interesting
1351 children, so we need to look at them. Ditto for anonymous
1354 if (pdi
.name
!= NULL
|| pdi
.tag
== DW_TAG_namespace
1355 || pdi
.tag
== DW_TAG_enumeration_type
)
1359 case DW_TAG_subprogram
:
1360 if (pdi
.has_pc_info
)
1362 if (pdi
.lowpc
< *lowpc
)
1366 if (pdi
.highpc
> *highpc
)
1368 *highpc
= pdi
.highpc
;
1370 if (!pdi
.is_declaration
)
1372 add_partial_symbol (&pdi
, cu
, namespace);
1376 case DW_TAG_variable
:
1377 case DW_TAG_typedef
:
1378 case DW_TAG_union_type
:
1379 if (!pdi
.is_declaration
)
1381 add_partial_symbol (&pdi
, cu
, namespace);
1384 case DW_TAG_class_type
:
1385 case DW_TAG_structure_type
:
1386 if (!pdi
.is_declaration
)
1388 info_ptr
= add_partial_structure (&pdi
, info_ptr
, cu
,
1390 info_ptr_updated
= 1;
1393 case DW_TAG_enumeration_type
:
1394 if (!pdi
.is_declaration
)
1396 info_ptr
= add_partial_enumeration (&pdi
, info_ptr
, cu
,
1398 info_ptr_updated
= 1;
1401 case DW_TAG_base_type
:
1402 case DW_TAG_subrange_type
:
1403 /* File scope base type definitions are added to the partial
1405 add_partial_symbol (&pdi
, cu
, namespace);
1407 case DW_TAG_namespace
:
1408 /* We've hit a DW_TAG_namespace entry, so we know this
1409 file has been compiled using a compiler that
1410 generates them; update NAMESPACE to reflect that. */
1411 if (namespace == NULL
)
1413 info_ptr
= add_partial_namespace (&pdi
, info_ptr
, lowpc
, highpc
,
1415 info_ptr_updated
= 1;
1425 /* If the die has a sibling, skip to the sibling, unless another
1426 function has already updated info_ptr for us. */
1428 /* NOTE: carlton/2003-06-16: This is a bit hackish, but whether
1429 or not we want to update this depends on enough stuff (not
1430 only pdi.tag but also whether or not pdi.name is NULL) that
1431 this seems like the easiest way to handle the issue. */
1433 if (!info_ptr_updated
)
1434 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1441 add_partial_symbol (struct partial_die_info
*pdi
,
1442 struct dwarf2_cu
*cu
, const char *namespace)
1444 struct objfile
*objfile
= cu
->objfile
;
1446 char *actual_name
= pdi
->name
;
1447 const struct partial_symbol
*psym
= NULL
;
1450 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1452 /* If we're not in the global namespace and if the namespace name
1453 isn't encoded in a mangled actual_name, add it. */
1455 if (pdi_needs_namespace (pdi
->tag
, namespace))
1457 actual_name
= alloca (strlen (pdi
->name
) + 2 + strlen (namespace) + 1);
1458 strcpy (actual_name
, namespace);
1459 strcat (actual_name
, "::");
1460 strcat (actual_name
, pdi
->name
);
1465 case DW_TAG_subprogram
:
1466 if (pdi
->is_external
)
1468 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1469 mst_text, objfile); */
1470 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1471 VAR_DOMAIN
, LOC_BLOCK
,
1472 &objfile
->global_psymbols
,
1473 0, pdi
->lowpc
+ baseaddr
,
1474 cu
->language
, objfile
);
1478 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1479 mst_file_text, objfile); */
1480 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1481 VAR_DOMAIN
, LOC_BLOCK
,
1482 &objfile
->static_psymbols
,
1483 0, pdi
->lowpc
+ baseaddr
,
1484 cu
->language
, objfile
);
1487 case DW_TAG_variable
:
1488 if (pdi
->is_external
)
1491 Don't enter into the minimal symbol tables as there is
1492 a minimal symbol table entry from the ELF symbols already.
1493 Enter into partial symbol table if it has a location
1494 descriptor or a type.
1495 If the location descriptor is missing, new_symbol will create
1496 a LOC_UNRESOLVED symbol, the address of the variable will then
1497 be determined from the minimal symbol table whenever the variable
1499 The address for the partial symbol table entry is not
1500 used by GDB, but it comes in handy for debugging partial symbol
1504 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1505 if (pdi
->locdesc
|| pdi
->has_type
)
1506 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1507 VAR_DOMAIN
, LOC_STATIC
,
1508 &objfile
->global_psymbols
,
1510 cu
->language
, objfile
);
1514 /* Static Variable. Skip symbols without location descriptors. */
1515 if (pdi
->locdesc
== NULL
)
1517 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1518 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1519 mst_file_data, objfile); */
1520 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1521 VAR_DOMAIN
, LOC_STATIC
,
1522 &objfile
->static_psymbols
,
1524 cu
->language
, objfile
);
1527 case DW_TAG_typedef
:
1528 case DW_TAG_base_type
:
1529 case DW_TAG_subrange_type
:
1530 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1531 VAR_DOMAIN
, LOC_TYPEDEF
,
1532 &objfile
->static_psymbols
,
1533 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1535 case DW_TAG_class_type
:
1536 case DW_TAG_structure_type
:
1537 case DW_TAG_union_type
:
1538 case DW_TAG_enumeration_type
:
1539 /* Skip aggregate types without children, these are external
1541 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1542 static vs. global. */
1543 if (pdi
->has_children
== 0)
1545 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1546 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1547 cu
->language
== language_cplus
1548 ? &objfile
->global_psymbols
1549 : &objfile
->static_psymbols
,
1550 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1552 if (cu
->language
== language_cplus
)
1554 /* For C++, these implicitly act as typedefs as well. */
1555 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1556 VAR_DOMAIN
, LOC_TYPEDEF
,
1557 &objfile
->global_psymbols
,
1558 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1561 case DW_TAG_enumerator
:
1562 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1563 VAR_DOMAIN
, LOC_CONST
,
1564 cu
->language
== language_cplus
1565 ? &objfile
->global_psymbols
1566 : &objfile
->static_psymbols
,
1567 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1573 /* Check to see if we should scan the name for possible namespace
1574 info. Only do this if this is C++, if we don't have namespace
1575 debugging info in the file, if the psym is of an appropriate type
1576 (otherwise we'll have psym == NULL), and if we actually had a
1577 mangled name to begin with. */
1579 if (cu
->language
== language_cplus
1580 && namespace == NULL
1582 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
1583 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
1587 /* Determine whether a die of type TAG living in the C++ namespace
1588 NAMESPACE needs to have the name of the namespace prepended to the
1589 name listed in the die. */
1592 pdi_needs_namespace (enum dwarf_tag tag
, const char *namespace)
1594 if (namespace == NULL
|| namespace[0] == '\0')
1599 case DW_TAG_typedef
:
1600 case DW_TAG_class_type
:
1601 case DW_TAG_structure_type
:
1602 case DW_TAG_union_type
:
1603 case DW_TAG_enumeration_type
:
1604 case DW_TAG_enumerator
:
1611 /* Read a partial die corresponding to a namespace; also, add a symbol
1612 corresponding to that namespace to the symbol table. NAMESPACE is
1613 the name of the enclosing namespace. */
1616 add_partial_namespace (struct partial_die_info
*pdi
, char *info_ptr
,
1617 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1618 struct dwarf2_cu
*cu
, const char *namespace)
1620 struct objfile
*objfile
= cu
->objfile
;
1621 const char *new_name
= pdi
->name
;
1624 /* Calculate the full name of the namespace that we just entered. */
1626 if (new_name
== NULL
)
1627 new_name
= "(anonymous namespace)";
1628 full_name
= alloca (strlen (namespace) + 2 + strlen (new_name
) + 1);
1629 strcpy (full_name
, namespace);
1630 if (*namespace != '\0')
1631 strcat (full_name
, "::");
1632 strcat (full_name
, new_name
);
1634 /* FIXME: carlton/2003-10-07: We can't just replace this by a call
1635 to add_partial_symbol, because we don't have a way to pass in the
1636 full name to that function; that might be a flaw in
1637 add_partial_symbol's interface. */
1639 add_psymbol_to_list (full_name
, strlen (full_name
),
1640 VAR_DOMAIN
, LOC_TYPEDEF
,
1641 &objfile
->global_psymbols
,
1642 0, 0, cu
->language
, objfile
);
1644 /* Now scan partial symbols in that namespace. */
1646 if (pdi
->has_children
)
1647 info_ptr
= scan_partial_symbols (info_ptr
, lowpc
, highpc
, cu
, full_name
);
1652 /* Read a partial die corresponding to a class or structure. */
1655 add_partial_structure (struct partial_die_info
*struct_pdi
, char *info_ptr
,
1656 struct dwarf2_cu
*cu
,
1657 const char *namespace)
1659 bfd
*abfd
= cu
->objfile
->obfd
;
1660 char *actual_class_name
= NULL
;
1662 if (cu
->language
== language_cplus
1663 && (namespace == NULL
|| namespace[0] == '\0')
1664 && struct_pdi
->name
!= NULL
1665 && struct_pdi
->has_children
)
1667 /* See if we can figure out if the class lives in a namespace
1668 (or is nested within another class.) We do this by looking
1669 for a member function; its demangled name will contain
1670 namespace info, if there is any. */
1672 /* NOTE: carlton/2003-10-07: Getting the info this way changes
1673 what template types look like, because the demangler
1674 frequently doesn't give the same name as the debug info. We
1675 could fix this by only using the demangled name to get the
1676 prefix (but see comment in read_structure_scope). */
1678 /* FIXME: carlton/2004-01-23: If NAMESPACE equals "", we have
1679 the appropriate debug information, so it would be nice to be
1680 able to avoid this hack. But NAMESPACE may not be the
1681 namespace where this class was defined: NAMESPACE reflects
1682 where STRUCT_PDI occurs in the tree of dies, but because of
1683 DW_AT_specification, that may not actually tell us where the
1684 class is defined. (See the comment in read_func_scope for an
1685 example of how this could occur.)
1687 Unfortunately, our current partial symtab data structures are
1688 completely unable to deal with DW_AT_specification. So, for
1689 now, the best thing to do is to get nesting information from
1690 places other than the tree structure of dies if there's any
1691 chance that a DW_AT_specification is involved. :-( */
1693 char *next_child
= info_ptr
;
1697 struct partial_die_info child_pdi
;
1699 next_child
= read_partial_die (&child_pdi
, abfd
, next_child
,
1703 if (child_pdi
.tag
== DW_TAG_subprogram
)
1705 actual_class_name
= class_name_from_physname (child_pdi
.name
);
1706 if (actual_class_name
!= NULL
)
1707 struct_pdi
->name
= actual_class_name
;
1712 next_child
= locate_pdi_sibling (&child_pdi
, next_child
,
1718 add_partial_symbol (struct_pdi
, cu
, namespace);
1719 xfree (actual_class_name
);
1721 return locate_pdi_sibling (struct_pdi
, info_ptr
, abfd
, cu
);
1724 /* Read a partial die corresponding to an enumeration type. */
1727 add_partial_enumeration (struct partial_die_info
*enum_pdi
, char *info_ptr
,
1728 struct dwarf2_cu
*cu
, const char *namespace)
1730 struct objfile
*objfile
= cu
->objfile
;
1731 bfd
*abfd
= objfile
->obfd
;
1732 struct partial_die_info pdi
;
1734 if (enum_pdi
->name
!= NULL
)
1735 add_partial_symbol (enum_pdi
, cu
, namespace);
1739 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1742 if (pdi
.tag
!= DW_TAG_enumerator
|| pdi
.name
== NULL
)
1743 complaint (&symfile_complaints
, "malformed enumerator DIE ignored");
1745 add_partial_symbol (&pdi
, cu
, namespace);
1751 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the next DIE
1755 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, char *info_ptr
,
1756 bfd
*abfd
, struct dwarf2_cu
*cu
)
1758 /* Do we know the sibling already? */
1760 if (orig_pdi
->sibling
)
1761 return orig_pdi
->sibling
;
1763 /* Are there any children to deal with? */
1765 if (!orig_pdi
->has_children
)
1768 /* Okay, we don't know the sibling, but we have children that we
1769 want to skip. So read children until we run into one without a
1770 tag; return whatever follows it. */
1774 struct partial_die_info pdi
;
1776 info_ptr
= read_partial_die (&pdi
, abfd
, info_ptr
, cu
);
1781 info_ptr
= locate_pdi_sibling (&pdi
, info_ptr
, abfd
, cu
);
1785 /* Expand this partial symbol table into a full symbol table. */
1788 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
1790 /* FIXME: This is barely more than a stub. */
1795 warning ("bug: psymtab for %s is already read in.", pst
->filename
);
1801 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1802 gdb_flush (gdb_stdout
);
1805 psymtab_to_symtab_1 (pst
);
1807 /* Finish up the debug error message. */
1809 printf_filtered ("done.\n");
1815 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1817 struct objfile
*objfile
= pst
->objfile
;
1818 bfd
*abfd
= objfile
->obfd
;
1819 struct dwarf2_cu cu
;
1820 struct die_info
*dies
;
1821 unsigned long offset
;
1822 CORE_ADDR lowpc
, highpc
;
1823 struct die_info
*child_die
;
1825 struct symtab
*symtab
;
1826 struct cleanup
*back_to
;
1827 struct attribute
*attr
;
1830 /* Set local variables from the partial symbol table info. */
1831 offset
= DWARF_INFO_OFFSET (pst
);
1832 dwarf_info_buffer
= DWARF_INFO_BUFFER (pst
);
1833 dwarf_abbrev_buffer
= DWARF_ABBREV_BUFFER (pst
);
1834 dwarf_abbrev_size
= DWARF_ABBREV_SIZE (pst
);
1835 dwarf_line_buffer
= DWARF_LINE_BUFFER (pst
);
1836 dwarf_line_size
= DWARF_LINE_SIZE (pst
);
1837 dwarf_str_buffer
= DWARF_STR_BUFFER (pst
);
1838 dwarf_str_size
= DWARF_STR_SIZE (pst
);
1839 dwarf_macinfo_buffer
= DWARF_MACINFO_BUFFER (pst
);
1840 dwarf_macinfo_size
= DWARF_MACINFO_SIZE (pst
);
1841 dwarf_ranges_buffer
= DWARF_RANGES_BUFFER (pst
);
1842 dwarf_ranges_size
= DWARF_RANGES_SIZE (pst
);
1843 dwarf_loc_buffer
= DWARF_LOC_BUFFER (pst
);
1844 dwarf_loc_size
= DWARF_LOC_SIZE (pst
);
1845 info_ptr
= dwarf_info_buffer
+ offset
;
1846 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1848 /* We're in the global namespace. */
1849 processing_current_prefix
= "";
1851 obstack_init (&dwarf2_tmp_obstack
);
1852 back_to
= make_cleanup (dwarf2_free_tmp_obstack
, NULL
);
1855 make_cleanup (really_free_pendings
, NULL
);
1857 cu
.objfile
= objfile
;
1859 /* read in the comp_unit header */
1860 info_ptr
= read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1862 /* Read the abbrevs for this compilation unit */
1863 dwarf2_read_abbrevs (abfd
, &cu
);
1864 make_cleanup (dwarf2_empty_abbrev_table
, cu
.header
.dwarf2_abbrevs
);
1866 cu
.header
.offset
= offset
;
1868 cu
.list_in_scope
= &file_symbols
;
1870 dies
= read_comp_unit (info_ptr
, abfd
, &cu
);
1872 make_cleanup_free_die_list (dies
);
1874 /* Find the base address of the compilation unit for range lists and
1875 location lists. It will normally be specified by DW_AT_low_pc.
1876 In DWARF-3 draft 4, the base address could be overridden by
1877 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1878 compilation units with discontinuous ranges. */
1880 cu
.header
.base_known
= 0;
1881 cu
.header
.base_address
= 0;
1883 attr
= dwarf2_attr (dies
, DW_AT_entry_pc
, &cu
);
1886 cu
.header
.base_address
= DW_ADDR (attr
);
1887 cu
.header
.base_known
= 1;
1891 attr
= dwarf2_attr (dies
, DW_AT_low_pc
, &cu
);
1894 cu
.header
.base_address
= DW_ADDR (attr
);
1895 cu
.header
.base_known
= 1;
1899 /* Do line number decoding in read_file_scope () */
1900 process_die (dies
, &cu
);
1902 /* Some compilers don't define a DW_AT_high_pc attribute for the
1903 compilation unit. If the DW_AT_high_pc is missing, synthesize
1904 it, by scanning the DIE's below the compilation unit. */
1905 get_scope_pc_bounds (dies
, &lowpc
, &highpc
, &cu
);
1907 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
1909 /* Set symtab language to language from DW_AT_language.
1910 If the compilation is from a C file generated by language preprocessors,
1911 do not set the language if it was already deduced by start_subfile. */
1913 && !(cu
.language
== language_c
&& symtab
->language
!= language_c
))
1915 symtab
->language
= cu
.language
;
1917 pst
->symtab
= symtab
;
1920 do_cleanups (back_to
);
1923 /* Process a die and its children. */
1926 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
1930 case DW_TAG_padding
:
1932 case DW_TAG_compile_unit
:
1933 read_file_scope (die
, cu
);
1935 case DW_TAG_subprogram
:
1936 read_subroutine_type (die
, cu
);
1937 read_func_scope (die
, cu
);
1939 case DW_TAG_inlined_subroutine
:
1940 /* FIXME: These are ignored for now.
1941 They could be used to set breakpoints on all inlined instances
1942 of a function and make GDB `next' properly over inlined functions. */
1944 case DW_TAG_lexical_block
:
1945 case DW_TAG_try_block
:
1946 case DW_TAG_catch_block
:
1947 read_lexical_block_scope (die
, cu
);
1949 case DW_TAG_class_type
:
1950 case DW_TAG_structure_type
:
1951 case DW_TAG_union_type
:
1952 read_structure_scope (die
, cu
);
1954 case DW_TAG_enumeration_type
:
1955 read_enumeration (die
, cu
);
1957 case DW_TAG_subroutine_type
:
1958 read_subroutine_type (die
, cu
);
1960 case DW_TAG_array_type
:
1961 read_array_type (die
, cu
);
1963 case DW_TAG_pointer_type
:
1964 read_tag_pointer_type (die
, cu
);
1966 case DW_TAG_ptr_to_member_type
:
1967 read_tag_ptr_to_member_type (die
, cu
);
1969 case DW_TAG_reference_type
:
1970 read_tag_reference_type (die
, cu
);
1972 case DW_TAG_string_type
:
1973 read_tag_string_type (die
, cu
);
1975 case DW_TAG_base_type
:
1976 read_base_type (die
, cu
);
1977 if (dwarf2_attr (die
, DW_AT_name
, cu
))
1979 /* Add a typedef symbol for the base type definition. */
1980 new_symbol (die
, die
->type
, cu
);
1983 case DW_TAG_subrange_type
:
1984 read_subrange_type (die
, cu
);
1985 if (dwarf2_attr (die
, DW_AT_name
, cu
))
1987 /* Add a typedef symbol for the base type definition. */
1988 new_symbol (die
, die
->type
, cu
);
1991 case DW_TAG_common_block
:
1992 read_common_block (die
, cu
);
1994 case DW_TAG_common_inclusion
:
1996 case DW_TAG_namespace
:
1997 processing_has_namespace_info
= 1;
1998 read_namespace (die
, cu
);
2000 case DW_TAG_imported_declaration
:
2001 case DW_TAG_imported_module
:
2002 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2003 information contained in these. DW_TAG_imported_declaration
2004 dies shouldn't have children; DW_TAG_imported_module dies
2005 shouldn't in the C++ case, but conceivably could in the
2006 Fortran case, so we'll have to replace this gdb_assert if
2007 Fortran compilers start generating that info. */
2008 processing_has_namespace_info
= 1;
2009 gdb_assert (die
->child
== NULL
);
2012 new_symbol (die
, NULL
, cu
);
2018 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2020 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2024 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2026 struct objfile
*objfile
= cu
->objfile
;
2027 struct comp_unit_head
*cu_header
= &cu
->header
;
2028 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2029 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2030 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2031 struct attribute
*attr
;
2032 char *name
= "<unknown>";
2033 char *comp_dir
= NULL
;
2034 struct die_info
*child_die
;
2035 bfd
*abfd
= objfile
->obfd
;
2036 struct line_header
*line_header
= 0;
2039 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2041 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2043 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2044 from finish_block. */
2045 if (lowpc
== ((CORE_ADDR
) -1))
2050 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2053 name
= DW_STRING (attr
);
2055 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2058 comp_dir
= DW_STRING (attr
);
2061 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2062 directory, get rid of it. */
2063 char *cp
= strchr (comp_dir
, ':');
2065 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2070 if (objfile
->ei
.entry_point
>= lowpc
&&
2071 objfile
->ei
.entry_point
< highpc
)
2073 objfile
->ei
.deprecated_entry_file_lowpc
= lowpc
;
2074 objfile
->ei
.deprecated_entry_file_highpc
= highpc
;
2077 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2080 set_cu_language (DW_UNSND (attr
), cu
);
2083 /* We assume that we're processing GCC output. */
2084 processing_gcc_compilation
= 2;
2086 /* FIXME:Do something here. */
2087 if (dip
->at_producer
!= NULL
)
2089 handle_producer (dip
->at_producer
);
2093 /* The compilation unit may be in a different language or objfile,
2094 zero out all remembered fundamental types. */
2095 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2097 start_symtab (name
, comp_dir
, lowpc
);
2098 record_debugformat ("DWARF 2");
2100 initialize_cu_func_list (cu
);
2102 /* Process all dies in compilation unit. */
2103 if (die
->child
!= NULL
)
2105 child_die
= die
->child
;
2106 while (child_die
&& child_die
->tag
)
2108 process_die (child_die
, cu
);
2109 child_die
= sibling_die (child_die
);
2113 /* Decode line number information if present. */
2114 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2117 unsigned int line_offset
= DW_UNSND (attr
);
2118 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2121 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2122 (void *) line_header
);
2123 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
);
2127 /* Decode macro information, if present. Dwarf 2 macro information
2128 refers to information in the line number info statement program
2129 header, so we can only read it if we've read the header
2131 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2132 if (attr
&& line_header
)
2134 unsigned int macro_offset
= DW_UNSND (attr
);
2135 dwarf_decode_macros (line_header
, macro_offset
,
2136 comp_dir
, abfd
, cu
);
2138 do_cleanups (back_to
);
2142 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2143 struct dwarf2_cu
*cu
)
2145 struct function_range
*thisfn
;
2147 thisfn
= (struct function_range
*)
2148 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct function_range
));
2149 thisfn
->name
= name
;
2150 thisfn
->lowpc
= lowpc
;
2151 thisfn
->highpc
= highpc
;
2152 thisfn
->seen_line
= 0;
2153 thisfn
->next
= NULL
;
2155 if (cu
->last_fn
== NULL
)
2156 cu
->first_fn
= thisfn
;
2158 cu
->last_fn
->next
= thisfn
;
2160 cu
->last_fn
= thisfn
;
2164 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2166 struct objfile
*objfile
= cu
->objfile
;
2167 struct context_stack
*new;
2170 struct die_info
*child_die
;
2171 struct attribute
*attr
;
2173 const char *previous_prefix
= processing_current_prefix
;
2174 struct cleanup
*back_to
= NULL
;
2177 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2179 name
= dwarf2_linkage_name (die
, cu
);
2181 /* Ignore functions with missing or empty names and functions with
2182 missing or invalid low and high pc attributes. */
2183 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2186 if (cu
->language
== language_cplus
)
2188 struct die_info
*spec_die
= die_specification (die
, cu
);
2190 /* NOTE: carlton/2004-01-23: We have to be careful in the
2191 presence of DW_AT_specification. For example, with GCC 3.4,
2196 // Definition of N::foo.
2200 then we'll have a tree of DIEs like this:
2202 1: DW_TAG_compile_unit
2203 2: DW_TAG_namespace // N
2204 3: DW_TAG_subprogram // declaration of N::foo
2205 4: DW_TAG_subprogram // definition of N::foo
2206 DW_AT_specification // refers to die #3
2208 Thus, when processing die #4, we have to pretend that we're
2209 in the context of its DW_AT_specification, namely the contex
2212 if (spec_die
!= NULL
)
2214 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2215 processing_current_prefix
= specification_prefix
;
2216 back_to
= make_cleanup (xfree
, specification_prefix
);
2223 /* Record the function range for dwarf_decode_lines. */
2224 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2226 if (objfile
->ei
.entry_point
>= lowpc
&&
2227 objfile
->ei
.entry_point
< highpc
)
2229 objfile
->ei
.entry_func_lowpc
= lowpc
;
2230 objfile
->ei
.entry_func_highpc
= highpc
;
2233 new = push_context (0, lowpc
);
2234 new->name
= new_symbol (die
, die
->type
, cu
);
2236 /* If there is a location expression for DW_AT_frame_base, record
2238 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2240 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2241 expression is being recorded directly in the function's symbol
2242 and not in a separate frame-base object. I guess this hack is
2243 to avoid adding some sort of frame-base adjunct/annex to the
2244 function's symbol :-(. The problem with doing this is that it
2245 results in a function symbol with a location expression that
2246 has nothing to do with the location of the function, ouch! The
2247 relationship should be: a function's symbol has-a frame base; a
2248 frame-base has-a location expression. */
2249 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2251 cu
->list_in_scope
= &local_symbols
;
2253 if (die
->child
!= NULL
)
2255 child_die
= die
->child
;
2256 while (child_die
&& child_die
->tag
)
2258 process_die (child_die
, cu
);
2259 child_die
= sibling_die (child_die
);
2263 new = pop_context ();
2264 /* Make a block for the local symbols within. */
2265 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2266 lowpc
, highpc
, objfile
);
2268 /* In C++, we can have functions nested inside functions (e.g., when
2269 a function declares a class that has methods). This means that
2270 when we finish processing a function scope, we may need to go
2271 back to building a containing block's symbol lists. */
2272 local_symbols
= new->locals
;
2273 param_symbols
= new->params
;
2275 /* If we've finished processing a top-level function, subsequent
2276 symbols go in the file symbol list. */
2277 if (outermost_context_p ())
2278 cu
->list_in_scope
= &file_symbols
;
2280 processing_current_prefix
= previous_prefix
;
2281 if (back_to
!= NULL
)
2282 do_cleanups (back_to
);
2285 /* Process all the DIES contained within a lexical block scope. Start
2286 a new scope, process the dies, and then close the scope. */
2289 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2291 struct objfile
*objfile
= cu
->objfile
;
2292 struct context_stack
*new;
2293 CORE_ADDR lowpc
, highpc
;
2294 struct die_info
*child_die
;
2297 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2299 /* Ignore blocks with missing or invalid low and high pc attributes. */
2300 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2301 as multiple lexical blocks? Handling children in a sane way would
2302 be nasty. Might be easier to properly extend generic blocks to
2304 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2309 push_context (0, lowpc
);
2310 if (die
->child
!= NULL
)
2312 child_die
= die
->child
;
2313 while (child_die
&& child_die
->tag
)
2315 process_die (child_die
, cu
);
2316 child_die
= sibling_die (child_die
);
2319 new = pop_context ();
2321 if (local_symbols
!= NULL
)
2323 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
2326 local_symbols
= new->locals
;
2329 /* Get low and high pc attributes from a die. Return 1 if the attributes
2330 are present and valid, otherwise, return 0. Return -1 if the range is
2331 discontinuous, i.e. derived from DW_AT_ranges information. */
2333 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
2334 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
2336 struct objfile
*objfile
= cu
->objfile
;
2337 struct comp_unit_head
*cu_header
= &cu
->header
;
2338 struct attribute
*attr
;
2339 bfd
*obfd
= objfile
->obfd
;
2344 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
2347 high
= DW_ADDR (attr
);
2348 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
2350 low
= DW_ADDR (attr
);
2352 /* Found high w/o low attribute. */
2355 /* Found consecutive range of addresses. */
2360 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
2363 unsigned int addr_size
= cu_header
->addr_size
;
2364 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2365 /* Value of the DW_AT_ranges attribute is the offset in the
2366 .debug_ranges section. */
2367 unsigned int offset
= DW_UNSND (attr
);
2368 /* Base address selection entry. */
2376 found_base
= cu_header
->base_known
;
2377 base
= cu_header
->base_address
;
2379 if (offset
>= dwarf_ranges_size
)
2381 complaint (&symfile_complaints
,
2382 "Offset %d out of bounds for DW_AT_ranges attribute",
2386 buffer
= dwarf_ranges_buffer
+ offset
;
2388 /* Read in the largest possible address. */
2389 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
2390 if ((marker
& mask
) == mask
)
2392 /* If we found the largest possible address, then
2393 read the base address. */
2394 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2395 buffer
+= 2 * addr_size
;
2396 offset
+= 2 * addr_size
;
2404 CORE_ADDR range_beginning
, range_end
;
2406 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
2407 buffer
+= addr_size
;
2408 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
2409 buffer
+= addr_size
;
2410 offset
+= 2 * addr_size
;
2412 /* An end of list marker is a pair of zero addresses. */
2413 if (range_beginning
== 0 && range_end
== 0)
2414 /* Found the end of list entry. */
2417 /* Each base address selection entry is a pair of 2 values.
2418 The first is the largest possible address, the second is
2419 the base address. Check for a base address here. */
2420 if ((range_beginning
& mask
) == mask
)
2422 /* If we found the largest possible address, then
2423 read the base address. */
2424 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
2431 /* We have no valid base address for the ranges
2433 complaint (&symfile_complaints
,
2434 "Invalid .debug_ranges data (no base address)");
2438 range_beginning
+= base
;
2441 /* FIXME: This is recording everything as a low-high
2442 segment of consecutive addresses. We should have a
2443 data structure for discontiguous block ranges
2447 low
= range_beginning
;
2453 if (range_beginning
< low
)
2454 low
= range_beginning
;
2455 if (range_end
> high
)
2461 /* If the first entry is an end-of-list marker, the range
2462 describes an empty scope, i.e. no instructions. */
2472 /* When using the GNU linker, .gnu.linkonce. sections are used to
2473 eliminate duplicate copies of functions and vtables and such.
2474 The linker will arbitrarily choose one and discard the others.
2475 The AT_*_pc values for such functions refer to local labels in
2476 these sections. If the section from that file was discarded, the
2477 labels are not in the output, so the relocs get a value of 0.
2478 If this is a discarded function, mark the pc bounds as invalid,
2479 so that GDB will ignore it. */
2480 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
2488 /* Get the low and high pc's represented by the scope DIE, and store
2489 them in *LOWPC and *HIGHPC. If the correct values can't be
2490 determined, set *LOWPC to -1 and *HIGHPC to 0. */
2493 get_scope_pc_bounds (struct die_info
*die
,
2494 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2495 struct dwarf2_cu
*cu
)
2497 CORE_ADDR best_low
= (CORE_ADDR
) -1;
2498 CORE_ADDR best_high
= (CORE_ADDR
) 0;
2499 CORE_ADDR current_low
, current_high
;
2501 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
2503 best_low
= current_low
;
2504 best_high
= current_high
;
2508 struct die_info
*child
= die
->child
;
2510 while (child
&& child
->tag
)
2512 switch (child
->tag
) {
2513 case DW_TAG_subprogram
:
2514 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
2516 best_low
= min (best_low
, current_low
);
2517 best_high
= max (best_high
, current_high
);
2520 case DW_TAG_namespace
:
2521 /* FIXME: carlton/2004-01-16: Should we do this for
2522 DW_TAG_class_type/DW_TAG_structure_type, too? I think
2523 that current GCC's always emit the DIEs corresponding
2524 to definitions of methods of classes as children of a
2525 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
2526 the DIEs giving the declarations, which could be
2527 anywhere). But I don't see any reason why the
2528 standards says that they have to be there. */
2529 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
2531 if (current_low
!= ((CORE_ADDR
) -1))
2533 best_low
= min (best_low
, current_low
);
2534 best_high
= max (best_high
, current_high
);
2542 child
= sibling_die (child
);
2547 *highpc
= best_high
;
2550 /* Add an aggregate field to the field list. */
2553 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
2554 struct dwarf2_cu
*cu
)
2556 struct objfile
*objfile
= cu
->objfile
;
2557 struct nextfield
*new_field
;
2558 struct attribute
*attr
;
2560 char *fieldname
= "";
2562 /* Allocate a new field list entry and link it in. */
2563 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2564 make_cleanup (xfree
, new_field
);
2565 memset (new_field
, 0, sizeof (struct nextfield
));
2566 new_field
->next
= fip
->fields
;
2567 fip
->fields
= new_field
;
2570 /* Handle accessibility and virtuality of field.
2571 The default accessibility for members is public, the default
2572 accessibility for inheritance is private. */
2573 if (die
->tag
!= DW_TAG_inheritance
)
2574 new_field
->accessibility
= DW_ACCESS_public
;
2576 new_field
->accessibility
= DW_ACCESS_private
;
2577 new_field
->virtuality
= DW_VIRTUALITY_none
;
2579 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
2581 new_field
->accessibility
= DW_UNSND (attr
);
2582 if (new_field
->accessibility
!= DW_ACCESS_public
)
2583 fip
->non_public_fields
= 1;
2584 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
2586 new_field
->virtuality
= DW_UNSND (attr
);
2588 fp
= &new_field
->field
;
2590 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
2592 /* Data member other than a C++ static data member. */
2594 /* Get type of field. */
2595 fp
->type
= die_type (die
, cu
);
2597 FIELD_STATIC_KIND (*fp
) = 0;
2599 /* Get bit size of field (zero if none). */
2600 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
2603 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
2607 FIELD_BITSIZE (*fp
) = 0;
2610 /* Get bit offset of field. */
2611 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
2614 FIELD_BITPOS (*fp
) =
2615 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
2618 FIELD_BITPOS (*fp
) = 0;
2619 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
2622 if (BITS_BIG_ENDIAN
)
2624 /* For big endian bits, the DW_AT_bit_offset gives the
2625 additional bit offset from the MSB of the containing
2626 anonymous object to the MSB of the field. We don't
2627 have to do anything special since we don't need to
2628 know the size of the anonymous object. */
2629 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
2633 /* For little endian bits, compute the bit offset to the
2634 MSB of the anonymous object, subtract off the number of
2635 bits from the MSB of the field to the MSB of the
2636 object, and then subtract off the number of bits of
2637 the field itself. The result is the bit offset of
2638 the LSB of the field. */
2640 int bit_offset
= DW_UNSND (attr
);
2642 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
2645 /* The size of the anonymous object containing
2646 the bit field is explicit, so use the
2647 indicated size (in bytes). */
2648 anonymous_size
= DW_UNSND (attr
);
2652 /* The size of the anonymous object containing
2653 the bit field must be inferred from the type
2654 attribute of the data member containing the
2656 anonymous_size
= TYPE_LENGTH (fp
->type
);
2658 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
2659 - bit_offset
- FIELD_BITSIZE (*fp
);
2663 /* Get name of field. */
2664 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2665 if (attr
&& DW_STRING (attr
))
2666 fieldname
= DW_STRING (attr
);
2667 fp
->name
= obsavestring (fieldname
, strlen (fieldname
),
2668 &objfile
->objfile_obstack
);
2670 /* Change accessibility for artificial fields (e.g. virtual table
2671 pointer or virtual base class pointer) to private. */
2672 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
2674 new_field
->accessibility
= DW_ACCESS_private
;
2675 fip
->non_public_fields
= 1;
2678 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
2680 /* C++ static member. */
2682 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2683 is a declaration, but all versions of G++ as of this writing
2684 (so through at least 3.2.1) incorrectly generate
2685 DW_TAG_variable tags. */
2689 /* Get name of field. */
2690 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2691 if (attr
&& DW_STRING (attr
))
2692 fieldname
= DW_STRING (attr
);
2696 /* Get physical name. */
2697 physname
= dwarf2_linkage_name (die
, cu
);
2699 SET_FIELD_PHYSNAME (*fp
, obsavestring (physname
, strlen (physname
),
2700 &objfile
->objfile_obstack
));
2701 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2702 FIELD_NAME (*fp
) = obsavestring (fieldname
, strlen (fieldname
),
2703 &objfile
->objfile_obstack
);
2705 else if (die
->tag
== DW_TAG_inheritance
)
2707 /* C++ base class field. */
2708 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
2710 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
2712 FIELD_BITSIZE (*fp
) = 0;
2713 FIELD_STATIC_KIND (*fp
) = 0;
2714 FIELD_TYPE (*fp
) = die_type (die
, cu
);
2715 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
2716 fip
->nbaseclasses
++;
2720 /* Create the vector of fields, and attach it to the type. */
2723 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
2724 struct dwarf2_cu
*cu
)
2726 int nfields
= fip
->nfields
;
2728 /* Record the field count, allocate space for the array of fields,
2729 and create blank accessibility bitfields if necessary. */
2730 TYPE_NFIELDS (type
) = nfields
;
2731 TYPE_FIELDS (type
) = (struct field
*)
2732 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2733 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2735 if (fip
->non_public_fields
)
2737 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2739 TYPE_FIELD_PRIVATE_BITS (type
) =
2740 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2741 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2743 TYPE_FIELD_PROTECTED_BITS (type
) =
2744 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2745 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2747 TYPE_FIELD_IGNORE_BITS (type
) =
2748 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2749 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2752 /* If the type has baseclasses, allocate and clear a bit vector for
2753 TYPE_FIELD_VIRTUAL_BITS. */
2754 if (fip
->nbaseclasses
)
2756 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
2759 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2760 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2761 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2762 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
2763 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
2766 /* Copy the saved-up fields into the field vector. Start from the head
2767 of the list, adding to the tail of the field array, so that they end
2768 up in the same order in the array in which they were added to the list. */
2769 while (nfields
-- > 0)
2771 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
2772 switch (fip
->fields
->accessibility
)
2774 case DW_ACCESS_private
:
2775 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2778 case DW_ACCESS_protected
:
2779 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2782 case DW_ACCESS_public
:
2786 /* Unknown accessibility. Complain and treat it as public. */
2788 complaint (&symfile_complaints
, "unsupported accessibility %d",
2789 fip
->fields
->accessibility
);
2793 if (nfields
< fip
->nbaseclasses
)
2795 switch (fip
->fields
->virtuality
)
2797 case DW_VIRTUALITY_virtual
:
2798 case DW_VIRTUALITY_pure_virtual
:
2799 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
2803 fip
->fields
= fip
->fields
->next
;
2807 /* Add a member function to the proper fieldlist. */
2810 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
2811 struct type
*type
, struct dwarf2_cu
*cu
)
2813 struct objfile
*objfile
= cu
->objfile
;
2814 struct attribute
*attr
;
2815 struct fnfieldlist
*flp
;
2817 struct fn_field
*fnp
;
2820 struct nextfnfield
*new_fnfield
;
2822 /* Get name of member function. */
2823 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2824 if (attr
&& DW_STRING (attr
))
2825 fieldname
= DW_STRING (attr
);
2829 /* Get the mangled name. */
2830 physname
= dwarf2_linkage_name (die
, cu
);
2832 /* Look up member function name in fieldlist. */
2833 for (i
= 0; i
< fip
->nfnfields
; i
++)
2835 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
2839 /* Create new list element if necessary. */
2840 if (i
< fip
->nfnfields
)
2841 flp
= &fip
->fnfieldlists
[i
];
2844 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
2846 fip
->fnfieldlists
= (struct fnfieldlist
*)
2847 xrealloc (fip
->fnfieldlists
,
2848 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
2849 * sizeof (struct fnfieldlist
));
2850 if (fip
->nfnfields
== 0)
2851 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
2853 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
2854 flp
->name
= fieldname
;
2860 /* Create a new member function field and chain it to the field list
2862 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
2863 make_cleanup (xfree
, new_fnfield
);
2864 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
2865 new_fnfield
->next
= flp
->head
;
2866 flp
->head
= new_fnfield
;
2869 /* Fill in the member function field info. */
2870 fnp
= &new_fnfield
->fnfield
;
2871 fnp
->physname
= obsavestring (physname
, strlen (physname
),
2872 &objfile
->objfile_obstack
);
2873 fnp
->type
= alloc_type (objfile
);
2874 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
2876 int nparams
= TYPE_NFIELDS (die
->type
);
2878 /* TYPE is the domain of this method, and DIE->TYPE is the type
2879 of the method itself (TYPE_CODE_METHOD). */
2880 smash_to_method_type (fnp
->type
, type
,
2881 TYPE_TARGET_TYPE (die
->type
),
2882 TYPE_FIELDS (die
->type
),
2883 TYPE_NFIELDS (die
->type
),
2884 TYPE_VARARGS (die
->type
));
2886 /* Handle static member functions.
2887 Dwarf2 has no clean way to discern C++ static and non-static
2888 member functions. G++ helps GDB by marking the first
2889 parameter for non-static member functions (which is the
2890 this pointer) as artificial. We obtain this information
2891 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2892 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
2893 fnp
->voffset
= VOFFSET_STATIC
;
2896 complaint (&symfile_complaints
, "member function type missing for '%s'",
2899 /* Get fcontext from DW_AT_containing_type if present. */
2900 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
2901 fnp
->fcontext
= die_containing_type (die
, cu
);
2903 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2904 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2906 /* Get accessibility. */
2907 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
2910 switch (DW_UNSND (attr
))
2912 case DW_ACCESS_private
:
2913 fnp
->is_private
= 1;
2915 case DW_ACCESS_protected
:
2916 fnp
->is_protected
= 1;
2921 /* Check for artificial methods. */
2922 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
2923 if (attr
&& DW_UNSND (attr
) != 0)
2924 fnp
->is_artificial
= 1;
2926 /* Get index in virtual function table if it is a virtual member function. */
2927 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
2930 /* Support the .debug_loc offsets */
2931 if (attr_form_is_block (attr
))
2933 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
2935 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
2937 dwarf2_complex_location_expr_complaint ();
2941 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2947 /* Create the vector of member function fields, and attach it to the type. */
2950 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
2951 struct dwarf2_cu
*cu
)
2953 struct fnfieldlist
*flp
;
2954 int total_length
= 0;
2957 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2958 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2959 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
2961 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
2963 struct nextfnfield
*nfp
= flp
->head
;
2964 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
2967 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
2968 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
2969 fn_flp
->fn_fields
= (struct fn_field
*)
2970 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
2971 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
2972 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
2974 total_length
+= flp
->length
;
2977 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
2978 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2981 /* Called when we find the DIE that starts a structure or union scope
2982 (definition) to process all dies that define the members of the
2985 NOTE: we need to call struct_type regardless of whether or not the
2986 DIE has an at_name attribute, since it might be an anonymous
2987 structure or union. This gets the type entered into our set of
2990 However, if the structure is incomplete (an opaque struct/union)
2991 then suppress creating a symbol table entry for it since gdb only
2992 wants to find the one with the complete definition. Note that if
2993 it is complete, we just call new_symbol, which does it's own
2994 checking about whether the struct/union is anonymous or not (and
2995 suppresses creating a symbol table entry itself). */
2998 read_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3000 struct objfile
*objfile
= cu
->objfile
;
3002 struct attribute
*attr
;
3003 const char *name
= NULL
;
3004 const char *previous_prefix
= processing_current_prefix
;
3005 struct cleanup
*back_to
= NULL
;
3006 /* This says whether or not we want to try to update the structure's
3007 name to include enclosing namespace/class information, if
3009 int need_to_update_name
= 0;
3011 type
= alloc_type (objfile
);
3013 INIT_CPLUS_SPECIFIC (type
);
3014 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3015 if (attr
&& DW_STRING (attr
))
3017 name
= DW_STRING (attr
);
3019 if (cu
->language
== language_cplus
)
3021 struct die_info
*spec_die
= die_specification (die
, cu
);
3023 if (spec_die
!= NULL
)
3025 char *specification_prefix
= determine_prefix (spec_die
, cu
);
3026 processing_current_prefix
= specification_prefix
;
3027 back_to
= make_cleanup (xfree
, specification_prefix
);
3031 if (processing_has_namespace_info
)
3033 /* FIXME: carlton/2003-11-10: This variable exists only for
3034 const-correctness reasons. When I tried to change
3035 TYPE_TAG_NAME to be a const char *, I ran into a cascade
3036 of changes which would have forced decode_line_1 to take
3038 char *new_prefix
= obconcat (&objfile
->objfile_obstack
,
3039 processing_current_prefix
,
3040 processing_current_prefix
[0] == '\0'
3043 TYPE_TAG_NAME (type
) = new_prefix
;
3044 processing_current_prefix
= new_prefix
;
3048 TYPE_TAG_NAME (type
) = obsavestring (name
, strlen (name
),
3049 &objfile
->objfile_obstack
);
3050 need_to_update_name
= (cu
->language
== language_cplus
);
3054 if (die
->tag
== DW_TAG_structure_type
)
3056 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3058 else if (die
->tag
== DW_TAG_union_type
)
3060 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3064 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3066 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3069 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3072 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3076 TYPE_LENGTH (type
) = 0;
3079 /* We need to add the type field to the die immediately so we don't
3080 infinitely recurse when dealing with pointers to the structure
3081 type within the structure itself. */
3084 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3086 struct field_info fi
;
3087 struct die_info
*child_die
;
3088 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3090 memset (&fi
, 0, sizeof (struct field_info
));
3092 child_die
= die
->child
;
3094 while (child_die
&& child_die
->tag
)
3096 if (child_die
->tag
== DW_TAG_member
3097 || child_die
->tag
== DW_TAG_variable
)
3099 /* NOTE: carlton/2002-11-05: A C++ static data member
3100 should be a DW_TAG_member that is a declaration, but
3101 all versions of G++ as of this writing (so through at
3102 least 3.2.1) incorrectly generate DW_TAG_variable
3103 tags for them instead. */
3104 dwarf2_add_field (&fi
, child_die
, cu
);
3106 else if (child_die
->tag
== DW_TAG_subprogram
)
3108 /* C++ member function. */
3109 process_die (child_die
, cu
);
3110 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3111 if (need_to_update_name
)
3113 /* The demangled names of member functions contain
3114 information about enclosing namespaces/classes,
3117 /* FIXME: carlton/2003-11-10: The excessive
3118 demangling here is a bit wasteful, as is the
3119 memory usage for names. */
3121 /* NOTE: carlton/2003-11-10: As commented in
3122 add_partial_structure, the demangler sometimes
3123 prints the type info in a different form from the
3124 debug info. We could solve this by using the
3125 demangled name to get the prefix; if doing so,
3126 however, we'd need to be careful when reading a
3127 class that's nested inside a template class.
3128 That would also cause problems when trying to
3129 determine RTTI information, since we use the
3130 demangler to determine the appropriate class
3132 char *actual_class_name
3133 = class_name_from_physname (dwarf2_linkage_name
3135 if (actual_class_name
!= NULL
3136 && strcmp (actual_class_name
, name
) != 0)
3138 TYPE_TAG_NAME (type
)
3139 = obsavestring (actual_class_name
,
3140 strlen (actual_class_name
),
3141 &objfile
->objfile_obstack
);
3143 xfree (actual_class_name
);
3144 need_to_update_name
= 0;
3147 else if (child_die
->tag
== DW_TAG_inheritance
)
3149 /* C++ base class field. */
3150 dwarf2_add_field (&fi
, child_die
, cu
);
3154 process_die (child_die
, cu
);
3156 child_die
= sibling_die (child_die
);
3159 /* Attach fields and member functions to the type. */
3161 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3164 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3166 /* Get the type which refers to the base class (possibly this
3167 class itself) which contains the vtable pointer for the current
3168 class from the DW_AT_containing_type attribute. */
3170 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3172 struct type
*t
= die_containing_type (die
, cu
);
3174 TYPE_VPTR_BASETYPE (type
) = t
;
3177 static const char vptr_name
[] =
3178 {'_', 'v', 'p', 't', 'r', '\0'};
3181 /* Our own class provides vtbl ptr. */
3182 for (i
= TYPE_NFIELDS (t
) - 1;
3183 i
>= TYPE_N_BASECLASSES (t
);
3186 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3188 if ((strncmp (fieldname
, vptr_name
,
3189 strlen (vptr_name
) - 1)
3191 && is_cplus_marker (fieldname
[strlen (vptr_name
)]))
3193 TYPE_VPTR_FIELDNO (type
) = i
;
3198 /* Complain if virtual function table field not found. */
3199 if (i
< TYPE_N_BASECLASSES (t
))
3200 complaint (&symfile_complaints
,
3201 "virtual function table pointer not found when defining class '%s'",
3202 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3207 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3212 new_symbol (die
, type
, cu
);
3214 do_cleanups (back_to
);
3218 /* No children, must be stub. */
3219 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3222 processing_current_prefix
= previous_prefix
;
3223 if (back_to
!= NULL
)
3224 do_cleanups (back_to
);
3227 /* Given a pointer to a die which begins an enumeration, process all
3228 the dies that define the members of the enumeration.
3230 This will be much nicer in draft 6 of the DWARF spec when our
3231 members will be dies instead squished into the DW_AT_element_list
3234 NOTE: We reverse the order of the element list. */
3237 read_enumeration (struct die_info
*die
, struct dwarf2_cu
*cu
)
3239 struct objfile
*objfile
= cu
->objfile
;
3240 struct die_info
*child_die
;
3242 struct field
*fields
;
3243 struct attribute
*attr
;
3246 int unsigned_enum
= 1;
3248 type
= alloc_type (objfile
);
3250 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3251 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3252 if (attr
&& DW_STRING (attr
))
3254 const char *name
= DW_STRING (attr
);
3256 if (processing_has_namespace_info
)
3258 TYPE_TAG_NAME (type
) = obconcat (&objfile
->objfile_obstack
,
3259 processing_current_prefix
,
3260 processing_current_prefix
[0] == '\0'
3266 TYPE_TAG_NAME (type
) = obsavestring (name
, strlen (name
),
3267 &objfile
->objfile_obstack
);
3271 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3274 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3278 TYPE_LENGTH (type
) = 0;
3283 if (die
->child
!= NULL
)
3285 child_die
= die
->child
;
3286 while (child_die
&& child_die
->tag
)
3288 if (child_die
->tag
!= DW_TAG_enumerator
)
3290 process_die (child_die
, cu
);
3294 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
3297 sym
= new_symbol (child_die
, type
, cu
);
3298 if (SYMBOL_VALUE (sym
) < 0)
3301 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3303 fields
= (struct field
*)
3305 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
3306 * sizeof (struct field
));
3309 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
3310 FIELD_TYPE (fields
[num_fields
]) = NULL
;
3311 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
3312 FIELD_BITSIZE (fields
[num_fields
]) = 0;
3313 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
3319 child_die
= sibling_die (child_die
);
3324 TYPE_NFIELDS (type
) = num_fields
;
3325 TYPE_FIELDS (type
) = (struct field
*)
3326 TYPE_ALLOC (type
, sizeof (struct field
) * num_fields
);
3327 memcpy (TYPE_FIELDS (type
), fields
,
3328 sizeof (struct field
) * num_fields
);
3332 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
3335 new_symbol (die
, type
, cu
);
3338 /* Extract all information from a DW_TAG_array_type DIE and put it in
3339 the DIE's type field. For now, this only handles one dimensional
3343 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3345 struct objfile
*objfile
= cu
->objfile
;
3346 struct die_info
*child_die
;
3347 struct type
*type
= NULL
;
3348 struct type
*element_type
, *range_type
, *index_type
;
3349 struct type
**range_types
= NULL
;
3350 struct attribute
*attr
;
3352 struct cleanup
*back_to
;
3354 /* Return if we've already decoded this type. */
3360 element_type
= die_type (die
, cu
);
3362 /* Irix 6.2 native cc creates array types without children for
3363 arrays with unspecified length. */
3364 if (die
->child
== NULL
)
3366 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
3367 range_type
= create_range_type (NULL
, index_type
, 0, -1);
3368 die
->type
= create_array_type (NULL
, element_type
, range_type
);
3372 back_to
= make_cleanup (null_cleanup
, NULL
);
3373 child_die
= die
->child
;
3374 while (child_die
&& child_die
->tag
)
3376 if (child_die
->tag
== DW_TAG_subrange_type
)
3378 read_subrange_type (child_die
, cu
);
3380 if (child_die
->type
!= NULL
)
3382 /* The range type was succesfully read. Save it for
3383 the array type creation. */
3384 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
3386 range_types
= (struct type
**)
3387 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
3388 * sizeof (struct type
*));
3390 make_cleanup (free_current_contents
, &range_types
);
3392 range_types
[ndim
++] = child_die
->type
;
3395 child_die
= sibling_die (child_die
);
3398 /* Dwarf2 dimensions are output from left to right, create the
3399 necessary array types in backwards order. */
3400 type
= element_type
;
3402 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
3404 /* Understand Dwarf2 support for vector types (like they occur on
3405 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3406 array type. This is not part of the Dwarf2/3 standard yet, but a
3407 custom vendor extension. The main difference between a regular
3408 array and the vector variant is that vectors are passed by value
3410 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
3412 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
3414 do_cleanups (back_to
);
3416 /* Install the type in the die. */
3420 /* First cut: install each common block member as a global variable. */
3423 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
3425 struct die_info
*child_die
;
3426 struct attribute
*attr
;
3428 CORE_ADDR base
= (CORE_ADDR
) 0;
3430 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
3433 /* Support the .debug_loc offsets */
3434 if (attr_form_is_block (attr
))
3436 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
3438 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3440 dwarf2_complex_location_expr_complaint ();
3444 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3445 "common block member");
3448 if (die
->child
!= NULL
)
3450 child_die
= die
->child
;
3451 while (child_die
&& child_die
->tag
)
3453 sym
= new_symbol (child_die
, NULL
, cu
);
3454 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
3457 SYMBOL_VALUE_ADDRESS (sym
) =
3458 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
3459 add_symbol_to_list (sym
, &global_symbols
);
3461 child_die
= sibling_die (child_die
);
3466 /* Read a C++ namespace. */
3469 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
3471 struct objfile
*objfile
= cu
->objfile
;
3472 const char *previous_prefix
= processing_current_prefix
;
3475 struct die_info
*current_die
;
3477 name
= namespace_name (die
, &is_anonymous
, cu
);
3479 /* Now build the name of the current namespace. */
3481 if (previous_prefix
[0] == '\0')
3483 processing_current_prefix
= name
;
3487 /* We need temp_name around because processing_current_prefix
3488 is a const char *. */
3489 char *temp_name
= alloca (strlen (previous_prefix
)
3490 + 2 + strlen(name
) + 1);
3491 strcpy (temp_name
, previous_prefix
);
3492 strcat (temp_name
, "::");
3493 strcat (temp_name
, name
);
3495 processing_current_prefix
= temp_name
;
3498 /* Add a symbol associated to this if we haven't seen the namespace
3499 before. Also, add a using directive if it's an anonymous
3502 if (dwarf2_extension (die
, cu
) == NULL
)
3506 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3507 this cast will hopefully become unnecessary. */
3508 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
3509 (char *) processing_current_prefix
,
3511 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
3513 new_symbol (die
, type
, cu
);
3516 cp_add_using_directive (processing_current_prefix
,
3517 strlen (previous_prefix
),
3518 strlen (processing_current_prefix
));
3521 if (die
->child
!= NULL
)
3523 struct die_info
*child_die
= die
->child
;
3525 while (child_die
&& child_die
->tag
)
3527 process_die (child_die
, cu
);
3528 child_die
= sibling_die (child_die
);
3532 processing_current_prefix
= previous_prefix
;
3535 /* Return the name of the namespace represented by DIE. Set
3536 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
3540 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
3542 struct die_info
*current_die
;
3543 const char *name
= NULL
;
3545 /* Loop through the extensions until we find a name. */
3547 for (current_die
= die
;
3548 current_die
!= NULL
;
3549 current_die
= dwarf2_extension (die
, cu
))
3551 name
= dwarf2_name (current_die
, cu
);
3556 /* Is it an anonymous namespace? */
3558 *is_anonymous
= (name
== NULL
);
3560 name
= "(anonymous namespace)";
3565 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3566 the user defined type vector. */
3569 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3571 struct comp_unit_head
*cu_header
= &cu
->header
;
3573 struct attribute
*attr_byte_size
;
3574 struct attribute
*attr_address_class
;
3575 int byte_size
, addr_class
;
3582 type
= lookup_pointer_type (die_type (die
, cu
));
3584 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3586 byte_size
= DW_UNSND (attr_byte_size
);
3588 byte_size
= cu_header
->addr_size
;
3590 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
3591 if (attr_address_class
)
3592 addr_class
= DW_UNSND (attr_address_class
);
3594 addr_class
= DW_ADDR_none
;
3596 /* If the pointer size or address class is different than the
3597 default, create a type variant marked as such and set the
3598 length accordingly. */
3599 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
3601 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3605 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
3606 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
3607 type
= make_type_with_address_space (type
, type_flags
);
3609 else if (TYPE_LENGTH (type
) != byte_size
)
3611 complaint (&symfile_complaints
, "invalid pointer size %d", byte_size
);
3614 /* Should we also complain about unhandled address classes? */
3618 TYPE_LENGTH (type
) = byte_size
;
3622 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3623 the user defined type vector. */
3626 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3628 struct objfile
*objfile
= cu
->objfile
;
3630 struct type
*to_type
;
3631 struct type
*domain
;
3638 type
= alloc_type (objfile
);
3639 to_type
= die_type (die
, cu
);
3640 domain
= die_containing_type (die
, cu
);
3641 smash_to_member_type (type
, domain
, to_type
);
3646 /* Extract all information from a DW_TAG_reference_type DIE and add to
3647 the user defined type vector. */
3650 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3652 struct comp_unit_head
*cu_header
= &cu
->header
;
3654 struct attribute
*attr
;
3661 type
= lookup_reference_type (die_type (die
, cu
));
3662 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3665 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3669 TYPE_LENGTH (type
) = cu_header
->addr_size
;
3675 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3677 struct type
*base_type
;
3684 base_type
= die_type (die
, cu
);
3685 die
->type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
3689 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3691 struct type
*base_type
;
3698 base_type
= die_type (die
, cu
);
3699 die
->type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
3702 /* Extract all information from a DW_TAG_string_type DIE and add to
3703 the user defined type vector. It isn't really a user defined type,
3704 but it behaves like one, with other DIE's using an AT_user_def_type
3705 attribute to reference it. */
3708 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3710 struct objfile
*objfile
= cu
->objfile
;
3711 struct type
*type
, *range_type
, *index_type
, *char_type
;
3712 struct attribute
*attr
;
3713 unsigned int length
;
3720 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
3723 length
= DW_UNSND (attr
);
3727 /* check for the DW_AT_byte_size attribute */
3728 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3731 length
= DW_UNSND (attr
);
3738 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
3739 range_type
= create_range_type (NULL
, index_type
, 1, length
);
3740 if (cu
->language
== language_fortran
)
3742 /* Need to create a unique string type for bounds
3744 type
= create_string_type (0, range_type
);
3748 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
3749 type
= create_string_type (char_type
, range_type
);
3754 /* Handle DIES due to C code like:
3758 int (*funcp)(int a, long l);
3762 ('funcp' generates a DW_TAG_subroutine_type DIE)
3766 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3768 struct type
*type
; /* Type that this function returns */
3769 struct type
*ftype
; /* Function that returns above type */
3770 struct attribute
*attr
;
3772 /* Decode the type that this subroutine returns */
3777 type
= die_type (die
, cu
);
3778 ftype
= lookup_function_type (type
);
3780 /* All functions in C++ have prototypes. */
3781 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
3782 if ((attr
&& (DW_UNSND (attr
) != 0))
3783 || cu
->language
== language_cplus
)
3784 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
3786 if (die
->child
!= NULL
)
3788 struct die_info
*child_die
;
3792 /* Count the number of parameters.
3793 FIXME: GDB currently ignores vararg functions, but knows about
3794 vararg member functions. */
3795 child_die
= die
->child
;
3796 while (child_die
&& child_die
->tag
)
3798 if (child_die
->tag
== DW_TAG_formal_parameter
)
3800 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
3801 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
3802 child_die
= sibling_die (child_die
);
3805 /* Allocate storage for parameters and fill them in. */
3806 TYPE_NFIELDS (ftype
) = nparams
;
3807 TYPE_FIELDS (ftype
) = (struct field
*)
3808 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
3810 child_die
= die
->child
;
3811 while (child_die
&& child_die
->tag
)
3813 if (child_die
->tag
== DW_TAG_formal_parameter
)
3815 /* Dwarf2 has no clean way to discern C++ static and non-static
3816 member functions. G++ helps GDB by marking the first
3817 parameter for non-static member functions (which is the
3818 this pointer) as artificial. We pass this information
3819 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3820 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
3822 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
3824 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
3825 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
3828 child_die
= sibling_die (child_die
);
3836 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
3838 struct objfile
*objfile
= cu
->objfile
;
3839 struct attribute
*attr
;
3844 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3845 if (attr
&& DW_STRING (attr
))
3847 name
= DW_STRING (attr
);
3849 die
->type
= init_type (TYPE_CODE_TYPEDEF
, 0, TYPE_FLAG_TARGET_STUB
, name
, objfile
);
3850 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
3854 /* Find a representation of a given base type and install
3855 it in the TYPE field of the die. */
3858 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3860 struct objfile
*objfile
= cu
->objfile
;
3862 struct attribute
*attr
;
3863 int encoding
= 0, size
= 0;
3865 /* If we've already decoded this die, this is a no-op. */
3871 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
3874 encoding
= DW_UNSND (attr
);
3876 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3879 size
= DW_UNSND (attr
);
3881 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3882 if (attr
&& DW_STRING (attr
))
3884 enum type_code code
= TYPE_CODE_INT
;
3889 case DW_ATE_address
:
3890 /* Turn DW_ATE_address into a void * pointer. */
3891 code
= TYPE_CODE_PTR
;
3892 type_flags
|= TYPE_FLAG_UNSIGNED
;
3894 case DW_ATE_boolean
:
3895 code
= TYPE_CODE_BOOL
;
3896 type_flags
|= TYPE_FLAG_UNSIGNED
;
3898 case DW_ATE_complex_float
:
3899 code
= TYPE_CODE_COMPLEX
;
3902 code
= TYPE_CODE_FLT
;
3905 case DW_ATE_signed_char
:
3907 case DW_ATE_unsigned
:
3908 case DW_ATE_unsigned_char
:
3909 type_flags
|= TYPE_FLAG_UNSIGNED
;
3912 complaint (&symfile_complaints
, "unsupported DW_AT_encoding: '%s'",
3913 dwarf_type_encoding_name (encoding
));
3916 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
3917 if (encoding
== DW_ATE_address
)
3918 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
3920 else if (encoding
== DW_ATE_complex_float
)
3923 TYPE_TARGET_TYPE (type
)
3924 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
3925 else if (size
== 16)
3926 TYPE_TARGET_TYPE (type
)
3927 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
3929 TYPE_TARGET_TYPE (type
)
3930 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
3935 type
= dwarf_base_type (encoding
, size
, cu
);
3940 /* Read the given DW_AT_subrange DIE. */
3943 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3945 struct type
*base_type
;
3946 struct type
*range_type
;
3947 struct attribute
*attr
;
3951 /* If we have already decoded this die, then nothing more to do. */
3955 base_type
= die_type (die
, cu
);
3956 if (base_type
== NULL
)
3958 complaint (&symfile_complaints
,
3959 "DW_AT_type missing from DW_TAG_subrange_type");
3963 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
3964 base_type
= alloc_type (NULL
);
3966 if (cu
->language
== language_fortran
)
3968 /* FORTRAN implies a lower bound of 1, if not given. */
3972 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
3974 low
= dwarf2_get_attr_constant_value (attr
, 0);
3976 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
3979 if (attr
->form
== DW_FORM_block1
)
3981 /* GCC encodes arrays with unspecified or dynamic length
3982 with a DW_FORM_block1 attribute.
3983 FIXME: GDB does not yet know how to handle dynamic
3984 arrays properly, treat them as arrays with unspecified
3987 FIXME: jimb/2003-09-22: GDB does not really know
3988 how to handle arrays of unspecified length
3989 either; we just represent them as zero-length
3990 arrays. Choose an appropriate upper bound given
3991 the lower bound we've computed above. */
3995 high
= dwarf2_get_attr_constant_value (attr
, 1);
3998 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4000 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4001 if (attr
&& DW_STRING (attr
))
4002 TYPE_NAME (range_type
) = DW_STRING (attr
);
4004 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4006 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4008 die
->type
= range_type
;
4012 /* Read a whole compilation unit into a linked list of dies. */
4014 static struct die_info
*
4015 read_comp_unit (char *info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4017 /* Reset die reference table; we are
4018 building new ones now. */
4019 dwarf2_empty_hash_tables ();
4021 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4024 /* Read a single die and all its descendents. Set the die's sibling
4025 field to NULL; set other fields in the die correctly, and set all
4026 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4027 location of the info_ptr after reading all of those dies. PARENT
4028 is the parent of the die in question. */
4030 static struct die_info
*
4031 read_die_and_children (char *info_ptr
, bfd
*abfd
,
4032 struct dwarf2_cu
*cu
,
4033 char **new_info_ptr
,
4034 struct die_info
*parent
)
4036 struct die_info
*die
;
4040 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4041 store_in_ref_table (die
->offset
, die
);
4045 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4051 *new_info_ptr
= cur_ptr
;
4054 die
->sibling
= NULL
;
4055 die
->parent
= parent
;
4059 /* Read a die, all of its descendents, and all of its siblings; set
4060 all of the fields of all of the dies correctly. Arguments are as
4061 in read_die_and_children. */
4063 static struct die_info
*
4064 read_die_and_siblings (char *info_ptr
, bfd
*abfd
,
4065 struct dwarf2_cu
*cu
,
4066 char **new_info_ptr
,
4067 struct die_info
*parent
)
4069 struct die_info
*first_die
, *last_sibling
;
4073 first_die
= last_sibling
= NULL
;
4077 struct die_info
*die
4078 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4086 last_sibling
->sibling
= die
;
4091 *new_info_ptr
= cur_ptr
;
4101 /* Free a linked list of dies. */
4104 free_die_list (struct die_info
*dies
)
4106 struct die_info
*die
, *next
;
4111 if (die
->child
!= NULL
)
4112 free_die_list (die
->child
);
4113 next
= die
->sibling
;
4121 do_free_die_list_cleanup (void *dies
)
4123 free_die_list (dies
);
4126 static struct cleanup
*
4127 make_cleanup_free_die_list (struct die_info
*dies
)
4129 return make_cleanup (do_free_die_list_cleanup
, dies
);
4133 /* Read the contents of the section at OFFSET and of size SIZE from the
4134 object file specified by OBJFILE into the objfile_obstack and return it. */
4137 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4139 bfd
*abfd
= objfile
->obfd
;
4141 bfd_size_type size
= bfd_get_section_size_before_reloc (sectp
);
4146 buf
= (char *) obstack_alloc (&objfile
->objfile_obstack
, size
);
4148 = (char *) symfile_relocate_debug_section (abfd
, sectp
, (bfd_byte
*) buf
);
4152 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4153 || bfd_bread (buf
, size
, abfd
) != size
)
4154 error ("Dwarf Error: Can't read DWARF data from '%s'",
4155 bfd_get_filename (abfd
));
4160 /* In DWARF version 2, the description of the debugging information is
4161 stored in a separate .debug_abbrev section. Before we read any
4162 dies from a section we read in all abbreviations and install them
4166 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4168 struct comp_unit_head
*cu_header
= &cu
->header
;
4170 struct abbrev_info
*cur_abbrev
;
4171 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4172 unsigned int abbrev_form
, hash_number
;
4174 /* Initialize dwarf2 abbrevs */
4175 memset (cu_header
->dwarf2_abbrevs
, 0,
4176 ABBREV_HASH_SIZE
*sizeof (struct abbrev_info
*));
4178 abbrev_ptr
= dwarf_abbrev_buffer
+ cu_header
->abbrev_offset
;
4179 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4180 abbrev_ptr
+= bytes_read
;
4182 /* loop until we reach an abbrev number of 0 */
4183 while (abbrev_number
)
4185 cur_abbrev
= dwarf_alloc_abbrev ();
4187 /* read in abbrev header */
4188 cur_abbrev
->number
= abbrev_number
;
4189 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4190 abbrev_ptr
+= bytes_read
;
4191 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
4194 /* now read in declarations */
4195 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4196 abbrev_ptr
+= bytes_read
;
4197 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4198 abbrev_ptr
+= bytes_read
;
4201 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
4203 cur_abbrev
->attrs
= (struct attr_abbrev
*)
4204 xrealloc (cur_abbrev
->attrs
,
4205 (cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
)
4206 * sizeof (struct attr_abbrev
));
4208 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
4209 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
4210 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4211 abbrev_ptr
+= bytes_read
;
4212 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4213 abbrev_ptr
+= bytes_read
;
4216 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
4217 cur_abbrev
->next
= cu_header
->dwarf2_abbrevs
[hash_number
];
4218 cu_header
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
4220 /* Get next abbreviation.
4221 Under Irix6 the abbreviations for a compilation unit are not
4222 always properly terminated with an abbrev number of 0.
4223 Exit loop if we encounter an abbreviation which we have
4224 already read (which means we are about to read the abbreviations
4225 for the next compile unit) or if the end of the abbreviation
4226 table is reached. */
4227 if ((unsigned int) (abbrev_ptr
- dwarf_abbrev_buffer
)
4228 >= dwarf_abbrev_size
)
4230 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4231 abbrev_ptr
+= bytes_read
;
4232 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
4237 /* Empty the abbrev table for a new compilation unit. */
4240 dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table
)
4243 struct abbrev_info
*abbrev
, *next
;
4244 struct abbrev_info
**abbrevs
;
4246 abbrevs
= (struct abbrev_info
**)ptr_to_abbrevs_table
;
4248 for (i
= 0; i
< ABBREV_HASH_SIZE
; ++i
)
4251 abbrev
= abbrevs
[i
];
4254 next
= abbrev
->next
;
4255 xfree (abbrev
->attrs
);
4263 /* Lookup an abbrev_info structure in the abbrev hash table. */
4265 static struct abbrev_info
*
4266 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
4268 struct comp_unit_head
*cu_header
= &cu
->header
;
4269 unsigned int hash_number
;
4270 struct abbrev_info
*abbrev
;
4272 hash_number
= number
% ABBREV_HASH_SIZE
;
4273 abbrev
= cu_header
->dwarf2_abbrevs
[hash_number
];
4277 if (abbrev
->number
== number
)
4280 abbrev
= abbrev
->next
;
4285 /* Read a minimal amount of information into the minimal die structure. */
4288 read_partial_die (struct partial_die_info
*part_die
, bfd
*abfd
,
4289 char *info_ptr
, struct dwarf2_cu
*cu
)
4291 unsigned int abbrev_number
, bytes_read
, i
;
4292 struct abbrev_info
*abbrev
;
4293 struct attribute attr
;
4294 struct attribute spec_attr
;
4295 int found_spec_attr
= 0;
4296 int has_low_pc_attr
= 0;
4297 int has_high_pc_attr
= 0;
4299 *part_die
= zeroed_partial_die
;
4300 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4301 info_ptr
+= bytes_read
;
4305 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4308 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number
,
4309 bfd_get_filename (abfd
));
4311 part_die
->offset
= info_ptr
- dwarf_info_buffer
;
4312 part_die
->tag
= abbrev
->tag
;
4313 part_die
->has_children
= abbrev
->has_children
;
4314 part_die
->abbrev
= abbrev_number
;
4316 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4318 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
4320 /* Store the data if it is of an attribute we want to keep in a
4321 partial symbol table. */
4326 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
4327 if (part_die
->name
== NULL
)
4328 part_die
->name
= DW_STRING (&attr
);
4330 case DW_AT_MIPS_linkage_name
:
4331 part_die
->name
= DW_STRING (&attr
);
4334 has_low_pc_attr
= 1;
4335 part_die
->lowpc
= DW_ADDR (&attr
);
4338 has_high_pc_attr
= 1;
4339 part_die
->highpc
= DW_ADDR (&attr
);
4341 case DW_AT_location
:
4342 /* Support the .debug_loc offsets */
4343 if (attr_form_is_block (&attr
))
4345 part_die
->locdesc
= DW_BLOCK (&attr
);
4347 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
4349 dwarf2_complex_location_expr_complaint ();
4353 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4354 "partial symbol information");
4357 case DW_AT_language
:
4358 part_die
->language
= DW_UNSND (&attr
);
4360 case DW_AT_external
:
4361 part_die
->is_external
= DW_UNSND (&attr
);
4363 case DW_AT_declaration
:
4364 part_die
->is_declaration
= DW_UNSND (&attr
);
4367 part_die
->has_type
= 1;
4369 case DW_AT_abstract_origin
:
4370 case DW_AT_specification
:
4371 found_spec_attr
= 1;
4375 /* Ignore absolute siblings, they might point outside of
4376 the current compile unit. */
4377 if (attr
.form
== DW_FORM_ref_addr
)
4378 complaint (&symfile_complaints
, "ignoring absolute DW_AT_sibling");
4381 dwarf_info_buffer
+ dwarf2_get_ref_die_offset (&attr
, cu
);
4388 /* If we found a reference attribute and the die has no name, try
4389 to find a name in the referred to die. */
4391 if (found_spec_attr
&& part_die
->name
== NULL
)
4393 struct partial_die_info spec_die
;
4396 spec_ptr
= dwarf_info_buffer
4397 + dwarf2_get_ref_die_offset (&spec_attr
, cu
);
4398 read_partial_die (&spec_die
, abfd
, spec_ptr
, cu
);
4401 part_die
->name
= spec_die
.name
;
4403 /* Copy DW_AT_external attribute if it is set. */
4404 if (spec_die
.is_external
)
4405 part_die
->is_external
= spec_die
.is_external
;
4409 /* When using the GNU linker, .gnu.linkonce. sections are used to
4410 eliminate duplicate copies of functions and vtables and such.
4411 The linker will arbitrarily choose one and discard the others.
4412 The AT_*_pc values for such functions refer to local labels in
4413 these sections. If the section from that file was discarded, the
4414 labels are not in the output, so the relocs get a value of 0.
4415 If this is a discarded function, mark the pc bounds as invalid,
4416 so that GDB will ignore it. */
4417 if (has_low_pc_attr
&& has_high_pc_attr
4418 && part_die
->lowpc
< part_die
->highpc
4419 && (part_die
->lowpc
!= 0
4420 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
4421 part_die
->has_pc_info
= 1;
4425 /* Read the die from the .debug_info section buffer. Set DIEP to
4426 point to a newly allocated die with its information, except for its
4427 child, sibling, and parent fields. Set HAS_CHILDREN to tell
4428 whether the die has children or not. */
4431 read_full_die (struct die_info
**diep
, bfd
*abfd
, char *info_ptr
,
4432 struct dwarf2_cu
*cu
, int *has_children
)
4434 unsigned int abbrev_number
, bytes_read
, i
, offset
;
4435 struct abbrev_info
*abbrev
;
4436 struct die_info
*die
;
4438 offset
= info_ptr
- dwarf_info_buffer
;
4439 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4440 info_ptr
+= bytes_read
;
4443 die
= dwarf_alloc_die ();
4445 die
->abbrev
= abbrev_number
;
4452 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4455 error ("Dwarf Error: could not find abbrev number %d [in module %s]",
4457 bfd_get_filename (abfd
));
4459 die
= dwarf_alloc_die ();
4460 die
->offset
= offset
;
4461 die
->tag
= abbrev
->tag
;
4462 die
->abbrev
= abbrev_number
;
4465 die
->num_attrs
= abbrev
->num_attrs
;
4466 die
->attrs
= (struct attribute
*)
4467 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
4469 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
4471 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
4472 abfd
, info_ptr
, cu
);
4476 *has_children
= abbrev
->has_children
;
4480 /* Read an attribute value described by an attribute form. */
4483 read_attribute_value (struct attribute
*attr
, unsigned form
,
4484 bfd
*abfd
, char *info_ptr
,
4485 struct dwarf2_cu
*cu
)
4487 struct comp_unit_head
*cu_header
= &cu
->header
;
4488 unsigned int bytes_read
;
4489 struct dwarf_block
*blk
;
4495 case DW_FORM_ref_addr
:
4496 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
4497 info_ptr
+= bytes_read
;
4499 case DW_FORM_block2
:
4500 blk
= dwarf_alloc_block ();
4501 blk
->size
= read_2_bytes (abfd
, info_ptr
);
4503 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4504 info_ptr
+= blk
->size
;
4505 DW_BLOCK (attr
) = blk
;
4507 case DW_FORM_block4
:
4508 blk
= dwarf_alloc_block ();
4509 blk
->size
= read_4_bytes (abfd
, info_ptr
);
4511 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4512 info_ptr
+= blk
->size
;
4513 DW_BLOCK (attr
) = blk
;
4516 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4520 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4524 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4527 case DW_FORM_string
:
4528 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
4529 info_ptr
+= bytes_read
;
4532 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
4534 info_ptr
+= bytes_read
;
4537 blk
= dwarf_alloc_block ();
4538 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4539 info_ptr
+= bytes_read
;
4540 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4541 info_ptr
+= blk
->size
;
4542 DW_BLOCK (attr
) = blk
;
4544 case DW_FORM_block1
:
4545 blk
= dwarf_alloc_block ();
4546 blk
->size
= read_1_byte (abfd
, info_ptr
);
4548 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
4549 info_ptr
+= blk
->size
;
4550 DW_BLOCK (attr
) = blk
;
4553 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4557 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4561 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
4562 info_ptr
+= bytes_read
;
4565 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4566 info_ptr
+= bytes_read
;
4569 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
4573 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
4577 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
4581 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
4584 case DW_FORM_ref_udata
:
4585 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4586 info_ptr
+= bytes_read
;
4588 case DW_FORM_indirect
:
4589 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4590 info_ptr
+= bytes_read
;
4591 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
4594 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4595 dwarf_form_name (form
),
4596 bfd_get_filename (abfd
));
4601 /* Read an attribute described by an abbreviated attribute. */
4604 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
4605 bfd
*abfd
, char *info_ptr
, struct dwarf2_cu
*cu
)
4607 attr
->name
= abbrev
->name
;
4608 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
4611 /* read dwarf information from a buffer */
4614 read_1_byte (bfd
*abfd
, char *buf
)
4616 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4620 read_1_signed_byte (bfd
*abfd
, char *buf
)
4622 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
4626 read_2_bytes (bfd
*abfd
, char *buf
)
4628 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4632 read_2_signed_bytes (bfd
*abfd
, char *buf
)
4634 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4638 read_4_bytes (bfd
*abfd
, char *buf
)
4640 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4644 read_4_signed_bytes (bfd
*abfd
, char *buf
)
4646 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4649 static unsigned long
4650 read_8_bytes (bfd
*abfd
, char *buf
)
4652 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4656 read_address (bfd
*abfd
, char *buf
, struct dwarf2_cu
*cu
, int *bytes_read
)
4658 struct comp_unit_head
*cu_header
= &cu
->header
;
4659 CORE_ADDR retval
= 0;
4661 if (cu_header
->signed_addr_p
)
4663 switch (cu_header
->addr_size
)
4666 retval
= bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
4669 retval
= bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
4672 retval
= bfd_get_signed_64 (abfd
, (bfd_byte
*) buf
);
4675 internal_error (__FILE__
, __LINE__
,
4676 "read_address: bad switch, signed [in module %s]",
4677 bfd_get_filename (abfd
));
4682 switch (cu_header
->addr_size
)
4685 retval
= bfd_get_16 (abfd
, (bfd_byte
*) buf
);
4688 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4691 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4694 internal_error (__FILE__
, __LINE__
,
4695 "read_address: bad switch, unsigned [in module %s]",
4696 bfd_get_filename (abfd
));
4700 *bytes_read
= cu_header
->addr_size
;
4704 /* Read the initial length from a section. The (draft) DWARF 3
4705 specification allows the initial length to take up either 4 bytes
4706 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4707 bytes describe the length and all offsets will be 8 bytes in length
4710 An older, non-standard 64-bit format is also handled by this
4711 function. The older format in question stores the initial length
4712 as an 8-byte quantity without an escape value. Lengths greater
4713 than 2^32 aren't very common which means that the initial 4 bytes
4714 is almost always zero. Since a length value of zero doesn't make
4715 sense for the 32-bit format, this initial zero can be considered to
4716 be an escape value which indicates the presence of the older 64-bit
4717 format. As written, the code can't detect (old format) lengths
4718 greater than 4GB. If it becomes necessary to handle lengths somewhat
4719 larger than 4GB, we could allow other small values (such as the
4720 non-sensical values of 1, 2, and 3) to also be used as escape values
4721 indicating the presence of the old format.
4723 The value returned via bytes_read should be used to increment
4724 the relevant pointer after calling read_initial_length().
4726 As a side effect, this function sets the fields initial_length_size
4727 and offset_size in cu_header to the values appropriate for the
4728 length field. (The format of the initial length field determines
4729 the width of file offsets to be fetched later with fetch_offset().)
4731 [ Note: read_initial_length() and read_offset() are based on the
4732 document entitled "DWARF Debugging Information Format", revision
4733 3, draft 8, dated November 19, 2001. This document was obtained
4736 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4738 This document is only a draft and is subject to change. (So beware.)
4740 Details regarding the older, non-standard 64-bit format were
4741 determined empirically by examining 64-bit ELF files produced
4742 by the SGI toolchain on an IRIX 6.5 machine.
4744 - Kevin, July 16, 2002
4748 read_initial_length (bfd
*abfd
, char *buf
, struct comp_unit_head
*cu_header
,
4753 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4755 if (retval
== 0xffffffff)
4757 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
4759 if (cu_header
!= NULL
)
4761 cu_header
->initial_length_size
= 12;
4762 cu_header
->offset_size
= 8;
4765 else if (retval
== 0)
4767 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4769 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4771 if (cu_header
!= NULL
)
4773 cu_header
->initial_length_size
= 8;
4774 cu_header
->offset_size
= 8;
4780 if (cu_header
!= NULL
)
4782 cu_header
->initial_length_size
= 4;
4783 cu_header
->offset_size
= 4;
4790 /* Read an offset from the data stream. The size of the offset is
4791 given by cu_header->offset_size. */
4794 read_offset (bfd
*abfd
, char *buf
, const struct comp_unit_head
*cu_header
,
4799 switch (cu_header
->offset_size
)
4802 retval
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
4806 retval
= bfd_get_64 (abfd
, (bfd_byte
*) buf
);
4810 internal_error (__FILE__
, __LINE__
,
4811 "read_offset: bad switch [in module %s]",
4812 bfd_get_filename (abfd
));
4819 read_n_bytes (bfd
*abfd
, char *buf
, unsigned int size
)
4821 /* If the size of a host char is 8 bits, we can return a pointer
4822 to the buffer, otherwise we have to copy the data to a buffer
4823 allocated on the temporary obstack. */
4824 gdb_assert (HOST_CHAR_BIT
== 8);
4829 read_string (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4831 /* If the size of a host char is 8 bits, we can return a pointer
4832 to the string, otherwise we have to copy the string to a buffer
4833 allocated on the temporary obstack. */
4834 gdb_assert (HOST_CHAR_BIT
== 8);
4837 *bytes_read_ptr
= 1;
4840 *bytes_read_ptr
= strlen (buf
) + 1;
4845 read_indirect_string (bfd
*abfd
, char *buf
,
4846 const struct comp_unit_head
*cu_header
,
4847 unsigned int *bytes_read_ptr
)
4849 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
4850 (int *) bytes_read_ptr
);
4852 if (dwarf_str_buffer
== NULL
)
4854 error ("DW_FORM_strp used without .debug_str section [in module %s]",
4855 bfd_get_filename (abfd
));
4858 if (str_offset
>= dwarf_str_size
)
4860 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4861 bfd_get_filename (abfd
));
4864 gdb_assert (HOST_CHAR_BIT
== 8);
4865 if (dwarf_str_buffer
[str_offset
] == '\0')
4867 return dwarf_str_buffer
+ str_offset
;
4870 static unsigned long
4871 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4873 unsigned long result
;
4874 unsigned int num_read
;
4884 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4887 result
|= ((unsigned long)(byte
& 127) << shift
);
4888 if ((byte
& 128) == 0)
4894 *bytes_read_ptr
= num_read
;
4899 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
4902 int i
, shift
, size
, num_read
;
4912 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
4915 result
|= ((long)(byte
& 127) << shift
);
4917 if ((byte
& 128) == 0)
4922 if ((shift
< size
) && (byte
& 0x40))
4924 result
|= -(1 << shift
);
4926 *bytes_read_ptr
= num_read
;
4931 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
4937 cu
->language
= language_c
;
4939 case DW_LANG_C_plus_plus
:
4940 cu
->language
= language_cplus
;
4942 case DW_LANG_Fortran77
:
4943 case DW_LANG_Fortran90
:
4944 case DW_LANG_Fortran95
:
4945 cu
->language
= language_fortran
;
4947 case DW_LANG_Mips_Assembler
:
4948 cu
->language
= language_asm
;
4951 cu
->language
= language_java
;
4955 case DW_LANG_Cobol74
:
4956 case DW_LANG_Cobol85
:
4957 case DW_LANG_Pascal83
:
4958 case DW_LANG_Modula2
:
4960 cu
->language
= language_minimal
;
4963 cu
->language_defn
= language_def (cu
->language
);
4966 /* Return the named attribute or NULL if not there. */
4968 static struct attribute
*
4969 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
4972 struct attribute
*spec
= NULL
;
4974 for (i
= 0; i
< die
->num_attrs
; ++i
)
4976 if (die
->attrs
[i
].name
== name
)
4978 return &die
->attrs
[i
];
4980 if (die
->attrs
[i
].name
== DW_AT_specification
4981 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
4982 spec
= &die
->attrs
[i
];
4986 struct die_info
*ref_die
=
4987 follow_die_ref (dwarf2_get_ref_die_offset (spec
, cu
));
4990 return dwarf2_attr (ref_die
, name
, cu
);
4997 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
4999 return (dwarf2_attr (die
, DW_AT_declaration
, cu
)
5000 && ! dwarf2_attr (die
, DW_AT_specification
, cu
));
5003 /* Return the die giving the specification for DIE, if there is
5006 static struct die_info
*
5007 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
5009 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
5011 if (spec_attr
== NULL
)
5014 return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr
, cu
));
5017 /* Free the line_header structure *LH, and any arrays and strings it
5020 free_line_header (struct line_header
*lh
)
5022 if (lh
->standard_opcode_lengths
)
5023 xfree (lh
->standard_opcode_lengths
);
5025 /* Remember that all the lh->file_names[i].name pointers are
5026 pointers into debug_line_buffer, and don't need to be freed. */
5028 xfree (lh
->file_names
);
5030 /* Similarly for the include directory names. */
5031 if (lh
->include_dirs
)
5032 xfree (lh
->include_dirs
);
5038 /* Add an entry to LH's include directory table. */
5040 add_include_dir (struct line_header
*lh
, char *include_dir
)
5042 /* Grow the array if necessary. */
5043 if (lh
->include_dirs_size
== 0)
5045 lh
->include_dirs_size
= 1; /* for testing */
5046 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
5047 * sizeof (*lh
->include_dirs
));
5049 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
5051 lh
->include_dirs_size
*= 2;
5052 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
5053 (lh
->include_dirs_size
5054 * sizeof (*lh
->include_dirs
)));
5057 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
5061 /* Add an entry to LH's file name table. */
5063 add_file_name (struct line_header
*lh
,
5065 unsigned int dir_index
,
5066 unsigned int mod_time
,
5067 unsigned int length
)
5069 struct file_entry
*fe
;
5071 /* Grow the array if necessary. */
5072 if (lh
->file_names_size
== 0)
5074 lh
->file_names_size
= 1; /* for testing */
5075 lh
->file_names
= xmalloc (lh
->file_names_size
5076 * sizeof (*lh
->file_names
));
5078 else if (lh
->num_file_names
>= lh
->file_names_size
)
5080 lh
->file_names_size
*= 2;
5081 lh
->file_names
= xrealloc (lh
->file_names
,
5082 (lh
->file_names_size
5083 * sizeof (*lh
->file_names
)));
5086 fe
= &lh
->file_names
[lh
->num_file_names
++];
5088 fe
->dir_index
= dir_index
;
5089 fe
->mod_time
= mod_time
;
5090 fe
->length
= length
;
5094 /* Read the statement program header starting at OFFSET in
5095 dwarf_line_buffer, according to the endianness of ABFD. Return a
5096 pointer to a struct line_header, allocated using xmalloc.
5098 NOTE: the strings in the include directory and file name tables of
5099 the returned object point into debug_line_buffer, and must not be
5101 static struct line_header
*
5102 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
5103 struct dwarf2_cu
*cu
)
5105 struct cleanup
*back_to
;
5106 struct line_header
*lh
;
5110 char *cur_dir
, *cur_file
;
5112 if (dwarf_line_buffer
== NULL
)
5114 complaint (&symfile_complaints
, "missing .debug_line section");
5118 /* Make sure that at least there's room for the total_length field. That
5119 could be 12 bytes long, but we're just going to fudge that. */
5120 if (offset
+ 4 >= dwarf_line_size
)
5122 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5126 lh
= xmalloc (sizeof (*lh
));
5127 memset (lh
, 0, sizeof (*lh
));
5128 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
5131 line_ptr
= dwarf_line_buffer
+ offset
;
5133 /* read in the header */
5134 lh
->total_length
= read_initial_length (abfd
, line_ptr
, NULL
, &bytes_read
);
5135 line_ptr
+= bytes_read
;
5136 if (line_ptr
+ lh
->total_length
> dwarf_line_buffer
+ dwarf_line_size
)
5138 dwarf2_statement_list_fits_in_line_number_section_complaint ();
5141 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
5142 lh
->version
= read_2_bytes (abfd
, line_ptr
);
5144 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
5145 line_ptr
+= bytes_read
;
5146 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
5148 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
5150 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
5152 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
5154 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
5156 lh
->standard_opcode_lengths
5157 = (unsigned char *) xmalloc (lh
->opcode_base
* sizeof (unsigned char));
5159 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
5160 for (i
= 1; i
< lh
->opcode_base
; ++i
)
5162 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
5166 /* Read directory table */
5167 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
5169 line_ptr
+= bytes_read
;
5170 add_include_dir (lh
, cur_dir
);
5172 line_ptr
+= bytes_read
;
5174 /* Read file name table */
5175 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
5177 unsigned int dir_index
, mod_time
, length
;
5179 line_ptr
+= bytes_read
;
5180 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5181 line_ptr
+= bytes_read
;
5182 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5183 line_ptr
+= bytes_read
;
5184 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5185 line_ptr
+= bytes_read
;
5187 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5189 line_ptr
+= bytes_read
;
5190 lh
->statement_program_start
= line_ptr
;
5192 if (line_ptr
> dwarf_line_buffer
+ dwarf_line_size
)
5193 complaint (&symfile_complaints
,
5194 "line number info header doesn't fit in `.debug_line' section");
5196 discard_cleanups (back_to
);
5200 /* This function exists to work around a bug in certain compilers
5201 (particularly GCC 2.95), in which the first line number marker of a
5202 function does not show up until after the prologue, right before
5203 the second line number marker. This function shifts ADDRESS down
5204 to the beginning of the function if necessary, and is called on
5205 addresses passed to record_line. */
5208 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
5210 struct function_range
*fn
;
5212 /* Find the function_range containing address. */
5217 cu
->cached_fn
= cu
->first_fn
;
5221 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5227 while (fn
&& fn
!= cu
->cached_fn
)
5228 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
5238 if (address
!= fn
->lowpc
)
5239 complaint (&symfile_complaints
,
5240 "misplaced first line number at 0x%lx for '%s'",
5241 (unsigned long) address
, fn
->name
);
5246 /* Decode the line number information for the compilation unit whose
5247 line number info is at OFFSET in the .debug_line section.
5248 The compilation directory of the file is passed in COMP_DIR. */
5251 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
5252 struct dwarf2_cu
*cu
)
5256 unsigned int bytes_read
;
5257 unsigned char op_code
, extended_op
, adj_opcode
;
5259 struct objfile
*objfile
= cu
->objfile
;
5261 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5263 line_ptr
= lh
->statement_program_start
;
5264 line_end
= lh
->statement_program_end
;
5266 /* Read the statement sequences until there's nothing left. */
5267 while (line_ptr
< line_end
)
5269 /* state machine registers */
5270 CORE_ADDR address
= 0;
5271 unsigned int file
= 1;
5272 unsigned int line
= 1;
5273 unsigned int column
= 0;
5274 int is_stmt
= lh
->default_is_stmt
;
5275 int basic_block
= 0;
5276 int end_sequence
= 0;
5278 /* Start a subfile for the current file of the state machine. */
5279 if (lh
->num_file_names
>= file
)
5281 /* lh->include_dirs and lh->file_names are 0-based, but the
5282 directory and file name numbers in the statement program
5284 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
5287 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5290 dwarf2_start_subfile (fe
->name
, dir
);
5293 /* Decode the table. */
5294 while (!end_sequence
)
5296 op_code
= read_1_byte (abfd
, line_ptr
);
5299 if (op_code
>= lh
->opcode_base
)
5300 { /* Special operand. */
5301 adj_opcode
= op_code
- lh
->opcode_base
;
5302 address
+= (adj_opcode
/ lh
->line_range
)
5303 * lh
->minimum_instruction_length
;
5304 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
5305 /* append row to matrix using current values */
5306 record_line (current_subfile
, line
,
5307 check_cu_functions (address
, cu
));
5310 else switch (op_code
)
5312 case DW_LNS_extended_op
:
5313 line_ptr
+= 1; /* ignore length */
5314 extended_op
= read_1_byte (abfd
, line_ptr
);
5316 switch (extended_op
)
5318 case DW_LNE_end_sequence
:
5320 record_line (current_subfile
, 0, address
);
5322 case DW_LNE_set_address
:
5323 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
5324 line_ptr
+= bytes_read
;
5325 address
+= baseaddr
;
5327 case DW_LNE_define_file
:
5330 unsigned int dir_index
, mod_time
, length
;
5332 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
5333 line_ptr
+= bytes_read
;
5335 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5336 line_ptr
+= bytes_read
;
5338 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5339 line_ptr
+= bytes_read
;
5341 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5342 line_ptr
+= bytes_read
;
5343 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
5347 complaint (&symfile_complaints
,
5348 "mangled .debug_line section");
5353 record_line (current_subfile
, line
,
5354 check_cu_functions (address
, cu
));
5357 case DW_LNS_advance_pc
:
5358 address
+= lh
->minimum_instruction_length
5359 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5360 line_ptr
+= bytes_read
;
5362 case DW_LNS_advance_line
:
5363 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
5364 line_ptr
+= bytes_read
;
5366 case DW_LNS_set_file
:
5368 /* lh->include_dirs and lh->file_names are 0-based,
5369 but the directory and file name numbers in the
5370 statement program are 1-based. */
5371 struct file_entry
*fe
;
5373 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5374 line_ptr
+= bytes_read
;
5375 fe
= &lh
->file_names
[file
- 1];
5377 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
5380 dwarf2_start_subfile (fe
->name
, dir
);
5383 case DW_LNS_set_column
:
5384 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5385 line_ptr
+= bytes_read
;
5387 case DW_LNS_negate_stmt
:
5388 is_stmt
= (!is_stmt
);
5390 case DW_LNS_set_basic_block
:
5393 /* Add to the address register of the state machine the
5394 address increment value corresponding to special opcode
5395 255. Ie, this value is scaled by the minimum instruction
5396 length since special opcode 255 would have scaled the
5398 case DW_LNS_const_add_pc
:
5399 address
+= (lh
->minimum_instruction_length
5400 * ((255 - lh
->opcode_base
) / lh
->line_range
));
5402 case DW_LNS_fixed_advance_pc
:
5403 address
+= read_2_bytes (abfd
, line_ptr
);
5407 { /* Unknown standard opcode, ignore it. */
5409 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
5411 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
5412 line_ptr
+= bytes_read
;
5420 /* Start a subfile for DWARF. FILENAME is the name of the file and
5421 DIRNAME the name of the source directory which contains FILENAME
5422 or NULL if not known.
5423 This routine tries to keep line numbers from identical absolute and
5424 relative file names in a common subfile.
5426 Using the `list' example from the GDB testsuite, which resides in
5427 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
5428 of /srcdir/list0.c yields the following debugging information for list0.c:
5430 DW_AT_name: /srcdir/list0.c
5431 DW_AT_comp_dir: /compdir
5432 files.files[0].name: list0.h
5433 files.files[0].dir: /srcdir
5434 files.files[1].name: list0.c
5435 files.files[1].dir: /srcdir
5437 The line number information for list0.c has to end up in a single
5438 subfile, so that `break /srcdir/list0.c:1' works as expected. */
5441 dwarf2_start_subfile (char *filename
, char *dirname
)
5443 /* If the filename isn't absolute, try to match an existing subfile
5444 with the full pathname. */
5446 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
5448 struct subfile
*subfile
;
5449 char *fullname
= concat (dirname
, "/", filename
, NULL
);
5451 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
5453 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
5455 current_subfile
= subfile
;
5462 start_subfile (filename
, dirname
);
5466 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
5467 struct dwarf2_cu
*cu
)
5469 struct objfile
*objfile
= cu
->objfile
;
5470 struct comp_unit_head
*cu_header
= &cu
->header
;
5472 /* NOTE drow/2003-01-30: There used to be a comment and some special
5473 code here to turn a symbol with DW_AT_external and a
5474 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
5475 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
5476 with some versions of binutils) where shared libraries could have
5477 relocations against symbols in their debug information - the
5478 minimal symbol would have the right address, but the debug info
5479 would not. It's no longer necessary, because we will explicitly
5480 apply relocations when we read in the debug information now. */
5482 /* A DW_AT_location attribute with no contents indicates that a
5483 variable has been optimized away. */
5484 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
5486 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
5490 /* Handle one degenerate form of location expression specially, to
5491 preserve GDB's previous behavior when section offsets are
5492 specified. If this is just a DW_OP_addr then mark this symbol
5495 if (attr_form_is_block (attr
)
5496 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
5497 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
5501 SYMBOL_VALUE_ADDRESS (sym
) =
5502 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
5503 fixup_symbol_section (sym
, objfile
);
5504 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
5505 SYMBOL_SECTION (sym
));
5506 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5510 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
5511 expression evaluator, and use LOC_COMPUTED only when necessary
5512 (i.e. when the value of a register or memory location is
5513 referenced, or a thread-local block, etc.). Then again, it might
5514 not be worthwhile. I'm assuming that it isn't unless performance
5515 or memory numbers show me otherwise. */
5517 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
5518 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
5521 /* Given a pointer to a DWARF information entry, figure out if we need
5522 to make a symbol table entry for it, and if so, create a new entry
5523 and return a pointer to it.
5524 If TYPE is NULL, determine symbol type from the die, otherwise
5525 used the passed type. */
5527 static struct symbol
*
5528 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
5530 struct objfile
*objfile
= cu
->objfile
;
5531 struct symbol
*sym
= NULL
;
5533 struct attribute
*attr
= NULL
;
5534 struct attribute
*attr2
= NULL
;
5537 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5539 if (die
->tag
!= DW_TAG_namespace
)
5540 name
= dwarf2_linkage_name (die
, cu
);
5542 name
= TYPE_NAME (type
);
5546 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
5547 sizeof (struct symbol
));
5548 OBJSTAT (objfile
, n_syms
++);
5549 memset (sym
, 0, sizeof (struct symbol
));
5551 /* Cache this symbol's name and the name's demangled form (if any). */
5552 SYMBOL_LANGUAGE (sym
) = cu
->language
;
5553 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
5555 /* Default assumptions.
5556 Use the passed type or decode it from the die. */
5557 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5558 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5560 SYMBOL_TYPE (sym
) = type
;
5562 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
5563 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
5566 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
5571 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5574 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
5576 SYMBOL_CLASS (sym
) = LOC_LABEL
;
5578 case DW_TAG_subprogram
:
5579 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
5581 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5582 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
5583 if (attr2
&& (DW_UNSND (attr2
) != 0))
5585 add_symbol_to_list (sym
, &global_symbols
);
5589 add_symbol_to_list (sym
, cu
->list_in_scope
);
5592 case DW_TAG_variable
:
5593 /* Compilation with minimal debug info may result in variables
5594 with missing type entries. Change the misleading `void' type
5595 to something sensible. */
5596 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
5597 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
5598 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
5599 "<variable, no debug info>",
5601 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
5604 dwarf2_const_value (attr
, sym
, cu
);
5605 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
5606 if (attr2
&& (DW_UNSND (attr2
) != 0))
5607 add_symbol_to_list (sym
, &global_symbols
);
5609 add_symbol_to_list (sym
, cu
->list_in_scope
);
5612 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
5615 var_decode_location (attr
, sym
, cu
);
5616 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
5617 if (attr2
&& (DW_UNSND (attr2
) != 0))
5618 add_symbol_to_list (sym
, &global_symbols
);
5620 add_symbol_to_list (sym
, cu
->list_in_scope
);
5624 /* We do not know the address of this symbol.
5625 If it is an external symbol and we have type information
5626 for it, enter the symbol as a LOC_UNRESOLVED symbol.
5627 The address of the variable will then be determined from
5628 the minimal symbol table whenever the variable is
5630 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
5631 if (attr2
&& (DW_UNSND (attr2
) != 0)
5632 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
5634 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
5635 add_symbol_to_list (sym
, &global_symbols
);
5639 case DW_TAG_formal_parameter
:
5640 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
5643 var_decode_location (attr
, sym
, cu
);
5644 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
5645 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
5646 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
5648 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
5651 dwarf2_const_value (attr
, sym
, cu
);
5653 add_symbol_to_list (sym
, cu
->list_in_scope
);
5655 case DW_TAG_unspecified_parameters
:
5656 /* From varargs functions; gdb doesn't seem to have any
5657 interest in this information, so just ignore it for now.
5660 case DW_TAG_class_type
:
5661 case DW_TAG_structure_type
:
5662 case DW_TAG_union_type
:
5663 case DW_TAG_enumeration_type
:
5664 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5665 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
5667 /* Make sure that the symbol includes appropriate enclosing
5668 classes/namespaces in its name. These are calculated in
5669 read_structure_scope, and the correct name is saved in
5672 if (cu
->language
== language_cplus
)
5674 struct type
*type
= SYMBOL_TYPE (sym
);
5676 if (TYPE_TAG_NAME (type
) != NULL
)
5678 /* FIXME: carlton/2003-11-10: Should this use
5679 SYMBOL_SET_NAMES instead? (The same problem also
5680 arises a further down in the function.) */
5681 SYMBOL_LINKAGE_NAME (sym
)
5682 = obsavestring (TYPE_TAG_NAME (type
),
5683 strlen (TYPE_TAG_NAME (type
)),
5684 &objfile
->objfile_obstack
);
5689 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
5690 really ever be static objects: otherwise, if you try
5691 to, say, break of a class's method and you're in a file
5692 which doesn't mention that class, it won't work unless
5693 the check for all static symbols in lookup_symbol_aux
5694 saves you. See the OtherFileClass tests in
5695 gdb.c++/namespace.exp. */
5697 struct pending
**list_to_add
;
5699 list_to_add
= (cu
->list_in_scope
== &file_symbols
5700 && cu
->language
== language_cplus
5701 ? &global_symbols
: cu
->list_in_scope
);
5703 add_symbol_to_list (sym
, list_to_add
);
5705 /* The semantics of C++ state that "struct foo { ... }" also
5706 defines a typedef for "foo". Synthesize a typedef symbol so
5707 that "ptype foo" works as expected. */
5708 if (cu
->language
== language_cplus
)
5710 struct symbol
*typedef_sym
= (struct symbol
*)
5711 obstack_alloc (&objfile
->objfile_obstack
,
5712 sizeof (struct symbol
));
5713 *typedef_sym
= *sym
;
5714 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
5715 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
5716 TYPE_NAME (SYMBOL_TYPE (sym
)) =
5717 obsavestring (SYMBOL_NATURAL_NAME (sym
),
5718 strlen (SYMBOL_NATURAL_NAME (sym
)),
5719 &objfile
->objfile_obstack
);
5720 add_symbol_to_list (typedef_sym
, list_to_add
);
5724 case DW_TAG_typedef
:
5725 if (processing_has_namespace_info
5726 && processing_current_prefix
[0] != '\0')
5728 SYMBOL_LINKAGE_NAME (sym
) = obconcat (&objfile
->objfile_obstack
,
5729 processing_current_prefix
,
5733 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5734 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5735 add_symbol_to_list (sym
, cu
->list_in_scope
);
5737 case DW_TAG_base_type
:
5738 case DW_TAG_subrange_type
:
5739 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5740 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5741 add_symbol_to_list (sym
, cu
->list_in_scope
);
5743 case DW_TAG_enumerator
:
5744 if (processing_has_namespace_info
5745 && processing_current_prefix
[0] != '\0')
5747 SYMBOL_LINKAGE_NAME (sym
) = obconcat (&objfile
->objfile_obstack
,
5748 processing_current_prefix
,
5752 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
5755 dwarf2_const_value (attr
, sym
, cu
);
5758 /* NOTE: carlton/2003-11-10: See comment above in the
5759 DW_TAG_class_type, etc. block. */
5761 struct pending
**list_to_add
;
5763 list_to_add
= (cu
->list_in_scope
== &file_symbols
5764 && cu
->language
== language_cplus
5765 ? &global_symbols
: cu
->list_in_scope
);
5767 add_symbol_to_list (sym
, list_to_add
);
5770 case DW_TAG_namespace
:
5771 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5772 add_symbol_to_list (sym
, &global_symbols
);
5775 /* Not a tag we recognize. Hopefully we aren't processing
5776 trash data, but since we must specifically ignore things
5777 we don't recognize, there is nothing else we should do at
5779 complaint (&symfile_complaints
, "unsupported tag: '%s'",
5780 dwarf_tag_name (die
->tag
));
5787 /* Copy constant value from an attribute to a symbol. */
5790 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
5791 struct dwarf2_cu
*cu
)
5793 struct objfile
*objfile
= cu
->objfile
;
5794 struct comp_unit_head
*cu_header
= &cu
->header
;
5795 struct dwarf_block
*blk
;
5800 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
5801 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5802 cu_header
->addr_size
,
5803 TYPE_LENGTH (SYMBOL_TYPE
5805 SYMBOL_VALUE_BYTES (sym
) = (char *)
5806 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
5807 /* NOTE: cagney/2003-05-09: In-lined store_address call with
5808 it's body - store_unsigned_integer. */
5809 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
5811 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5813 case DW_FORM_block1
:
5814 case DW_FORM_block2
:
5815 case DW_FORM_block4
:
5817 blk
= DW_BLOCK (attr
);
5818 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
5819 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
5821 TYPE_LENGTH (SYMBOL_TYPE
5823 SYMBOL_VALUE_BYTES (sym
) = (char *)
5824 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
5825 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
5826 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
5829 /* The DW_AT_const_value attributes are supposed to carry the
5830 symbol's value "represented as it would be on the target
5831 architecture." By the time we get here, it's already been
5832 converted to host endianness, so we just need to sign- or
5833 zero-extend it as appropriate. */
5835 dwarf2_const_value_data (attr
, sym
, 8);
5838 dwarf2_const_value_data (attr
, sym
, 16);
5841 dwarf2_const_value_data (attr
, sym
, 32);
5844 dwarf2_const_value_data (attr
, sym
, 64);
5848 SYMBOL_VALUE (sym
) = DW_SND (attr
);
5849 SYMBOL_CLASS (sym
) = LOC_CONST
;
5853 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
5854 SYMBOL_CLASS (sym
) = LOC_CONST
;
5858 complaint (&symfile_complaints
,
5859 "unsupported const value attribute form: '%s'",
5860 dwarf_form_name (attr
->form
));
5861 SYMBOL_VALUE (sym
) = 0;
5862 SYMBOL_CLASS (sym
) = LOC_CONST
;
5868 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5869 or zero-extend it as appropriate for the symbol's type. */
5871 dwarf2_const_value_data (struct attribute
*attr
,
5875 LONGEST l
= DW_UNSND (attr
);
5877 if (bits
< sizeof (l
) * 8)
5879 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
5880 l
&= ((LONGEST
) 1 << bits
) - 1;
5882 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
5885 SYMBOL_VALUE (sym
) = l
;
5886 SYMBOL_CLASS (sym
) = LOC_CONST
;
5890 /* Return the type of the die in question using its DW_AT_type attribute. */
5892 static struct type
*
5893 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5896 struct attribute
*type_attr
;
5897 struct die_info
*type_die
;
5900 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
5903 /* A missing DW_AT_type represents a void type. */
5904 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
5908 ref
= dwarf2_get_ref_die_offset (type_attr
, cu
);
5909 type_die
= follow_die_ref (ref
);
5912 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5913 ref
, cu
->objfile
->name
);
5917 type
= tag_type_to_type (type_die
, cu
);
5920 dump_die (type_die
);
5921 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5927 /* Return the containing type of the die in question using its
5928 DW_AT_containing_type attribute. */
5930 static struct type
*
5931 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5933 struct type
*type
= NULL
;
5934 struct attribute
*type_attr
;
5935 struct die_info
*type_die
= NULL
;
5938 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
5941 ref
= dwarf2_get_ref_die_offset (type_attr
, cu
);
5942 type_die
= follow_die_ref (ref
);
5945 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref
,
5949 type
= tag_type_to_type (type_die
, cu
);
5954 dump_die (type_die
);
5955 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
5962 static struct type
*
5963 type_at_offset (unsigned int offset
, struct dwarf2_cu
*cu
)
5965 struct die_info
*die
;
5968 die
= follow_die_ref (offset
);
5971 error ("Dwarf Error: Cannot find type referent at offset %d.", offset
);
5974 type
= tag_type_to_type (die
, cu
);
5979 static struct type
*
5980 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5988 read_type_die (die
, cu
);
5992 error ("Dwarf Error: Cannot find type of die [in module %s]",
6000 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
6002 char *prefix
= determine_prefix (die
, cu
);
6003 const char *old_prefix
= processing_current_prefix
;
6004 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
6005 processing_current_prefix
= prefix
;
6009 case DW_TAG_class_type
:
6010 case DW_TAG_structure_type
:
6011 case DW_TAG_union_type
:
6012 read_structure_scope (die
, cu
);
6014 case DW_TAG_enumeration_type
:
6015 read_enumeration (die
, cu
);
6017 case DW_TAG_subprogram
:
6018 case DW_TAG_subroutine_type
:
6019 read_subroutine_type (die
, cu
);
6021 case DW_TAG_array_type
:
6022 read_array_type (die
, cu
);
6024 case DW_TAG_pointer_type
:
6025 read_tag_pointer_type (die
, cu
);
6027 case DW_TAG_ptr_to_member_type
:
6028 read_tag_ptr_to_member_type (die
, cu
);
6030 case DW_TAG_reference_type
:
6031 read_tag_reference_type (die
, cu
);
6033 case DW_TAG_const_type
:
6034 read_tag_const_type (die
, cu
);
6036 case DW_TAG_volatile_type
:
6037 read_tag_volatile_type (die
, cu
);
6039 case DW_TAG_string_type
:
6040 read_tag_string_type (die
, cu
);
6042 case DW_TAG_typedef
:
6043 read_typedef (die
, cu
);
6045 case DW_TAG_subrange_type
:
6046 read_subrange_type (die
, cu
);
6048 case DW_TAG_base_type
:
6049 read_base_type (die
, cu
);
6052 complaint (&symfile_complaints
, "unexepected tag in read_type_die: '%s'",
6053 dwarf_tag_name (die
->tag
));
6057 processing_current_prefix
= old_prefix
;
6058 do_cleanups (back_to
);
6061 /* Return the name of the namespace/class that DIE is defined within,
6062 or "" if we can't tell. The caller should xfree the result. */
6064 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
6065 therein) for an example of how to use this function to deal with
6066 DW_AT_specification. */
6069 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
6071 char *prefix
= determine_prefix_aux (die
, cu
);
6073 return prefix
? prefix
: xstrdup ("");
6076 /* Return the name of the namespace/class that DIE is defined
6077 within, or NULL if we can't tell. The caller should xfree the
6081 determine_prefix_aux (struct die_info
*die
, struct dwarf2_cu
*cu
)
6083 struct die_info
*parent
;
6085 if (cu
->language
!= language_cplus
)
6088 parent
= die
->parent
;
6092 return (processing_has_namespace_info
? xstrdup ("") : NULL
);
6096 char *parent_prefix
= determine_prefix_aux (parent
, cu
);
6099 switch (parent
->tag
) {
6100 case DW_TAG_namespace
:
6104 retval
= typename_concat (parent_prefix
,
6105 namespace_name (parent
, &dummy
, cu
));
6108 case DW_TAG_class_type
:
6109 case DW_TAG_structure_type
:
6111 if (parent_prefix
!= NULL
)
6113 const char *parent_name
= dwarf2_name (parent
, cu
);
6115 if (parent_name
!= NULL
)
6116 retval
= typename_concat (parent_prefix
, dwarf2_name (parent
, cu
));
6118 /* FIXME: carlton/2003-11-10: I'm not sure what the
6119 best thing to do here is. */
6120 retval
= typename_concat (parent_prefix
,
6121 "<<anonymous class>>");
6124 retval
= class_name (parent
, cu
);
6128 retval
= parent_prefix
;
6132 if (retval
!= parent_prefix
)
6133 xfree (parent_prefix
);
6138 /* Return a newly-allocated string formed by concatenating PREFIX,
6139 "::", and SUFFIX, except that if PREFIX is NULL or the empty
6140 string, just return a copy of SUFFIX. */
6143 typename_concat (const char *prefix
, const char *suffix
)
6145 if (prefix
== NULL
|| prefix
[0] == '\0')
6146 return xstrdup (suffix
);
6149 char *retval
= xmalloc (strlen (prefix
) + 2 + strlen (suffix
) + 1);
6151 strcpy (retval
, prefix
);
6152 strcat (retval
, "::");
6153 strcat (retval
, suffix
);
6159 /* Return a newly-allocated string giving the name of the class given
6163 class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
6165 struct die_info
*child
;
6168 for (child
= die
->child
; child
!= NULL
; child
= sibling_die (child
))
6170 if (child
->tag
== DW_TAG_subprogram
)
6171 return class_name_from_physname (dwarf2_linkage_name (child
, cu
));
6174 name
= dwarf2_name (die
, cu
);
6176 return xstrdup (name
);
6178 return xstrdup ("");
6181 static struct type
*
6182 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
6184 struct objfile
*objfile
= cu
->objfile
;
6186 /* FIXME - this should not produce a new (struct type *)
6187 every time. It should cache base types. */
6191 case DW_ATE_address
:
6192 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
6194 case DW_ATE_boolean
:
6195 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
6197 case DW_ATE_complex_float
:
6200 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
6204 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
6210 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
6214 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
6221 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
6224 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
6228 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
6232 case DW_ATE_signed_char
:
6233 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
6235 case DW_ATE_unsigned
:
6239 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
6242 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
6246 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
6250 case DW_ATE_unsigned_char
:
6251 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
6254 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
6261 copy_die (struct die_info
*old_die
)
6263 struct die_info
*new_die
;
6266 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
6267 memset (new_die
, 0, sizeof (struct die_info
));
6269 new_die
->tag
= old_die
->tag
;
6270 new_die
->has_children
= old_die
->has_children
;
6271 new_die
->abbrev
= old_die
->abbrev
;
6272 new_die
->offset
= old_die
->offset
;
6273 new_die
->type
= NULL
;
6275 num_attrs
= old_die
->num_attrs
;
6276 new_die
->num_attrs
= num_attrs
;
6277 new_die
->attrs
= (struct attribute
*)
6278 xmalloc (num_attrs
* sizeof (struct attribute
));
6280 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
6282 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
6283 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
6284 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
6287 new_die
->next
= NULL
;
6292 /* Return sibling of die, NULL if no sibling. */
6294 static struct die_info
*
6295 sibling_die (struct die_info
*die
)
6297 return die
->sibling
;
6300 /* Get linkage name of a die, return NULL if not found. */
6303 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
6305 struct attribute
*attr
;
6307 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
6308 if (attr
&& DW_STRING (attr
))
6309 return DW_STRING (attr
);
6310 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
6311 if (attr
&& DW_STRING (attr
))
6312 return DW_STRING (attr
);
6316 /* Get name of a die, return NULL if not found. */
6319 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
6321 struct attribute
*attr
;
6323 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
6324 if (attr
&& DW_STRING (attr
))
6325 return DW_STRING (attr
);
6329 /* Return the die that this die in an extension of, or NULL if there
6332 static struct die_info
*
6333 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
6335 struct attribute
*attr
;
6336 struct die_info
*extension_die
;
6339 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
6343 ref
= dwarf2_get_ref_die_offset (attr
, cu
);
6344 extension_die
= follow_die_ref (ref
);
6347 error ("Dwarf Error: Cannot find referent at offset %d.", ref
);
6350 return extension_die
;
6353 /* Convert a DIE tag into its string name. */
6356 dwarf_tag_name (unsigned tag
)
6360 case DW_TAG_padding
:
6361 return "DW_TAG_padding";
6362 case DW_TAG_array_type
:
6363 return "DW_TAG_array_type";
6364 case DW_TAG_class_type
:
6365 return "DW_TAG_class_type";
6366 case DW_TAG_entry_point
:
6367 return "DW_TAG_entry_point";
6368 case DW_TAG_enumeration_type
:
6369 return "DW_TAG_enumeration_type";
6370 case DW_TAG_formal_parameter
:
6371 return "DW_TAG_formal_parameter";
6372 case DW_TAG_imported_declaration
:
6373 return "DW_TAG_imported_declaration";
6375 return "DW_TAG_label";
6376 case DW_TAG_lexical_block
:
6377 return "DW_TAG_lexical_block";
6379 return "DW_TAG_member";
6380 case DW_TAG_pointer_type
:
6381 return "DW_TAG_pointer_type";
6382 case DW_TAG_reference_type
:
6383 return "DW_TAG_reference_type";
6384 case DW_TAG_compile_unit
:
6385 return "DW_TAG_compile_unit";
6386 case DW_TAG_string_type
:
6387 return "DW_TAG_string_type";
6388 case DW_TAG_structure_type
:
6389 return "DW_TAG_structure_type";
6390 case DW_TAG_subroutine_type
:
6391 return "DW_TAG_subroutine_type";
6392 case DW_TAG_typedef
:
6393 return "DW_TAG_typedef";
6394 case DW_TAG_union_type
:
6395 return "DW_TAG_union_type";
6396 case DW_TAG_unspecified_parameters
:
6397 return "DW_TAG_unspecified_parameters";
6398 case DW_TAG_variant
:
6399 return "DW_TAG_variant";
6400 case DW_TAG_common_block
:
6401 return "DW_TAG_common_block";
6402 case DW_TAG_common_inclusion
:
6403 return "DW_TAG_common_inclusion";
6404 case DW_TAG_inheritance
:
6405 return "DW_TAG_inheritance";
6406 case DW_TAG_inlined_subroutine
:
6407 return "DW_TAG_inlined_subroutine";
6409 return "DW_TAG_module";
6410 case DW_TAG_ptr_to_member_type
:
6411 return "DW_TAG_ptr_to_member_type";
6412 case DW_TAG_set_type
:
6413 return "DW_TAG_set_type";
6414 case DW_TAG_subrange_type
:
6415 return "DW_TAG_subrange_type";
6416 case DW_TAG_with_stmt
:
6417 return "DW_TAG_with_stmt";
6418 case DW_TAG_access_declaration
:
6419 return "DW_TAG_access_declaration";
6420 case DW_TAG_base_type
:
6421 return "DW_TAG_base_type";
6422 case DW_TAG_catch_block
:
6423 return "DW_TAG_catch_block";
6424 case DW_TAG_const_type
:
6425 return "DW_TAG_const_type";
6426 case DW_TAG_constant
:
6427 return "DW_TAG_constant";
6428 case DW_TAG_enumerator
:
6429 return "DW_TAG_enumerator";
6430 case DW_TAG_file_type
:
6431 return "DW_TAG_file_type";
6433 return "DW_TAG_friend";
6434 case DW_TAG_namelist
:
6435 return "DW_TAG_namelist";
6436 case DW_TAG_namelist_item
:
6437 return "DW_TAG_namelist_item";
6438 case DW_TAG_packed_type
:
6439 return "DW_TAG_packed_type";
6440 case DW_TAG_subprogram
:
6441 return "DW_TAG_subprogram";
6442 case DW_TAG_template_type_param
:
6443 return "DW_TAG_template_type_param";
6444 case DW_TAG_template_value_param
:
6445 return "DW_TAG_template_value_param";
6446 case DW_TAG_thrown_type
:
6447 return "DW_TAG_thrown_type";
6448 case DW_TAG_try_block
:
6449 return "DW_TAG_try_block";
6450 case DW_TAG_variant_part
:
6451 return "DW_TAG_variant_part";
6452 case DW_TAG_variable
:
6453 return "DW_TAG_variable";
6454 case DW_TAG_volatile_type
:
6455 return "DW_TAG_volatile_type";
6456 case DW_TAG_dwarf_procedure
:
6457 return "DW_TAG_dwarf_procedure";
6458 case DW_TAG_restrict_type
:
6459 return "DW_TAG_restrict_type";
6460 case DW_TAG_interface_type
:
6461 return "DW_TAG_interface_type";
6462 case DW_TAG_namespace
:
6463 return "DW_TAG_namespace";
6464 case DW_TAG_imported_module
:
6465 return "DW_TAG_imported_module";
6466 case DW_TAG_unspecified_type
:
6467 return "DW_TAG_unspecified_type";
6468 case DW_TAG_partial_unit
:
6469 return "DW_TAG_partial_unit";
6470 case DW_TAG_imported_unit
:
6471 return "DW_TAG_imported_unit";
6472 case DW_TAG_MIPS_loop
:
6473 return "DW_TAG_MIPS_loop";
6474 case DW_TAG_format_label
:
6475 return "DW_TAG_format_label";
6476 case DW_TAG_function_template
:
6477 return "DW_TAG_function_template";
6478 case DW_TAG_class_template
:
6479 return "DW_TAG_class_template";
6481 return "DW_TAG_<unknown>";
6485 /* Convert a DWARF attribute code into its string name. */
6488 dwarf_attr_name (unsigned attr
)
6493 return "DW_AT_sibling";
6494 case DW_AT_location
:
6495 return "DW_AT_location";
6497 return "DW_AT_name";
6498 case DW_AT_ordering
:
6499 return "DW_AT_ordering";
6500 case DW_AT_subscr_data
:
6501 return "DW_AT_subscr_data";
6502 case DW_AT_byte_size
:
6503 return "DW_AT_byte_size";
6504 case DW_AT_bit_offset
:
6505 return "DW_AT_bit_offset";
6506 case DW_AT_bit_size
:
6507 return "DW_AT_bit_size";
6508 case DW_AT_element_list
:
6509 return "DW_AT_element_list";
6510 case DW_AT_stmt_list
:
6511 return "DW_AT_stmt_list";
6513 return "DW_AT_low_pc";
6515 return "DW_AT_high_pc";
6516 case DW_AT_language
:
6517 return "DW_AT_language";
6519 return "DW_AT_member";
6521 return "DW_AT_discr";
6522 case DW_AT_discr_value
:
6523 return "DW_AT_discr_value";
6524 case DW_AT_visibility
:
6525 return "DW_AT_visibility";
6527 return "DW_AT_import";
6528 case DW_AT_string_length
:
6529 return "DW_AT_string_length";
6530 case DW_AT_common_reference
:
6531 return "DW_AT_common_reference";
6532 case DW_AT_comp_dir
:
6533 return "DW_AT_comp_dir";
6534 case DW_AT_const_value
:
6535 return "DW_AT_const_value";
6536 case DW_AT_containing_type
:
6537 return "DW_AT_containing_type";
6538 case DW_AT_default_value
:
6539 return "DW_AT_default_value";
6541 return "DW_AT_inline";
6542 case DW_AT_is_optional
:
6543 return "DW_AT_is_optional";
6544 case DW_AT_lower_bound
:
6545 return "DW_AT_lower_bound";
6546 case DW_AT_producer
:
6547 return "DW_AT_producer";
6548 case DW_AT_prototyped
:
6549 return "DW_AT_prototyped";
6550 case DW_AT_return_addr
:
6551 return "DW_AT_return_addr";
6552 case DW_AT_start_scope
:
6553 return "DW_AT_start_scope";
6554 case DW_AT_stride_size
:
6555 return "DW_AT_stride_size";
6556 case DW_AT_upper_bound
:
6557 return "DW_AT_upper_bound";
6558 case DW_AT_abstract_origin
:
6559 return "DW_AT_abstract_origin";
6560 case DW_AT_accessibility
:
6561 return "DW_AT_accessibility";
6562 case DW_AT_address_class
:
6563 return "DW_AT_address_class";
6564 case DW_AT_artificial
:
6565 return "DW_AT_artificial";
6566 case DW_AT_base_types
:
6567 return "DW_AT_base_types";
6568 case DW_AT_calling_convention
:
6569 return "DW_AT_calling_convention";
6571 return "DW_AT_count";
6572 case DW_AT_data_member_location
:
6573 return "DW_AT_data_member_location";
6574 case DW_AT_decl_column
:
6575 return "DW_AT_decl_column";
6576 case DW_AT_decl_file
:
6577 return "DW_AT_decl_file";
6578 case DW_AT_decl_line
:
6579 return "DW_AT_decl_line";
6580 case DW_AT_declaration
:
6581 return "DW_AT_declaration";
6582 case DW_AT_discr_list
:
6583 return "DW_AT_discr_list";
6584 case DW_AT_encoding
:
6585 return "DW_AT_encoding";
6586 case DW_AT_external
:
6587 return "DW_AT_external";
6588 case DW_AT_frame_base
:
6589 return "DW_AT_frame_base";
6591 return "DW_AT_friend";
6592 case DW_AT_identifier_case
:
6593 return "DW_AT_identifier_case";
6594 case DW_AT_macro_info
:
6595 return "DW_AT_macro_info";
6596 case DW_AT_namelist_items
:
6597 return "DW_AT_namelist_items";
6598 case DW_AT_priority
:
6599 return "DW_AT_priority";
6601 return "DW_AT_segment";
6602 case DW_AT_specification
:
6603 return "DW_AT_specification";
6604 case DW_AT_static_link
:
6605 return "DW_AT_static_link";
6607 return "DW_AT_type";
6608 case DW_AT_use_location
:
6609 return "DW_AT_use_location";
6610 case DW_AT_variable_parameter
:
6611 return "DW_AT_variable_parameter";
6612 case DW_AT_virtuality
:
6613 return "DW_AT_virtuality";
6614 case DW_AT_vtable_elem_location
:
6615 return "DW_AT_vtable_elem_location";
6616 case DW_AT_allocated
:
6617 return "DW_AT_allocated";
6618 case DW_AT_associated
:
6619 return "DW_AT_associated";
6620 case DW_AT_data_location
:
6621 return "DW_AT_data_location";
6623 return "DW_AT_stride";
6624 case DW_AT_entry_pc
:
6625 return "DW_AT_entry_pc";
6626 case DW_AT_use_UTF8
:
6627 return "DW_AT_use_UTF8";
6628 case DW_AT_extension
:
6629 return "DW_AT_extension";
6631 return "DW_AT_ranges";
6632 case DW_AT_trampoline
:
6633 return "DW_AT_trampoline";
6634 case DW_AT_call_column
:
6635 return "DW_AT_call_column";
6636 case DW_AT_call_file
:
6637 return "DW_AT_call_file";
6638 case DW_AT_call_line
:
6639 return "DW_AT_call_line";
6641 case DW_AT_MIPS_fde
:
6642 return "DW_AT_MIPS_fde";
6643 case DW_AT_MIPS_loop_begin
:
6644 return "DW_AT_MIPS_loop_begin";
6645 case DW_AT_MIPS_tail_loop_begin
:
6646 return "DW_AT_MIPS_tail_loop_begin";
6647 case DW_AT_MIPS_epilog_begin
:
6648 return "DW_AT_MIPS_epilog_begin";
6649 case DW_AT_MIPS_loop_unroll_factor
:
6650 return "DW_AT_MIPS_loop_unroll_factor";
6651 case DW_AT_MIPS_software_pipeline_depth
:
6652 return "DW_AT_MIPS_software_pipeline_depth";
6654 case DW_AT_MIPS_linkage_name
:
6655 return "DW_AT_MIPS_linkage_name";
6657 case DW_AT_sf_names
:
6658 return "DW_AT_sf_names";
6659 case DW_AT_src_info
:
6660 return "DW_AT_src_info";
6661 case DW_AT_mac_info
:
6662 return "DW_AT_mac_info";
6663 case DW_AT_src_coords
:
6664 return "DW_AT_src_coords";
6665 case DW_AT_body_begin
:
6666 return "DW_AT_body_begin";
6667 case DW_AT_body_end
:
6668 return "DW_AT_body_end";
6669 case DW_AT_GNU_vector
:
6670 return "DW_AT_GNU_vector";
6672 return "DW_AT_<unknown>";
6676 /* Convert a DWARF value form code into its string name. */
6679 dwarf_form_name (unsigned form
)
6684 return "DW_FORM_addr";
6685 case DW_FORM_block2
:
6686 return "DW_FORM_block2";
6687 case DW_FORM_block4
:
6688 return "DW_FORM_block4";
6690 return "DW_FORM_data2";
6692 return "DW_FORM_data4";
6694 return "DW_FORM_data8";
6695 case DW_FORM_string
:
6696 return "DW_FORM_string";
6698 return "DW_FORM_block";
6699 case DW_FORM_block1
:
6700 return "DW_FORM_block1";
6702 return "DW_FORM_data1";
6704 return "DW_FORM_flag";
6706 return "DW_FORM_sdata";
6708 return "DW_FORM_strp";
6710 return "DW_FORM_udata";
6711 case DW_FORM_ref_addr
:
6712 return "DW_FORM_ref_addr";
6714 return "DW_FORM_ref1";
6716 return "DW_FORM_ref2";
6718 return "DW_FORM_ref4";
6720 return "DW_FORM_ref8";
6721 case DW_FORM_ref_udata
:
6722 return "DW_FORM_ref_udata";
6723 case DW_FORM_indirect
:
6724 return "DW_FORM_indirect";
6726 return "DW_FORM_<unknown>";
6730 /* Convert a DWARF stack opcode into its string name. */
6733 dwarf_stack_op_name (unsigned op
)
6738 return "DW_OP_addr";
6740 return "DW_OP_deref";
6742 return "DW_OP_const1u";
6744 return "DW_OP_const1s";
6746 return "DW_OP_const2u";
6748 return "DW_OP_const2s";
6750 return "DW_OP_const4u";
6752 return "DW_OP_const4s";
6754 return "DW_OP_const8u";
6756 return "DW_OP_const8s";
6758 return "DW_OP_constu";
6760 return "DW_OP_consts";
6764 return "DW_OP_drop";
6766 return "DW_OP_over";
6768 return "DW_OP_pick";
6770 return "DW_OP_swap";
6774 return "DW_OP_xderef";
6782 return "DW_OP_minus";
6794 return "DW_OP_plus";
6795 case DW_OP_plus_uconst
:
6796 return "DW_OP_plus_uconst";
6802 return "DW_OP_shra";
6820 return "DW_OP_skip";
6822 return "DW_OP_lit0";
6824 return "DW_OP_lit1";
6826 return "DW_OP_lit2";
6828 return "DW_OP_lit3";
6830 return "DW_OP_lit4";
6832 return "DW_OP_lit5";
6834 return "DW_OP_lit6";
6836 return "DW_OP_lit7";
6838 return "DW_OP_lit8";
6840 return "DW_OP_lit9";
6842 return "DW_OP_lit10";
6844 return "DW_OP_lit11";
6846 return "DW_OP_lit12";
6848 return "DW_OP_lit13";
6850 return "DW_OP_lit14";
6852 return "DW_OP_lit15";
6854 return "DW_OP_lit16";
6856 return "DW_OP_lit17";
6858 return "DW_OP_lit18";
6860 return "DW_OP_lit19";
6862 return "DW_OP_lit20";
6864 return "DW_OP_lit21";
6866 return "DW_OP_lit22";
6868 return "DW_OP_lit23";
6870 return "DW_OP_lit24";
6872 return "DW_OP_lit25";
6874 return "DW_OP_lit26";
6876 return "DW_OP_lit27";
6878 return "DW_OP_lit28";
6880 return "DW_OP_lit29";
6882 return "DW_OP_lit30";
6884 return "DW_OP_lit31";
6886 return "DW_OP_reg0";
6888 return "DW_OP_reg1";
6890 return "DW_OP_reg2";
6892 return "DW_OP_reg3";
6894 return "DW_OP_reg4";
6896 return "DW_OP_reg5";
6898 return "DW_OP_reg6";
6900 return "DW_OP_reg7";
6902 return "DW_OP_reg8";
6904 return "DW_OP_reg9";
6906 return "DW_OP_reg10";
6908 return "DW_OP_reg11";
6910 return "DW_OP_reg12";
6912 return "DW_OP_reg13";
6914 return "DW_OP_reg14";
6916 return "DW_OP_reg15";
6918 return "DW_OP_reg16";
6920 return "DW_OP_reg17";
6922 return "DW_OP_reg18";
6924 return "DW_OP_reg19";
6926 return "DW_OP_reg20";
6928 return "DW_OP_reg21";
6930 return "DW_OP_reg22";
6932 return "DW_OP_reg23";
6934 return "DW_OP_reg24";
6936 return "DW_OP_reg25";
6938 return "DW_OP_reg26";
6940 return "DW_OP_reg27";
6942 return "DW_OP_reg28";
6944 return "DW_OP_reg29";
6946 return "DW_OP_reg30";
6948 return "DW_OP_reg31";
6950 return "DW_OP_breg0";
6952 return "DW_OP_breg1";
6954 return "DW_OP_breg2";
6956 return "DW_OP_breg3";
6958 return "DW_OP_breg4";
6960 return "DW_OP_breg5";
6962 return "DW_OP_breg6";
6964 return "DW_OP_breg7";
6966 return "DW_OP_breg8";
6968 return "DW_OP_breg9";
6970 return "DW_OP_breg10";
6972 return "DW_OP_breg11";
6974 return "DW_OP_breg12";
6976 return "DW_OP_breg13";
6978 return "DW_OP_breg14";
6980 return "DW_OP_breg15";
6982 return "DW_OP_breg16";
6984 return "DW_OP_breg17";
6986 return "DW_OP_breg18";
6988 return "DW_OP_breg19";
6990 return "DW_OP_breg20";
6992 return "DW_OP_breg21";
6994 return "DW_OP_breg22";
6996 return "DW_OP_breg23";
6998 return "DW_OP_breg24";
7000 return "DW_OP_breg25";
7002 return "DW_OP_breg26";
7004 return "DW_OP_breg27";
7006 return "DW_OP_breg28";
7008 return "DW_OP_breg29";
7010 return "DW_OP_breg30";
7012 return "DW_OP_breg31";
7014 return "DW_OP_regx";
7016 return "DW_OP_fbreg";
7018 return "DW_OP_bregx";
7020 return "DW_OP_piece";
7021 case DW_OP_deref_size
:
7022 return "DW_OP_deref_size";
7023 case DW_OP_xderef_size
:
7024 return "DW_OP_xderef_size";
7027 /* DWARF 3 extensions. */
7028 case DW_OP_push_object_address
:
7029 return "DW_OP_push_object_address";
7031 return "DW_OP_call2";
7033 return "DW_OP_call4";
7034 case DW_OP_call_ref
:
7035 return "DW_OP_call_ref";
7036 /* GNU extensions. */
7037 case DW_OP_GNU_push_tls_address
:
7038 return "DW_OP_GNU_push_tls_address";
7040 return "OP_<unknown>";
7045 dwarf_bool_name (unsigned mybool
)
7053 /* Convert a DWARF type code into its string name. */
7056 dwarf_type_encoding_name (unsigned enc
)
7060 case DW_ATE_address
:
7061 return "DW_ATE_address";
7062 case DW_ATE_boolean
:
7063 return "DW_ATE_boolean";
7064 case DW_ATE_complex_float
:
7065 return "DW_ATE_complex_float";
7067 return "DW_ATE_float";
7069 return "DW_ATE_signed";
7070 case DW_ATE_signed_char
:
7071 return "DW_ATE_signed_char";
7072 case DW_ATE_unsigned
:
7073 return "DW_ATE_unsigned";
7074 case DW_ATE_unsigned_char
:
7075 return "DW_ATE_unsigned_char";
7076 case DW_ATE_imaginary_float
:
7077 return "DW_ATE_imaginary_float";
7079 return "DW_ATE_<unknown>";
7083 /* Convert a DWARF call frame info operation to its string name. */
7087 dwarf_cfi_name (unsigned cfi_opc
)
7091 case DW_CFA_advance_loc
:
7092 return "DW_CFA_advance_loc";
7094 return "DW_CFA_offset";
7095 case DW_CFA_restore
:
7096 return "DW_CFA_restore";
7098 return "DW_CFA_nop";
7099 case DW_CFA_set_loc
:
7100 return "DW_CFA_set_loc";
7101 case DW_CFA_advance_loc1
:
7102 return "DW_CFA_advance_loc1";
7103 case DW_CFA_advance_loc2
:
7104 return "DW_CFA_advance_loc2";
7105 case DW_CFA_advance_loc4
:
7106 return "DW_CFA_advance_loc4";
7107 case DW_CFA_offset_extended
:
7108 return "DW_CFA_offset_extended";
7109 case DW_CFA_restore_extended
:
7110 return "DW_CFA_restore_extended";
7111 case DW_CFA_undefined
:
7112 return "DW_CFA_undefined";
7113 case DW_CFA_same_value
:
7114 return "DW_CFA_same_value";
7115 case DW_CFA_register
:
7116 return "DW_CFA_register";
7117 case DW_CFA_remember_state
:
7118 return "DW_CFA_remember_state";
7119 case DW_CFA_restore_state
:
7120 return "DW_CFA_restore_state";
7121 case DW_CFA_def_cfa
:
7122 return "DW_CFA_def_cfa";
7123 case DW_CFA_def_cfa_register
:
7124 return "DW_CFA_def_cfa_register";
7125 case DW_CFA_def_cfa_offset
:
7126 return "DW_CFA_def_cfa_offset";
7129 case DW_CFA_def_cfa_expression
:
7130 return "DW_CFA_def_cfa_expression";
7131 case DW_CFA_expression
:
7132 return "DW_CFA_expression";
7133 case DW_CFA_offset_extended_sf
:
7134 return "DW_CFA_offset_extended_sf";
7135 case DW_CFA_def_cfa_sf
:
7136 return "DW_CFA_def_cfa_sf";
7137 case DW_CFA_def_cfa_offset_sf
:
7138 return "DW_CFA_def_cfa_offset_sf";
7140 /* SGI/MIPS specific */
7141 case DW_CFA_MIPS_advance_loc8
:
7142 return "DW_CFA_MIPS_advance_loc8";
7144 /* GNU extensions */
7145 case DW_CFA_GNU_window_save
:
7146 return "DW_CFA_GNU_window_save";
7147 case DW_CFA_GNU_args_size
:
7148 return "DW_CFA_GNU_args_size";
7149 case DW_CFA_GNU_negative_offset_extended
:
7150 return "DW_CFA_GNU_negative_offset_extended";
7153 return "DW_CFA_<unknown>";
7159 dump_die (struct die_info
*die
)
7163 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
7164 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
7165 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
7166 dwarf_bool_name (die
->child
!= NULL
));
7168 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
7169 for (i
= 0; i
< die
->num_attrs
; ++i
)
7171 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
7172 dwarf_attr_name (die
->attrs
[i
].name
),
7173 dwarf_form_name (die
->attrs
[i
].form
));
7174 switch (die
->attrs
[i
].form
)
7176 case DW_FORM_ref_addr
:
7178 fprintf_unfiltered (gdb_stderr
, "address: ");
7179 print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
7181 case DW_FORM_block2
:
7182 case DW_FORM_block4
:
7184 case DW_FORM_block1
:
7185 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
7196 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
7198 case DW_FORM_string
:
7200 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
7201 DW_STRING (&die
->attrs
[i
])
7202 ? DW_STRING (&die
->attrs
[i
]) : "");
7205 if (DW_UNSND (&die
->attrs
[i
]))
7206 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
7208 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
7210 case DW_FORM_indirect
:
7211 /* the reader will have reduced the indirect form to
7212 the "base form" so this form should not occur */
7213 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
7216 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
7217 die
->attrs
[i
].form
);
7219 fprintf_unfiltered (gdb_stderr
, "\n");
7224 dump_die_list (struct die_info
*die
)
7229 if (die
->child
!= NULL
)
7230 dump_die_list (die
->child
);
7231 if (die
->sibling
!= NULL
)
7232 dump_die_list (die
->sibling
);
7237 store_in_ref_table (unsigned int offset
, struct die_info
*die
)
7240 struct die_info
*old
;
7242 h
= (offset
% REF_HASH_SIZE
);
7243 old
= die_ref_table
[h
];
7244 die
->next_ref
= old
;
7245 die_ref_table
[h
] = die
;
7250 dwarf2_empty_hash_tables (void)
7252 memset (die_ref_table
, 0, sizeof (die_ref_table
));
7256 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
7258 unsigned int result
= 0;
7262 case DW_FORM_ref_addr
:
7263 result
= DW_ADDR (attr
);
7269 case DW_FORM_ref_udata
:
7270 result
= cu
->header
.offset
+ DW_UNSND (attr
);
7273 complaint (&symfile_complaints
,
7274 "unsupported die ref attribute form: '%s'",
7275 dwarf_form_name (attr
->form
));
7280 /* Return the constant value held by the given attribute. Return -1
7281 if the value held by the attribute is not constant. */
7284 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
7286 if (attr
->form
== DW_FORM_sdata
)
7287 return DW_SND (attr
);
7288 else if (attr
->form
== DW_FORM_udata
7289 || attr
->form
== DW_FORM_data1
7290 || attr
->form
== DW_FORM_data2
7291 || attr
->form
== DW_FORM_data4
7292 || attr
->form
== DW_FORM_data8
)
7293 return DW_UNSND (attr
);
7296 complaint (&symfile_complaints
, "Attribute value is not a constant (%s)",
7297 dwarf_form_name (attr
->form
));
7298 return default_value
;
7302 static struct die_info
*
7303 follow_die_ref (unsigned int offset
)
7305 struct die_info
*die
;
7308 h
= (offset
% REF_HASH_SIZE
);
7309 die
= die_ref_table
[h
];
7312 if (die
->offset
== offset
)
7316 die
= die
->next_ref
;
7321 static struct type
*
7322 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
7323 struct dwarf2_cu
*cu
)
7325 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
7327 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
7328 typeid, objfile
->name
);
7331 /* Look for this particular type in the fundamental type vector. If
7332 one is not found, create and install one appropriate for the
7333 current language and the current target machine. */
7335 if (cu
->ftypes
[typeid] == NULL
)
7337 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
7340 return (cu
->ftypes
[typeid]);
7343 /* Decode simple location descriptions.
7344 Given a pointer to a dwarf block that defines a location, compute
7345 the location and return the value.
7347 NOTE drow/2003-11-18: This function is called in two situations
7348 now: for the address of static or global variables (partial symbols
7349 only) and for offsets into structures which are expected to be
7350 (more or less) constant. The partial symbol case should go away,
7351 and only the constant case should remain. That will let this
7352 function complain more accurately. A few special modes are allowed
7353 without complaint for global variables (for instance, global
7354 register values and thread-local values).
7356 A location description containing no operations indicates that the
7357 object is optimized out. The return value is 0 for that case.
7358 FIXME drow/2003-11-16: No callers check for this case any more; soon all
7359 callers will only want a very basic result and this can become a
7362 When the result is a register number, the global isreg flag is set,
7363 otherwise it is cleared.
7365 Note that stack[0] is unused except as a default error return.
7366 Note that stack overflow is not yet handled. */
7369 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
7371 struct objfile
*objfile
= cu
->objfile
;
7372 struct comp_unit_head
*cu_header
= &cu
->header
;
7374 int size
= blk
->size
;
7375 char *data
= blk
->data
;
7376 CORE_ADDR stack
[64];
7378 unsigned int bytes_read
, unsnd
;
7423 stack
[++stacki
] = op
- DW_OP_lit0
;
7459 stack
[++stacki
] = op
- DW_OP_reg0
;
7461 dwarf2_complex_location_expr_complaint ();
7466 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7468 stack
[++stacki
] = unsnd
;
7470 dwarf2_complex_location_expr_complaint ();
7474 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
7480 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
7485 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
7490 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
7495 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
7500 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
7505 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
7510 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
7516 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
7521 stack
[stacki
+ 1] = stack
[stacki
];
7526 stack
[stacki
- 1] += stack
[stacki
];
7530 case DW_OP_plus_uconst
:
7531 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
7536 stack
[stacki
- 1] -= stack
[stacki
];
7541 /* If we're not the last op, then we definitely can't encode
7542 this using GDB's address_class enum. This is valid for partial
7543 global symbols, although the variable's address will be bogus
7546 dwarf2_complex_location_expr_complaint ();
7549 case DW_OP_GNU_push_tls_address
:
7550 /* The top of the stack has the offset from the beginning
7551 of the thread control block at which the variable is located. */
7552 /* Nothing should follow this operator, so the top of stack would
7554 /* This is valid for partial global symbols, but the variable's
7555 address will be bogus in the psymtab. */
7557 dwarf2_complex_location_expr_complaint ();
7561 complaint (&symfile_complaints
, "unsupported stack op: '%s'",
7562 dwarf_stack_op_name (op
));
7563 return (stack
[stacki
]);
7566 return (stack
[stacki
]);
7569 /* memory allocation interface */
7572 dwarf2_free_tmp_obstack (void *ignore
)
7574 obstack_free (&dwarf2_tmp_obstack
, NULL
);
7577 static struct dwarf_block
*
7578 dwarf_alloc_block (void)
7580 struct dwarf_block
*blk
;
7582 blk
= (struct dwarf_block
*)
7583 obstack_alloc (&dwarf2_tmp_obstack
, sizeof (struct dwarf_block
));
7587 static struct abbrev_info
*
7588 dwarf_alloc_abbrev (void)
7590 struct abbrev_info
*abbrev
;
7592 abbrev
= (struct abbrev_info
*) xmalloc (sizeof (struct abbrev_info
));
7593 memset (abbrev
, 0, sizeof (struct abbrev_info
));
7597 static struct die_info
*
7598 dwarf_alloc_die (void)
7600 struct die_info
*die
;
7602 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7603 memset (die
, 0, sizeof (struct die_info
));
7608 /* Macro support. */
7611 /* Return the full name of file number I in *LH's file name table.
7612 Use COMP_DIR as the name of the current directory of the
7613 compilation. The result is allocated using xmalloc; the caller is
7614 responsible for freeing it. */
7616 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
7618 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
7620 if (IS_ABSOLUTE_PATH (fe
->name
))
7621 return xstrdup (fe
->name
);
7629 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7635 dir_len
= strlen (dir
);
7636 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
7637 strcpy (full_name
, dir
);
7638 full_name
[dir_len
] = '/';
7639 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
7643 return xstrdup (fe
->name
);
7648 static struct macro_source_file
*
7649 macro_start_file (int file
, int line
,
7650 struct macro_source_file
*current_file
,
7651 const char *comp_dir
,
7652 struct line_header
*lh
, struct objfile
*objfile
)
7654 /* The full name of this source file. */
7655 char *full_name
= file_full_name (file
, lh
, comp_dir
);
7657 /* We don't create a macro table for this compilation unit
7658 at all until we actually get a filename. */
7659 if (! pending_macros
)
7660 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
7661 objfile
->macro_cache
);
7664 /* If we have no current file, then this must be the start_file
7665 directive for the compilation unit's main source file. */
7666 current_file
= macro_set_main (pending_macros
, full_name
);
7668 current_file
= macro_include (current_file
, line
, full_name
);
7672 return current_file
;
7676 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7677 followed by a null byte. */
7679 copy_string (const char *buf
, int len
)
7681 char *s
= xmalloc (len
+ 1);
7682 memcpy (s
, buf
, len
);
7690 consume_improper_spaces (const char *p
, const char *body
)
7694 complaint (&symfile_complaints
,
7695 "macro definition contains spaces in formal argument list:\n`%s'",
7707 parse_macro_definition (struct macro_source_file
*file
, int line
,
7712 /* The body string takes one of two forms. For object-like macro
7713 definitions, it should be:
7715 <macro name> " " <definition>
7717 For function-like macro definitions, it should be:
7719 <macro name> "() " <definition>
7721 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7723 Spaces may appear only where explicitly indicated, and in the
7726 The Dwarf 2 spec says that an object-like macro's name is always
7727 followed by a space, but versions of GCC around March 2002 omit
7728 the space when the macro's definition is the empty string.
7730 The Dwarf 2 spec says that there should be no spaces between the
7731 formal arguments in a function-like macro's formal argument list,
7732 but versions of GCC around March 2002 include spaces after the
7736 /* Find the extent of the macro name. The macro name is terminated
7737 by either a space or null character (for an object-like macro) or
7738 an opening paren (for a function-like macro). */
7739 for (p
= body
; *p
; p
++)
7740 if (*p
== ' ' || *p
== '(')
7743 if (*p
== ' ' || *p
== '\0')
7745 /* It's an object-like macro. */
7746 int name_len
= p
- body
;
7747 char *name
= copy_string (body
, name_len
);
7748 const char *replacement
;
7751 replacement
= body
+ name_len
+ 1;
7754 dwarf2_macro_malformed_definition_complaint (body
);
7755 replacement
= body
+ name_len
;
7758 macro_define_object (file
, line
, name
, replacement
);
7764 /* It's a function-like macro. */
7765 char *name
= copy_string (body
, p
- body
);
7768 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
7772 p
= consume_improper_spaces (p
, body
);
7774 /* Parse the formal argument list. */
7775 while (*p
&& *p
!= ')')
7777 /* Find the extent of the current argument name. */
7778 const char *arg_start
= p
;
7780 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
7783 if (! *p
|| p
== arg_start
)
7784 dwarf2_macro_malformed_definition_complaint (body
);
7787 /* Make sure argv has room for the new argument. */
7788 if (argc
>= argv_size
)
7791 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
7794 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
7797 p
= consume_improper_spaces (p
, body
);
7799 /* Consume the comma, if present. */
7804 p
= consume_improper_spaces (p
, body
);
7813 /* Perfectly formed definition, no complaints. */
7814 macro_define_function (file
, line
, name
,
7815 argc
, (const char **) argv
,
7817 else if (*p
== '\0')
7819 /* Complain, but do define it. */
7820 dwarf2_macro_malformed_definition_complaint (body
);
7821 macro_define_function (file
, line
, name
,
7822 argc
, (const char **) argv
,
7826 /* Just complain. */
7827 dwarf2_macro_malformed_definition_complaint (body
);
7830 /* Just complain. */
7831 dwarf2_macro_malformed_definition_complaint (body
);
7837 for (i
= 0; i
< argc
; i
++)
7843 dwarf2_macro_malformed_definition_complaint (body
);
7848 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
7849 char *comp_dir
, bfd
*abfd
,
7850 struct dwarf2_cu
*cu
)
7852 char *mac_ptr
, *mac_end
;
7853 struct macro_source_file
*current_file
= 0;
7855 if (dwarf_macinfo_buffer
== NULL
)
7857 complaint (&symfile_complaints
, "missing .debug_macinfo section");
7861 mac_ptr
= dwarf_macinfo_buffer
+ offset
;
7862 mac_end
= dwarf_macinfo_buffer
+ dwarf_macinfo_size
;
7866 enum dwarf_macinfo_record_type macinfo_type
;
7868 /* Do we at least have room for a macinfo type byte? */
7869 if (mac_ptr
>= mac_end
)
7871 dwarf2_macros_too_long_complaint ();
7875 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
7878 switch (macinfo_type
)
7880 /* A zero macinfo type indicates the end of the macro
7885 case DW_MACINFO_define
:
7886 case DW_MACINFO_undef
:
7892 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7893 mac_ptr
+= bytes_read
;
7894 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
7895 mac_ptr
+= bytes_read
;
7898 complaint (&symfile_complaints
,
7899 "debug info gives macro %s outside of any file: %s",
7901 DW_MACINFO_define
? "definition" : macinfo_type
==
7902 DW_MACINFO_undef
? "undefinition" :
7903 "something-or-other", body
);
7906 if (macinfo_type
== DW_MACINFO_define
)
7907 parse_macro_definition (current_file
, line
, body
);
7908 else if (macinfo_type
== DW_MACINFO_undef
)
7909 macro_undef (current_file
, line
, body
);
7914 case DW_MACINFO_start_file
:
7919 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7920 mac_ptr
+= bytes_read
;
7921 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7922 mac_ptr
+= bytes_read
;
7924 current_file
= macro_start_file (file
, line
,
7925 current_file
, comp_dir
,
7930 case DW_MACINFO_end_file
:
7932 complaint (&symfile_complaints
,
7933 "macro debug info has an unmatched `close_file' directive");
7936 current_file
= current_file
->included_by
;
7939 enum dwarf_macinfo_record_type next_type
;
7941 /* GCC circa March 2002 doesn't produce the zero
7942 type byte marking the end of the compilation
7943 unit. Complain if it's not there, but exit no
7946 /* Do we at least have room for a macinfo type byte? */
7947 if (mac_ptr
>= mac_end
)
7949 dwarf2_macros_too_long_complaint ();
7953 /* We don't increment mac_ptr here, so this is just
7955 next_type
= read_1_byte (abfd
, mac_ptr
);
7957 complaint (&symfile_complaints
,
7958 "no terminating 0-type entry for macros in `.debug_macinfo' section");
7965 case DW_MACINFO_vendor_ext
:
7971 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
7972 mac_ptr
+= bytes_read
;
7973 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
7974 mac_ptr
+= bytes_read
;
7976 /* We don't recognize any vendor extensions. */
7983 /* Check if the attribute's form is a DW_FORM_block*
7984 if so return true else false. */
7986 attr_form_is_block (struct attribute
*attr
)
7988 return (attr
== NULL
? 0 :
7989 attr
->form
== DW_FORM_block1
7990 || attr
->form
== DW_FORM_block2
7991 || attr
->form
== DW_FORM_block4
7992 || attr
->form
== DW_FORM_block
);
7996 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
7997 struct dwarf2_cu
*cu
)
7999 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
8001 struct dwarf2_loclist_baton
*baton
;
8003 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
8004 sizeof (struct dwarf2_loclist_baton
));
8005 baton
->objfile
= cu
->objfile
;
8007 /* We don't know how long the location list is, but make sure we
8008 don't run off the edge of the section. */
8009 baton
->size
= dwarf_loc_size
- DW_UNSND (attr
);
8010 baton
->data
= dwarf_loc_buffer
+ DW_UNSND (attr
);
8011 baton
->base_address
= cu
->header
.base_address
;
8012 if (cu
->header
.base_known
== 0)
8013 complaint (&symfile_complaints
,
8014 "Location list used without specifying the CU base address.");
8016 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
8017 SYMBOL_LOCATION_BATON (sym
) = baton
;
8021 struct dwarf2_locexpr_baton
*baton
;
8023 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
8024 sizeof (struct dwarf2_locexpr_baton
));
8025 baton
->objfile
= cu
->objfile
;
8027 if (attr_form_is_block (attr
))
8029 /* Note that we're just copying the block's data pointer
8030 here, not the actual data. We're still pointing into the
8031 dwarf_info_buffer for SYM's objfile; right now we never
8032 release that buffer, but when we do clean up properly
8033 this may need to change. */
8034 baton
->size
= DW_BLOCK (attr
)->size
;
8035 baton
->data
= DW_BLOCK (attr
)->data
;
8039 dwarf2_invalid_attrib_class_complaint ("location description",
8040 SYMBOL_NATURAL_NAME (sym
));
8045 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
8046 SYMBOL_LOCATION_BATON (sym
) = baton
;