1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008 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
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 3 of the License, or
18 (at your option) any later version.
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU 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, see <http://www.gnu.org/licenses/>. */
33 #include "elf/dwarf2.h"
36 #include "expression.h"
37 #include "filenames.h" /* for DOSish file names */
40 #include "complaints.h"
42 #include "dwarf2expr.h"
43 #include "dwarf2loc.h"
44 #include "cp-support.h"
51 #include "gdb_string.h"
52 #include "gdb_assert.h"
53 #include <sys/types.h>
58 /* A note on memory usage for this file.
60 At the present time, this code reads the debug info sections into
61 the objfile's objfile_obstack. A definite improvement for startup
62 time, on platforms which do not emit relocations for debug
63 sections, would be to use mmap instead. The object's complete
64 debug information is loaded into memory, partly to simplify
65 absolute DIE references.
67 Whether using obstacks or mmap, the sections should remain loaded
68 until the objfile is released, and pointers into the section data
69 can be used for any other data associated to the objfile (symbol
70 names, type names, location expressions to name a few). */
73 /* .debug_info header for a compilation unit
74 Because of alignment constraints, this structure has padding and cannot
75 be mapped directly onto the beginning of the .debug_info section. */
76 typedef struct comp_unit_header
78 unsigned int length
; /* length of the .debug_info
80 unsigned short version
; /* version number -- 2 for DWARF
82 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
83 unsigned char addr_size
; /* byte size of an address -- 4 */
86 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
89 /* .debug_pubnames header
90 Because of alignment constraints, this structure has padding and cannot
91 be mapped directly onto the beginning of the .debug_info section. */
92 typedef struct pubnames_header
94 unsigned int length
; /* length of the .debug_pubnames
96 unsigned char version
; /* version number -- 2 for DWARF
98 unsigned int info_offset
; /* offset into .debug_info section */
99 unsigned int info_size
; /* byte size of .debug_info section
103 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
105 /* .debug_pubnames header
106 Because of alignment constraints, this structure has padding and cannot
107 be mapped directly onto the beginning of the .debug_info section. */
108 typedef struct aranges_header
110 unsigned int length
; /* byte len of the .debug_aranges
112 unsigned short version
; /* version number -- 2 for DWARF
114 unsigned int info_offset
; /* offset into .debug_info section */
115 unsigned char addr_size
; /* byte size of an address */
116 unsigned char seg_size
; /* byte size of segment descriptor */
119 #define _ACTUAL_ARANGES_HEADER_SIZE 12
121 /* .debug_line statement program prologue
122 Because of alignment constraints, this structure has padding and cannot
123 be mapped directly onto the beginning of the .debug_info section. */
124 typedef struct statement_prologue
126 unsigned int total_length
; /* byte length of the statement
128 unsigned short version
; /* version number -- 2 for DWARF
130 unsigned int prologue_length
; /* # bytes between prologue &
132 unsigned char minimum_instruction_length
; /* byte size of
134 unsigned char default_is_stmt
; /* initial value of is_stmt
137 unsigned char line_range
;
138 unsigned char opcode_base
; /* number assigned to first special
140 unsigned char *standard_opcode_lengths
;
144 static const struct objfile_data
*dwarf2_objfile_data_key
;
146 struct dwarf2_per_objfile
148 /* Sizes of debugging sections. */
149 unsigned int info_size
;
150 unsigned int abbrev_size
;
151 unsigned int line_size
;
152 unsigned int pubnames_size
;
153 unsigned int aranges_size
;
154 unsigned int loc_size
;
155 unsigned int macinfo_size
;
156 unsigned int str_size
;
157 unsigned int ranges_size
;
158 unsigned int frame_size
;
159 unsigned int eh_frame_size
;
161 /* Loaded data from the sections. */
162 gdb_byte
*info_buffer
;
163 gdb_byte
*abbrev_buffer
;
164 gdb_byte
*line_buffer
;
165 gdb_byte
*str_buffer
;
166 gdb_byte
*macinfo_buffer
;
167 gdb_byte
*ranges_buffer
;
168 gdb_byte
*loc_buffer
;
170 /* A list of all the compilation units. This is used to locate
171 the target compilation unit of a particular reference. */
172 struct dwarf2_per_cu_data
**all_comp_units
;
174 /* The number of compilation units in ALL_COMP_UNITS. */
177 /* A chain of compilation units that are currently read in, so that
178 they can be freed later. */
179 struct dwarf2_per_cu_data
*read_in_chain
;
181 /* A flag indicating wether this objfile has a section loaded at a
183 int has_section_at_zero
;
186 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
188 static asection
*dwarf_info_section
;
189 static asection
*dwarf_abbrev_section
;
190 static asection
*dwarf_line_section
;
191 static asection
*dwarf_pubnames_section
;
192 static asection
*dwarf_aranges_section
;
193 static asection
*dwarf_loc_section
;
194 static asection
*dwarf_macinfo_section
;
195 static asection
*dwarf_str_section
;
196 static asection
*dwarf_ranges_section
;
197 asection
*dwarf_frame_section
;
198 asection
*dwarf_eh_frame_section
;
200 /* names of the debugging sections */
202 /* Note that if the debugging section has been compressed, it might
203 have a name like .zdebug_info. */
205 #define INFO_SECTION "debug_info"
206 #define ABBREV_SECTION "debug_abbrev"
207 #define LINE_SECTION "debug_line"
208 #define PUBNAMES_SECTION "debug_pubnames"
209 #define ARANGES_SECTION "debug_aranges"
210 #define LOC_SECTION "debug_loc"
211 #define MACINFO_SECTION "debug_macinfo"
212 #define STR_SECTION "debug_str"
213 #define RANGES_SECTION "debug_ranges"
214 #define FRAME_SECTION "debug_frame"
215 #define EH_FRAME_SECTION "eh_frame"
217 /* local data types */
219 /* We hold several abbreviation tables in memory at the same time. */
220 #ifndef ABBREV_HASH_SIZE
221 #define ABBREV_HASH_SIZE 121
224 /* The data in a compilation unit header, after target2host
225 translation, looks like this. */
226 struct comp_unit_head
228 unsigned long length
;
230 unsigned int abbrev_offset
;
231 unsigned char addr_size
;
232 unsigned char signed_addr_p
;
234 /* Size of file offsets; either 4 or 8. */
235 unsigned int offset_size
;
237 /* Size of the length field; either 4 or 12. */
238 unsigned int initial_length_size
;
240 /* Offset to the first byte of this compilation unit header in the
241 .debug_info section, for resolving relative reference dies. */
244 /* Pointer to this compilation unit header in the .debug_info
246 gdb_byte
*cu_head_ptr
;
248 /* Pointer to the first die of this compilation unit. This will be
249 the first byte following the compilation unit header. */
250 gdb_byte
*first_die_ptr
;
252 /* Pointer to the next compilation unit header in the program. */
253 struct comp_unit_head
*next
;
255 /* Base address of this compilation unit. */
256 CORE_ADDR base_address
;
258 /* Non-zero if base_address has been set. */
262 /* Internal state when decoding a particular compilation unit. */
265 /* The objfile containing this compilation unit. */
266 struct objfile
*objfile
;
268 /* The header of the compilation unit.
270 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
271 should logically be moved to the dwarf2_cu structure. */
272 struct comp_unit_head header
;
274 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
276 /* The language we are debugging. */
277 enum language language
;
278 const struct language_defn
*language_defn
;
280 const char *producer
;
282 /* The generic symbol table building routines have separate lists for
283 file scope symbols and all all other scopes (local scopes). So
284 we need to select the right one to pass to add_symbol_to_list().
285 We do it by keeping a pointer to the correct list in list_in_scope.
287 FIXME: The original dwarf code just treated the file scope as the
288 first local scope, and all other local scopes as nested local
289 scopes, and worked fine. Check to see if we really need to
290 distinguish these in buildsym.c. */
291 struct pending
**list_in_scope
;
293 /* DWARF abbreviation table associated with this compilation unit. */
294 struct abbrev_info
**dwarf2_abbrevs
;
296 /* Storage for the abbrev table. */
297 struct obstack abbrev_obstack
;
299 /* Hash table holding all the loaded partial DIEs. */
302 /* `.debug_ranges' offset for this `DW_TAG_compile_unit' DIE. */
303 unsigned long ranges_offset
;
305 /* Storage for things with the same lifetime as this read-in compilation
306 unit, including partial DIEs. */
307 struct obstack comp_unit_obstack
;
309 /* When multiple dwarf2_cu structures are living in memory, this field
310 chains them all together, so that they can be released efficiently.
311 We will probably also want a generation counter so that most-recently-used
312 compilation units are cached... */
313 struct dwarf2_per_cu_data
*read_in_chain
;
315 /* Backchain to our per_cu entry if the tree has been built. */
316 struct dwarf2_per_cu_data
*per_cu
;
318 /* Pointer to the die -> type map. Although it is stored
319 permanently in per_cu, we copy it here to avoid double
323 /* How many compilation units ago was this CU last referenced? */
326 /* A hash table of die offsets for following references. */
329 /* Full DIEs if read in. */
330 struct die_info
*dies
;
332 /* A set of pointers to dwarf2_per_cu_data objects for compilation
333 units referenced by this one. Only set during full symbol processing;
334 partial symbol tables do not have dependencies. */
337 /* Header data from the line table, during full symbol processing. */
338 struct line_header
*line_header
;
340 /* Mark used when releasing cached dies. */
341 unsigned int mark
: 1;
343 /* This flag will be set if this compilation unit might include
344 inter-compilation-unit references. */
345 unsigned int has_form_ref_addr
: 1;
347 /* This flag will be set if this compilation unit includes any
348 DW_TAG_namespace DIEs. If we know that there are explicit
349 DIEs for namespaces, we don't need to try to infer them
350 from mangled names. */
351 unsigned int has_namespace_info
: 1;
353 /* Field `ranges_offset' is filled in; flag as the value may be zero. */
354 unsigned int has_ranges_offset
: 1;
357 /* Persistent data held for a compilation unit, even when not
358 processing it. We put a pointer to this structure in the
359 read_symtab_private field of the psymtab. If we encounter
360 inter-compilation-unit references, we also maintain a sorted
361 list of all compilation units. */
363 struct dwarf2_per_cu_data
365 /* The start offset and length of this compilation unit. 2**30-1
366 bytes should suffice to store the length of any compilation unit
367 - if it doesn't, GDB will fall over anyway. */
368 unsigned long offset
;
369 unsigned long length
: 30;
371 /* Flag indicating this compilation unit will be read in before
372 any of the current compilation units are processed. */
373 unsigned long queued
: 1;
375 /* This flag will be set if we need to load absolutely all DIEs
376 for this compilation unit, instead of just the ones we think
377 are interesting. It gets set if we look for a DIE in the
378 hash table and don't find it. */
379 unsigned int load_all_dies
: 1;
381 /* Set iff currently read in. */
382 struct dwarf2_cu
*cu
;
384 /* If full symbols for this CU have been read in, then this field
385 holds a map of DIE offsets to types. It isn't always possible
386 to reconstruct this information later, so we have to preserve
390 /* The partial symbol table associated with this compilation unit,
391 or NULL for partial units (which do not have an associated
393 struct partial_symtab
*psymtab
;
396 /* The line number information for a compilation unit (found in the
397 .debug_line section) begins with a "statement program header",
398 which contains the following information. */
401 unsigned int total_length
;
402 unsigned short version
;
403 unsigned int header_length
;
404 unsigned char minimum_instruction_length
;
405 unsigned char default_is_stmt
;
407 unsigned char line_range
;
408 unsigned char opcode_base
;
410 /* standard_opcode_lengths[i] is the number of operands for the
411 standard opcode whose value is i. This means that
412 standard_opcode_lengths[0] is unused, and the last meaningful
413 element is standard_opcode_lengths[opcode_base - 1]. */
414 unsigned char *standard_opcode_lengths
;
416 /* The include_directories table. NOTE! These strings are not
417 allocated with xmalloc; instead, they are pointers into
418 debug_line_buffer. If you try to free them, `free' will get
420 unsigned int num_include_dirs
, include_dirs_size
;
423 /* The file_names table. NOTE! These strings are not allocated
424 with xmalloc; instead, they are pointers into debug_line_buffer.
425 Don't try to free them directly. */
426 unsigned int num_file_names
, file_names_size
;
430 unsigned int dir_index
;
431 unsigned int mod_time
;
433 int included_p
; /* Non-zero if referenced by the Line Number Program. */
434 struct symtab
*symtab
; /* The associated symbol table, if any. */
437 /* The start and end of the statement program following this
438 header. These point into dwarf2_per_objfile->line_buffer. */
439 gdb_byte
*statement_program_start
, *statement_program_end
;
442 /* When we construct a partial symbol table entry we only
443 need this much information. */
444 struct partial_die_info
446 /* Offset of this DIE. */
449 /* DWARF-2 tag for this DIE. */
450 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
452 /* Language code associated with this DIE. This is only used
453 for the compilation unit DIE. */
454 unsigned int language
: 8;
456 /* Assorted flags describing the data found in this DIE. */
457 unsigned int has_children
: 1;
458 unsigned int is_external
: 1;
459 unsigned int is_declaration
: 1;
460 unsigned int has_type
: 1;
461 unsigned int has_specification
: 1;
462 unsigned int has_stmt_list
: 1;
463 unsigned int has_pc_info
: 1;
465 /* Flag set if the SCOPE field of this structure has been
467 unsigned int scope_set
: 1;
469 /* Flag set if the DIE has a byte_size attribute. */
470 unsigned int has_byte_size
: 1;
472 /* The name of this DIE. Normally the value of DW_AT_name, but
473 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
478 /* The scope to prepend to our children. This is generally
479 allocated on the comp_unit_obstack, so will disappear
480 when this compilation unit leaves the cache. */
483 /* The location description associated with this DIE, if any. */
484 struct dwarf_block
*locdesc
;
486 /* If HAS_PC_INFO, the PC range associated with this DIE. */
490 /* Pointer into the info_buffer pointing at the target of
491 DW_AT_sibling, if any. */
494 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
495 DW_AT_specification (or DW_AT_abstract_origin or
497 unsigned int spec_offset
;
499 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
500 unsigned int line_offset
;
502 /* Pointers to this DIE's parent, first child, and next sibling,
504 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
507 /* This data structure holds the information of an abbrev. */
510 unsigned int number
; /* number identifying abbrev */
511 enum dwarf_tag tag
; /* dwarf tag */
512 unsigned short has_children
; /* boolean */
513 unsigned short num_attrs
; /* number of attributes */
514 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
515 struct abbrev_info
*next
; /* next in chain */
520 enum dwarf_attribute name
;
521 enum dwarf_form form
;
524 /* Attributes have a name and a value */
527 enum dwarf_attribute name
;
528 enum dwarf_form form
;
532 struct dwarf_block
*blk
;
540 /* This data structure holds a complete die structure. */
543 enum dwarf_tag tag
; /* Tag indicating type of die */
544 unsigned int abbrev
; /* Abbrev number */
545 unsigned int offset
; /* Offset in .debug_info section */
546 unsigned int num_attrs
; /* Number of attributes */
548 /* The dies in a compilation unit form an n-ary tree. PARENT
549 points to this die's parent; CHILD points to the first child of
550 this node; and all the children of a given node are chained
551 together via their SIBLING fields, terminated by a die whose
553 struct die_info
*child
; /* Its first child, if any. */
554 struct die_info
*sibling
; /* Its next sibling, if any. */
555 struct die_info
*parent
; /* Its parent, if any. */
557 /* An array of attributes, with NUM_ATTRS elements. There may be
558 zero, but it's not common and zero-sized arrays are not
559 sufficiently portable C. */
560 struct attribute attrs
[1];
563 struct function_range
566 CORE_ADDR lowpc
, highpc
;
568 struct function_range
*next
;
571 /* Get at parts of an attribute structure */
573 #define DW_STRING(attr) ((attr)->u.str)
574 #define DW_UNSND(attr) ((attr)->u.unsnd)
575 #define DW_BLOCK(attr) ((attr)->u.blk)
576 #define DW_SND(attr) ((attr)->u.snd)
577 #define DW_ADDR(attr) ((attr)->u.addr)
579 /* Blocks are a bunch of untyped bytes. */
586 #ifndef ATTR_ALLOC_CHUNK
587 #define ATTR_ALLOC_CHUNK 4
590 /* Allocate fields for structs, unions and enums in this size. */
591 #ifndef DW_FIELD_ALLOC_CHUNK
592 #define DW_FIELD_ALLOC_CHUNK 4
595 /* A zeroed version of a partial die for initialization purposes. */
596 static struct partial_die_info zeroed_partial_die
;
598 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
599 but this would require a corresponding change in unpack_field_as_long
601 static int bits_per_byte
= 8;
603 /* The routines that read and process dies for a C struct or C++ class
604 pass lists of data member fields and lists of member function fields
605 in an instance of a field_info structure, as defined below. */
608 /* List of data member and baseclasses fields. */
611 struct nextfield
*next
;
618 /* Number of fields. */
621 /* Number of baseclasses. */
624 /* Set if the accesibility of one of the fields is not public. */
625 int non_public_fields
;
627 /* Member function fields array, entries are allocated in the order they
628 are encountered in the object file. */
631 struct nextfnfield
*next
;
632 struct fn_field fnfield
;
636 /* Member function fieldlist array, contains name of possibly overloaded
637 member function, number of overloaded member functions and a pointer
638 to the head of the member function field chain. */
643 struct nextfnfield
*head
;
647 /* Number of entries in the fnfieldlists array. */
651 /* One item on the queue of compilation units to read in full symbols
653 struct dwarf2_queue_item
655 struct dwarf2_per_cu_data
*per_cu
;
656 struct dwarf2_queue_item
*next
;
659 /* The current queue. */
660 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
662 /* Loaded secondary compilation units are kept in memory until they
663 have not been referenced for the processing of this many
664 compilation units. Set this to zero to disable caching. Cache
665 sizes of up to at least twenty will improve startup time for
666 typical inter-CU-reference binaries, at an obvious memory cost. */
667 static int dwarf2_max_cache_age
= 5;
669 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
670 struct cmd_list_element
*c
, const char *value
)
672 fprintf_filtered (file
, _("\
673 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
678 /* Various complaints about symbol reading that don't abort the process */
681 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
683 complaint (&symfile_complaints
,
684 _("statement list doesn't fit in .debug_line section"));
688 dwarf2_debug_line_missing_file_complaint (void)
690 complaint (&symfile_complaints
,
691 _(".debug_line section has line data without a file"));
695 dwarf2_complex_location_expr_complaint (void)
697 complaint (&symfile_complaints
, _("location expression too complex"));
701 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
704 complaint (&symfile_complaints
,
705 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
710 dwarf2_macros_too_long_complaint (void)
712 complaint (&symfile_complaints
,
713 _("macro info runs off end of `.debug_macinfo' section"));
717 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
719 complaint (&symfile_complaints
,
720 _("macro debug info contains a malformed macro definition:\n`%s'"),
725 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
727 complaint (&symfile_complaints
,
728 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
731 /* local function prototypes */
733 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
736 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
739 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
742 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
743 struct partial_die_info
*,
744 struct partial_symtab
*);
746 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
748 static void scan_partial_symbols (struct partial_die_info
*,
749 CORE_ADDR
*, CORE_ADDR
*,
752 static void add_partial_symbol (struct partial_die_info
*,
755 static int pdi_needs_namespace (enum dwarf_tag tag
);
757 static void add_partial_namespace (struct partial_die_info
*pdi
,
758 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
759 struct dwarf2_cu
*cu
);
761 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
762 struct dwarf2_cu
*cu
);
764 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
767 struct dwarf2_cu
*cu
);
769 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
771 static void psymtab_to_symtab_1 (struct partial_symtab
*);
773 gdb_byte
*dwarf2_read_section (struct objfile
*, asection
*);
775 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
777 static void dwarf2_free_abbrev_table (void *);
779 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
782 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
785 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
788 static gdb_byte
*read_partial_die (struct partial_die_info
*,
789 struct abbrev_info
*abbrev
, unsigned int,
790 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
792 static struct partial_die_info
*find_partial_die (unsigned long,
795 static void fixup_partial_die (struct partial_die_info
*,
798 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
799 struct dwarf2_cu
*, int *);
801 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
802 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
804 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
805 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
807 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
809 static int read_1_signed_byte (bfd
*, gdb_byte
*);
811 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
813 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
815 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
817 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
820 static LONGEST
read_initial_length (bfd
*, gdb_byte
*,
821 struct comp_unit_head
*, unsigned int *);
823 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
826 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
828 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
830 static char *read_indirect_string (bfd
*, gdb_byte
*,
831 const struct comp_unit_head
*,
834 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
836 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
838 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
840 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
842 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
845 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
846 struct dwarf2_cu
*cu
);
848 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
850 static struct die_info
*die_specification (struct die_info
*die
,
851 struct dwarf2_cu
**);
853 static void free_line_header (struct line_header
*lh
);
855 static void add_file_name (struct line_header
*, char *, unsigned int,
856 unsigned int, unsigned int);
858 static struct line_header
*(dwarf_decode_line_header
859 (unsigned int offset
,
860 bfd
*abfd
, struct dwarf2_cu
*cu
));
862 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
863 struct dwarf2_cu
*, struct partial_symtab
*);
865 static void dwarf2_start_subfile (char *, char *, char *);
867 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
870 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
873 static void dwarf2_const_value_data (struct attribute
*attr
,
877 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
879 static struct type
*die_containing_type (struct die_info
*,
882 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
884 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
886 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
888 static char *typename_concat (struct obstack
*,
893 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
895 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
897 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
899 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
900 struct dwarf2_cu
*, struct partial_symtab
*);
902 static int dwarf2_get_pc_bounds (struct die_info
*,
903 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
905 static void get_scope_pc_bounds (struct die_info
*,
906 CORE_ADDR
*, CORE_ADDR
*,
909 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
910 CORE_ADDR
, struct dwarf2_cu
*);
912 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
915 static void dwarf2_attach_fields_to_type (struct field_info
*,
916 struct type
*, struct dwarf2_cu
*);
918 static void dwarf2_add_member_fn (struct field_info
*,
919 struct die_info
*, struct type
*,
922 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
923 struct type
*, struct dwarf2_cu
*);
925 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
927 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
929 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
931 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
933 static const char *namespace_name (struct die_info
*die
,
934 int *is_anonymous
, struct dwarf2_cu
*);
936 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
938 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
940 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
943 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
945 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
947 gdb_byte
**new_info_ptr
,
948 struct die_info
*parent
);
950 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
952 gdb_byte
**new_info_ptr
,
953 struct die_info
*parent
);
955 static void process_die (struct die_info
*, struct dwarf2_cu
*);
957 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
959 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
961 static struct die_info
*dwarf2_extension (struct die_info
*die
,
962 struct dwarf2_cu
**);
964 static char *dwarf_tag_name (unsigned int);
966 static char *dwarf_attr_name (unsigned int);
968 static char *dwarf_form_name (unsigned int);
970 static char *dwarf_stack_op_name (unsigned int);
972 static char *dwarf_bool_name (unsigned int);
974 static char *dwarf_type_encoding_name (unsigned int);
977 static char *dwarf_cfi_name (unsigned int);
980 static struct die_info
*sibling_die (struct die_info
*);
982 static void dump_die (struct die_info
*);
984 static void dump_die_list (struct die_info
*);
986 static void store_in_ref_table (struct die_info
*,
989 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
992 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
994 static struct die_info
*follow_die_ref (struct die_info
*,
996 struct dwarf2_cu
**);
998 /* memory allocation interface */
1000 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1002 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1004 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1006 static void initialize_cu_func_list (struct dwarf2_cu
*);
1008 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1009 struct dwarf2_cu
*);
1011 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1012 char *, bfd
*, struct dwarf2_cu
*);
1014 static int attr_form_is_block (struct attribute
*);
1016 static int attr_form_is_section_offset (struct attribute
*);
1018 static int attr_form_is_constant (struct attribute
*);
1020 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1022 struct dwarf2_cu
*cu
);
1024 static gdb_byte
*skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
1025 struct dwarf2_cu
*cu
);
1027 static void free_stack_comp_unit (void *);
1029 static hashval_t
partial_die_hash (const void *item
);
1031 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1033 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1034 (unsigned long offset
, struct objfile
*objfile
);
1036 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1037 (unsigned long offset
, struct objfile
*objfile
);
1039 static void free_one_comp_unit (void *);
1041 static void free_cached_comp_units (void *);
1043 static void age_cached_comp_units (void);
1045 static void free_one_cached_comp_unit (void *);
1047 static struct type
*set_die_type (struct die_info
*, struct type
*,
1048 struct dwarf2_cu
*);
1050 static void create_all_comp_units (struct objfile
*);
1052 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*,
1055 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1057 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1058 struct dwarf2_per_cu_data
*);
1060 static void dwarf2_mark (struct dwarf2_cu
*);
1062 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1064 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1066 /* Try to locate the sections we need for DWARF 2 debugging
1067 information and return true if we have enough to do something. */
1070 dwarf2_has_info (struct objfile
*objfile
)
1072 struct dwarf2_per_objfile
*data
;
1074 /* Initialize per-objfile state. */
1075 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1076 memset (data
, 0, sizeof (*data
));
1077 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1078 dwarf2_per_objfile
= data
;
1080 dwarf_info_section
= 0;
1081 dwarf_abbrev_section
= 0;
1082 dwarf_line_section
= 0;
1083 dwarf_str_section
= 0;
1084 dwarf_macinfo_section
= 0;
1085 dwarf_frame_section
= 0;
1086 dwarf_eh_frame_section
= 0;
1087 dwarf_ranges_section
= 0;
1088 dwarf_loc_section
= 0;
1090 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1091 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1094 /* When loading sections, we can either look for ".<name>", or for
1095 * ".z<name>", which indicates a compressed section. */
1098 section_is_p (asection
*sectp
, const char *name
)
1100 return ((sectp
->name
[0] == '.'
1101 && strcmp (sectp
->name
+ 1, name
) == 0)
1102 || (sectp
->name
[0] == '.' && sectp
->name
[1] == 'z'
1103 && strcmp (sectp
->name
+ 2, name
) == 0));
1106 /* This function is mapped across the sections and remembers the
1107 offset and size of each of the debugging sections we are interested
1111 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1113 if (section_is_p (sectp
, INFO_SECTION
))
1115 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1116 dwarf_info_section
= sectp
;
1118 else if (section_is_p (sectp
, ABBREV_SECTION
))
1120 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1121 dwarf_abbrev_section
= sectp
;
1123 else if (section_is_p (sectp
, LINE_SECTION
))
1125 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1126 dwarf_line_section
= sectp
;
1128 else if (section_is_p (sectp
, PUBNAMES_SECTION
))
1130 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1131 dwarf_pubnames_section
= sectp
;
1133 else if (section_is_p (sectp
, ARANGES_SECTION
))
1135 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1136 dwarf_aranges_section
= sectp
;
1138 else if (section_is_p (sectp
, LOC_SECTION
))
1140 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1141 dwarf_loc_section
= sectp
;
1143 else if (section_is_p (sectp
, MACINFO_SECTION
))
1145 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1146 dwarf_macinfo_section
= sectp
;
1148 else if (section_is_p (sectp
, STR_SECTION
))
1150 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1151 dwarf_str_section
= sectp
;
1153 else if (section_is_p (sectp
, FRAME_SECTION
))
1155 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1156 dwarf_frame_section
= sectp
;
1158 else if (section_is_p (sectp
, EH_FRAME_SECTION
))
1160 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1161 if (aflag
& SEC_HAS_CONTENTS
)
1163 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1164 dwarf_eh_frame_section
= sectp
;
1167 else if (section_is_p (sectp
, RANGES_SECTION
))
1169 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1170 dwarf_ranges_section
= sectp
;
1173 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1174 && bfd_section_vma (abfd
, sectp
) == 0)
1175 dwarf2_per_objfile
->has_section_at_zero
= 1;
1178 /* This function is called after decompressing a section, so
1179 dwarf2_per_objfile can record its new, uncompressed size. */
1182 dwarf2_resize_section (asection
*sectp
, bfd_size_type new_size
)
1184 if (section_is_p (sectp
, INFO_SECTION
))
1185 dwarf2_per_objfile
->info_size
= new_size
;
1186 else if (section_is_p (sectp
, ABBREV_SECTION
))
1187 dwarf2_per_objfile
->abbrev_size
= new_size
;
1188 else if (section_is_p (sectp
, LINE_SECTION
))
1189 dwarf2_per_objfile
->line_size
= new_size
;
1190 else if (section_is_p (sectp
, PUBNAMES_SECTION
))
1191 dwarf2_per_objfile
->pubnames_size
= new_size
;
1192 else if (section_is_p (sectp
, ARANGES_SECTION
))
1193 dwarf2_per_objfile
->aranges_size
= new_size
;
1194 else if (section_is_p (sectp
, LOC_SECTION
))
1195 dwarf2_per_objfile
->loc_size
= new_size
;
1196 else if (section_is_p (sectp
, MACINFO_SECTION
))
1197 dwarf2_per_objfile
->macinfo_size
= new_size
;
1198 else if (section_is_p (sectp
, STR_SECTION
))
1199 dwarf2_per_objfile
->str_size
= new_size
;
1200 else if (section_is_p (sectp
, FRAME_SECTION
))
1201 dwarf2_per_objfile
->frame_size
= new_size
;
1202 else if (section_is_p (sectp
, EH_FRAME_SECTION
))
1203 dwarf2_per_objfile
->eh_frame_size
= new_size
;
1204 else if (section_is_p (sectp
, RANGES_SECTION
))
1205 dwarf2_per_objfile
->ranges_size
= new_size
;
1207 internal_error (__FILE__
, __LINE__
,
1208 _("dwarf2_resize_section: missing section_is_p check: %s"),
1212 /* Build a partial symbol table. */
1215 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1217 /* We definitely need the .debug_info and .debug_abbrev sections */
1219 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1220 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1222 if (dwarf_line_section
)
1223 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1225 dwarf2_per_objfile
->line_buffer
= NULL
;
1227 if (dwarf_str_section
)
1228 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1230 dwarf2_per_objfile
->str_buffer
= NULL
;
1232 if (dwarf_macinfo_section
)
1233 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1234 dwarf_macinfo_section
);
1236 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1238 if (dwarf_ranges_section
)
1239 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1241 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1243 if (dwarf_loc_section
)
1244 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1246 dwarf2_per_objfile
->loc_buffer
= NULL
;
1249 || (objfile
->global_psymbols
.size
== 0
1250 && objfile
->static_psymbols
.size
== 0))
1252 init_psymbol_list (objfile
, 1024);
1256 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1258 /* Things are significantly easier if we have .debug_aranges and
1259 .debug_pubnames sections */
1261 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1265 /* only test this case for now */
1267 /* In this case we have to work a bit harder */
1268 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1273 /* Build the partial symbol table from the information in the
1274 .debug_pubnames and .debug_aranges sections. */
1277 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1279 bfd
*abfd
= objfile
->obfd
;
1280 char *aranges_buffer
, *pubnames_buffer
;
1281 char *aranges_ptr
, *pubnames_ptr
;
1282 unsigned int entry_length
, version
, info_offset
, info_size
;
1284 pubnames_buffer
= dwarf2_read_section (objfile
,
1285 dwarf_pubnames_section
);
1286 pubnames_ptr
= pubnames_buffer
;
1287 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1289 struct comp_unit_head cu_header
;
1290 unsigned int bytes_read
;
1292 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1294 pubnames_ptr
+= bytes_read
;
1295 version
= read_1_byte (abfd
, pubnames_ptr
);
1297 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1299 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1303 aranges_buffer
= dwarf2_read_section (objfile
,
1304 dwarf_aranges_section
);
1309 /* Read in the comp unit header information from the debug_info at
1313 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1314 gdb_byte
*info_ptr
, bfd
*abfd
)
1317 unsigned int bytes_read
;
1318 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1320 info_ptr
+= bytes_read
;
1321 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1323 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1325 info_ptr
+= bytes_read
;
1326 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1328 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1329 if (signed_addr
< 0)
1330 internal_error (__FILE__
, __LINE__
,
1331 _("read_comp_unit_head: dwarf from non elf file"));
1332 cu_header
->signed_addr_p
= signed_addr
;
1337 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1340 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1342 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1344 if (header
->version
!= 2 && header
->version
!= 3)
1345 error (_("Dwarf Error: wrong version in compilation unit header "
1346 "(is %d, should be %d) [in module %s]"), header
->version
,
1347 2, bfd_get_filename (abfd
));
1349 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1350 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1351 "(offset 0x%lx + 6) [in module %s]"),
1352 (long) header
->abbrev_offset
,
1353 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1354 bfd_get_filename (abfd
));
1356 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1357 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1358 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1359 "(offset 0x%lx + 0) [in module %s]"),
1360 (long) header
->length
,
1361 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1362 bfd_get_filename (abfd
));
1367 /* Allocate a new partial symtab for file named NAME and mark this new
1368 partial symtab as being an include of PST. */
1371 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1372 struct objfile
*objfile
)
1374 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1376 subpst
->section_offsets
= pst
->section_offsets
;
1377 subpst
->textlow
= 0;
1378 subpst
->texthigh
= 0;
1380 subpst
->dependencies
= (struct partial_symtab
**)
1381 obstack_alloc (&objfile
->objfile_obstack
,
1382 sizeof (struct partial_symtab
*));
1383 subpst
->dependencies
[0] = pst
;
1384 subpst
->number_of_dependencies
= 1;
1386 subpst
->globals_offset
= 0;
1387 subpst
->n_global_syms
= 0;
1388 subpst
->statics_offset
= 0;
1389 subpst
->n_static_syms
= 0;
1390 subpst
->symtab
= NULL
;
1391 subpst
->read_symtab
= pst
->read_symtab
;
1394 /* No private part is necessary for include psymtabs. This property
1395 can be used to differentiate between such include psymtabs and
1396 the regular ones. */
1397 subpst
->read_symtab_private
= NULL
;
1400 /* Read the Line Number Program data and extract the list of files
1401 included by the source file represented by PST. Build an include
1402 partial symtab for each of these included files.
1404 This procedure assumes that there *is* a Line Number Program in
1405 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1406 before calling this procedure. */
1409 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1410 struct partial_die_info
*pdi
,
1411 struct partial_symtab
*pst
)
1413 struct objfile
*objfile
= cu
->objfile
;
1414 bfd
*abfd
= objfile
->obfd
;
1415 struct line_header
*lh
;
1417 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1419 return; /* No linetable, so no includes. */
1421 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1423 free_line_header (lh
);
1427 /* Build the partial symbol table by doing a quick pass through the
1428 .debug_info and .debug_abbrev sections. */
1431 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1433 /* Instead of reading this into a big buffer, we should probably use
1434 mmap() on architectures that support it. (FIXME) */
1435 bfd
*abfd
= objfile
->obfd
;
1437 gdb_byte
*beg_of_comp_unit
;
1438 struct partial_die_info comp_unit_die
;
1439 struct partial_symtab
*pst
;
1440 struct cleanup
*back_to
;
1441 CORE_ADDR lowpc
, highpc
, baseaddr
;
1443 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1445 /* Any cached compilation units will be linked by the per-objfile
1446 read_in_chain. Make sure to free them when we're done. */
1447 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1449 create_all_comp_units (objfile
);
1451 objfile
->psymtabs_addrmap
= addrmap_create_mutable
1452 (&objfile
->objfile_obstack
);
1454 /* Since the objects we're extracting from .debug_info vary in
1455 length, only the individual functions to extract them (like
1456 read_comp_unit_head and load_partial_die) can really know whether
1457 the buffer is large enough to hold another complete object.
1459 At the moment, they don't actually check that. If .debug_info
1460 holds just one extra byte after the last compilation unit's dies,
1461 then read_comp_unit_head will happily read off the end of the
1462 buffer. read_partial_die is similarly casual. Those functions
1465 For this loop condition, simply checking whether there's any data
1466 left at all should be sufficient. */
1467 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1468 + dwarf2_per_objfile
->info_size
))
1470 struct cleanup
*back_to_inner
;
1471 struct dwarf2_cu cu
;
1472 struct abbrev_info
*abbrev
;
1473 unsigned int bytes_read
;
1474 struct dwarf2_per_cu_data
*this_cu
;
1476 beg_of_comp_unit
= info_ptr
;
1478 memset (&cu
, 0, sizeof (cu
));
1480 obstack_init (&cu
.comp_unit_obstack
);
1482 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1484 cu
.objfile
= objfile
;
1485 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1487 /* Complete the cu_header */
1488 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1489 cu
.header
.first_die_ptr
= info_ptr
;
1490 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1492 cu
.list_in_scope
= &file_symbols
;
1494 /* Read the abbrevs for this compilation unit into a table */
1495 dwarf2_read_abbrevs (abfd
, &cu
);
1496 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1498 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1500 /* Read the compilation unit die */
1501 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1502 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1503 abfd
, info_ptr
, &cu
);
1505 if (comp_unit_die
.tag
== DW_TAG_partial_unit
)
1507 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1508 + cu
.header
.initial_length_size
);
1509 do_cleanups (back_to_inner
);
1513 /* Set the language we're debugging */
1514 set_cu_language (comp_unit_die
.language
, &cu
);
1516 /* Allocate a new partial symbol table structure */
1517 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1518 comp_unit_die
.name
? comp_unit_die
.name
: "",
1519 /* TEXTLOW and TEXTHIGH are set below. */
1521 objfile
->global_psymbols
.next
,
1522 objfile
->static_psymbols
.next
);
1524 if (comp_unit_die
.dirname
)
1525 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1527 pst
->read_symtab_private
= (char *) this_cu
;
1529 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1531 /* Store the function that reads in the rest of the symbol table */
1532 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1534 /* If this compilation unit was already read in, free the
1535 cached copy in order to read it in again. This is
1536 necessary because we skipped some symbols when we first
1537 read in the compilation unit (see load_partial_dies).
1538 This problem could be avoided, but the benefit is
1540 if (this_cu
->cu
!= NULL
)
1541 free_one_cached_comp_unit (this_cu
->cu
);
1543 cu
.per_cu
= this_cu
;
1545 /* Note that this is a pointer to our stack frame, being
1546 added to a global data structure. It will be cleaned up
1547 in free_stack_comp_unit when we finish with this
1548 compilation unit. */
1551 this_cu
->psymtab
= pst
;
1553 /* Possibly set the default values of LOWPC and HIGHPC from
1555 if (cu
.has_ranges_offset
)
1557 if (dwarf2_ranges_read (cu
.ranges_offset
, &comp_unit_die
.lowpc
,
1558 &comp_unit_die
.highpc
, &cu
, pst
))
1559 comp_unit_die
.has_pc_info
= 1;
1562 /* Check if comp unit has_children.
1563 If so, read the rest of the partial symbols from this comp unit.
1564 If not, there's no more debug_info for this comp unit. */
1565 if (comp_unit_die
.has_children
)
1567 struct partial_die_info
*first_die
;
1569 lowpc
= ((CORE_ADDR
) -1);
1570 highpc
= ((CORE_ADDR
) 0);
1572 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1574 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1576 /* If we didn't find a lowpc, set it to highpc to avoid
1577 complaints from `maint check'. */
1578 if (lowpc
== ((CORE_ADDR
) -1))
1581 /* If the compilation unit didn't have an explicit address range,
1582 then use the information extracted from its child dies. */
1583 if (! comp_unit_die
.has_pc_info
)
1585 comp_unit_die
.lowpc
= lowpc
;
1586 comp_unit_die
.highpc
= highpc
;
1589 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1590 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1592 /* Store the contiguous range; `DW_AT_ranges' range is stored above. The
1593 range can be also empty for CUs with no code. */
1594 if (!cu
.has_ranges_offset
&& pst
->textlow
< pst
->texthigh
)
1595 addrmap_set_empty (objfile
->psymtabs_addrmap
, pst
->textlow
,
1596 pst
->texthigh
- 1, pst
);
1598 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1599 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1600 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1601 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1602 sort_pst_symbols (pst
);
1604 /* If there is already a psymtab or symtab for a file of this
1605 name, remove it. (If there is a symtab, more drastic things
1606 also happen.) This happens in VxWorks. */
1607 free_named_symtabs (pst
->filename
);
1609 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1610 + cu
.header
.initial_length_size
;
1612 if (comp_unit_die
.has_stmt_list
)
1614 /* Get the list of files included in the current compilation unit,
1615 and build a psymtab for each of them. */
1616 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1619 do_cleanups (back_to_inner
);
1622 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
1623 &objfile
->objfile_obstack
);
1625 do_cleanups (back_to
);
1628 /* Load the DIEs for a secondary CU into memory. */
1631 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1633 bfd
*abfd
= objfile
->obfd
;
1634 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1635 struct partial_die_info comp_unit_die
;
1636 struct dwarf2_cu
*cu
;
1637 struct abbrev_info
*abbrev
;
1638 unsigned int bytes_read
;
1639 struct cleanup
*back_to
;
1641 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1642 beg_of_comp_unit
= info_ptr
;
1644 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1645 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1647 obstack_init (&cu
->comp_unit_obstack
);
1649 cu
->objfile
= objfile
;
1650 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1652 /* Complete the cu_header. */
1653 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1654 cu
->header
.first_die_ptr
= info_ptr
;
1655 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1657 /* Read the abbrevs for this compilation unit into a table. */
1658 dwarf2_read_abbrevs (abfd
, cu
);
1659 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1661 /* Read the compilation unit die. */
1662 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1663 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1664 abfd
, info_ptr
, cu
);
1666 /* Set the language we're debugging. */
1667 set_cu_language (comp_unit_die
.language
, cu
);
1669 /* Link this compilation unit into the compilation unit tree. */
1671 cu
->per_cu
= this_cu
;
1672 cu
->type_hash
= cu
->per_cu
->type_hash
;
1674 /* Check if comp unit has_children.
1675 If so, read the rest of the partial symbols from this comp unit.
1676 If not, there's no more debug_info for this comp unit. */
1677 if (comp_unit_die
.has_children
)
1678 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1680 do_cleanups (back_to
);
1683 /* Create a list of all compilation units in OBJFILE. We do this only
1684 if an inter-comp-unit reference is found; presumably if there is one,
1685 there will be many, and one will occur early in the .debug_info section.
1686 So there's no point in building this list incrementally. */
1689 create_all_comp_units (struct objfile
*objfile
)
1693 struct dwarf2_per_cu_data
**all_comp_units
;
1694 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1698 all_comp_units
= xmalloc (n_allocated
1699 * sizeof (struct dwarf2_per_cu_data
*));
1701 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1703 struct comp_unit_head cu_header
;
1704 gdb_byte
*beg_of_comp_unit
;
1705 struct dwarf2_per_cu_data
*this_cu
;
1706 unsigned long offset
;
1707 unsigned int bytes_read
;
1709 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1711 /* Read just enough information to find out where the next
1712 compilation unit is. */
1713 cu_header
.initial_length_size
= 0;
1714 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1715 &cu_header
, &bytes_read
);
1717 /* Save the compilation unit for later lookup. */
1718 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1719 sizeof (struct dwarf2_per_cu_data
));
1720 memset (this_cu
, 0, sizeof (*this_cu
));
1721 this_cu
->offset
= offset
;
1722 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1724 if (n_comp_units
== n_allocated
)
1727 all_comp_units
= xrealloc (all_comp_units
,
1729 * sizeof (struct dwarf2_per_cu_data
*));
1731 all_comp_units
[n_comp_units
++] = this_cu
;
1733 info_ptr
= info_ptr
+ this_cu
->length
;
1736 dwarf2_per_objfile
->all_comp_units
1737 = obstack_alloc (&objfile
->objfile_obstack
,
1738 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1739 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1740 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1741 xfree (all_comp_units
);
1742 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1745 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1746 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1750 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1751 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1753 struct objfile
*objfile
= cu
->objfile
;
1754 bfd
*abfd
= objfile
->obfd
;
1755 struct partial_die_info
*pdi
;
1757 /* Now, march along the PDI's, descending into ones which have
1758 interesting children but skipping the children of the other ones,
1759 until we reach the end of the compilation unit. */
1765 fixup_partial_die (pdi
, cu
);
1767 /* Anonymous namespaces have no name but have interesting
1768 children, so we need to look at them. Ditto for anonymous
1771 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1772 || pdi
->tag
== DW_TAG_enumeration_type
)
1776 case DW_TAG_subprogram
:
1777 if (pdi
->has_pc_info
)
1779 if (pdi
->lowpc
< *lowpc
)
1781 *lowpc
= pdi
->lowpc
;
1783 if (pdi
->highpc
> *highpc
)
1785 *highpc
= pdi
->highpc
;
1787 if (!pdi
->is_declaration
)
1789 add_partial_symbol (pdi
, cu
);
1793 case DW_TAG_variable
:
1794 case DW_TAG_typedef
:
1795 case DW_TAG_union_type
:
1796 if (!pdi
->is_declaration
)
1798 add_partial_symbol (pdi
, cu
);
1801 case DW_TAG_class_type
:
1802 case DW_TAG_interface_type
:
1803 case DW_TAG_structure_type
:
1804 if (!pdi
->is_declaration
)
1806 add_partial_symbol (pdi
, cu
);
1809 case DW_TAG_enumeration_type
:
1810 if (!pdi
->is_declaration
)
1811 add_partial_enumeration (pdi
, cu
);
1813 case DW_TAG_base_type
:
1814 case DW_TAG_subrange_type
:
1815 /* File scope base type definitions are added to the partial
1817 add_partial_symbol (pdi
, cu
);
1819 case DW_TAG_namespace
:
1820 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1827 /* If the die has a sibling, skip to the sibling. */
1829 pdi
= pdi
->die_sibling
;
1833 /* Functions used to compute the fully scoped name of a partial DIE.
1835 Normally, this is simple. For C++, the parent DIE's fully scoped
1836 name is concatenated with "::" and the partial DIE's name. For
1837 Java, the same thing occurs except that "." is used instead of "::".
1838 Enumerators are an exception; they use the scope of their parent
1839 enumeration type, i.e. the name of the enumeration type is not
1840 prepended to the enumerator.
1842 There are two complexities. One is DW_AT_specification; in this
1843 case "parent" means the parent of the target of the specification,
1844 instead of the direct parent of the DIE. The other is compilers
1845 which do not emit DW_TAG_namespace; in this case we try to guess
1846 the fully qualified name of structure types from their members'
1847 linkage names. This must be done using the DIE's children rather
1848 than the children of any DW_AT_specification target. We only need
1849 to do this for structures at the top level, i.e. if the target of
1850 any DW_AT_specification (if any; otherwise the DIE itself) does not
1853 /* Compute the scope prefix associated with PDI's parent, in
1854 compilation unit CU. The result will be allocated on CU's
1855 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1856 field. NULL is returned if no prefix is necessary. */
1858 partial_die_parent_scope (struct partial_die_info
*pdi
,
1859 struct dwarf2_cu
*cu
)
1861 char *grandparent_scope
;
1862 struct partial_die_info
*parent
, *real_pdi
;
1864 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1865 then this means the parent of the specification DIE. */
1868 while (real_pdi
->has_specification
)
1869 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1871 parent
= real_pdi
->die_parent
;
1875 if (parent
->scope_set
)
1876 return parent
->scope
;
1878 fixup_partial_die (parent
, cu
);
1880 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1882 if (parent
->tag
== DW_TAG_namespace
1883 || parent
->tag
== DW_TAG_structure_type
1884 || parent
->tag
== DW_TAG_class_type
1885 || parent
->tag
== DW_TAG_interface_type
1886 || parent
->tag
== DW_TAG_union_type
)
1888 if (grandparent_scope
== NULL
)
1889 parent
->scope
= parent
->name
;
1891 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1894 else if (parent
->tag
== DW_TAG_enumeration_type
)
1895 /* Enumerators should not get the name of the enumeration as a prefix. */
1896 parent
->scope
= grandparent_scope
;
1899 /* FIXME drow/2004-04-01: What should we be doing with
1900 function-local names? For partial symbols, we should probably be
1902 complaint (&symfile_complaints
,
1903 _("unhandled containing DIE tag %d for DIE at %d"),
1904 parent
->tag
, pdi
->offset
);
1905 parent
->scope
= grandparent_scope
;
1908 parent
->scope_set
= 1;
1909 return parent
->scope
;
1912 /* Return the fully scoped name associated with PDI, from compilation unit
1913 CU. The result will be allocated with malloc. */
1915 partial_die_full_name (struct partial_die_info
*pdi
,
1916 struct dwarf2_cu
*cu
)
1920 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1921 if (parent_scope
== NULL
)
1924 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1928 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1930 struct objfile
*objfile
= cu
->objfile
;
1932 char *actual_name
= NULL
;
1933 const char *my_prefix
;
1934 const struct partial_symbol
*psym
= NULL
;
1936 int built_actual_name
= 0;
1938 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1940 if (pdi_needs_namespace (pdi
->tag
))
1942 actual_name
= partial_die_full_name (pdi
, cu
);
1944 built_actual_name
= 1;
1947 if (actual_name
== NULL
)
1948 actual_name
= pdi
->name
;
1952 case DW_TAG_subprogram
:
1953 if (pdi
->is_external
|| cu
->language
== language_ada
)
1955 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
1956 of the global scope. But in Ada, we want to be able to access
1957 nested procedures globally. So all Ada subprograms are stored
1958 in the global scope. */
1959 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1960 mst_text, objfile); */
1961 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1962 VAR_DOMAIN
, LOC_BLOCK
,
1963 &objfile
->global_psymbols
,
1964 0, pdi
->lowpc
+ baseaddr
,
1965 cu
->language
, objfile
);
1969 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1970 mst_file_text, objfile); */
1971 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1972 VAR_DOMAIN
, LOC_BLOCK
,
1973 &objfile
->static_psymbols
,
1974 0, pdi
->lowpc
+ baseaddr
,
1975 cu
->language
, objfile
);
1978 case DW_TAG_variable
:
1979 if (pdi
->is_external
)
1982 Don't enter into the minimal symbol tables as there is
1983 a minimal symbol table entry from the ELF symbols already.
1984 Enter into partial symbol table if it has a location
1985 descriptor or a type.
1986 If the location descriptor is missing, new_symbol will create
1987 a LOC_UNRESOLVED symbol, the address of the variable will then
1988 be determined from the minimal symbol table whenever the variable
1990 The address for the partial symbol table entry is not
1991 used by GDB, but it comes in handy for debugging partial symbol
1995 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1996 if (pdi
->locdesc
|| pdi
->has_type
)
1997 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1998 VAR_DOMAIN
, LOC_STATIC
,
1999 &objfile
->global_psymbols
,
2001 cu
->language
, objfile
);
2005 /* Static Variable. Skip symbols without location descriptors. */
2006 if (pdi
->locdesc
== NULL
)
2008 if (built_actual_name
)
2009 xfree (actual_name
);
2012 addr
= decode_locdesc (pdi
->locdesc
, cu
);
2013 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
2014 mst_file_data, objfile); */
2015 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2016 VAR_DOMAIN
, LOC_STATIC
,
2017 &objfile
->static_psymbols
,
2019 cu
->language
, objfile
);
2022 case DW_TAG_typedef
:
2023 case DW_TAG_base_type
:
2024 case DW_TAG_subrange_type
:
2025 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2026 VAR_DOMAIN
, LOC_TYPEDEF
,
2027 &objfile
->static_psymbols
,
2028 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2030 case DW_TAG_namespace
:
2031 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2032 VAR_DOMAIN
, LOC_TYPEDEF
,
2033 &objfile
->global_psymbols
,
2034 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2036 case DW_TAG_class_type
:
2037 case DW_TAG_interface_type
:
2038 case DW_TAG_structure_type
:
2039 case DW_TAG_union_type
:
2040 case DW_TAG_enumeration_type
:
2041 /* Skip external references. The DWARF standard says in the section
2042 about "Structure, Union, and Class Type Entries": "An incomplete
2043 structure, union or class type is represented by a structure,
2044 union or class entry that does not have a byte size attribute
2045 and that has a DW_AT_declaration attribute." */
2046 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
2048 if (built_actual_name
)
2049 xfree (actual_name
);
2053 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
2054 static vs. global. */
2055 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2056 STRUCT_DOMAIN
, LOC_TYPEDEF
,
2057 (cu
->language
== language_cplus
2058 || cu
->language
== language_java
)
2059 ? &objfile
->global_psymbols
2060 : &objfile
->static_psymbols
,
2061 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2064 case DW_TAG_enumerator
:
2065 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2066 VAR_DOMAIN
, LOC_CONST
,
2067 (cu
->language
== language_cplus
2068 || cu
->language
== language_java
)
2069 ? &objfile
->global_psymbols
2070 : &objfile
->static_psymbols
,
2071 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2077 /* Check to see if we should scan the name for possible namespace
2078 info. Only do this if this is C++, if we don't have namespace
2079 debugging info in the file, if the psym is of an appropriate type
2080 (otherwise we'll have psym == NULL), and if we actually had a
2081 mangled name to begin with. */
2083 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2084 cases which do not set PSYM above? */
2086 if (cu
->language
== language_cplus
2087 && cu
->has_namespace_info
== 0
2089 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2090 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2093 if (built_actual_name
)
2094 xfree (actual_name
);
2097 /* Determine whether a die of type TAG living in a C++ class or
2098 namespace needs to have the name of the scope prepended to the
2099 name listed in the die. */
2102 pdi_needs_namespace (enum dwarf_tag tag
)
2106 case DW_TAG_namespace
:
2107 case DW_TAG_typedef
:
2108 case DW_TAG_class_type
:
2109 case DW_TAG_interface_type
:
2110 case DW_TAG_structure_type
:
2111 case DW_TAG_union_type
:
2112 case DW_TAG_enumeration_type
:
2113 case DW_TAG_enumerator
:
2120 /* Read a partial die corresponding to a namespace; also, add a symbol
2121 corresponding to that namespace to the symbol table. NAMESPACE is
2122 the name of the enclosing namespace. */
2125 add_partial_namespace (struct partial_die_info
*pdi
,
2126 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2127 struct dwarf2_cu
*cu
)
2129 struct objfile
*objfile
= cu
->objfile
;
2131 /* Add a symbol for the namespace. */
2133 add_partial_symbol (pdi
, cu
);
2135 /* Now scan partial symbols in that namespace. */
2137 if (pdi
->has_children
)
2138 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2141 /* See if we can figure out if the class lives in a namespace. We do
2142 this by looking for a member function; its demangled name will
2143 contain namespace info, if there is any. */
2146 guess_structure_name (struct partial_die_info
*struct_pdi
,
2147 struct dwarf2_cu
*cu
)
2149 if ((cu
->language
== language_cplus
2150 || cu
->language
== language_java
)
2151 && cu
->has_namespace_info
== 0
2152 && struct_pdi
->has_children
)
2154 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2155 what template types look like, because the demangler
2156 frequently doesn't give the same name as the debug info. We
2157 could fix this by only using the demangled name to get the
2158 prefix (but see comment in read_structure_type). */
2160 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2161 struct partial_die_info
*real_pdi
;
2163 /* If this DIE (this DIE's specification, if any) has a parent, then
2164 we should not do this. We'll prepend the parent's fully qualified
2165 name when we create the partial symbol. */
2167 real_pdi
= struct_pdi
;
2168 while (real_pdi
->has_specification
)
2169 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2171 if (real_pdi
->die_parent
!= NULL
)
2174 while (child_pdi
!= NULL
)
2176 if (child_pdi
->tag
== DW_TAG_subprogram
)
2178 char *actual_class_name
2179 = language_class_name_from_physname (cu
->language_defn
,
2181 if (actual_class_name
!= NULL
)
2184 = obsavestring (actual_class_name
,
2185 strlen (actual_class_name
),
2186 &cu
->comp_unit_obstack
);
2187 xfree (actual_class_name
);
2192 child_pdi
= child_pdi
->die_sibling
;
2197 /* Read a partial die corresponding to an enumeration type. */
2200 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2201 struct dwarf2_cu
*cu
)
2203 struct objfile
*objfile
= cu
->objfile
;
2204 bfd
*abfd
= objfile
->obfd
;
2205 struct partial_die_info
*pdi
;
2207 if (enum_pdi
->name
!= NULL
)
2208 add_partial_symbol (enum_pdi
, cu
);
2210 pdi
= enum_pdi
->die_child
;
2213 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2214 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2216 add_partial_symbol (pdi
, cu
);
2217 pdi
= pdi
->die_sibling
;
2221 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2222 Return the corresponding abbrev, or NULL if the number is zero (indicating
2223 an empty DIE). In either case *BYTES_READ will be set to the length of
2224 the initial number. */
2226 static struct abbrev_info
*
2227 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2228 struct dwarf2_cu
*cu
)
2230 bfd
*abfd
= cu
->objfile
->obfd
;
2231 unsigned int abbrev_number
;
2232 struct abbrev_info
*abbrev
;
2234 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2236 if (abbrev_number
== 0)
2239 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2242 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2243 bfd_get_filename (abfd
));
2249 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2250 pointer to the end of a series of DIEs, terminated by an empty
2251 DIE. Any children of the skipped DIEs will also be skipped. */
2254 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2256 struct abbrev_info
*abbrev
;
2257 unsigned int bytes_read
;
2261 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2263 return info_ptr
+ bytes_read
;
2265 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2269 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2270 should point just after the initial uleb128 of a DIE, and the
2271 abbrev corresponding to that skipped uleb128 should be passed in
2272 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2276 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2277 struct dwarf2_cu
*cu
)
2279 unsigned int bytes_read
;
2280 struct attribute attr
;
2281 bfd
*abfd
= cu
->objfile
->obfd
;
2282 unsigned int form
, i
;
2284 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2286 /* The only abbrev we care about is DW_AT_sibling. */
2287 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2289 read_attribute (&attr
, &abbrev
->attrs
[i
],
2290 abfd
, info_ptr
, cu
);
2291 if (attr
.form
== DW_FORM_ref_addr
)
2292 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2294 return dwarf2_per_objfile
->info_buffer
2295 + dwarf2_get_ref_die_offset (&attr
, cu
);
2298 /* If it isn't DW_AT_sibling, skip this attribute. */
2299 form
= abbrev
->attrs
[i
].form
;
2304 case DW_FORM_ref_addr
:
2305 info_ptr
+= cu
->header
.addr_size
;
2324 case DW_FORM_string
:
2325 read_string (abfd
, info_ptr
, &bytes_read
);
2326 info_ptr
+= bytes_read
;
2329 info_ptr
+= cu
->header
.offset_size
;
2332 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2333 info_ptr
+= bytes_read
;
2335 case DW_FORM_block1
:
2336 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2338 case DW_FORM_block2
:
2339 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2341 case DW_FORM_block4
:
2342 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2346 case DW_FORM_ref_udata
:
2347 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2349 case DW_FORM_indirect
:
2350 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2351 info_ptr
+= bytes_read
;
2352 /* We need to continue parsing from here, so just go back to
2354 goto skip_attribute
;
2357 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2358 dwarf_form_name (form
),
2359 bfd_get_filename (abfd
));
2363 if (abbrev
->has_children
)
2364 return skip_children (info_ptr
, cu
);
2369 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2370 the next DIE after ORIG_PDI. */
2373 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2374 bfd
*abfd
, struct dwarf2_cu
*cu
)
2376 /* Do we know the sibling already? */
2378 if (orig_pdi
->sibling
)
2379 return orig_pdi
->sibling
;
2381 /* Are there any children to deal with? */
2383 if (!orig_pdi
->has_children
)
2386 /* Skip the children the long way. */
2388 return skip_children (info_ptr
, cu
);
2391 /* Expand this partial symbol table into a full symbol table. */
2394 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2396 /* FIXME: This is barely more than a stub. */
2401 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2407 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2408 gdb_flush (gdb_stdout
);
2411 /* Restore our global data. */
2412 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2413 dwarf2_objfile_data_key
);
2415 psymtab_to_symtab_1 (pst
);
2417 /* Finish up the debug error message. */
2419 printf_filtered (_("done.\n"));
2424 /* Add PER_CU to the queue. */
2427 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2429 struct dwarf2_queue_item
*item
;
2432 item
= xmalloc (sizeof (*item
));
2433 item
->per_cu
= per_cu
;
2436 if (dwarf2_queue
== NULL
)
2437 dwarf2_queue
= item
;
2439 dwarf2_queue_tail
->next
= item
;
2441 dwarf2_queue_tail
= item
;
2443 /* Either PER_CU is the CU we want to process, or we're following a reference
2444 pointing into PER_CU. Either way, we need its DIEs now. */
2445 load_full_comp_unit (item
->per_cu
, objfile
);
2446 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2447 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2450 /* Process the queue. */
2453 process_queue (struct objfile
*objfile
)
2455 struct dwarf2_queue_item
*item
, *next_item
;
2457 /* The queue starts out with one item, but following a DIE reference
2458 may load a new CU, adding it to the end of the queue. */
2459 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2461 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2462 process_full_comp_unit (item
->per_cu
);
2464 item
->per_cu
->queued
= 0;
2465 next_item
= item
->next
;
2469 dwarf2_queue_tail
= NULL
;
2472 /* Free all allocated queue entries. This function only releases anything if
2473 an error was thrown; if the queue was processed then it would have been
2474 freed as we went along. */
2477 dwarf2_release_queue (void *dummy
)
2479 struct dwarf2_queue_item
*item
, *last
;
2481 item
= dwarf2_queue
;
2484 /* Anything still marked queued is likely to be in an
2485 inconsistent state, so discard it. */
2486 if (item
->per_cu
->queued
)
2488 if (item
->per_cu
->cu
!= NULL
)
2489 free_one_cached_comp_unit (item
->per_cu
->cu
);
2490 item
->per_cu
->queued
= 0;
2498 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2501 /* Read in full symbols for PST, and anything it depends on. */
2504 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2506 struct dwarf2_per_cu_data
*per_cu
;
2507 struct cleanup
*back_to
;
2510 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2511 if (!pst
->dependencies
[i
]->readin
)
2513 /* Inform about additional files that need to be read in. */
2516 /* FIXME: i18n: Need to make this a single string. */
2517 fputs_filtered (" ", gdb_stdout
);
2519 fputs_filtered ("and ", gdb_stdout
);
2521 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2522 wrap_here (""); /* Flush output */
2523 gdb_flush (gdb_stdout
);
2525 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2528 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2532 /* It's an include file, no symbols to read for it.
2533 Everything is in the parent symtab. */
2538 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2540 queue_comp_unit (per_cu
, pst
->objfile
);
2542 process_queue (pst
->objfile
);
2544 /* Age the cache, releasing compilation units that have not
2545 been used recently. */
2546 age_cached_comp_units ();
2548 do_cleanups (back_to
);
2551 /* Load the DIEs associated with PST and PER_CU into memory. */
2553 static struct dwarf2_cu
*
2554 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2556 bfd
*abfd
= objfile
->obfd
;
2557 struct dwarf2_cu
*cu
;
2558 unsigned long offset
;
2560 struct cleanup
*back_to
, *free_cu_cleanup
;
2561 struct attribute
*attr
;
2564 /* Set local variables from the partial symbol table info. */
2565 offset
= per_cu
->offset
;
2567 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2569 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2570 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2572 /* If an error occurs while loading, release our storage. */
2573 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2575 cu
->objfile
= objfile
;
2577 /* read in the comp_unit header */
2578 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2580 /* Read the abbrevs for this compilation unit */
2581 dwarf2_read_abbrevs (abfd
, cu
);
2582 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2584 cu
->header
.offset
= offset
;
2586 cu
->per_cu
= per_cu
;
2588 cu
->type_hash
= per_cu
->type_hash
;
2590 /* We use this obstack for block values in dwarf_alloc_block. */
2591 obstack_init (&cu
->comp_unit_obstack
);
2593 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2595 /* We try not to read any attributes in this function, because not
2596 all objfiles needed for references have been loaded yet, and symbol
2597 table processing isn't initialized. But we have to set the CU language,
2598 or we won't be able to build types correctly. */
2599 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2601 set_cu_language (DW_UNSND (attr
), cu
);
2603 set_cu_language (language_minimal
, cu
);
2605 do_cleanups (back_to
);
2607 /* We've successfully allocated this compilation unit. Let our caller
2608 clean it up when finished with it. */
2609 discard_cleanups (free_cu_cleanup
);
2614 /* Generate full symbol information for PST and CU, whose DIEs have
2615 already been loaded into memory. */
2618 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2620 struct partial_symtab
*pst
= per_cu
->psymtab
;
2621 struct dwarf2_cu
*cu
= per_cu
->cu
;
2622 struct objfile
*objfile
= pst
->objfile
;
2623 bfd
*abfd
= objfile
->obfd
;
2624 CORE_ADDR lowpc
, highpc
;
2625 struct symtab
*symtab
;
2626 struct cleanup
*back_to
;
2627 struct attribute
*attr
;
2630 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2632 /* We're in the global namespace. */
2633 processing_current_prefix
= "";
2636 back_to
= make_cleanup (really_free_pendings
, NULL
);
2638 cu
->list_in_scope
= &file_symbols
;
2640 /* Find the base address of the compilation unit for range lists and
2641 location lists. It will normally be specified by DW_AT_low_pc.
2642 In DWARF-3 draft 4, the base address could be overridden by
2643 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2644 compilation units with discontinuous ranges. */
2646 cu
->header
.base_known
= 0;
2647 cu
->header
.base_address
= 0;
2649 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2652 cu
->header
.base_address
= DW_ADDR (attr
);
2653 cu
->header
.base_known
= 1;
2657 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2660 cu
->header
.base_address
= DW_ADDR (attr
);
2661 cu
->header
.base_known
= 1;
2665 /* Do line number decoding in read_file_scope () */
2666 process_die (cu
->dies
, cu
);
2668 /* Some compilers don't define a DW_AT_high_pc attribute for the
2669 compilation unit. If the DW_AT_high_pc is missing, synthesize
2670 it, by scanning the DIE's below the compilation unit. */
2671 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2673 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2675 /* Set symtab language to language from DW_AT_language.
2676 If the compilation is from a C file generated by language preprocessors,
2677 do not set the language if it was already deduced by start_subfile. */
2679 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2681 symtab
->language
= cu
->language
;
2683 pst
->symtab
= symtab
;
2686 do_cleanups (back_to
);
2689 /* Process a die and its children. */
2692 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2696 case DW_TAG_padding
:
2698 case DW_TAG_compile_unit
:
2699 read_file_scope (die
, cu
);
2701 case DW_TAG_subprogram
:
2702 read_func_scope (die
, cu
);
2704 case DW_TAG_inlined_subroutine
:
2705 /* FIXME: These are ignored for now.
2706 They could be used to set breakpoints on all inlined instances
2707 of a function and make GDB `next' properly over inlined functions. */
2709 case DW_TAG_lexical_block
:
2710 case DW_TAG_try_block
:
2711 case DW_TAG_catch_block
:
2712 read_lexical_block_scope (die
, cu
);
2714 case DW_TAG_class_type
:
2715 case DW_TAG_interface_type
:
2716 case DW_TAG_structure_type
:
2717 case DW_TAG_union_type
:
2718 process_structure_scope (die
, cu
);
2720 case DW_TAG_enumeration_type
:
2721 process_enumeration_scope (die
, cu
);
2724 /* These dies have a type, but processing them does not create
2725 a symbol or recurse to process the children. Therefore we can
2726 read them on-demand through read_type_die. */
2727 case DW_TAG_subroutine_type
:
2728 case DW_TAG_set_type
:
2729 case DW_TAG_array_type
:
2730 case DW_TAG_pointer_type
:
2731 case DW_TAG_ptr_to_member_type
:
2732 case DW_TAG_reference_type
:
2733 case DW_TAG_string_type
:
2736 case DW_TAG_base_type
:
2737 case DW_TAG_subrange_type
:
2738 /* Add a typedef symbol for the type definition, if it has a
2740 new_symbol (die
, read_type_die (die
, cu
), cu
);
2742 case DW_TAG_common_block
:
2743 read_common_block (die
, cu
);
2745 case DW_TAG_common_inclusion
:
2747 case DW_TAG_namespace
:
2748 processing_has_namespace_info
= 1;
2749 read_namespace (die
, cu
);
2751 case DW_TAG_imported_declaration
:
2752 case DW_TAG_imported_module
:
2753 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2754 information contained in these. DW_TAG_imported_declaration
2755 dies shouldn't have children; DW_TAG_imported_module dies
2756 shouldn't in the C++ case, but conceivably could in the
2757 Fortran case, so we'll have to replace this gdb_assert if
2758 Fortran compilers start generating that info. */
2759 processing_has_namespace_info
= 1;
2760 gdb_assert (die
->child
== NULL
);
2763 new_symbol (die
, NULL
, cu
);
2769 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2771 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2775 free_cu_line_header (void *arg
)
2777 struct dwarf2_cu
*cu
= arg
;
2779 free_line_header (cu
->line_header
);
2780 cu
->line_header
= NULL
;
2784 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2786 struct objfile
*objfile
= cu
->objfile
;
2787 struct comp_unit_head
*cu_header
= &cu
->header
;
2788 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2789 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2790 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2791 struct attribute
*attr
;
2793 char *comp_dir
= NULL
;
2794 struct die_info
*child_die
;
2795 bfd
*abfd
= objfile
->obfd
;
2796 struct line_header
*line_header
= 0;
2799 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2801 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2803 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2804 from finish_block. */
2805 if (lowpc
== ((CORE_ADDR
) -1))
2810 /* Find the filename. Do not use dwarf2_name here, since the filename
2811 is not a source language identifier. */
2812 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2815 name
= DW_STRING (attr
);
2818 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2820 comp_dir
= DW_STRING (attr
);
2821 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
2823 comp_dir
= ldirname (name
);
2824 if (comp_dir
!= NULL
)
2825 make_cleanup (xfree
, comp_dir
);
2827 if (comp_dir
!= NULL
)
2829 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2830 directory, get rid of it. */
2831 char *cp
= strchr (comp_dir
, ':');
2833 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2840 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2843 set_cu_language (DW_UNSND (attr
), cu
);
2846 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2848 cu
->producer
= DW_STRING (attr
);
2850 /* We assume that we're processing GCC output. */
2851 processing_gcc_compilation
= 2;
2853 start_symtab (name
, comp_dir
, lowpc
);
2854 record_debugformat ("DWARF 2");
2855 record_producer (cu
->producer
);
2857 initialize_cu_func_list (cu
);
2859 /* Decode line number information if present. We do this before
2860 processing child DIEs, so that the line header table is available
2861 for DW_AT_decl_file. */
2862 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2865 unsigned int line_offset
= DW_UNSND (attr
);
2866 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2869 cu
->line_header
= line_header
;
2870 make_cleanup (free_cu_line_header
, cu
);
2871 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2875 /* Process all dies in compilation unit. */
2876 if (die
->child
!= NULL
)
2878 child_die
= die
->child
;
2879 while (child_die
&& child_die
->tag
)
2881 process_die (child_die
, cu
);
2882 child_die
= sibling_die (child_die
);
2886 /* Decode macro information, if present. Dwarf 2 macro information
2887 refers to information in the line number info statement program
2888 header, so we can only read it if we've read the header
2890 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2891 if (attr
&& line_header
)
2893 unsigned int macro_offset
= DW_UNSND (attr
);
2894 dwarf_decode_macros (line_header
, macro_offset
,
2895 comp_dir
, abfd
, cu
);
2897 do_cleanups (back_to
);
2901 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2902 struct dwarf2_cu
*cu
)
2904 struct function_range
*thisfn
;
2906 thisfn
= (struct function_range
*)
2907 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2908 thisfn
->name
= name
;
2909 thisfn
->lowpc
= lowpc
;
2910 thisfn
->highpc
= highpc
;
2911 thisfn
->seen_line
= 0;
2912 thisfn
->next
= NULL
;
2914 if (cu
->last_fn
== NULL
)
2915 cu
->first_fn
= thisfn
;
2917 cu
->last_fn
->next
= thisfn
;
2919 cu
->last_fn
= thisfn
;
2923 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2925 struct objfile
*objfile
= cu
->objfile
;
2926 struct context_stack
*new;
2929 struct die_info
*child_die
;
2930 struct attribute
*attr
;
2932 const char *previous_prefix
= processing_current_prefix
;
2933 struct cleanup
*back_to
= NULL
;
2935 struct block
*block
;
2937 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2939 name
= dwarf2_linkage_name (die
, cu
);
2941 /* Ignore functions with missing or empty names and functions with
2942 missing or invalid low and high pc attributes. */
2943 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2946 if (cu
->language
== language_cplus
2947 || cu
->language
== language_java
)
2949 struct dwarf2_cu
*spec_cu
= cu
;
2950 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
2952 /* NOTE: carlton/2004-01-23: We have to be careful in the
2953 presence of DW_AT_specification. For example, with GCC 3.4,
2958 // Definition of N::foo.
2962 then we'll have a tree of DIEs like this:
2964 1: DW_TAG_compile_unit
2965 2: DW_TAG_namespace // N
2966 3: DW_TAG_subprogram // declaration of N::foo
2967 4: DW_TAG_subprogram // definition of N::foo
2968 DW_AT_specification // refers to die #3
2970 Thus, when processing die #4, we have to pretend that we're
2971 in the context of its DW_AT_specification, namely the contex
2974 if (spec_die
!= NULL
)
2976 char *specification_prefix
= determine_prefix (spec_die
, spec_cu
);
2977 processing_current_prefix
= specification_prefix
;
2978 back_to
= make_cleanup (xfree
, specification_prefix
);
2985 /* Record the function range for dwarf_decode_lines. */
2986 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2988 new = push_context (0, lowpc
);
2989 new->name
= new_symbol (die
, read_type_die (die
, cu
), cu
);
2991 /* If there is a location expression for DW_AT_frame_base, record
2993 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2995 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2996 expression is being recorded directly in the function's symbol
2997 and not in a separate frame-base object. I guess this hack is
2998 to avoid adding some sort of frame-base adjunct/annex to the
2999 function's symbol :-(. The problem with doing this is that it
3000 results in a function symbol with a location expression that
3001 has nothing to do with the location of the function, ouch! The
3002 relationship should be: a function's symbol has-a frame base; a
3003 frame-base has-a location expression. */
3004 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
3006 cu
->list_in_scope
= &local_symbols
;
3008 if (die
->child
!= NULL
)
3010 child_die
= die
->child
;
3011 while (child_die
&& child_die
->tag
)
3013 process_die (child_die
, cu
);
3014 child_die
= sibling_die (child_die
);
3018 new = pop_context ();
3019 /* Make a block for the local symbols within. */
3020 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
3021 lowpc
, highpc
, objfile
);
3023 /* If we have address ranges, record them. */
3024 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3026 /* In C++, we can have functions nested inside functions (e.g., when
3027 a function declares a class that has methods). This means that
3028 when we finish processing a function scope, we may need to go
3029 back to building a containing block's symbol lists. */
3030 local_symbols
= new->locals
;
3031 param_symbols
= new->params
;
3033 /* If we've finished processing a top-level function, subsequent
3034 symbols go in the file symbol list. */
3035 if (outermost_context_p ())
3036 cu
->list_in_scope
= &file_symbols
;
3038 processing_current_prefix
= previous_prefix
;
3039 if (back_to
!= NULL
)
3040 do_cleanups (back_to
);
3043 /* Process all the DIES contained within a lexical block scope. Start
3044 a new scope, process the dies, and then close the scope. */
3047 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3049 struct objfile
*objfile
= cu
->objfile
;
3050 struct context_stack
*new;
3051 CORE_ADDR lowpc
, highpc
;
3052 struct die_info
*child_die
;
3055 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3057 /* Ignore blocks with missing or invalid low and high pc attributes. */
3058 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3059 as multiple lexical blocks? Handling children in a sane way would
3060 be nasty. Might be easier to properly extend generic blocks to
3062 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3067 push_context (0, lowpc
);
3068 if (die
->child
!= NULL
)
3070 child_die
= die
->child
;
3071 while (child_die
&& child_die
->tag
)
3073 process_die (child_die
, cu
);
3074 child_die
= sibling_die (child_die
);
3077 new = pop_context ();
3079 if (local_symbols
!= NULL
)
3082 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3085 /* Note that recording ranges after traversing children, as we
3086 do here, means that recording a parent's ranges entails
3087 walking across all its children's ranges as they appear in
3088 the address map, which is quadratic behavior.
3090 It would be nicer to record the parent's ranges before
3091 traversing its children, simply overriding whatever you find
3092 there. But since we don't even decide whether to create a
3093 block until after we've traversed its children, that's hard
3095 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3097 local_symbols
= new->locals
;
3100 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
3101 Return 1 if the attributes are present and valid, otherwise, return 0.
3102 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
3105 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
3106 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
3107 struct partial_symtab
*ranges_pst
)
3109 struct objfile
*objfile
= cu
->objfile
;
3110 struct comp_unit_head
*cu_header
= &cu
->header
;
3111 bfd
*obfd
= objfile
->obfd
;
3112 unsigned int addr_size
= cu_header
->addr_size
;
3113 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3114 /* Base address selection entry. */
3125 found_base
= cu_header
->base_known
;
3126 base
= cu_header
->base_address
;
3128 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3130 complaint (&symfile_complaints
,
3131 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3135 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3137 /* Read in the largest possible address. */
3138 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3139 if ((marker
& mask
) == mask
)
3141 /* If we found the largest possible address, then
3142 read the base address. */
3143 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3144 buffer
+= 2 * addr_size
;
3145 offset
+= 2 * addr_size
;
3151 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3155 CORE_ADDR range_beginning
, range_end
;
3157 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3158 buffer
+= addr_size
;
3159 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3160 buffer
+= addr_size
;
3161 offset
+= 2 * addr_size
;
3163 /* An end of list marker is a pair of zero addresses. */
3164 if (range_beginning
== 0 && range_end
== 0)
3165 /* Found the end of list entry. */
3168 /* Each base address selection entry is a pair of 2 values.
3169 The first is the largest possible address, the second is
3170 the base address. Check for a base address here. */
3171 if ((range_beginning
& mask
) == mask
)
3173 /* If we found the largest possible address, then
3174 read the base address. */
3175 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3182 /* We have no valid base address for the ranges
3184 complaint (&symfile_complaints
,
3185 _("Invalid .debug_ranges data (no base address)"));
3189 range_beginning
+= base
;
3192 if (ranges_pst
!= NULL
&& range_beginning
< range_end
)
3193 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3194 range_beginning
+ baseaddr
, range_end
- 1 + baseaddr
,
3197 /* FIXME: This is recording everything as a low-high
3198 segment of consecutive addresses. We should have a
3199 data structure for discontiguous block ranges
3203 low
= range_beginning
;
3209 if (range_beginning
< low
)
3210 low
= range_beginning
;
3211 if (range_end
> high
)
3217 /* If the first entry is an end-of-list marker, the range
3218 describes an empty scope, i.e. no instructions. */
3224 *high_return
= high
;
3228 /* Get low and high pc attributes from a die. Return 1 if the attributes
3229 are present and valid, otherwise, return 0. Return -1 if the range is
3230 discontinuous, i.e. derived from DW_AT_ranges information. */
3232 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3233 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3235 struct attribute
*attr
;
3240 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3243 high
= DW_ADDR (attr
);
3244 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3246 low
= DW_ADDR (attr
);
3248 /* Found high w/o low attribute. */
3251 /* Found consecutive range of addresses. */
3256 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3259 /* Value of the DW_AT_ranges attribute is the offset in the
3260 .debug_ranges section. */
3261 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, NULL
))
3263 /* Found discontinuous range of addresses. */
3271 /* When using the GNU linker, .gnu.linkonce. sections are used to
3272 eliminate duplicate copies of functions and vtables and such.
3273 The linker will arbitrarily choose one and discard the others.
3274 The AT_*_pc values for such functions refer to local labels in
3275 these sections. If the section from that file was discarded, the
3276 labels are not in the output, so the relocs get a value of 0.
3277 If this is a discarded function, mark the pc bounds as invalid,
3278 so that GDB will ignore it. */
3279 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3287 /* Get the low and high pc's represented by the scope DIE, and store
3288 them in *LOWPC and *HIGHPC. If the correct values can't be
3289 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3292 get_scope_pc_bounds (struct die_info
*die
,
3293 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3294 struct dwarf2_cu
*cu
)
3296 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3297 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3298 CORE_ADDR current_low
, current_high
;
3300 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3302 best_low
= current_low
;
3303 best_high
= current_high
;
3307 struct die_info
*child
= die
->child
;
3309 while (child
&& child
->tag
)
3311 switch (child
->tag
) {
3312 case DW_TAG_subprogram
:
3313 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3315 best_low
= min (best_low
, current_low
);
3316 best_high
= max (best_high
, current_high
);
3319 case DW_TAG_namespace
:
3320 /* FIXME: carlton/2004-01-16: Should we do this for
3321 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3322 that current GCC's always emit the DIEs corresponding
3323 to definitions of methods of classes as children of a
3324 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3325 the DIEs giving the declarations, which could be
3326 anywhere). But I don't see any reason why the
3327 standards says that they have to be there. */
3328 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3330 if (current_low
!= ((CORE_ADDR
) -1))
3332 best_low
= min (best_low
, current_low
);
3333 best_high
= max (best_high
, current_high
);
3341 child
= sibling_die (child
);
3346 *highpc
= best_high
;
3349 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
3352 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
3353 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
3355 struct attribute
*attr
;
3357 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3360 CORE_ADDR high
= DW_ADDR (attr
);
3361 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3364 CORE_ADDR low
= DW_ADDR (attr
);
3365 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
3369 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3372 bfd
*obfd
= cu
->objfile
->obfd
;
3374 /* The value of the DW_AT_ranges attribute is the offset of the
3375 address range list in the .debug_ranges section. */
3376 unsigned long offset
= DW_UNSND (attr
);
3377 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3379 /* For some target architectures, but not others, the
3380 read_address function sign-extends the addresses it returns.
3381 To recognize base address selection entries, we need a
3383 unsigned int addr_size
= cu
->header
.addr_size
;
3384 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3386 /* The base address, to which the next pair is relative. Note
3387 that this 'base' is a DWARF concept: most entries in a range
3388 list are relative, to reduce the number of relocs against the
3389 debugging information. This is separate from this function's
3390 'baseaddr' argument, which GDB uses to relocate debugging
3391 information from a shared library based on the address at
3392 which the library was loaded. */
3393 CORE_ADDR base
= cu
->header
.base_address
;
3394 int base_known
= cu
->header
.base_known
;
3396 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3398 complaint (&symfile_complaints
,
3399 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
3406 unsigned int bytes_read
;
3407 CORE_ADDR start
, end
;
3409 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
3410 buffer
+= bytes_read
;
3411 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
3412 buffer
+= bytes_read
;
3414 /* Did we find the end of the range list? */
3415 if (start
== 0 && end
== 0)
3418 /* Did we find a base address selection entry? */
3419 else if ((start
& base_select_mask
) == base_select_mask
)
3425 /* We found an ordinary address range. */
3430 complaint (&symfile_complaints
,
3431 _("Invalid .debug_ranges data (no base address)"));
3435 record_block_range (block
,
3436 baseaddr
+ base
+ start
,
3437 baseaddr
+ base
+ end
- 1);
3443 /* Add an aggregate field to the field list. */
3446 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3447 struct dwarf2_cu
*cu
)
3449 struct objfile
*objfile
= cu
->objfile
;
3450 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3451 struct nextfield
*new_field
;
3452 struct attribute
*attr
;
3454 char *fieldname
= "";
3456 /* Allocate a new field list entry and link it in. */
3457 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3458 make_cleanup (xfree
, new_field
);
3459 memset (new_field
, 0, sizeof (struct nextfield
));
3460 new_field
->next
= fip
->fields
;
3461 fip
->fields
= new_field
;
3464 /* Handle accessibility and virtuality of field.
3465 The default accessibility for members is public, the default
3466 accessibility for inheritance is private. */
3467 if (die
->tag
!= DW_TAG_inheritance
)
3468 new_field
->accessibility
= DW_ACCESS_public
;
3470 new_field
->accessibility
= DW_ACCESS_private
;
3471 new_field
->virtuality
= DW_VIRTUALITY_none
;
3473 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3475 new_field
->accessibility
= DW_UNSND (attr
);
3476 if (new_field
->accessibility
!= DW_ACCESS_public
)
3477 fip
->non_public_fields
= 1;
3478 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3480 new_field
->virtuality
= DW_UNSND (attr
);
3482 fp
= &new_field
->field
;
3484 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3486 /* Data member other than a C++ static data member. */
3488 /* Get type of field. */
3489 fp
->type
= die_type (die
, cu
);
3491 FIELD_STATIC_KIND (*fp
) = 0;
3493 /* Get bit size of field (zero if none). */
3494 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3497 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3501 FIELD_BITSIZE (*fp
) = 0;
3504 /* Get bit offset of field. */
3505 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3510 if (attr_form_is_section_offset (attr
))
3512 dwarf2_complex_location_expr_complaint ();
3515 else if (attr_form_is_constant (attr
))
3516 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
3518 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
3520 FIELD_BITPOS (*fp
) = byte_offset
* bits_per_byte
;
3523 FIELD_BITPOS (*fp
) = 0;
3524 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3527 if (gdbarch_bits_big_endian (gdbarch
))
3529 /* For big endian bits, the DW_AT_bit_offset gives the
3530 additional bit offset from the MSB of the containing
3531 anonymous object to the MSB of the field. We don't
3532 have to do anything special since we don't need to
3533 know the size of the anonymous object. */
3534 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3538 /* For little endian bits, compute the bit offset to the
3539 MSB of the anonymous object, subtract off the number of
3540 bits from the MSB of the field to the MSB of the
3541 object, and then subtract off the number of bits of
3542 the field itself. The result is the bit offset of
3543 the LSB of the field. */
3545 int bit_offset
= DW_UNSND (attr
);
3547 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3550 /* The size of the anonymous object containing
3551 the bit field is explicit, so use the
3552 indicated size (in bytes). */
3553 anonymous_size
= DW_UNSND (attr
);
3557 /* The size of the anonymous object containing
3558 the bit field must be inferred from the type
3559 attribute of the data member containing the
3561 anonymous_size
= TYPE_LENGTH (fp
->type
);
3563 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3564 - bit_offset
- FIELD_BITSIZE (*fp
);
3568 /* Get name of field. */
3569 fieldname
= dwarf2_name (die
, cu
);
3570 if (fieldname
== NULL
)
3573 /* The name is already allocated along with this objfile, so we don't
3574 need to duplicate it for the type. */
3575 fp
->name
= fieldname
;
3577 /* Change accessibility for artificial fields (e.g. virtual table
3578 pointer or virtual base class pointer) to private. */
3579 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3581 new_field
->accessibility
= DW_ACCESS_private
;
3582 fip
->non_public_fields
= 1;
3585 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3587 /* C++ static member. */
3589 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3590 is a declaration, but all versions of G++ as of this writing
3591 (so through at least 3.2.1) incorrectly generate
3592 DW_TAG_variable tags. */
3596 /* Get name of field. */
3597 fieldname
= dwarf2_name (die
, cu
);
3598 if (fieldname
== NULL
)
3601 /* Get physical name. */
3602 physname
= dwarf2_linkage_name (die
, cu
);
3604 /* The name is already allocated along with this objfile, so we don't
3605 need to duplicate it for the type. */
3606 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3607 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3608 FIELD_NAME (*fp
) = fieldname
;
3610 else if (die
->tag
== DW_TAG_inheritance
)
3612 /* C++ base class field. */
3613 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3615 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3617 FIELD_BITSIZE (*fp
) = 0;
3618 FIELD_STATIC_KIND (*fp
) = 0;
3619 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3620 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3621 fip
->nbaseclasses
++;
3625 /* Create the vector of fields, and attach it to the type. */
3628 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3629 struct dwarf2_cu
*cu
)
3631 int nfields
= fip
->nfields
;
3633 /* Record the field count, allocate space for the array of fields,
3634 and create blank accessibility bitfields if necessary. */
3635 TYPE_NFIELDS (type
) = nfields
;
3636 TYPE_FIELDS (type
) = (struct field
*)
3637 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3638 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3640 if (fip
->non_public_fields
)
3642 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3644 TYPE_FIELD_PRIVATE_BITS (type
) =
3645 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3646 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3648 TYPE_FIELD_PROTECTED_BITS (type
) =
3649 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3650 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3652 TYPE_FIELD_IGNORE_BITS (type
) =
3653 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3654 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3657 /* If the type has baseclasses, allocate and clear a bit vector for
3658 TYPE_FIELD_VIRTUAL_BITS. */
3659 if (fip
->nbaseclasses
)
3661 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3662 unsigned char *pointer
;
3664 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3665 pointer
= TYPE_ALLOC (type
, num_bytes
);
3666 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3667 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3668 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3671 /* Copy the saved-up fields into the field vector. Start from the head
3672 of the list, adding to the tail of the field array, so that they end
3673 up in the same order in the array in which they were added to the list. */
3674 while (nfields
-- > 0)
3676 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3677 switch (fip
->fields
->accessibility
)
3679 case DW_ACCESS_private
:
3680 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3683 case DW_ACCESS_protected
:
3684 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3687 case DW_ACCESS_public
:
3691 /* Unknown accessibility. Complain and treat it as public. */
3693 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3694 fip
->fields
->accessibility
);
3698 if (nfields
< fip
->nbaseclasses
)
3700 switch (fip
->fields
->virtuality
)
3702 case DW_VIRTUALITY_virtual
:
3703 case DW_VIRTUALITY_pure_virtual
:
3704 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3708 fip
->fields
= fip
->fields
->next
;
3712 /* Add a member function to the proper fieldlist. */
3715 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3716 struct type
*type
, struct dwarf2_cu
*cu
)
3718 struct objfile
*objfile
= cu
->objfile
;
3719 struct attribute
*attr
;
3720 struct fnfieldlist
*flp
;
3722 struct fn_field
*fnp
;
3725 struct nextfnfield
*new_fnfield
;
3726 struct type
*this_type
;
3728 /* Get name of member function. */
3729 fieldname
= dwarf2_name (die
, cu
);
3730 if (fieldname
== NULL
)
3733 /* Get the mangled name. */
3734 physname
= dwarf2_linkage_name (die
, cu
);
3736 /* Look up member function name in fieldlist. */
3737 for (i
= 0; i
< fip
->nfnfields
; i
++)
3739 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3743 /* Create new list element if necessary. */
3744 if (i
< fip
->nfnfields
)
3745 flp
= &fip
->fnfieldlists
[i
];
3748 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3750 fip
->fnfieldlists
= (struct fnfieldlist
*)
3751 xrealloc (fip
->fnfieldlists
,
3752 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3753 * sizeof (struct fnfieldlist
));
3754 if (fip
->nfnfields
== 0)
3755 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3757 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3758 flp
->name
= fieldname
;
3764 /* Create a new member function field and chain it to the field list
3766 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3767 make_cleanup (xfree
, new_fnfield
);
3768 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3769 new_fnfield
->next
= flp
->head
;
3770 flp
->head
= new_fnfield
;
3773 /* Fill in the member function field info. */
3774 fnp
= &new_fnfield
->fnfield
;
3775 /* The name is already allocated along with this objfile, so we don't
3776 need to duplicate it for the type. */
3777 fnp
->physname
= physname
? physname
: "";
3778 fnp
->type
= alloc_type (objfile
);
3779 this_type
= read_type_die (die
, cu
);
3780 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
3782 int nparams
= TYPE_NFIELDS (this_type
);
3784 /* TYPE is the domain of this method, and THIS_TYPE is the type
3785 of the method itself (TYPE_CODE_METHOD). */
3786 smash_to_method_type (fnp
->type
, type
,
3787 TYPE_TARGET_TYPE (this_type
),
3788 TYPE_FIELDS (this_type
),
3789 TYPE_NFIELDS (this_type
),
3790 TYPE_VARARGS (this_type
));
3792 /* Handle static member functions.
3793 Dwarf2 has no clean way to discern C++ static and non-static
3794 member functions. G++ helps GDB by marking the first
3795 parameter for non-static member functions (which is the
3796 this pointer) as artificial. We obtain this information
3797 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3798 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
3799 fnp
->voffset
= VOFFSET_STATIC
;
3802 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3805 /* Get fcontext from DW_AT_containing_type if present. */
3806 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3807 fnp
->fcontext
= die_containing_type (die
, cu
);
3809 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3810 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3812 /* Get accessibility. */
3813 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3816 switch (DW_UNSND (attr
))
3818 case DW_ACCESS_private
:
3819 fnp
->is_private
= 1;
3821 case DW_ACCESS_protected
:
3822 fnp
->is_protected
= 1;
3827 /* Check for artificial methods. */
3828 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3829 if (attr
&& DW_UNSND (attr
) != 0)
3830 fnp
->is_artificial
= 1;
3832 /* Get index in virtual function table if it is a virtual member function. */
3833 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3836 /* Support the .debug_loc offsets */
3837 if (attr_form_is_block (attr
))
3839 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3841 else if (attr_form_is_section_offset (attr
))
3843 dwarf2_complex_location_expr_complaint ();
3847 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3853 /* Create the vector of member function fields, and attach it to the type. */
3856 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3857 struct dwarf2_cu
*cu
)
3859 struct fnfieldlist
*flp
;
3860 int total_length
= 0;
3863 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3864 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3865 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3867 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3869 struct nextfnfield
*nfp
= flp
->head
;
3870 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3873 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3874 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3875 fn_flp
->fn_fields
= (struct fn_field
*)
3876 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3877 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3878 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3880 total_length
+= flp
->length
;
3883 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3884 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3887 /* Returns non-zero if NAME is the name of a vtable member in CU's
3888 language, zero otherwise. */
3890 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3892 static const char vptr
[] = "_vptr";
3893 static const char vtable
[] = "vtable";
3895 /* Look for the C++ and Java forms of the vtable. */
3896 if ((cu
->language
== language_java
3897 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3898 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3899 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3905 /* GCC outputs unnamed structures that are really pointers to member
3906 functions, with the ABI-specified layout. If DIE (from CU) describes
3907 such a structure, set its type, and return nonzero. Otherwise return
3910 GCC shouldn't do this; it should just output pointer to member DIEs.
3911 This is GCC PR debug/28767. */
3913 static struct type
*
3914 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
3916 struct objfile
*objfile
= cu
->objfile
;
3918 struct die_info
*pfn_die
, *delta_die
;
3919 struct attribute
*pfn_name
, *delta_name
;
3920 struct type
*pfn_type
, *domain_type
;
3922 /* Check for a structure with no name and two children. */
3923 if (die
->tag
!= DW_TAG_structure_type
3924 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
3925 || die
->child
== NULL
3926 || die
->child
->sibling
== NULL
3927 || (die
->child
->sibling
->sibling
!= NULL
3928 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
3931 /* Check for __pfn and __delta members. */
3932 pfn_die
= die
->child
;
3933 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
3934 if (pfn_die
->tag
!= DW_TAG_member
3936 || DW_STRING (pfn_name
) == NULL
3937 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
3940 delta_die
= pfn_die
->sibling
;
3941 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
3942 if (delta_die
->tag
!= DW_TAG_member
3943 || delta_name
== NULL
3944 || DW_STRING (delta_name
) == NULL
3945 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
3948 /* Find the type of the method. */
3949 pfn_type
= die_type (pfn_die
, cu
);
3950 if (pfn_type
== NULL
3951 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
3952 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
3955 /* Look for the "this" argument. */
3956 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
3957 if (TYPE_NFIELDS (pfn_type
) == 0
3958 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
3961 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
3962 type
= alloc_type (objfile
);
3963 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
3964 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
3965 TYPE_VARARGS (pfn_type
));
3966 type
= lookup_methodptr_type (type
);
3967 return set_die_type (die
, type
, cu
);
3970 /* Called when we find the DIE that starts a structure or union scope
3971 (definition) to process all dies that define the members of the
3974 NOTE: we need to call struct_type regardless of whether or not the
3975 DIE has an at_name attribute, since it might be an anonymous
3976 structure or union. This gets the type entered into our set of
3979 However, if the structure is incomplete (an opaque struct/union)
3980 then suppress creating a symbol table entry for it since gdb only
3981 wants to find the one with the complete definition. Note that if
3982 it is complete, we just call new_symbol, which does it's own
3983 checking about whether the struct/union is anonymous or not (and
3984 suppresses creating a symbol table entry itself). */
3986 static struct type
*
3987 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3989 struct objfile
*objfile
= cu
->objfile
;
3991 struct attribute
*attr
;
3992 const char *previous_prefix
= processing_current_prefix
;
3993 struct cleanup
*back_to
= NULL
;
3996 type
= quirk_gcc_member_function_pointer (die
, cu
);
4000 type
= alloc_type (objfile
);
4001 INIT_CPLUS_SPECIFIC (type
);
4002 name
= dwarf2_name (die
, cu
);
4005 if (cu
->language
== language_cplus
4006 || cu
->language
== language_java
)
4008 char *new_prefix
= determine_class_name (die
, cu
);
4009 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
4010 strlen (new_prefix
),
4011 &objfile
->objfile_obstack
);
4012 back_to
= make_cleanup (xfree
, new_prefix
);
4013 processing_current_prefix
= new_prefix
;
4017 /* The name is already allocated along with this objfile, so
4018 we don't need to duplicate it for the type. */
4019 TYPE_TAG_NAME (type
) = name
;
4023 if (die
->tag
== DW_TAG_structure_type
)
4025 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
4027 else if (die
->tag
== DW_TAG_union_type
)
4029 TYPE_CODE (type
) = TYPE_CODE_UNION
;
4033 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
4035 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
4038 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4041 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4045 TYPE_LENGTH (type
) = 0;
4048 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB_SUPPORTED
;
4049 if (die_is_declaration (die
, cu
))
4050 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
4052 /* We need to add the type field to the die immediately so we don't
4053 infinitely recurse when dealing with pointers to the structure
4054 type within the structure itself. */
4055 set_die_type (die
, type
, cu
);
4057 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
4059 struct field_info fi
;
4060 struct die_info
*child_die
;
4061 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
4063 memset (&fi
, 0, sizeof (struct field_info
));
4065 child_die
= die
->child
;
4067 while (child_die
&& child_die
->tag
)
4069 if (child_die
->tag
== DW_TAG_member
4070 || child_die
->tag
== DW_TAG_variable
)
4072 /* NOTE: carlton/2002-11-05: A C++ static data member
4073 should be a DW_TAG_member that is a declaration, but
4074 all versions of G++ as of this writing (so through at
4075 least 3.2.1) incorrectly generate DW_TAG_variable
4076 tags for them instead. */
4077 dwarf2_add_field (&fi
, child_die
, cu
);
4079 else if (child_die
->tag
== DW_TAG_subprogram
)
4081 /* C++ member function. */
4082 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
4084 else if (child_die
->tag
== DW_TAG_inheritance
)
4086 /* C++ base class field. */
4087 dwarf2_add_field (&fi
, child_die
, cu
);
4089 child_die
= sibling_die (child_die
);
4092 /* Attach fields and member functions to the type. */
4094 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
4097 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
4099 /* Get the type which refers to the base class (possibly this
4100 class itself) which contains the vtable pointer for the current
4101 class from the DW_AT_containing_type attribute. */
4103 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
4105 struct type
*t
= die_containing_type (die
, cu
);
4107 TYPE_VPTR_BASETYPE (type
) = t
;
4112 /* Our own class provides vtbl ptr. */
4113 for (i
= TYPE_NFIELDS (t
) - 1;
4114 i
>= TYPE_N_BASECLASSES (t
);
4117 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
4119 if (is_vtable_name (fieldname
, cu
))
4121 TYPE_VPTR_FIELDNO (type
) = i
;
4126 /* Complain if virtual function table field not found. */
4127 if (i
< TYPE_N_BASECLASSES (t
))
4128 complaint (&symfile_complaints
,
4129 _("virtual function table pointer not found when defining class '%s'"),
4130 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
4135 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
4138 else if (cu
->producer
4139 && strncmp (cu
->producer
,
4140 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
4142 /* The IBM XLC compiler does not provide direct indication
4143 of the containing type, but the vtable pointer is
4144 always named __vfp. */
4148 for (i
= TYPE_NFIELDS (type
) - 1;
4149 i
>= TYPE_N_BASECLASSES (type
);
4152 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
4154 TYPE_VPTR_FIELDNO (type
) = i
;
4155 TYPE_VPTR_BASETYPE (type
) = type
;
4162 do_cleanups (back_to
);
4165 processing_current_prefix
= previous_prefix
;
4166 if (back_to
!= NULL
)
4167 do_cleanups (back_to
);
4173 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4175 struct objfile
*objfile
= cu
->objfile
;
4176 const char *previous_prefix
= processing_current_prefix
;
4177 struct die_info
*child_die
= die
->child
;
4178 struct type
*this_type
;
4180 this_type
= get_die_type (die
, cu
);
4181 if (this_type
== NULL
)
4182 this_type
= read_structure_type (die
, cu
);
4183 if (TYPE_TAG_NAME (this_type
) != NULL
)
4184 processing_current_prefix
= TYPE_TAG_NAME (this_type
);
4186 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4187 snapshots) has been known to create a die giving a declaration
4188 for a class that has, as a child, a die giving a definition for a
4189 nested class. So we have to process our children even if the
4190 current die is a declaration. Normally, of course, a declaration
4191 won't have any children at all. */
4193 while (child_die
!= NULL
&& child_die
->tag
)
4195 if (child_die
->tag
== DW_TAG_member
4196 || child_die
->tag
== DW_TAG_variable
4197 || child_die
->tag
== DW_TAG_inheritance
)
4202 process_die (child_die
, cu
);
4204 child_die
= sibling_die (child_die
);
4207 /* Do not consider external references. According to the DWARF standard,
4208 these DIEs are identified by the fact that they have no byte_size
4209 attribute, and a declaration attribute. */
4210 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
4211 || !die_is_declaration (die
, cu
))
4212 new_symbol (die
, this_type
, cu
);
4214 processing_current_prefix
= previous_prefix
;
4217 /* Given a DW_AT_enumeration_type die, set its type. We do not
4218 complete the type's fields yet, or create any symbols. */
4220 static struct type
*
4221 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4223 struct objfile
*objfile
= cu
->objfile
;
4225 struct attribute
*attr
;
4228 type
= alloc_type (objfile
);
4230 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4231 name
= dwarf2_name (die
, cu
);
4234 if (processing_has_namespace_info
)
4236 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
4237 processing_current_prefix
,
4242 /* The name is already allocated along with this objfile, so
4243 we don't need to duplicate it for the type. */
4244 TYPE_TAG_NAME (type
) = name
;
4248 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4251 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4255 TYPE_LENGTH (type
) = 0;
4258 /* The enumeration DIE can be incomplete. In Ada, any type can be
4259 declared as private in the package spec, and then defined only
4260 inside the package body. Such types are known as Taft Amendment
4261 Types. When another package uses such a type, an incomplete DIE
4262 may be generated by the compiler. */
4263 if (die_is_declaration (die
, cu
))
4264 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
4266 return set_die_type (die
, type
, cu
);
4269 /* Determine the name of the type represented by DIE, which should be
4270 a named C++ or Java compound type. Return the name in question; the caller
4271 is responsible for xfree()'ing it. */
4274 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4276 struct cleanup
*back_to
= NULL
;
4277 struct dwarf2_cu
*spec_cu
= cu
;
4278 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
4279 char *new_prefix
= NULL
;
4281 /* If this is the definition of a class that is declared by another
4282 die, then processing_current_prefix may not be accurate; see
4283 read_func_scope for a similar example. */
4284 if (spec_die
!= NULL
)
4286 char *specification_prefix
= determine_prefix (spec_die
, spec_cu
);
4287 processing_current_prefix
= specification_prefix
;
4288 back_to
= make_cleanup (xfree
, specification_prefix
);
4291 /* If we don't have namespace debug info, guess the name by trying
4292 to demangle the names of members, just like we did in
4293 guess_structure_name. */
4294 if (!processing_has_namespace_info
)
4296 struct die_info
*child
;
4298 for (child
= die
->child
;
4299 child
!= NULL
&& child
->tag
!= 0;
4300 child
= sibling_die (child
))
4302 if (child
->tag
== DW_TAG_subprogram
)
4305 = language_class_name_from_physname (cu
->language_defn
,
4309 if (new_prefix
!= NULL
)
4315 if (new_prefix
== NULL
)
4317 const char *name
= dwarf2_name (die
, cu
);
4318 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4319 name
? name
: "<<anonymous>>",
4323 if (back_to
!= NULL
)
4324 do_cleanups (back_to
);
4329 /* Given a pointer to a die which begins an enumeration, process all
4330 the dies that define the members of the enumeration, and create the
4331 symbol for the enumeration type.
4333 NOTE: We reverse the order of the element list. */
4336 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4338 struct objfile
*objfile
= cu
->objfile
;
4339 struct die_info
*child_die
;
4340 struct field
*fields
;
4343 int unsigned_enum
= 1;
4345 struct type
*this_type
;
4349 this_type
= get_die_type (die
, cu
);
4350 if (this_type
== NULL
)
4351 this_type
= read_enumeration_type (die
, cu
);
4352 if (die
->child
!= NULL
)
4354 child_die
= die
->child
;
4355 while (child_die
&& child_die
->tag
)
4357 if (child_die
->tag
!= DW_TAG_enumerator
)
4359 process_die (child_die
, cu
);
4363 name
= dwarf2_name (child_die
, cu
);
4366 sym
= new_symbol (child_die
, this_type
, cu
);
4367 if (SYMBOL_VALUE (sym
) < 0)
4370 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4372 fields
= (struct field
*)
4374 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4375 * sizeof (struct field
));
4378 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
4379 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4380 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4381 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4382 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4388 child_die
= sibling_die (child_die
);
4393 TYPE_NFIELDS (this_type
) = num_fields
;
4394 TYPE_FIELDS (this_type
) = (struct field
*)
4395 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
4396 memcpy (TYPE_FIELDS (this_type
), fields
,
4397 sizeof (struct field
) * num_fields
);
4401 TYPE_FLAGS (this_type
) |= TYPE_FLAG_UNSIGNED
;
4404 new_symbol (die
, this_type
, cu
);
4407 /* Extract all information from a DW_TAG_array_type DIE and put it in
4408 the DIE's type field. For now, this only handles one dimensional
4411 static struct type
*
4412 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4414 struct objfile
*objfile
= cu
->objfile
;
4415 struct die_info
*child_die
;
4416 struct type
*type
= NULL
;
4417 struct type
*element_type
, *range_type
, *index_type
;
4418 struct type
**range_types
= NULL
;
4419 struct attribute
*attr
;
4421 struct cleanup
*back_to
;
4424 element_type
= die_type (die
, cu
);
4426 /* Irix 6.2 native cc creates array types without children for
4427 arrays with unspecified length. */
4428 if (die
->child
== NULL
)
4430 index_type
= builtin_type_int32
;
4431 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4432 type
= create_array_type (NULL
, element_type
, range_type
);
4433 return set_die_type (die
, type
, cu
);
4436 back_to
= make_cleanup (null_cleanup
, NULL
);
4437 child_die
= die
->child
;
4438 while (child_die
&& child_die
->tag
)
4440 if (child_die
->tag
== DW_TAG_subrange_type
)
4442 struct type
*child_type
= read_type_die (child_die
, cu
);
4443 if (child_type
!= NULL
)
4445 /* The range type was succesfully read. Save it for
4446 the array type creation. */
4447 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4449 range_types
= (struct type
**)
4450 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4451 * sizeof (struct type
*));
4453 make_cleanup (free_current_contents
, &range_types
);
4455 range_types
[ndim
++] = child_type
;
4458 child_die
= sibling_die (child_die
);
4461 /* Dwarf2 dimensions are output from left to right, create the
4462 necessary array types in backwards order. */
4464 type
= element_type
;
4466 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4470 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4475 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4478 /* Understand Dwarf2 support for vector types (like they occur on
4479 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4480 array type. This is not part of the Dwarf2/3 standard yet, but a
4481 custom vendor extension. The main difference between a regular
4482 array and the vector variant is that vectors are passed by value
4484 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4486 make_vector_type (type
);
4488 name
= dwarf2_name (die
, cu
);
4490 TYPE_NAME (type
) = name
;
4492 do_cleanups (back_to
);
4494 /* Install the type in the die. */
4495 return set_die_type (die
, type
, cu
);
4498 static enum dwarf_array_dim_ordering
4499 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4501 struct attribute
*attr
;
4503 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4505 if (attr
) return DW_SND (attr
);
4508 GNU F77 is a special case, as at 08/2004 array type info is the
4509 opposite order to the dwarf2 specification, but data is still
4510 laid out as per normal fortran.
4512 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4516 if (cu
->language
== language_fortran
&&
4517 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4519 return DW_ORD_row_major
;
4522 switch (cu
->language_defn
->la_array_ordering
)
4524 case array_column_major
:
4525 return DW_ORD_col_major
;
4526 case array_row_major
:
4528 return DW_ORD_row_major
;
4532 /* Extract all information from a DW_TAG_set_type DIE and put it in
4533 the DIE's type field. */
4535 static struct type
*
4536 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4538 struct type
*set_type
= create_set_type (NULL
, die_type (die
, cu
));
4540 return set_die_type (die
, set_type
, cu
);
4543 /* First cut: install each common block member as a global variable. */
4546 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4548 struct die_info
*child_die
;
4549 struct attribute
*attr
;
4551 CORE_ADDR base
= (CORE_ADDR
) 0;
4553 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4556 /* Support the .debug_loc offsets */
4557 if (attr_form_is_block (attr
))
4559 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4561 else if (attr_form_is_section_offset (attr
))
4563 dwarf2_complex_location_expr_complaint ();
4567 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4568 "common block member");
4571 if (die
->child
!= NULL
)
4573 child_die
= die
->child
;
4574 while (child_die
&& child_die
->tag
)
4576 sym
= new_symbol (child_die
, NULL
, cu
);
4577 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4580 SYMBOL_VALUE_ADDRESS (sym
) =
4581 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4582 add_symbol_to_list (sym
, &global_symbols
);
4584 child_die
= sibling_die (child_die
);
4589 /* Read a C++ namespace. */
4592 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4594 struct objfile
*objfile
= cu
->objfile
;
4595 const char *previous_prefix
= processing_current_prefix
;
4598 struct die_info
*current_die
;
4599 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4601 name
= namespace_name (die
, &is_anonymous
, cu
);
4603 /* Now build the name of the current namespace. */
4605 if (previous_prefix
[0] == '\0')
4607 processing_current_prefix
= name
;
4611 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4612 make_cleanup (xfree
, temp_name
);
4613 processing_current_prefix
= temp_name
;
4616 /* Add a symbol associated to this if we haven't seen the namespace
4617 before. Also, add a using directive if it's an anonymous
4620 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
4624 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4625 this cast will hopefully become unnecessary. */
4626 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4627 (char *) processing_current_prefix
,
4629 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4631 new_symbol (die
, type
, cu
);
4632 set_die_type (die
, type
, cu
);
4635 cp_add_using_directive (processing_current_prefix
,
4636 strlen (previous_prefix
),
4637 strlen (processing_current_prefix
));
4640 if (die
->child
!= NULL
)
4642 struct die_info
*child_die
= die
->child
;
4644 while (child_die
&& child_die
->tag
)
4646 process_die (child_die
, cu
);
4647 child_die
= sibling_die (child_die
);
4651 processing_current_prefix
= previous_prefix
;
4652 do_cleanups (back_to
);
4655 /* Return the name of the namespace represented by DIE. Set
4656 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4660 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4662 struct die_info
*current_die
;
4663 const char *name
= NULL
;
4665 /* Loop through the extensions until we find a name. */
4667 for (current_die
= die
;
4668 current_die
!= NULL
;
4669 current_die
= dwarf2_extension (die
, &cu
))
4671 name
= dwarf2_name (current_die
, cu
);
4676 /* Is it an anonymous namespace? */
4678 *is_anonymous
= (name
== NULL
);
4680 name
= "(anonymous namespace)";
4685 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4686 the user defined type vector. */
4688 static struct type
*
4689 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4691 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
4692 struct comp_unit_head
*cu_header
= &cu
->header
;
4694 struct attribute
*attr_byte_size
;
4695 struct attribute
*attr_address_class
;
4696 int byte_size
, addr_class
;
4698 type
= lookup_pointer_type (die_type (die
, cu
));
4700 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4702 byte_size
= DW_UNSND (attr_byte_size
);
4704 byte_size
= cu_header
->addr_size
;
4706 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4707 if (attr_address_class
)
4708 addr_class
= DW_UNSND (attr_address_class
);
4710 addr_class
= DW_ADDR_none
;
4712 /* If the pointer size or address class is different than the
4713 default, create a type variant marked as such and set the
4714 length accordingly. */
4715 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4717 if (gdbarch_address_class_type_flags_p (gdbarch
))
4721 type_flags
= gdbarch_address_class_type_flags
4722 (gdbarch
, byte_size
, addr_class
);
4723 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4724 type
= make_type_with_address_space (type
, type_flags
);
4726 else if (TYPE_LENGTH (type
) != byte_size
)
4728 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4731 /* Should we also complain about unhandled address classes? */
4735 TYPE_LENGTH (type
) = byte_size
;
4736 return set_die_type (die
, type
, cu
);
4739 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4740 the user defined type vector. */
4742 static struct type
*
4743 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4745 struct objfile
*objfile
= cu
->objfile
;
4747 struct type
*to_type
;
4748 struct type
*domain
;
4750 to_type
= die_type (die
, cu
);
4751 domain
= die_containing_type (die
, cu
);
4753 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
4754 type
= lookup_methodptr_type (to_type
);
4756 type
= lookup_memberptr_type (to_type
, domain
);
4758 return set_die_type (die
, type
, cu
);
4761 /* Extract all information from a DW_TAG_reference_type DIE and add to
4762 the user defined type vector. */
4764 static struct type
*
4765 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4767 struct comp_unit_head
*cu_header
= &cu
->header
;
4769 struct attribute
*attr
;
4771 type
= lookup_reference_type (die_type (die
, cu
));
4772 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4775 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4779 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4781 return set_die_type (die
, type
, cu
);
4784 static struct type
*
4785 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4787 struct type
*base_type
, *cv_type
;
4789 base_type
= die_type (die
, cu
);
4790 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
4791 return set_die_type (die
, cv_type
, cu
);
4794 static struct type
*
4795 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4797 struct type
*base_type
, *cv_type
;
4799 base_type
= die_type (die
, cu
);
4800 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
4801 return set_die_type (die
, cv_type
, cu
);
4804 /* Extract all information from a DW_TAG_string_type DIE and add to
4805 the user defined type vector. It isn't really a user defined type,
4806 but it behaves like one, with other DIE's using an AT_user_def_type
4807 attribute to reference it. */
4809 static struct type
*
4810 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4812 struct objfile
*objfile
= cu
->objfile
;
4813 struct type
*type
, *range_type
, *index_type
, *char_type
;
4814 struct attribute
*attr
;
4815 unsigned int length
;
4817 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4820 length
= DW_UNSND (attr
);
4824 /* check for the DW_AT_byte_size attribute */
4825 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4828 length
= DW_UNSND (attr
);
4836 index_type
= builtin_type_int32
;
4837 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4838 type
= create_string_type (NULL
, range_type
);
4840 return set_die_type (die
, type
, cu
);
4843 /* Handle DIES due to C code like:
4847 int (*funcp)(int a, long l);
4851 ('funcp' generates a DW_TAG_subroutine_type DIE)
4854 static struct type
*
4855 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4857 struct type
*type
; /* Type that this function returns */
4858 struct type
*ftype
; /* Function that returns above type */
4859 struct attribute
*attr
;
4861 type
= die_type (die
, cu
);
4862 ftype
= make_function_type (type
, (struct type
**) 0);
4864 /* All functions in C++, Pascal and Java have prototypes. */
4865 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4866 if ((attr
&& (DW_UNSND (attr
) != 0))
4867 || cu
->language
== language_cplus
4868 || cu
->language
== language_java
4869 || cu
->language
== language_pascal
)
4870 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4872 /* Store the calling convention in the type if it's available in
4873 the subroutine die. Otherwise set the calling convention to
4874 the default value DW_CC_normal. */
4875 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
4876 TYPE_CALLING_CONVENTION (ftype
) = attr
? DW_UNSND (attr
) : DW_CC_normal
;
4878 if (die
->child
!= NULL
)
4880 struct die_info
*child_die
;
4884 /* Count the number of parameters.
4885 FIXME: GDB currently ignores vararg functions, but knows about
4886 vararg member functions. */
4887 child_die
= die
->child
;
4888 while (child_die
&& child_die
->tag
)
4890 if (child_die
->tag
== DW_TAG_formal_parameter
)
4892 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4893 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4894 child_die
= sibling_die (child_die
);
4897 /* Allocate storage for parameters and fill them in. */
4898 TYPE_NFIELDS (ftype
) = nparams
;
4899 TYPE_FIELDS (ftype
) = (struct field
*)
4900 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4902 child_die
= die
->child
;
4903 while (child_die
&& child_die
->tag
)
4905 if (child_die
->tag
== DW_TAG_formal_parameter
)
4907 /* Dwarf2 has no clean way to discern C++ static and non-static
4908 member functions. G++ helps GDB by marking the first
4909 parameter for non-static member functions (which is the
4910 this pointer) as artificial. We pass this information
4911 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4912 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4914 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4916 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4917 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4920 child_die
= sibling_die (child_die
);
4924 return set_die_type (die
, ftype
, cu
);
4927 static struct type
*
4928 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4930 struct objfile
*objfile
= cu
->objfile
;
4931 struct attribute
*attr
;
4933 struct type
*this_type
;
4935 name
= dwarf2_name (die
, cu
);
4936 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
4937 TYPE_FLAG_TARGET_STUB
, name
, objfile
);
4938 set_die_type (die
, this_type
, cu
);
4939 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
4943 /* Find a representation of a given base type and install
4944 it in the TYPE field of the die. */
4946 static struct type
*
4947 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4949 struct objfile
*objfile
= cu
->objfile
;
4951 struct attribute
*attr
;
4952 int encoding
= 0, size
= 0;
4954 enum type_code code
= TYPE_CODE_INT
;
4956 struct type
*target_type
= NULL
;
4958 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4961 encoding
= DW_UNSND (attr
);
4963 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4966 size
= DW_UNSND (attr
);
4968 name
= dwarf2_name (die
, cu
);
4971 complaint (&symfile_complaints
,
4972 _("DW_AT_name missing from DW_TAG_base_type"));
4977 case DW_ATE_address
:
4978 /* Turn DW_ATE_address into a void * pointer. */
4979 code
= TYPE_CODE_PTR
;
4980 type_flags
|= TYPE_FLAG_UNSIGNED
;
4981 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
4983 case DW_ATE_boolean
:
4984 code
= TYPE_CODE_BOOL
;
4985 type_flags
|= TYPE_FLAG_UNSIGNED
;
4987 case DW_ATE_complex_float
:
4988 code
= TYPE_CODE_COMPLEX
;
4989 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
4991 case DW_ATE_decimal_float
:
4992 code
= TYPE_CODE_DECFLOAT
;
4995 code
= TYPE_CODE_FLT
;
4999 case DW_ATE_unsigned
:
5000 type_flags
|= TYPE_FLAG_UNSIGNED
;
5002 case DW_ATE_signed_char
:
5003 if (cu
->language
== language_ada
|| cu
->language
== language_m2
)
5004 code
= TYPE_CODE_CHAR
;
5006 case DW_ATE_unsigned_char
:
5007 if (cu
->language
== language_ada
|| cu
->language
== language_m2
)
5008 code
= TYPE_CODE_CHAR
;
5009 type_flags
|= TYPE_FLAG_UNSIGNED
;
5012 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
5013 dwarf_type_encoding_name (encoding
));
5017 type
= init_type (code
, size
, type_flags
, name
, objfile
);
5018 TYPE_TARGET_TYPE (type
) = target_type
;
5020 return set_die_type (die
, type
, cu
);
5023 /* Read the given DW_AT_subrange DIE. */
5025 static struct type
*
5026 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5028 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
5029 struct type
*base_type
;
5030 struct type
*range_type
;
5031 struct attribute
*attr
;
5036 base_type
= die_type (die
, cu
);
5037 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
5039 complaint (&symfile_complaints
,
5040 _("DW_AT_type missing from DW_TAG_subrange_type"));
5042 = init_type (TYPE_CODE_INT
, gdbarch_addr_bit (gdbarch
) / 8,
5043 0, NULL
, cu
->objfile
);
5046 if (cu
->language
== language_fortran
)
5048 /* FORTRAN implies a lower bound of 1, if not given. */
5052 /* FIXME: For variable sized arrays either of these could be
5053 a variable rather than a constant value. We'll allow it,
5054 but we don't know how to handle it. */
5055 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
5057 low
= dwarf2_get_attr_constant_value (attr
, 0);
5059 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
5062 if (attr
->form
== DW_FORM_block1
)
5064 /* GCC encodes arrays with unspecified or dynamic length
5065 with a DW_FORM_block1 attribute.
5066 FIXME: GDB does not yet know how to handle dynamic
5067 arrays properly, treat them as arrays with unspecified
5070 FIXME: jimb/2003-09-22: GDB does not really know
5071 how to handle arrays of unspecified length
5072 either; we just represent them as zero-length
5073 arrays. Choose an appropriate upper bound given
5074 the lower bound we've computed above. */
5078 high
= dwarf2_get_attr_constant_value (attr
, 1);
5081 range_type
= create_range_type (NULL
, base_type
, low
, high
);
5083 name
= dwarf2_name (die
, cu
);
5085 TYPE_NAME (range_type
) = name
;
5087 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5089 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
5091 return set_die_type (die
, range_type
, cu
);
5094 static struct type
*
5095 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5099 /* For now, we only support the C meaning of an unspecified type: void. */
5101 type
= init_type (TYPE_CODE_VOID
, 0, 0, dwarf2_name (die
, cu
),
5104 return set_die_type (die
, type
, cu
);
5107 /* Trivial hash function for die_info: the hash value of a DIE
5108 is its offset in .debug_info for this objfile. */
5111 die_hash (const void *item
)
5113 const struct die_info
*die
= item
;
5117 /* Trivial comparison function for die_info structures: two DIEs
5118 are equal if they have the same offset. */
5121 die_eq (const void *item_lhs
, const void *item_rhs
)
5123 const struct die_info
*die_lhs
= item_lhs
;
5124 const struct die_info
*die_rhs
= item_rhs
;
5125 return die_lhs
->offset
== die_rhs
->offset
;
5128 /* Read a whole compilation unit into a linked list of dies. */
5130 static struct die_info
*
5131 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
5134 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5138 &cu
->comp_unit_obstack
,
5139 hashtab_obstack_allocate
,
5140 dummy_obstack_deallocate
);
5142 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
5145 /* Read a single die and all its descendents. Set the die's sibling
5146 field to NULL; set other fields in the die correctly, and set all
5147 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
5148 location of the info_ptr after reading all of those dies. PARENT
5149 is the parent of the die in question. */
5151 static struct die_info
*
5152 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
5153 struct dwarf2_cu
*cu
,
5154 gdb_byte
**new_info_ptr
,
5155 struct die_info
*parent
)
5157 struct die_info
*die
;
5161 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
5164 *new_info_ptr
= cur_ptr
;
5167 store_in_ref_table (die
, cu
);
5171 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
5177 *new_info_ptr
= cur_ptr
;
5180 die
->sibling
= NULL
;
5181 die
->parent
= parent
;
5185 /* Read a die, all of its descendents, and all of its siblings; set
5186 all of the fields of all of the dies correctly. Arguments are as
5187 in read_die_and_children. */
5189 static struct die_info
*
5190 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5191 struct dwarf2_cu
*cu
,
5192 gdb_byte
**new_info_ptr
,
5193 struct die_info
*parent
)
5195 struct die_info
*first_die
, *last_sibling
;
5199 first_die
= last_sibling
= NULL
;
5203 struct die_info
*die
5204 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5208 *new_info_ptr
= cur_ptr
;
5215 last_sibling
->sibling
= die
;
5221 /* Decompress a section that was compressed using zlib. Store the
5222 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
5225 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
5226 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
5228 bfd
*abfd
= objfile
->obfd
;
5230 error (_("Support for zlib-compressed DWARF data (from '%s') "
5231 "is disabled in this copy of GDB"),
5232 bfd_get_filename (abfd
));
5234 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
5235 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
5236 bfd_size_type uncompressed_size
;
5237 gdb_byte
*uncompressed_buffer
;
5240 int header_size
= 12;
5242 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5243 || bfd_bread (compressed_buffer
, compressed_size
, abfd
) != compressed_size
)
5244 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5245 bfd_get_filename (abfd
));
5247 /* Read the zlib header. In this case, it should be "ZLIB" followed
5248 by the uncompressed section size, 8 bytes in big-endian order. */
5249 if (compressed_size
< header_size
5250 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
5251 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
5252 bfd_get_filename (abfd
));
5253 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
5254 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
5255 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
5256 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
5257 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
5258 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
5259 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
5260 uncompressed_size
+= compressed_buffer
[11];
5262 /* It is possible the section consists of several compressed
5263 buffers concatenated together, so we uncompress in a loop. */
5267 strm
.avail_in
= compressed_size
- header_size
;
5268 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
5269 strm
.avail_out
= uncompressed_size
;
5270 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
5272 rc
= inflateInit (&strm
);
5273 while (strm
.avail_in
> 0)
5276 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
5277 bfd_get_filename (abfd
), rc
);
5278 strm
.next_out
= ((Bytef
*) uncompressed_buffer
5279 + (uncompressed_size
- strm
.avail_out
));
5280 rc
= inflate (&strm
, Z_FINISH
);
5281 if (rc
!= Z_STREAM_END
)
5282 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
5283 bfd_get_filename (abfd
), rc
);
5284 rc
= inflateReset (&strm
);
5286 rc
= inflateEnd (&strm
);
5288 || strm
.avail_out
!= 0)
5289 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
5290 bfd_get_filename (abfd
), rc
);
5292 xfree (compressed_buffer
);
5293 *outbuf
= uncompressed_buffer
;
5294 *outsize
= uncompressed_size
;
5299 /* Read the contents of the section at OFFSET and of size SIZE from the
5300 object file specified by OBJFILE into the objfile_obstack and return it.
5301 If the section is compressed, uncompress it before returning. */
5304 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
5306 bfd
*abfd
= objfile
->obfd
;
5307 gdb_byte
*buf
, *retbuf
;
5308 bfd_size_type size
= bfd_get_section_size (sectp
);
5309 unsigned char header
[4];
5314 /* Check if the file has a 4-byte header indicating compression. */
5315 if (size
> sizeof (header
)
5316 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
5317 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
5319 /* Upon decompression, update the buffer and its size. */
5320 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
5322 zlib_decompress_section (objfile
, sectp
, &buf
, &size
);
5323 dwarf2_resize_section (sectp
, size
);
5328 /* If we get here, we are a normal, not-compressed section. */
5329 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5330 /* When debugging .o files, we may need to apply relocations; see
5331 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
5332 We never compress sections in .o files, so we only need to
5333 try this when the section is not compressed. */
5334 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5338 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5339 || bfd_bread (buf
, size
, abfd
) != size
)
5340 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5341 bfd_get_filename (abfd
));
5346 /* In DWARF version 2, the description of the debugging information is
5347 stored in a separate .debug_abbrev section. Before we read any
5348 dies from a section we read in all abbreviations and install them
5349 in a hash table. This function also sets flags in CU describing
5350 the data found in the abbrev table. */
5353 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5355 struct comp_unit_head
*cu_header
= &cu
->header
;
5356 gdb_byte
*abbrev_ptr
;
5357 struct abbrev_info
*cur_abbrev
;
5358 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5359 unsigned int abbrev_form
, hash_number
;
5360 struct attr_abbrev
*cur_attrs
;
5361 unsigned int allocated_attrs
;
5363 /* Initialize dwarf2 abbrevs */
5364 obstack_init (&cu
->abbrev_obstack
);
5365 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5367 * sizeof (struct abbrev_info
*)));
5368 memset (cu
->dwarf2_abbrevs
, 0,
5369 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5371 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5372 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5373 abbrev_ptr
+= bytes_read
;
5375 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5376 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5378 /* loop until we reach an abbrev number of 0 */
5379 while (abbrev_number
)
5381 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5383 /* read in abbrev header */
5384 cur_abbrev
->number
= abbrev_number
;
5385 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5386 abbrev_ptr
+= bytes_read
;
5387 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5390 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5391 cu
->has_namespace_info
= 1;
5393 /* now read in declarations */
5394 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5395 abbrev_ptr
+= bytes_read
;
5396 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5397 abbrev_ptr
+= bytes_read
;
5400 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5402 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5404 = xrealloc (cur_attrs
, (allocated_attrs
5405 * sizeof (struct attr_abbrev
)));
5408 /* Record whether this compilation unit might have
5409 inter-compilation-unit references. If we don't know what form
5410 this attribute will have, then it might potentially be a
5411 DW_FORM_ref_addr, so we conservatively expect inter-CU
5414 if (abbrev_form
== DW_FORM_ref_addr
5415 || abbrev_form
== DW_FORM_indirect
)
5416 cu
->has_form_ref_addr
= 1;
5418 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5419 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5420 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5421 abbrev_ptr
+= bytes_read
;
5422 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5423 abbrev_ptr
+= bytes_read
;
5426 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5427 (cur_abbrev
->num_attrs
5428 * sizeof (struct attr_abbrev
)));
5429 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5430 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5432 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5433 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5434 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5436 /* Get next abbreviation.
5437 Under Irix6 the abbreviations for a compilation unit are not
5438 always properly terminated with an abbrev number of 0.
5439 Exit loop if we encounter an abbreviation which we have
5440 already read (which means we are about to read the abbreviations
5441 for the next compile unit) or if the end of the abbreviation
5442 table is reached. */
5443 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5444 >= dwarf2_per_objfile
->abbrev_size
)
5446 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5447 abbrev_ptr
+= bytes_read
;
5448 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5455 /* Release the memory used by the abbrev table for a compilation unit. */
5458 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5460 struct dwarf2_cu
*cu
= ptr_to_cu
;
5462 obstack_free (&cu
->abbrev_obstack
, NULL
);
5463 cu
->dwarf2_abbrevs
= NULL
;
5466 /* Lookup an abbrev_info structure in the abbrev hash table. */
5468 static struct abbrev_info
*
5469 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5471 unsigned int hash_number
;
5472 struct abbrev_info
*abbrev
;
5474 hash_number
= number
% ABBREV_HASH_SIZE
;
5475 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5479 if (abbrev
->number
== number
)
5482 abbrev
= abbrev
->next
;
5487 /* Returns nonzero if TAG represents a type that we might generate a partial
5491 is_type_tag_for_partial (int tag
)
5496 /* Some types that would be reasonable to generate partial symbols for,
5497 that we don't at present. */
5498 case DW_TAG_array_type
:
5499 case DW_TAG_file_type
:
5500 case DW_TAG_ptr_to_member_type
:
5501 case DW_TAG_set_type
:
5502 case DW_TAG_string_type
:
5503 case DW_TAG_subroutine_type
:
5505 case DW_TAG_base_type
:
5506 case DW_TAG_class_type
:
5507 case DW_TAG_interface_type
:
5508 case DW_TAG_enumeration_type
:
5509 case DW_TAG_structure_type
:
5510 case DW_TAG_subrange_type
:
5511 case DW_TAG_typedef
:
5512 case DW_TAG_union_type
:
5519 /* Load all DIEs that are interesting for partial symbols into memory. */
5521 static struct partial_die_info
*
5522 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5523 struct dwarf2_cu
*cu
)
5525 struct partial_die_info
*part_die
;
5526 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5527 struct abbrev_info
*abbrev
;
5528 unsigned int bytes_read
;
5529 unsigned int load_all
= 0;
5531 int nesting_level
= 1;
5536 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5540 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5544 &cu
->comp_unit_obstack
,
5545 hashtab_obstack_allocate
,
5546 dummy_obstack_deallocate
);
5548 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5549 sizeof (struct partial_die_info
));
5553 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5555 /* A NULL abbrev means the end of a series of children. */
5558 if (--nesting_level
== 0)
5560 /* PART_DIE was probably the last thing allocated on the
5561 comp_unit_obstack, so we could call obstack_free
5562 here. We don't do that because the waste is small,
5563 and will be cleaned up when we're done with this
5564 compilation unit. This way, we're also more robust
5565 against other users of the comp_unit_obstack. */
5568 info_ptr
+= bytes_read
;
5569 last_die
= parent_die
;
5570 parent_die
= parent_die
->die_parent
;
5574 /* Check whether this DIE is interesting enough to save. Normally
5575 we would not be interested in members here, but there may be
5576 later variables referencing them via DW_AT_specification (for
5579 && !is_type_tag_for_partial (abbrev
->tag
)
5580 && abbrev
->tag
!= DW_TAG_enumerator
5581 && abbrev
->tag
!= DW_TAG_subprogram
5582 && abbrev
->tag
!= DW_TAG_variable
5583 && abbrev
->tag
!= DW_TAG_namespace
5584 && abbrev
->tag
!= DW_TAG_member
)
5586 /* Otherwise we skip to the next sibling, if any. */
5587 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5591 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5592 abfd
, info_ptr
, cu
);
5594 /* This two-pass algorithm for processing partial symbols has a
5595 high cost in cache pressure. Thus, handle some simple cases
5596 here which cover the majority of C partial symbols. DIEs
5597 which neither have specification tags in them, nor could have
5598 specification tags elsewhere pointing at them, can simply be
5599 processed and discarded.
5601 This segment is also optional; scan_partial_symbols and
5602 add_partial_symbol will handle these DIEs if we chain
5603 them in normally. When compilers which do not emit large
5604 quantities of duplicate debug information are more common,
5605 this code can probably be removed. */
5607 /* Any complete simple types at the top level (pretty much all
5608 of them, for a language without namespaces), can be processed
5610 if (parent_die
== NULL
5611 && part_die
->has_specification
== 0
5612 && part_die
->is_declaration
== 0
5613 && (part_die
->tag
== DW_TAG_typedef
5614 || part_die
->tag
== DW_TAG_base_type
5615 || part_die
->tag
== DW_TAG_subrange_type
))
5617 if (building_psymtab
&& part_die
->name
!= NULL
)
5618 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5619 VAR_DOMAIN
, LOC_TYPEDEF
,
5620 &cu
->objfile
->static_psymbols
,
5621 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5622 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5626 /* If we're at the second level, and we're an enumerator, and
5627 our parent has no specification (meaning possibly lives in a
5628 namespace elsewhere), then we can add the partial symbol now
5629 instead of queueing it. */
5630 if (part_die
->tag
== DW_TAG_enumerator
5631 && parent_die
!= NULL
5632 && parent_die
->die_parent
== NULL
5633 && parent_die
->tag
== DW_TAG_enumeration_type
5634 && parent_die
->has_specification
== 0)
5636 if (part_die
->name
== NULL
)
5637 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5638 else if (building_psymtab
)
5639 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5640 VAR_DOMAIN
, LOC_CONST
,
5641 (cu
->language
== language_cplus
5642 || cu
->language
== language_java
)
5643 ? &cu
->objfile
->global_psymbols
5644 : &cu
->objfile
->static_psymbols
,
5645 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5647 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5651 /* We'll save this DIE so link it in. */
5652 part_die
->die_parent
= parent_die
;
5653 part_die
->die_sibling
= NULL
;
5654 part_die
->die_child
= NULL
;
5656 if (last_die
&& last_die
== parent_die
)
5657 last_die
->die_child
= part_die
;
5659 last_die
->die_sibling
= part_die
;
5661 last_die
= part_die
;
5663 if (first_die
== NULL
)
5664 first_die
= part_die
;
5666 /* Maybe add the DIE to the hash table. Not all DIEs that we
5667 find interesting need to be in the hash table, because we
5668 also have the parent/sibling/child chains; only those that we
5669 might refer to by offset later during partial symbol reading.
5671 For now this means things that might have be the target of a
5672 DW_AT_specification, DW_AT_abstract_origin, or
5673 DW_AT_extension. DW_AT_extension will refer only to
5674 namespaces; DW_AT_abstract_origin refers to functions (and
5675 many things under the function DIE, but we do not recurse
5676 into function DIEs during partial symbol reading) and
5677 possibly variables as well; DW_AT_specification refers to
5678 declarations. Declarations ought to have the DW_AT_declaration
5679 flag. It happens that GCC forgets to put it in sometimes, but
5680 only for functions, not for types.
5682 Adding more things than necessary to the hash table is harmless
5683 except for the performance cost. Adding too few will result in
5684 wasted time in find_partial_die, when we reread the compilation
5685 unit with load_all_dies set. */
5688 || abbrev
->tag
== DW_TAG_subprogram
5689 || abbrev
->tag
== DW_TAG_variable
5690 || abbrev
->tag
== DW_TAG_namespace
5691 || part_die
->is_declaration
)
5695 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5696 part_die
->offset
, INSERT
);
5700 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5701 sizeof (struct partial_die_info
));
5703 /* For some DIEs we want to follow their children (if any). For C
5704 we have no reason to follow the children of structures; for other
5705 languages we have to, both so that we can get at method physnames
5706 to infer fully qualified class names, and for DW_AT_specification. */
5707 if (last_die
->has_children
5709 || last_die
->tag
== DW_TAG_namespace
5710 || last_die
->tag
== DW_TAG_enumeration_type
5711 || (cu
->language
!= language_c
5712 && (last_die
->tag
== DW_TAG_class_type
5713 || last_die
->tag
== DW_TAG_interface_type
5714 || last_die
->tag
== DW_TAG_structure_type
5715 || last_die
->tag
== DW_TAG_union_type
))))
5718 parent_die
= last_die
;
5722 /* Otherwise we skip to the next sibling, if any. */
5723 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5725 /* Back to the top, do it again. */
5729 /* Read a minimal amount of information into the minimal die structure. */
5732 read_partial_die (struct partial_die_info
*part_die
,
5733 struct abbrev_info
*abbrev
,
5734 unsigned int abbrev_len
, bfd
*abfd
,
5735 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5737 unsigned int bytes_read
, i
;
5738 struct attribute attr
;
5739 int has_low_pc_attr
= 0;
5740 int has_high_pc_attr
= 0;
5741 CORE_ADDR base_address
= 0;
5745 base_address_low_pc
,
5746 /* Overrides BASE_ADDRESS_LOW_PC. */
5747 base_address_entry_pc
5749 base_address_type
= base_address_none
;
5751 memset (part_die
, 0, sizeof (struct partial_die_info
));
5753 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5755 info_ptr
+= abbrev_len
;
5760 part_die
->tag
= abbrev
->tag
;
5761 part_die
->has_children
= abbrev
->has_children
;
5763 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5765 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5767 /* Store the data if it is of an attribute we want to keep in a
5768 partial symbol table. */
5773 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5774 if (part_die
->name
== NULL
)
5775 part_die
->name
= DW_STRING (&attr
);
5777 case DW_AT_comp_dir
:
5778 if (part_die
->dirname
== NULL
)
5779 part_die
->dirname
= DW_STRING (&attr
);
5781 case DW_AT_MIPS_linkage_name
:
5782 part_die
->name
= DW_STRING (&attr
);
5785 has_low_pc_attr
= 1;
5786 part_die
->lowpc
= DW_ADDR (&attr
);
5787 if (part_die
->tag
== DW_TAG_compile_unit
5788 && base_address_type
< base_address_low_pc
)
5790 base_address
= DW_ADDR (&attr
);
5791 base_address_type
= base_address_low_pc
;
5795 has_high_pc_attr
= 1;
5796 part_die
->highpc
= DW_ADDR (&attr
);
5798 case DW_AT_entry_pc
:
5799 if (part_die
->tag
== DW_TAG_compile_unit
5800 && base_address_type
< base_address_entry_pc
)
5802 base_address
= DW_ADDR (&attr
);
5803 base_address_type
= base_address_entry_pc
;
5807 if (part_die
->tag
== DW_TAG_compile_unit
)
5809 cu
->ranges_offset
= DW_UNSND (&attr
);
5810 cu
->has_ranges_offset
= 1;
5813 case DW_AT_location
:
5814 /* Support the .debug_loc offsets */
5815 if (attr_form_is_block (&attr
))
5817 part_die
->locdesc
= DW_BLOCK (&attr
);
5819 else if (attr_form_is_section_offset (&attr
))
5821 dwarf2_complex_location_expr_complaint ();
5825 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5826 "partial symbol information");
5829 case DW_AT_language
:
5830 part_die
->language
= DW_UNSND (&attr
);
5832 case DW_AT_external
:
5833 part_die
->is_external
= DW_UNSND (&attr
);
5835 case DW_AT_declaration
:
5836 part_die
->is_declaration
= DW_UNSND (&attr
);
5839 part_die
->has_type
= 1;
5841 case DW_AT_abstract_origin
:
5842 case DW_AT_specification
:
5843 case DW_AT_extension
:
5844 part_die
->has_specification
= 1;
5845 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5848 /* Ignore absolute siblings, they might point outside of
5849 the current compile unit. */
5850 if (attr
.form
== DW_FORM_ref_addr
)
5851 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5853 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5854 + dwarf2_get_ref_die_offset (&attr
, cu
);
5856 case DW_AT_stmt_list
:
5857 part_die
->has_stmt_list
= 1;
5858 part_die
->line_offset
= DW_UNSND (&attr
);
5860 case DW_AT_byte_size
:
5861 part_die
->has_byte_size
= 1;
5863 case DW_AT_calling_convention
:
5864 /* DWARF doesn't provide a way to identify a program's source-level
5865 entry point. DW_AT_calling_convention attributes are only meant
5866 to describe functions' calling conventions.
5868 However, because it's a necessary piece of information in
5869 Fortran, and because DW_CC_program is the only piece of debugging
5870 information whose definition refers to a 'main program' at all,
5871 several compilers have begun marking Fortran main programs with
5872 DW_CC_program --- even when those functions use the standard
5873 calling conventions.
5875 So until DWARF specifies a way to provide this information and
5876 compilers pick up the new representation, we'll support this
5878 if (DW_UNSND (&attr
) == DW_CC_program
5879 && cu
->language
== language_fortran
)
5880 set_main_name (part_die
->name
);
5887 /* When using the GNU linker, .gnu.linkonce. sections are used to
5888 eliminate duplicate copies of functions and vtables and such.
5889 The linker will arbitrarily choose one and discard the others.
5890 The AT_*_pc values for such functions refer to local labels in
5891 these sections. If the section from that file was discarded, the
5892 labels are not in the output, so the relocs get a value of 0.
5893 If this is a discarded function, mark the pc bounds as invalid,
5894 so that GDB will ignore it. */
5895 if (has_low_pc_attr
&& has_high_pc_attr
5896 && part_die
->lowpc
< part_die
->highpc
5897 && (part_die
->lowpc
!= 0
5898 || dwarf2_per_objfile
->has_section_at_zero
))
5899 part_die
->has_pc_info
= 1;
5901 if (base_address_type
!= base_address_none
&& !cu
->header
.base_known
)
5903 gdb_assert (part_die
->tag
== DW_TAG_compile_unit
);
5904 cu
->header
.base_known
= 1;
5905 cu
->header
.base_address
= base_address
;
5911 /* Find a cached partial DIE at OFFSET in CU. */
5913 static struct partial_die_info
*
5914 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5916 struct partial_die_info
*lookup_die
= NULL
;
5917 struct partial_die_info part_die
;
5919 part_die
.offset
= offset
;
5920 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5925 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5927 static struct partial_die_info
*
5928 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5930 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5931 struct partial_die_info
*pd
= NULL
;
5933 if (offset
>= cu
->header
.offset
5934 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5936 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5941 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5943 if (per_cu
->cu
== NULL
)
5945 load_comp_unit (per_cu
, cu
->objfile
);
5946 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5947 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5950 per_cu
->cu
->last_used
= 0;
5951 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5953 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5955 struct cleanup
*back_to
;
5956 struct partial_die_info comp_unit_die
;
5957 struct abbrev_info
*abbrev
;
5958 unsigned int bytes_read
;
5961 per_cu
->load_all_dies
= 1;
5963 /* Re-read the DIEs. */
5964 back_to
= make_cleanup (null_cleanup
, 0);
5965 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5967 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5968 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5970 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5971 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5972 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5973 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5975 if (comp_unit_die
.has_children
)
5976 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5977 do_cleanups (back_to
);
5979 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5983 internal_error (__FILE__
, __LINE__
,
5984 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5985 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5989 /* Adjust PART_DIE before generating a symbol for it. This function
5990 may set the is_external flag or change the DIE's name. */
5993 fixup_partial_die (struct partial_die_info
*part_die
,
5994 struct dwarf2_cu
*cu
)
5996 /* If we found a reference attribute and the DIE has no name, try
5997 to find a name in the referred to DIE. */
5999 if (part_die
->name
== NULL
&& part_die
->has_specification
)
6001 struct partial_die_info
*spec_die
;
6003 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
6005 fixup_partial_die (spec_die
, cu
);
6009 part_die
->name
= spec_die
->name
;
6011 /* Copy DW_AT_external attribute if it is set. */
6012 if (spec_die
->is_external
)
6013 part_die
->is_external
= spec_die
->is_external
;
6017 /* Set default names for some unnamed DIEs. */
6018 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
6019 || part_die
->tag
== DW_TAG_class_type
))
6020 part_die
->name
= "(anonymous class)";
6022 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
6023 part_die
->name
= "(anonymous namespace)";
6025 if (part_die
->tag
== DW_TAG_structure_type
6026 || part_die
->tag
== DW_TAG_class_type
6027 || part_die
->tag
== DW_TAG_union_type
)
6028 guess_structure_name (part_die
, cu
);
6031 /* Read the die from the .debug_info section buffer. Set DIEP to
6032 point to a newly allocated die with its information, except for its
6033 child, sibling, and parent fields. Set HAS_CHILDREN to tell
6034 whether the die has children or not. */
6037 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
6038 struct dwarf2_cu
*cu
, int *has_children
)
6040 unsigned int abbrev_number
, bytes_read
, i
, offset
;
6041 struct abbrev_info
*abbrev
;
6042 struct die_info
*die
;
6044 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
6045 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6046 info_ptr
+= bytes_read
;
6054 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
6057 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
6059 bfd_get_filename (abfd
));
6061 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
6062 die
->offset
= offset
;
6063 die
->tag
= abbrev
->tag
;
6064 die
->abbrev
= abbrev_number
;
6066 die
->num_attrs
= abbrev
->num_attrs
;
6068 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
6069 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
6070 abfd
, info_ptr
, cu
);
6073 *has_children
= abbrev
->has_children
;
6077 /* Read an attribute value described by an attribute form. */
6080 read_attribute_value (struct attribute
*attr
, unsigned form
,
6081 bfd
*abfd
, gdb_byte
*info_ptr
,
6082 struct dwarf2_cu
*cu
)
6084 struct comp_unit_head
*cu_header
= &cu
->header
;
6085 unsigned int bytes_read
;
6086 struct dwarf_block
*blk
;
6092 case DW_FORM_ref_addr
:
6093 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
6094 info_ptr
+= bytes_read
;
6096 case DW_FORM_block2
:
6097 blk
= dwarf_alloc_block (cu
);
6098 blk
->size
= read_2_bytes (abfd
, info_ptr
);
6100 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6101 info_ptr
+= blk
->size
;
6102 DW_BLOCK (attr
) = blk
;
6104 case DW_FORM_block4
:
6105 blk
= dwarf_alloc_block (cu
);
6106 blk
->size
= read_4_bytes (abfd
, info_ptr
);
6108 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6109 info_ptr
+= blk
->size
;
6110 DW_BLOCK (attr
) = blk
;
6113 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
6117 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
6121 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
6124 case DW_FORM_string
:
6125 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
6126 info_ptr
+= bytes_read
;
6129 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
6131 info_ptr
+= bytes_read
;
6134 blk
= dwarf_alloc_block (cu
);
6135 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6136 info_ptr
+= bytes_read
;
6137 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6138 info_ptr
+= blk
->size
;
6139 DW_BLOCK (attr
) = blk
;
6141 case DW_FORM_block1
:
6142 blk
= dwarf_alloc_block (cu
);
6143 blk
->size
= read_1_byte (abfd
, info_ptr
);
6145 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6146 info_ptr
+= blk
->size
;
6147 DW_BLOCK (attr
) = blk
;
6150 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
6154 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
6158 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
6159 info_ptr
+= bytes_read
;
6162 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6163 info_ptr
+= bytes_read
;
6166 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
6170 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
6174 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
6178 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
6181 case DW_FORM_ref_udata
:
6182 DW_ADDR (attr
) = (cu
->header
.offset
6183 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
6184 info_ptr
+= bytes_read
;
6186 case DW_FORM_indirect
:
6187 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6188 info_ptr
+= bytes_read
;
6189 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
6192 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
6193 dwarf_form_name (form
),
6194 bfd_get_filename (abfd
));
6197 /* We have seen instances where the compiler tried to emit a byte
6198 size attribute of -1 which ended up being encoded as an unsigned
6199 0xffffffff. Although 0xffffffff is technically a valid size value,
6200 an object of this size seems pretty unlikely so we can relatively
6201 safely treat these cases as if the size attribute was invalid and
6202 treat them as zero by default. */
6203 if (attr
->name
== DW_AT_byte_size
6204 && form
== DW_FORM_data4
6205 && DW_UNSND (attr
) >= 0xffffffff)
6208 (&symfile_complaints
,
6209 _("Suspicious DW_AT_byte_size value treated as zero instead of 0x%lx"),
6211 DW_UNSND (attr
) = 0;
6217 /* Read an attribute described by an abbreviated attribute. */
6220 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
6221 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
6223 attr
->name
= abbrev
->name
;
6224 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
6227 /* read dwarf information from a buffer */
6230 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
6232 return bfd_get_8 (abfd
, buf
);
6236 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
6238 return bfd_get_signed_8 (abfd
, buf
);
6242 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
6244 return bfd_get_16 (abfd
, buf
);
6248 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6250 return bfd_get_signed_16 (abfd
, buf
);
6254 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
6256 return bfd_get_32 (abfd
, buf
);
6260 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6262 return bfd_get_signed_32 (abfd
, buf
);
6265 static unsigned long
6266 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
6268 return bfd_get_64 (abfd
, buf
);
6272 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
6273 unsigned int *bytes_read
)
6275 struct comp_unit_head
*cu_header
= &cu
->header
;
6276 CORE_ADDR retval
= 0;
6278 if (cu_header
->signed_addr_p
)
6280 switch (cu_header
->addr_size
)
6283 retval
= bfd_get_signed_16 (abfd
, buf
);
6286 retval
= bfd_get_signed_32 (abfd
, buf
);
6289 retval
= bfd_get_signed_64 (abfd
, buf
);
6292 internal_error (__FILE__
, __LINE__
,
6293 _("read_address: bad switch, signed [in module %s]"),
6294 bfd_get_filename (abfd
));
6299 switch (cu_header
->addr_size
)
6302 retval
= bfd_get_16 (abfd
, buf
);
6305 retval
= bfd_get_32 (abfd
, buf
);
6308 retval
= bfd_get_64 (abfd
, buf
);
6311 internal_error (__FILE__
, __LINE__
,
6312 _("read_address: bad switch, unsigned [in module %s]"),
6313 bfd_get_filename (abfd
));
6317 *bytes_read
= cu_header
->addr_size
;
6321 /* Read the initial length from a section. The (draft) DWARF 3
6322 specification allows the initial length to take up either 4 bytes
6323 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6324 bytes describe the length and all offsets will be 8 bytes in length
6327 An older, non-standard 64-bit format is also handled by this
6328 function. The older format in question stores the initial length
6329 as an 8-byte quantity without an escape value. Lengths greater
6330 than 2^32 aren't very common which means that the initial 4 bytes
6331 is almost always zero. Since a length value of zero doesn't make
6332 sense for the 32-bit format, this initial zero can be considered to
6333 be an escape value which indicates the presence of the older 64-bit
6334 format. As written, the code can't detect (old format) lengths
6335 greater than 4GB. If it becomes necessary to handle lengths
6336 somewhat larger than 4GB, we could allow other small values (such
6337 as the non-sensical values of 1, 2, and 3) to also be used as
6338 escape values indicating the presence of the old format.
6340 The value returned via bytes_read should be used to increment the
6341 relevant pointer after calling read_initial_length().
6343 As a side effect, this function sets the fields initial_length_size
6344 and offset_size in cu_header to the values appropriate for the
6345 length field. (The format of the initial length field determines
6346 the width of file offsets to be fetched later with read_offset().)
6348 [ Note: read_initial_length() and read_offset() are based on the
6349 document entitled "DWARF Debugging Information Format", revision
6350 3, draft 8, dated November 19, 2001. This document was obtained
6353 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6355 This document is only a draft and is subject to change. (So beware.)
6357 Details regarding the older, non-standard 64-bit format were
6358 determined empirically by examining 64-bit ELF files produced by
6359 the SGI toolchain on an IRIX 6.5 machine.
6361 - Kevin, July 16, 2002
6365 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
6366 unsigned int *bytes_read
)
6368 LONGEST length
= bfd_get_32 (abfd
, buf
);
6370 if (length
== 0xffffffff)
6372 length
= bfd_get_64 (abfd
, buf
+ 4);
6375 else if (length
== 0)
6377 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6378 length
= bfd_get_64 (abfd
, buf
);
6388 gdb_assert (cu_header
->initial_length_size
== 0
6389 || cu_header
->initial_length_size
== 4
6390 || cu_header
->initial_length_size
== 8
6391 || cu_header
->initial_length_size
== 12);
6393 if (cu_header
->initial_length_size
!= 0
6394 && cu_header
->initial_length_size
!= *bytes_read
)
6395 complaint (&symfile_complaints
,
6396 _("intermixed 32-bit and 64-bit DWARF sections"));
6398 cu_header
->initial_length_size
= *bytes_read
;
6399 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6405 /* Read an offset from the data stream. The size of the offset is
6406 given by cu_header->offset_size. */
6409 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6410 unsigned int *bytes_read
)
6414 switch (cu_header
->offset_size
)
6417 retval
= bfd_get_32 (abfd
, buf
);
6421 retval
= bfd_get_64 (abfd
, buf
);
6425 internal_error (__FILE__
, __LINE__
,
6426 _("read_offset: bad switch [in module %s]"),
6427 bfd_get_filename (abfd
));
6434 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6436 /* If the size of a host char is 8 bits, we can return a pointer
6437 to the buffer, otherwise we have to copy the data to a buffer
6438 allocated on the temporary obstack. */
6439 gdb_assert (HOST_CHAR_BIT
== 8);
6444 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6446 /* If the size of a host char is 8 bits, we can return a pointer
6447 to the string, otherwise we have to copy the string to a buffer
6448 allocated on the temporary obstack. */
6449 gdb_assert (HOST_CHAR_BIT
== 8);
6452 *bytes_read_ptr
= 1;
6455 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6456 return (char *) buf
;
6460 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6461 const struct comp_unit_head
*cu_header
,
6462 unsigned int *bytes_read_ptr
)
6464 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6467 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6469 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6470 bfd_get_filename (abfd
));
6473 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6475 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6476 bfd_get_filename (abfd
));
6479 gdb_assert (HOST_CHAR_BIT
== 8);
6480 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6482 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6485 static unsigned long
6486 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6488 unsigned long result
;
6489 unsigned int num_read
;
6499 byte
= bfd_get_8 (abfd
, buf
);
6502 result
|= ((unsigned long)(byte
& 127) << shift
);
6503 if ((byte
& 128) == 0)
6509 *bytes_read_ptr
= num_read
;
6514 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6517 int i
, shift
, num_read
;
6526 byte
= bfd_get_8 (abfd
, buf
);
6529 result
|= ((long)(byte
& 127) << shift
);
6531 if ((byte
& 128) == 0)
6536 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6537 result
|= -(((long)1) << shift
);
6538 *bytes_read_ptr
= num_read
;
6542 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6545 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6551 byte
= bfd_get_8 (abfd
, buf
);
6553 if ((byte
& 128) == 0)
6559 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6565 cu
->language
= language_c
;
6567 case DW_LANG_C_plus_plus
:
6568 cu
->language
= language_cplus
;
6570 case DW_LANG_Fortran77
:
6571 case DW_LANG_Fortran90
:
6572 case DW_LANG_Fortran95
:
6573 cu
->language
= language_fortran
;
6575 case DW_LANG_Mips_Assembler
:
6576 cu
->language
= language_asm
;
6579 cu
->language
= language_java
;
6583 cu
->language
= language_ada
;
6585 case DW_LANG_Modula2
:
6586 cu
->language
= language_m2
;
6588 case DW_LANG_Pascal83
:
6589 cu
->language
= language_pascal
;
6592 cu
->language
= language_objc
;
6594 case DW_LANG_Cobol74
:
6595 case DW_LANG_Cobol85
:
6597 cu
->language
= language_minimal
;
6600 cu
->language_defn
= language_def (cu
->language
);
6603 /* Return the named attribute or NULL if not there. */
6605 static struct attribute
*
6606 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6609 struct attribute
*spec
= NULL
;
6611 for (i
= 0; i
< die
->num_attrs
; ++i
)
6613 if (die
->attrs
[i
].name
== name
)
6614 return &die
->attrs
[i
];
6615 if (die
->attrs
[i
].name
== DW_AT_specification
6616 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6617 spec
= &die
->attrs
[i
];
6622 die
= follow_die_ref (die
, spec
, &cu
);
6623 return dwarf2_attr (die
, name
, cu
);
6629 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6630 and holds a non-zero value. This function should only be used for
6631 DW_FORM_flag attributes. */
6634 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6636 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6638 return (attr
&& DW_UNSND (attr
));
6642 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6644 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6645 which value is non-zero. However, we have to be careful with
6646 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6647 (via dwarf2_flag_true_p) follows this attribute. So we may
6648 end up accidently finding a declaration attribute that belongs
6649 to a different DIE referenced by the specification attribute,
6650 even though the given DIE does not have a declaration attribute. */
6651 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6652 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6655 /* Return the die giving the specification for DIE, if there is
6656 one. *SPEC_CU is the CU containing DIE on input, and the CU
6657 containing the return value on output. */
6659 static struct die_info
*
6660 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
6662 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
6665 if (spec_attr
== NULL
)
6668 return follow_die_ref (die
, spec_attr
, spec_cu
);
6671 /* Free the line_header structure *LH, and any arrays and strings it
6674 free_line_header (struct line_header
*lh
)
6676 if (lh
->standard_opcode_lengths
)
6677 xfree (lh
->standard_opcode_lengths
);
6679 /* Remember that all the lh->file_names[i].name pointers are
6680 pointers into debug_line_buffer, and don't need to be freed. */
6682 xfree (lh
->file_names
);
6684 /* Similarly for the include directory names. */
6685 if (lh
->include_dirs
)
6686 xfree (lh
->include_dirs
);
6692 /* Add an entry to LH's include directory table. */
6694 add_include_dir (struct line_header
*lh
, char *include_dir
)
6696 /* Grow the array if necessary. */
6697 if (lh
->include_dirs_size
== 0)
6699 lh
->include_dirs_size
= 1; /* for testing */
6700 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6701 * sizeof (*lh
->include_dirs
));
6703 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6705 lh
->include_dirs_size
*= 2;
6706 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6707 (lh
->include_dirs_size
6708 * sizeof (*lh
->include_dirs
)));
6711 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6715 /* Add an entry to LH's file name table. */
6717 add_file_name (struct line_header
*lh
,
6719 unsigned int dir_index
,
6720 unsigned int mod_time
,
6721 unsigned int length
)
6723 struct file_entry
*fe
;
6725 /* Grow the array if necessary. */
6726 if (lh
->file_names_size
== 0)
6728 lh
->file_names_size
= 1; /* for testing */
6729 lh
->file_names
= xmalloc (lh
->file_names_size
6730 * sizeof (*lh
->file_names
));
6732 else if (lh
->num_file_names
>= lh
->file_names_size
)
6734 lh
->file_names_size
*= 2;
6735 lh
->file_names
= xrealloc (lh
->file_names
,
6736 (lh
->file_names_size
6737 * sizeof (*lh
->file_names
)));
6740 fe
= &lh
->file_names
[lh
->num_file_names
++];
6742 fe
->dir_index
= dir_index
;
6743 fe
->mod_time
= mod_time
;
6744 fe
->length
= length
;
6750 /* Read the statement program header starting at OFFSET in
6751 .debug_line, according to the endianness of ABFD. Return a pointer
6752 to a struct line_header, allocated using xmalloc.
6754 NOTE: the strings in the include directory and file name tables of
6755 the returned object point into debug_line_buffer, and must not be
6757 static struct line_header
*
6758 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6759 struct dwarf2_cu
*cu
)
6761 struct cleanup
*back_to
;
6762 struct line_header
*lh
;
6764 unsigned int bytes_read
;
6766 char *cur_dir
, *cur_file
;
6768 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6770 complaint (&symfile_complaints
, _("missing .debug_line section"));
6774 /* Make sure that at least there's room for the total_length field.
6775 That could be 12 bytes long, but we're just going to fudge that. */
6776 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6778 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6782 lh
= xmalloc (sizeof (*lh
));
6783 memset (lh
, 0, sizeof (*lh
));
6784 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6787 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6789 /* Read in the header. */
6791 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6792 line_ptr
+= bytes_read
;
6793 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6794 + dwarf2_per_objfile
->line_size
))
6796 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6799 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6800 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6802 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6803 line_ptr
+= bytes_read
;
6804 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6806 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6808 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6810 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6812 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6814 lh
->standard_opcode_lengths
6815 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6817 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6818 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6820 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6824 /* Read directory table. */
6825 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6827 line_ptr
+= bytes_read
;
6828 add_include_dir (lh
, cur_dir
);
6830 line_ptr
+= bytes_read
;
6832 /* Read file name table. */
6833 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6835 unsigned int dir_index
, mod_time
, length
;
6837 line_ptr
+= bytes_read
;
6838 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6839 line_ptr
+= bytes_read
;
6840 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6841 line_ptr
+= bytes_read
;
6842 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6843 line_ptr
+= bytes_read
;
6845 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6847 line_ptr
+= bytes_read
;
6848 lh
->statement_program_start
= line_ptr
;
6850 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6851 + dwarf2_per_objfile
->line_size
))
6852 complaint (&symfile_complaints
,
6853 _("line number info header doesn't fit in `.debug_line' section"));
6855 discard_cleanups (back_to
);
6859 /* This function exists to work around a bug in certain compilers
6860 (particularly GCC 2.95), in which the first line number marker of a
6861 function does not show up until after the prologue, right before
6862 the second line number marker. This function shifts ADDRESS down
6863 to the beginning of the function if necessary, and is called on
6864 addresses passed to record_line. */
6867 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6869 struct function_range
*fn
;
6871 /* Find the function_range containing address. */
6876 cu
->cached_fn
= cu
->first_fn
;
6880 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6886 while (fn
&& fn
!= cu
->cached_fn
)
6887 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6897 if (address
!= fn
->lowpc
)
6898 complaint (&symfile_complaints
,
6899 _("misplaced first line number at 0x%lx for '%s'"),
6900 (unsigned long) address
, fn
->name
);
6905 /* Decode the Line Number Program (LNP) for the given line_header
6906 structure and CU. The actual information extracted and the type
6907 of structures created from the LNP depends on the value of PST.
6909 1. If PST is NULL, then this procedure uses the data from the program
6910 to create all necessary symbol tables, and their linetables.
6911 The compilation directory of the file is passed in COMP_DIR,
6912 and must not be NULL.
6914 2. If PST is not NULL, this procedure reads the program to determine
6915 the list of files included by the unit represented by PST, and
6916 builds all the associated partial symbol tables. In this case,
6917 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6918 is not used to compute the full name of the symtab, and therefore
6919 omitting it when building the partial symtab does not introduce
6920 the potential for inconsistency - a partial symtab and its associated
6921 symbtab having a different fullname -). */
6924 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6925 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6927 gdb_byte
*line_ptr
, *extended_end
;
6929 unsigned int bytes_read
, extended_len
;
6930 unsigned char op_code
, extended_op
, adj_opcode
;
6932 struct objfile
*objfile
= cu
->objfile
;
6933 const int decode_for_pst_p
= (pst
!= NULL
);
6934 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
6936 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6938 line_ptr
= lh
->statement_program_start
;
6939 line_end
= lh
->statement_program_end
;
6941 /* Read the statement sequences until there's nothing left. */
6942 while (line_ptr
< line_end
)
6944 /* state machine registers */
6945 CORE_ADDR address
= 0;
6946 unsigned int file
= 1;
6947 unsigned int line
= 1;
6948 unsigned int column
= 0;
6949 int is_stmt
= lh
->default_is_stmt
;
6950 int basic_block
= 0;
6951 int end_sequence
= 0;
6953 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6955 /* Start a subfile for the current file of the state machine. */
6956 /* lh->include_dirs and lh->file_names are 0-based, but the
6957 directory and file name numbers in the statement program
6959 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6963 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6965 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6968 /* Decode the table. */
6969 while (!end_sequence
)
6971 op_code
= read_1_byte (abfd
, line_ptr
);
6974 if (op_code
>= lh
->opcode_base
)
6976 /* Special operand. */
6977 adj_opcode
= op_code
- lh
->opcode_base
;
6978 address
+= (adj_opcode
/ lh
->line_range
)
6979 * lh
->minimum_instruction_length
;
6980 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6981 if (lh
->num_file_names
< file
)
6982 dwarf2_debug_line_missing_file_complaint ();
6985 lh
->file_names
[file
- 1].included_p
= 1;
6986 if (!decode_for_pst_p
)
6988 if (last_subfile
!= current_subfile
)
6991 record_line (last_subfile
, 0, address
);
6992 last_subfile
= current_subfile
;
6994 /* Append row to matrix using current values. */
6995 record_line (current_subfile
, line
,
6996 check_cu_functions (address
, cu
));
7001 else switch (op_code
)
7003 case DW_LNS_extended_op
:
7004 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7005 line_ptr
+= bytes_read
;
7006 extended_end
= line_ptr
+ extended_len
;
7007 extended_op
= read_1_byte (abfd
, line_ptr
);
7009 switch (extended_op
)
7011 case DW_LNE_end_sequence
:
7014 if (lh
->num_file_names
< file
)
7015 dwarf2_debug_line_missing_file_complaint ();
7018 lh
->file_names
[file
- 1].included_p
= 1;
7019 if (!decode_for_pst_p
)
7020 record_line (current_subfile
, 0, address
);
7023 case DW_LNE_set_address
:
7024 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
7025 line_ptr
+= bytes_read
;
7026 address
+= baseaddr
;
7028 case DW_LNE_define_file
:
7031 unsigned int dir_index
, mod_time
, length
;
7033 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
7034 line_ptr
+= bytes_read
;
7036 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7037 line_ptr
+= bytes_read
;
7039 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7040 line_ptr
+= bytes_read
;
7042 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7043 line_ptr
+= bytes_read
;
7044 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
7048 complaint (&symfile_complaints
,
7049 _("mangled .debug_line section"));
7052 /* Make sure that we parsed the extended op correctly. If e.g.
7053 we expected a different address size than the producer used,
7054 we may have read the wrong number of bytes. */
7055 if (line_ptr
!= extended_end
)
7057 complaint (&symfile_complaints
,
7058 _("mangled .debug_line section"));
7063 if (lh
->num_file_names
< file
)
7064 dwarf2_debug_line_missing_file_complaint ();
7067 lh
->file_names
[file
- 1].included_p
= 1;
7068 if (!decode_for_pst_p
)
7070 if (last_subfile
!= current_subfile
)
7073 record_line (last_subfile
, 0, address
);
7074 last_subfile
= current_subfile
;
7076 record_line (current_subfile
, line
,
7077 check_cu_functions (address
, cu
));
7082 case DW_LNS_advance_pc
:
7083 address
+= lh
->minimum_instruction_length
7084 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7085 line_ptr
+= bytes_read
;
7087 case DW_LNS_advance_line
:
7088 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
7089 line_ptr
+= bytes_read
;
7091 case DW_LNS_set_file
:
7093 /* The arrays lh->include_dirs and lh->file_names are
7094 0-based, but the directory and file name numbers in
7095 the statement program are 1-based. */
7096 struct file_entry
*fe
;
7099 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7100 line_ptr
+= bytes_read
;
7101 if (lh
->num_file_names
< file
)
7102 dwarf2_debug_line_missing_file_complaint ();
7105 fe
= &lh
->file_names
[file
- 1];
7107 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7108 if (!decode_for_pst_p
)
7110 last_subfile
= current_subfile
;
7111 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7116 case DW_LNS_set_column
:
7117 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7118 line_ptr
+= bytes_read
;
7120 case DW_LNS_negate_stmt
:
7121 is_stmt
= (!is_stmt
);
7123 case DW_LNS_set_basic_block
:
7126 /* Add to the address register of the state machine the
7127 address increment value corresponding to special opcode
7128 255. I.e., this value is scaled by the minimum
7129 instruction length since special opcode 255 would have
7130 scaled the the increment. */
7131 case DW_LNS_const_add_pc
:
7132 address
+= (lh
->minimum_instruction_length
7133 * ((255 - lh
->opcode_base
) / lh
->line_range
));
7135 case DW_LNS_fixed_advance_pc
:
7136 address
+= read_2_bytes (abfd
, line_ptr
);
7141 /* Unknown standard opcode, ignore it. */
7144 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
7146 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7147 line_ptr
+= bytes_read
;
7154 if (decode_for_pst_p
)
7158 /* Now that we're done scanning the Line Header Program, we can
7159 create the psymtab of each included file. */
7160 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
7161 if (lh
->file_names
[file_index
].included_p
== 1)
7163 const struct file_entry fe
= lh
->file_names
[file_index
];
7164 char *include_name
= fe
.name
;
7165 char *dir_name
= NULL
;
7166 char *pst_filename
= pst
->filename
;
7169 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
7171 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
7173 include_name
= concat (dir_name
, SLASH_STRING
,
7174 include_name
, (char *)NULL
);
7175 make_cleanup (xfree
, include_name
);
7178 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
7180 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
7181 pst_filename
, (char *)NULL
);
7182 make_cleanup (xfree
, pst_filename
);
7185 if (strcmp (include_name
, pst_filename
) != 0)
7186 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
7191 /* Make sure a symtab is created for every file, even files
7192 which contain only variables (i.e. no code with associated
7196 struct file_entry
*fe
;
7198 for (i
= 0; i
< lh
->num_file_names
; i
++)
7201 fe
= &lh
->file_names
[i
];
7203 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7204 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7206 /* Skip the main file; we don't need it, and it must be
7207 allocated last, so that it will show up before the
7208 non-primary symtabs in the objfile's symtab list. */
7209 if (current_subfile
== first_subfile
)
7212 if (current_subfile
->symtab
== NULL
)
7213 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
7215 fe
->symtab
= current_subfile
->symtab
;
7220 /* Start a subfile for DWARF. FILENAME is the name of the file and
7221 DIRNAME the name of the source directory which contains FILENAME
7222 or NULL if not known. COMP_DIR is the compilation directory for the
7223 linetable's compilation unit or NULL if not known.
7224 This routine tries to keep line numbers from identical absolute and
7225 relative file names in a common subfile.
7227 Using the `list' example from the GDB testsuite, which resides in
7228 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
7229 of /srcdir/list0.c yields the following debugging information for list0.c:
7231 DW_AT_name: /srcdir/list0.c
7232 DW_AT_comp_dir: /compdir
7233 files.files[0].name: list0.h
7234 files.files[0].dir: /srcdir
7235 files.files[1].name: list0.c
7236 files.files[1].dir: /srcdir
7238 The line number information for list0.c has to end up in a single
7239 subfile, so that `break /srcdir/list0.c:1' works as expected.
7240 start_subfile will ensure that this happens provided that we pass the
7241 concatenation of files.files[1].dir and files.files[1].name as the
7245 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
7249 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
7250 `start_symtab' will always pass the contents of DW_AT_comp_dir as
7251 second argument to start_subfile. To be consistent, we do the
7252 same here. In order not to lose the line information directory,
7253 we concatenate it to the filename when it makes sense.
7254 Note that the Dwarf3 standard says (speaking of filenames in line
7255 information): ``The directory index is ignored for file names
7256 that represent full path names''. Thus ignoring dirname in the
7257 `else' branch below isn't an issue. */
7259 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
7260 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
7262 fullname
= filename
;
7264 start_subfile (fullname
, comp_dir
);
7266 if (fullname
!= filename
)
7271 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
7272 struct dwarf2_cu
*cu
)
7274 struct objfile
*objfile
= cu
->objfile
;
7275 struct comp_unit_head
*cu_header
= &cu
->header
;
7277 /* NOTE drow/2003-01-30: There used to be a comment and some special
7278 code here to turn a symbol with DW_AT_external and a
7279 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
7280 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
7281 with some versions of binutils) where shared libraries could have
7282 relocations against symbols in their debug information - the
7283 minimal symbol would have the right address, but the debug info
7284 would not. It's no longer necessary, because we will explicitly
7285 apply relocations when we read in the debug information now. */
7287 /* A DW_AT_location attribute with no contents indicates that a
7288 variable has been optimized away. */
7289 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
7291 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7295 /* Handle one degenerate form of location expression specially, to
7296 preserve GDB's previous behavior when section offsets are
7297 specified. If this is just a DW_OP_addr then mark this symbol
7300 if (attr_form_is_block (attr
)
7301 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
7302 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
7306 SYMBOL_VALUE_ADDRESS (sym
) =
7307 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
7308 SYMBOL_CLASS (sym
) = LOC_STATIC
;
7309 fixup_symbol_section (sym
, objfile
);
7310 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
7311 SYMBOL_SECTION (sym
));
7315 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
7316 expression evaluator, and use LOC_COMPUTED only when necessary
7317 (i.e. when the value of a register or memory location is
7318 referenced, or a thread-local block, etc.). Then again, it might
7319 not be worthwhile. I'm assuming that it isn't unless performance
7320 or memory numbers show me otherwise. */
7322 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
7323 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
7326 /* Given a pointer to a DWARF information entry, figure out if we need
7327 to make a symbol table entry for it, and if so, create a new entry
7328 and return a pointer to it.
7329 If TYPE is NULL, determine symbol type from the die, otherwise
7330 used the passed type. */
7332 static struct symbol
*
7333 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
7335 struct objfile
*objfile
= cu
->objfile
;
7336 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7337 struct symbol
*sym
= NULL
;
7339 struct attribute
*attr
= NULL
;
7340 struct attribute
*attr2
= NULL
;
7343 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7345 if (die
->tag
!= DW_TAG_namespace
)
7346 name
= dwarf2_linkage_name (die
, cu
);
7348 name
= TYPE_NAME (type
);
7352 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
7353 sizeof (struct symbol
));
7354 OBJSTAT (objfile
, n_syms
++);
7355 memset (sym
, 0, sizeof (struct symbol
));
7357 /* Cache this symbol's name and the name's demangled form (if any). */
7358 SYMBOL_LANGUAGE (sym
) = cu
->language
;
7359 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
7361 /* Default assumptions.
7362 Use the passed type or decode it from the die. */
7363 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7364 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7366 SYMBOL_TYPE (sym
) = type
;
7368 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
7369 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
7372 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
7375 attr
= dwarf2_attr (die
, DW_AT_decl_file
, cu
);
7378 int file_index
= DW_UNSND (attr
);
7379 if (cu
->line_header
== NULL
7380 || file_index
> cu
->line_header
->num_file_names
)
7381 complaint (&symfile_complaints
,
7382 _("file index out of range"));
7383 else if (file_index
> 0)
7385 struct file_entry
*fe
;
7386 fe
= &cu
->line_header
->file_names
[file_index
- 1];
7387 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
7394 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7397 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
7399 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7401 case DW_TAG_subprogram
:
7402 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7404 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7405 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7406 if ((attr2
&& (DW_UNSND (attr2
) != 0))
7407 || cu
->language
== language_ada
)
7409 /* Subprograms marked external are stored as a global symbol.
7410 Ada subprograms, whether marked external or not, are always
7411 stored as a global symbol, because we want to be able to
7412 access them globally. For instance, we want to be able
7413 to break on a nested subprogram without having to
7414 specify the context. */
7415 add_symbol_to_list (sym
, &global_symbols
);
7419 add_symbol_to_list (sym
, cu
->list_in_scope
);
7422 case DW_TAG_variable
:
7423 /* Compilation with minimal debug info may result in variables
7424 with missing type entries. Change the misleading `void' type
7425 to something sensible. */
7426 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7428 = builtin_type (gdbarch
)->nodebug_data_symbol
;
7430 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7433 dwarf2_const_value (attr
, sym
, cu
);
7434 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7435 if (attr2
&& (DW_UNSND (attr2
) != 0))
7436 add_symbol_to_list (sym
, &global_symbols
);
7438 add_symbol_to_list (sym
, cu
->list_in_scope
);
7441 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7444 var_decode_location (attr
, sym
, cu
);
7445 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7446 if (attr2
&& (DW_UNSND (attr2
) != 0))
7447 add_symbol_to_list (sym
, &global_symbols
);
7449 add_symbol_to_list (sym
, cu
->list_in_scope
);
7453 /* We do not know the address of this symbol.
7454 If it is an external symbol and we have type information
7455 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7456 The address of the variable will then be determined from
7457 the minimal symbol table whenever the variable is
7459 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7460 if (attr2
&& (DW_UNSND (attr2
) != 0)
7461 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7463 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7464 add_symbol_to_list (sym
, &global_symbols
);
7468 case DW_TAG_formal_parameter
:
7469 SYMBOL_IS_ARGUMENT (sym
) = 1;
7470 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7473 var_decode_location (attr
, sym
, cu
);
7475 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7478 dwarf2_const_value (attr
, sym
, cu
);
7480 add_symbol_to_list (sym
, cu
->list_in_scope
);
7482 case DW_TAG_unspecified_parameters
:
7483 /* From varargs functions; gdb doesn't seem to have any
7484 interest in this information, so just ignore it for now.
7487 case DW_TAG_class_type
:
7488 case DW_TAG_interface_type
:
7489 case DW_TAG_structure_type
:
7490 case DW_TAG_union_type
:
7491 case DW_TAG_set_type
:
7492 case DW_TAG_enumeration_type
:
7493 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7494 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7496 /* Make sure that the symbol includes appropriate enclosing
7497 classes/namespaces in its name. These are calculated in
7498 read_structure_type, and the correct name is saved in
7501 if (cu
->language
== language_cplus
7502 || cu
->language
== language_java
)
7504 struct type
*type
= SYMBOL_TYPE (sym
);
7506 if (TYPE_TAG_NAME (type
) != NULL
)
7508 /* FIXME: carlton/2003-11-10: Should this use
7509 SYMBOL_SET_NAMES instead? (The same problem also
7510 arises further down in this function.) */
7511 /* The type's name is already allocated along with
7512 this objfile, so we don't need to duplicate it
7514 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7519 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7520 really ever be static objects: otherwise, if you try
7521 to, say, break of a class's method and you're in a file
7522 which doesn't mention that class, it won't work unless
7523 the check for all static symbols in lookup_symbol_aux
7524 saves you. See the OtherFileClass tests in
7525 gdb.c++/namespace.exp. */
7527 struct pending
**list_to_add
;
7529 list_to_add
= (cu
->list_in_scope
== &file_symbols
7530 && (cu
->language
== language_cplus
7531 || cu
->language
== language_java
)
7532 ? &global_symbols
: cu
->list_in_scope
);
7534 add_symbol_to_list (sym
, list_to_add
);
7536 /* The semantics of C++ state that "struct foo { ... }" also
7537 defines a typedef for "foo". A Java class declaration also
7538 defines a typedef for the class. */
7539 if (cu
->language
== language_cplus
7540 || cu
->language
== language_java
7541 || cu
->language
== language_ada
)
7543 /* The symbol's name is already allocated along with
7544 this objfile, so we don't need to duplicate it for
7546 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7547 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7551 case DW_TAG_typedef
:
7552 if (processing_has_namespace_info
7553 && processing_current_prefix
[0] != '\0')
7555 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7556 processing_current_prefix
,
7559 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7560 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7561 add_symbol_to_list (sym
, cu
->list_in_scope
);
7563 case DW_TAG_base_type
:
7564 case DW_TAG_subrange_type
:
7565 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7566 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7567 add_symbol_to_list (sym
, cu
->list_in_scope
);
7569 case DW_TAG_enumerator
:
7570 if (processing_has_namespace_info
7571 && processing_current_prefix
[0] != '\0')
7573 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7574 processing_current_prefix
,
7577 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7580 dwarf2_const_value (attr
, sym
, cu
);
7583 /* NOTE: carlton/2003-11-10: See comment above in the
7584 DW_TAG_class_type, etc. block. */
7586 struct pending
**list_to_add
;
7588 list_to_add
= (cu
->list_in_scope
== &file_symbols
7589 && (cu
->language
== language_cplus
7590 || cu
->language
== language_java
)
7591 ? &global_symbols
: cu
->list_in_scope
);
7593 add_symbol_to_list (sym
, list_to_add
);
7596 case DW_TAG_namespace
:
7597 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7598 add_symbol_to_list (sym
, &global_symbols
);
7601 /* Not a tag we recognize. Hopefully we aren't processing
7602 trash data, but since we must specifically ignore things
7603 we don't recognize, there is nothing else we should do at
7605 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7606 dwarf_tag_name (die
->tag
));
7613 /* Copy constant value from an attribute to a symbol. */
7616 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7617 struct dwarf2_cu
*cu
)
7619 struct objfile
*objfile
= cu
->objfile
;
7620 struct comp_unit_head
*cu_header
= &cu
->header
;
7621 struct dwarf_block
*blk
;
7626 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7627 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
7628 cu_header
->addr_size
,
7629 TYPE_LENGTH (SYMBOL_TYPE
7631 SYMBOL_VALUE_BYTES (sym
) =
7632 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7633 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7634 it's body - store_unsigned_integer. */
7635 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7637 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7640 /* DW_STRING is already allocated on the obstack, point directly
7642 SYMBOL_VALUE_BYTES (sym
) = (gdb_byte
*) DW_STRING (attr
);
7643 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7645 case DW_FORM_block1
:
7646 case DW_FORM_block2
:
7647 case DW_FORM_block4
:
7649 blk
= DW_BLOCK (attr
);
7650 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7651 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
7653 TYPE_LENGTH (SYMBOL_TYPE
7655 SYMBOL_VALUE_BYTES (sym
) =
7656 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7657 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7658 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7661 /* The DW_AT_const_value attributes are supposed to carry the
7662 symbol's value "represented as it would be on the target
7663 architecture." By the time we get here, it's already been
7664 converted to host endianness, so we just need to sign- or
7665 zero-extend it as appropriate. */
7667 dwarf2_const_value_data (attr
, sym
, 8);
7670 dwarf2_const_value_data (attr
, sym
, 16);
7673 dwarf2_const_value_data (attr
, sym
, 32);
7676 dwarf2_const_value_data (attr
, sym
, 64);
7680 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7681 SYMBOL_CLASS (sym
) = LOC_CONST
;
7685 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7686 SYMBOL_CLASS (sym
) = LOC_CONST
;
7690 complaint (&symfile_complaints
,
7691 _("unsupported const value attribute form: '%s'"),
7692 dwarf_form_name (attr
->form
));
7693 SYMBOL_VALUE (sym
) = 0;
7694 SYMBOL_CLASS (sym
) = LOC_CONST
;
7700 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7701 or zero-extend it as appropriate for the symbol's type. */
7703 dwarf2_const_value_data (struct attribute
*attr
,
7707 LONGEST l
= DW_UNSND (attr
);
7709 if (bits
< sizeof (l
) * 8)
7711 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7712 l
&= ((LONGEST
) 1 << bits
) - 1;
7714 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7717 SYMBOL_VALUE (sym
) = l
;
7718 SYMBOL_CLASS (sym
) = LOC_CONST
;
7722 /* Return the type of the die in question using its DW_AT_type attribute. */
7724 static struct type
*
7725 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7727 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
7729 struct attribute
*type_attr
;
7730 struct die_info
*type_die
;
7732 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7735 /* A missing DW_AT_type represents a void type. */
7736 return builtin_type (gdbarch
)->builtin_void
;
7739 type_die
= follow_die_ref (die
, type_attr
, &cu
);
7741 type
= tag_type_to_type (type_die
, cu
);
7744 dump_die (type_die
);
7745 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7751 /* Return the containing type of the die in question using its
7752 DW_AT_containing_type attribute. */
7754 static struct type
*
7755 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7757 struct type
*type
= NULL
;
7758 struct attribute
*type_attr
;
7759 struct die_info
*type_die
= NULL
;
7761 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7764 type_die
= follow_die_ref (die
, type_attr
, &cu
);
7765 type
= tag_type_to_type (type_die
, cu
);
7770 dump_die (type_die
);
7771 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7777 static struct type
*
7778 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7780 struct type
*this_type
;
7782 this_type
= read_type_die (die
, cu
);
7786 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7792 static struct type
*
7793 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7796 const char *old_prefix
;
7797 struct cleanup
*back_to
;
7798 struct type
*this_type
;
7800 this_type
= get_die_type (die
, cu
);
7804 prefix
= determine_prefix (die
, cu
);
7805 old_prefix
= processing_current_prefix
;
7806 back_to
= make_cleanup (xfree
, prefix
);
7807 processing_current_prefix
= prefix
;
7811 case DW_TAG_class_type
:
7812 case DW_TAG_interface_type
:
7813 case DW_TAG_structure_type
:
7814 case DW_TAG_union_type
:
7815 this_type
= read_structure_type (die
, cu
);
7817 case DW_TAG_enumeration_type
:
7818 this_type
= read_enumeration_type (die
, cu
);
7820 case DW_TAG_subprogram
:
7821 case DW_TAG_subroutine_type
:
7822 this_type
= read_subroutine_type (die
, cu
);
7824 case DW_TAG_array_type
:
7825 this_type
= read_array_type (die
, cu
);
7827 case DW_TAG_set_type
:
7828 this_type
= read_set_type (die
, cu
);
7830 case DW_TAG_pointer_type
:
7831 this_type
= read_tag_pointer_type (die
, cu
);
7833 case DW_TAG_ptr_to_member_type
:
7834 this_type
= read_tag_ptr_to_member_type (die
, cu
);
7836 case DW_TAG_reference_type
:
7837 this_type
= read_tag_reference_type (die
, cu
);
7839 case DW_TAG_const_type
:
7840 this_type
= read_tag_const_type (die
, cu
);
7842 case DW_TAG_volatile_type
:
7843 this_type
= read_tag_volatile_type (die
, cu
);
7845 case DW_TAG_string_type
:
7846 this_type
= read_tag_string_type (die
, cu
);
7848 case DW_TAG_typedef
:
7849 this_type
= read_typedef (die
, cu
);
7851 case DW_TAG_subrange_type
:
7852 this_type
= read_subrange_type (die
, cu
);
7854 case DW_TAG_base_type
:
7855 this_type
= read_base_type (die
, cu
);
7857 case DW_TAG_unspecified_type
:
7858 this_type
= read_unspecified_type (die
, cu
);
7861 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7862 dwarf_tag_name (die
->tag
));
7866 processing_current_prefix
= old_prefix
;
7867 do_cleanups (back_to
);
7871 /* Return the name of the namespace/class that DIE is defined within,
7872 or "" if we can't tell. The caller should xfree the result. */
7874 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7875 therein) for an example of how to use this function to deal with
7876 DW_AT_specification. */
7879 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7881 struct die_info
*parent
;
7883 if (cu
->language
!= language_cplus
7884 && cu
->language
!= language_java
)
7887 parent
= die
->parent
;
7891 return xstrdup ("");
7895 switch (parent
->tag
) {
7896 case DW_TAG_namespace
:
7898 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7899 before doing this check? */
7900 struct type
*parent_type
= get_die_type (parent
, cu
);
7901 if (parent_type
!= NULL
&& TYPE_TAG_NAME (parent_type
) != NULL
)
7903 return xstrdup (TYPE_TAG_NAME (parent_type
));
7908 char *parent_prefix
= determine_prefix (parent
, cu
);
7909 char *retval
= typename_concat (NULL
, parent_prefix
,
7910 namespace_name (parent
, &dummy
,
7913 xfree (parent_prefix
);
7918 case DW_TAG_class_type
:
7919 case DW_TAG_interface_type
:
7920 case DW_TAG_structure_type
:
7922 struct type
*parent_type
= get_die_type (parent
, cu
);
7923 if (parent_type
!= NULL
&& TYPE_TAG_NAME (parent_type
) != NULL
)
7925 return xstrdup (TYPE_TAG_NAME (parent_type
));
7929 const char *old_prefix
= processing_current_prefix
;
7930 char *new_prefix
= determine_prefix (parent
, cu
);
7933 processing_current_prefix
= new_prefix
;
7934 retval
= determine_class_name (parent
, cu
);
7935 processing_current_prefix
= old_prefix
;
7942 return determine_prefix (parent
, cu
);
7947 /* Return a newly-allocated string formed by concatenating PREFIX and
7948 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7949 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7950 perform an obconcat, otherwise allocate storage for the result. The CU argument
7951 is used to determine the language and hence, the appropriate separator. */
7953 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7956 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7957 struct dwarf2_cu
*cu
)
7961 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7963 else if (cu
->language
== language_java
)
7970 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7975 strcpy (retval
, prefix
);
7976 strcat (retval
, sep
);
7979 strcat (retval
, suffix
);
7985 /* We have an obstack. */
7986 return obconcat (obs
, prefix
, sep
, suffix
);
7990 /* Return sibling of die, NULL if no sibling. */
7992 static struct die_info
*
7993 sibling_die (struct die_info
*die
)
7995 return die
->sibling
;
7998 /* Get linkage name of a die, return NULL if not found. */
8001 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
8003 struct attribute
*attr
;
8005 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8006 if (attr
&& DW_STRING (attr
))
8007 return DW_STRING (attr
);
8008 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8009 if (attr
&& DW_STRING (attr
))
8010 return DW_STRING (attr
);
8014 /* Get name of a die, return NULL if not found. */
8017 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
8019 struct attribute
*attr
;
8021 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8022 if (attr
&& DW_STRING (attr
))
8023 return DW_STRING (attr
);
8027 /* Return the die that this die in an extension of, or NULL if there
8028 is none. *EXT_CU is the CU containing DIE on input, and the CU
8029 containing the return value on output. */
8031 static struct die_info
*
8032 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
8034 struct attribute
*attr
;
8036 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
8040 return follow_die_ref (die
, attr
, ext_cu
);
8043 /* Convert a DIE tag into its string name. */
8046 dwarf_tag_name (unsigned tag
)
8050 case DW_TAG_padding
:
8051 return "DW_TAG_padding";
8052 case DW_TAG_array_type
:
8053 return "DW_TAG_array_type";
8054 case DW_TAG_class_type
:
8055 return "DW_TAG_class_type";
8056 case DW_TAG_entry_point
:
8057 return "DW_TAG_entry_point";
8058 case DW_TAG_enumeration_type
:
8059 return "DW_TAG_enumeration_type";
8060 case DW_TAG_formal_parameter
:
8061 return "DW_TAG_formal_parameter";
8062 case DW_TAG_imported_declaration
:
8063 return "DW_TAG_imported_declaration";
8065 return "DW_TAG_label";
8066 case DW_TAG_lexical_block
:
8067 return "DW_TAG_lexical_block";
8069 return "DW_TAG_member";
8070 case DW_TAG_pointer_type
:
8071 return "DW_TAG_pointer_type";
8072 case DW_TAG_reference_type
:
8073 return "DW_TAG_reference_type";
8074 case DW_TAG_compile_unit
:
8075 return "DW_TAG_compile_unit";
8076 case DW_TAG_string_type
:
8077 return "DW_TAG_string_type";
8078 case DW_TAG_structure_type
:
8079 return "DW_TAG_structure_type";
8080 case DW_TAG_subroutine_type
:
8081 return "DW_TAG_subroutine_type";
8082 case DW_TAG_typedef
:
8083 return "DW_TAG_typedef";
8084 case DW_TAG_union_type
:
8085 return "DW_TAG_union_type";
8086 case DW_TAG_unspecified_parameters
:
8087 return "DW_TAG_unspecified_parameters";
8088 case DW_TAG_variant
:
8089 return "DW_TAG_variant";
8090 case DW_TAG_common_block
:
8091 return "DW_TAG_common_block";
8092 case DW_TAG_common_inclusion
:
8093 return "DW_TAG_common_inclusion";
8094 case DW_TAG_inheritance
:
8095 return "DW_TAG_inheritance";
8096 case DW_TAG_inlined_subroutine
:
8097 return "DW_TAG_inlined_subroutine";
8099 return "DW_TAG_module";
8100 case DW_TAG_ptr_to_member_type
:
8101 return "DW_TAG_ptr_to_member_type";
8102 case DW_TAG_set_type
:
8103 return "DW_TAG_set_type";
8104 case DW_TAG_subrange_type
:
8105 return "DW_TAG_subrange_type";
8106 case DW_TAG_with_stmt
:
8107 return "DW_TAG_with_stmt";
8108 case DW_TAG_access_declaration
:
8109 return "DW_TAG_access_declaration";
8110 case DW_TAG_base_type
:
8111 return "DW_TAG_base_type";
8112 case DW_TAG_catch_block
:
8113 return "DW_TAG_catch_block";
8114 case DW_TAG_const_type
:
8115 return "DW_TAG_const_type";
8116 case DW_TAG_constant
:
8117 return "DW_TAG_constant";
8118 case DW_TAG_enumerator
:
8119 return "DW_TAG_enumerator";
8120 case DW_TAG_file_type
:
8121 return "DW_TAG_file_type";
8123 return "DW_TAG_friend";
8124 case DW_TAG_namelist
:
8125 return "DW_TAG_namelist";
8126 case DW_TAG_namelist_item
:
8127 return "DW_TAG_namelist_item";
8128 case DW_TAG_packed_type
:
8129 return "DW_TAG_packed_type";
8130 case DW_TAG_subprogram
:
8131 return "DW_TAG_subprogram";
8132 case DW_TAG_template_type_param
:
8133 return "DW_TAG_template_type_param";
8134 case DW_TAG_template_value_param
:
8135 return "DW_TAG_template_value_param";
8136 case DW_TAG_thrown_type
:
8137 return "DW_TAG_thrown_type";
8138 case DW_TAG_try_block
:
8139 return "DW_TAG_try_block";
8140 case DW_TAG_variant_part
:
8141 return "DW_TAG_variant_part";
8142 case DW_TAG_variable
:
8143 return "DW_TAG_variable";
8144 case DW_TAG_volatile_type
:
8145 return "DW_TAG_volatile_type";
8146 case DW_TAG_dwarf_procedure
:
8147 return "DW_TAG_dwarf_procedure";
8148 case DW_TAG_restrict_type
:
8149 return "DW_TAG_restrict_type";
8150 case DW_TAG_interface_type
:
8151 return "DW_TAG_interface_type";
8152 case DW_TAG_namespace
:
8153 return "DW_TAG_namespace";
8154 case DW_TAG_imported_module
:
8155 return "DW_TAG_imported_module";
8156 case DW_TAG_unspecified_type
:
8157 return "DW_TAG_unspecified_type";
8158 case DW_TAG_partial_unit
:
8159 return "DW_TAG_partial_unit";
8160 case DW_TAG_imported_unit
:
8161 return "DW_TAG_imported_unit";
8162 case DW_TAG_condition
:
8163 return "DW_TAG_condition";
8164 case DW_TAG_shared_type
:
8165 return "DW_TAG_shared_type";
8166 case DW_TAG_MIPS_loop
:
8167 return "DW_TAG_MIPS_loop";
8168 case DW_TAG_HP_array_descriptor
:
8169 return "DW_TAG_HP_array_descriptor";
8170 case DW_TAG_format_label
:
8171 return "DW_TAG_format_label";
8172 case DW_TAG_function_template
:
8173 return "DW_TAG_function_template";
8174 case DW_TAG_class_template
:
8175 return "DW_TAG_class_template";
8176 case DW_TAG_GNU_BINCL
:
8177 return "DW_TAG_GNU_BINCL";
8178 case DW_TAG_GNU_EINCL
:
8179 return "DW_TAG_GNU_EINCL";
8180 case DW_TAG_upc_shared_type
:
8181 return "DW_TAG_upc_shared_type";
8182 case DW_TAG_upc_strict_type
:
8183 return "DW_TAG_upc_strict_type";
8184 case DW_TAG_upc_relaxed_type
:
8185 return "DW_TAG_upc_relaxed_type";
8186 case DW_TAG_PGI_kanji_type
:
8187 return "DW_TAG_PGI_kanji_type";
8188 case DW_TAG_PGI_interface_block
:
8189 return "DW_TAG_PGI_interface_block";
8191 return "DW_TAG_<unknown>";
8195 /* Convert a DWARF attribute code into its string name. */
8198 dwarf_attr_name (unsigned attr
)
8203 return "DW_AT_sibling";
8204 case DW_AT_location
:
8205 return "DW_AT_location";
8207 return "DW_AT_name";
8208 case DW_AT_ordering
:
8209 return "DW_AT_ordering";
8210 case DW_AT_subscr_data
:
8211 return "DW_AT_subscr_data";
8212 case DW_AT_byte_size
:
8213 return "DW_AT_byte_size";
8214 case DW_AT_bit_offset
:
8215 return "DW_AT_bit_offset";
8216 case DW_AT_bit_size
:
8217 return "DW_AT_bit_size";
8218 case DW_AT_element_list
:
8219 return "DW_AT_element_list";
8220 case DW_AT_stmt_list
:
8221 return "DW_AT_stmt_list";
8223 return "DW_AT_low_pc";
8225 return "DW_AT_high_pc";
8226 case DW_AT_language
:
8227 return "DW_AT_language";
8229 return "DW_AT_member";
8231 return "DW_AT_discr";
8232 case DW_AT_discr_value
:
8233 return "DW_AT_discr_value";
8234 case DW_AT_visibility
:
8235 return "DW_AT_visibility";
8237 return "DW_AT_import";
8238 case DW_AT_string_length
:
8239 return "DW_AT_string_length";
8240 case DW_AT_common_reference
:
8241 return "DW_AT_common_reference";
8242 case DW_AT_comp_dir
:
8243 return "DW_AT_comp_dir";
8244 case DW_AT_const_value
:
8245 return "DW_AT_const_value";
8246 case DW_AT_containing_type
:
8247 return "DW_AT_containing_type";
8248 case DW_AT_default_value
:
8249 return "DW_AT_default_value";
8251 return "DW_AT_inline";
8252 case DW_AT_is_optional
:
8253 return "DW_AT_is_optional";
8254 case DW_AT_lower_bound
:
8255 return "DW_AT_lower_bound";
8256 case DW_AT_producer
:
8257 return "DW_AT_producer";
8258 case DW_AT_prototyped
:
8259 return "DW_AT_prototyped";
8260 case DW_AT_return_addr
:
8261 return "DW_AT_return_addr";
8262 case DW_AT_start_scope
:
8263 return "DW_AT_start_scope";
8264 case DW_AT_bit_stride
:
8265 return "DW_AT_bit_stride";
8266 case DW_AT_upper_bound
:
8267 return "DW_AT_upper_bound";
8268 case DW_AT_abstract_origin
:
8269 return "DW_AT_abstract_origin";
8270 case DW_AT_accessibility
:
8271 return "DW_AT_accessibility";
8272 case DW_AT_address_class
:
8273 return "DW_AT_address_class";
8274 case DW_AT_artificial
:
8275 return "DW_AT_artificial";
8276 case DW_AT_base_types
:
8277 return "DW_AT_base_types";
8278 case DW_AT_calling_convention
:
8279 return "DW_AT_calling_convention";
8281 return "DW_AT_count";
8282 case DW_AT_data_member_location
:
8283 return "DW_AT_data_member_location";
8284 case DW_AT_decl_column
:
8285 return "DW_AT_decl_column";
8286 case DW_AT_decl_file
:
8287 return "DW_AT_decl_file";
8288 case DW_AT_decl_line
:
8289 return "DW_AT_decl_line";
8290 case DW_AT_declaration
:
8291 return "DW_AT_declaration";
8292 case DW_AT_discr_list
:
8293 return "DW_AT_discr_list";
8294 case DW_AT_encoding
:
8295 return "DW_AT_encoding";
8296 case DW_AT_external
:
8297 return "DW_AT_external";
8298 case DW_AT_frame_base
:
8299 return "DW_AT_frame_base";
8301 return "DW_AT_friend";
8302 case DW_AT_identifier_case
:
8303 return "DW_AT_identifier_case";
8304 case DW_AT_macro_info
:
8305 return "DW_AT_macro_info";
8306 case DW_AT_namelist_items
:
8307 return "DW_AT_namelist_items";
8308 case DW_AT_priority
:
8309 return "DW_AT_priority";
8311 return "DW_AT_segment";
8312 case DW_AT_specification
:
8313 return "DW_AT_specification";
8314 case DW_AT_static_link
:
8315 return "DW_AT_static_link";
8317 return "DW_AT_type";
8318 case DW_AT_use_location
:
8319 return "DW_AT_use_location";
8320 case DW_AT_variable_parameter
:
8321 return "DW_AT_variable_parameter";
8322 case DW_AT_virtuality
:
8323 return "DW_AT_virtuality";
8324 case DW_AT_vtable_elem_location
:
8325 return "DW_AT_vtable_elem_location";
8326 /* DWARF 3 values. */
8327 case DW_AT_allocated
:
8328 return "DW_AT_allocated";
8329 case DW_AT_associated
:
8330 return "DW_AT_associated";
8331 case DW_AT_data_location
:
8332 return "DW_AT_data_location";
8333 case DW_AT_byte_stride
:
8334 return "DW_AT_byte_stride";
8335 case DW_AT_entry_pc
:
8336 return "DW_AT_entry_pc";
8337 case DW_AT_use_UTF8
:
8338 return "DW_AT_use_UTF8";
8339 case DW_AT_extension
:
8340 return "DW_AT_extension";
8342 return "DW_AT_ranges";
8343 case DW_AT_trampoline
:
8344 return "DW_AT_trampoline";
8345 case DW_AT_call_column
:
8346 return "DW_AT_call_column";
8347 case DW_AT_call_file
:
8348 return "DW_AT_call_file";
8349 case DW_AT_call_line
:
8350 return "DW_AT_call_line";
8351 case DW_AT_description
:
8352 return "DW_AT_description";
8353 case DW_AT_binary_scale
:
8354 return "DW_AT_binary_scale";
8355 case DW_AT_decimal_scale
:
8356 return "DW_AT_decimal_scale";
8358 return "DW_AT_small";
8359 case DW_AT_decimal_sign
:
8360 return "DW_AT_decimal_sign";
8361 case DW_AT_digit_count
:
8362 return "DW_AT_digit_count";
8363 case DW_AT_picture_string
:
8364 return "DW_AT_picture_string";
8366 return "DW_AT_mutable";
8367 case DW_AT_threads_scaled
:
8368 return "DW_AT_threads_scaled";
8369 case DW_AT_explicit
:
8370 return "DW_AT_explicit";
8371 case DW_AT_object_pointer
:
8372 return "DW_AT_object_pointer";
8373 case DW_AT_endianity
:
8374 return "DW_AT_endianity";
8375 case DW_AT_elemental
:
8376 return "DW_AT_elemental";
8378 return "DW_AT_pure";
8379 case DW_AT_recursive
:
8380 return "DW_AT_recursive";
8382 /* SGI/MIPS extensions. */
8383 case DW_AT_MIPS_fde
:
8384 return "DW_AT_MIPS_fde";
8385 case DW_AT_MIPS_loop_begin
:
8386 return "DW_AT_MIPS_loop_begin";
8387 case DW_AT_MIPS_tail_loop_begin
:
8388 return "DW_AT_MIPS_tail_loop_begin";
8389 case DW_AT_MIPS_epilog_begin
:
8390 return "DW_AT_MIPS_epilog_begin";
8391 case DW_AT_MIPS_loop_unroll_factor
:
8392 return "DW_AT_MIPS_loop_unroll_factor";
8393 case DW_AT_MIPS_software_pipeline_depth
:
8394 return "DW_AT_MIPS_software_pipeline_depth";
8395 case DW_AT_MIPS_linkage_name
:
8396 return "DW_AT_MIPS_linkage_name";
8397 case DW_AT_MIPS_stride
:
8398 return "DW_AT_MIPS_stride";
8399 case DW_AT_MIPS_abstract_name
:
8400 return "DW_AT_MIPS_abstract_name";
8401 case DW_AT_MIPS_clone_origin
:
8402 return "DW_AT_MIPS_clone_origin";
8403 case DW_AT_MIPS_has_inlines
:
8404 return "DW_AT_MIPS_has_inlines";
8406 /* HP extensions. */
8407 case DW_AT_HP_block_index
:
8408 return "DW_AT_HP_block_index";
8409 case DW_AT_HP_unmodifiable
:
8410 return "DW_AT_HP_unmodifiable";
8411 case DW_AT_HP_actuals_stmt_list
:
8412 return "DW_AT_HP_actuals_stmt_list";
8413 case DW_AT_HP_proc_per_section
:
8414 return "DW_AT_HP_proc_per_section";
8415 case DW_AT_HP_raw_data_ptr
:
8416 return "DW_AT_HP_raw_data_ptr";
8417 case DW_AT_HP_pass_by_reference
:
8418 return "DW_AT_HP_pass_by_reference";
8419 case DW_AT_HP_opt_level
:
8420 return "DW_AT_HP_opt_level";
8421 case DW_AT_HP_prof_version_id
:
8422 return "DW_AT_HP_prof_version_id";
8423 case DW_AT_HP_opt_flags
:
8424 return "DW_AT_HP_opt_flags";
8425 case DW_AT_HP_cold_region_low_pc
:
8426 return "DW_AT_HP_cold_region_low_pc";
8427 case DW_AT_HP_cold_region_high_pc
:
8428 return "DW_AT_HP_cold_region_high_pc";
8429 case DW_AT_HP_all_variables_modifiable
:
8430 return "DW_AT_HP_all_variables_modifiable";
8431 case DW_AT_HP_linkage_name
:
8432 return "DW_AT_HP_linkage_name";
8433 case DW_AT_HP_prof_flags
:
8434 return "DW_AT_HP_prof_flags";
8435 /* GNU extensions. */
8436 case DW_AT_sf_names
:
8437 return "DW_AT_sf_names";
8438 case DW_AT_src_info
:
8439 return "DW_AT_src_info";
8440 case DW_AT_mac_info
:
8441 return "DW_AT_mac_info";
8442 case DW_AT_src_coords
:
8443 return "DW_AT_src_coords";
8444 case DW_AT_body_begin
:
8445 return "DW_AT_body_begin";
8446 case DW_AT_body_end
:
8447 return "DW_AT_body_end";
8448 case DW_AT_GNU_vector
:
8449 return "DW_AT_GNU_vector";
8450 /* VMS extensions. */
8451 case DW_AT_VMS_rtnbeg_pd_address
:
8452 return "DW_AT_VMS_rtnbeg_pd_address";
8453 /* UPC extension. */
8454 case DW_AT_upc_threads_scaled
:
8455 return "DW_AT_upc_threads_scaled";
8456 /* PGI (STMicroelectronics) extensions. */
8457 case DW_AT_PGI_lbase
:
8458 return "DW_AT_PGI_lbase";
8459 case DW_AT_PGI_soffset
:
8460 return "DW_AT_PGI_soffset";
8461 case DW_AT_PGI_lstride
:
8462 return "DW_AT_PGI_lstride";
8464 return "DW_AT_<unknown>";
8468 /* Convert a DWARF value form code into its string name. */
8471 dwarf_form_name (unsigned form
)
8476 return "DW_FORM_addr";
8477 case DW_FORM_block2
:
8478 return "DW_FORM_block2";
8479 case DW_FORM_block4
:
8480 return "DW_FORM_block4";
8482 return "DW_FORM_data2";
8484 return "DW_FORM_data4";
8486 return "DW_FORM_data8";
8487 case DW_FORM_string
:
8488 return "DW_FORM_string";
8490 return "DW_FORM_block";
8491 case DW_FORM_block1
:
8492 return "DW_FORM_block1";
8494 return "DW_FORM_data1";
8496 return "DW_FORM_flag";
8498 return "DW_FORM_sdata";
8500 return "DW_FORM_strp";
8502 return "DW_FORM_udata";
8503 case DW_FORM_ref_addr
:
8504 return "DW_FORM_ref_addr";
8506 return "DW_FORM_ref1";
8508 return "DW_FORM_ref2";
8510 return "DW_FORM_ref4";
8512 return "DW_FORM_ref8";
8513 case DW_FORM_ref_udata
:
8514 return "DW_FORM_ref_udata";
8515 case DW_FORM_indirect
:
8516 return "DW_FORM_indirect";
8518 return "DW_FORM_<unknown>";
8522 /* Convert a DWARF stack opcode into its string name. */
8525 dwarf_stack_op_name (unsigned op
)
8530 return "DW_OP_addr";
8532 return "DW_OP_deref";
8534 return "DW_OP_const1u";
8536 return "DW_OP_const1s";
8538 return "DW_OP_const2u";
8540 return "DW_OP_const2s";
8542 return "DW_OP_const4u";
8544 return "DW_OP_const4s";
8546 return "DW_OP_const8u";
8548 return "DW_OP_const8s";
8550 return "DW_OP_constu";
8552 return "DW_OP_consts";
8556 return "DW_OP_drop";
8558 return "DW_OP_over";
8560 return "DW_OP_pick";
8562 return "DW_OP_swap";
8566 return "DW_OP_xderef";
8574 return "DW_OP_minus";
8586 return "DW_OP_plus";
8587 case DW_OP_plus_uconst
:
8588 return "DW_OP_plus_uconst";
8594 return "DW_OP_shra";
8612 return "DW_OP_skip";
8614 return "DW_OP_lit0";
8616 return "DW_OP_lit1";
8618 return "DW_OP_lit2";
8620 return "DW_OP_lit3";
8622 return "DW_OP_lit4";
8624 return "DW_OP_lit5";
8626 return "DW_OP_lit6";
8628 return "DW_OP_lit7";
8630 return "DW_OP_lit8";
8632 return "DW_OP_lit9";
8634 return "DW_OP_lit10";
8636 return "DW_OP_lit11";
8638 return "DW_OP_lit12";
8640 return "DW_OP_lit13";
8642 return "DW_OP_lit14";
8644 return "DW_OP_lit15";
8646 return "DW_OP_lit16";
8648 return "DW_OP_lit17";
8650 return "DW_OP_lit18";
8652 return "DW_OP_lit19";
8654 return "DW_OP_lit20";
8656 return "DW_OP_lit21";
8658 return "DW_OP_lit22";
8660 return "DW_OP_lit23";
8662 return "DW_OP_lit24";
8664 return "DW_OP_lit25";
8666 return "DW_OP_lit26";
8668 return "DW_OP_lit27";
8670 return "DW_OP_lit28";
8672 return "DW_OP_lit29";
8674 return "DW_OP_lit30";
8676 return "DW_OP_lit31";
8678 return "DW_OP_reg0";
8680 return "DW_OP_reg1";
8682 return "DW_OP_reg2";
8684 return "DW_OP_reg3";
8686 return "DW_OP_reg4";
8688 return "DW_OP_reg5";
8690 return "DW_OP_reg6";
8692 return "DW_OP_reg7";
8694 return "DW_OP_reg8";
8696 return "DW_OP_reg9";
8698 return "DW_OP_reg10";
8700 return "DW_OP_reg11";
8702 return "DW_OP_reg12";
8704 return "DW_OP_reg13";
8706 return "DW_OP_reg14";
8708 return "DW_OP_reg15";
8710 return "DW_OP_reg16";
8712 return "DW_OP_reg17";
8714 return "DW_OP_reg18";
8716 return "DW_OP_reg19";
8718 return "DW_OP_reg20";
8720 return "DW_OP_reg21";
8722 return "DW_OP_reg22";
8724 return "DW_OP_reg23";
8726 return "DW_OP_reg24";
8728 return "DW_OP_reg25";
8730 return "DW_OP_reg26";
8732 return "DW_OP_reg27";
8734 return "DW_OP_reg28";
8736 return "DW_OP_reg29";
8738 return "DW_OP_reg30";
8740 return "DW_OP_reg31";
8742 return "DW_OP_breg0";
8744 return "DW_OP_breg1";
8746 return "DW_OP_breg2";
8748 return "DW_OP_breg3";
8750 return "DW_OP_breg4";
8752 return "DW_OP_breg5";
8754 return "DW_OP_breg6";
8756 return "DW_OP_breg7";
8758 return "DW_OP_breg8";
8760 return "DW_OP_breg9";
8762 return "DW_OP_breg10";
8764 return "DW_OP_breg11";
8766 return "DW_OP_breg12";
8768 return "DW_OP_breg13";
8770 return "DW_OP_breg14";
8772 return "DW_OP_breg15";
8774 return "DW_OP_breg16";
8776 return "DW_OP_breg17";
8778 return "DW_OP_breg18";
8780 return "DW_OP_breg19";
8782 return "DW_OP_breg20";
8784 return "DW_OP_breg21";
8786 return "DW_OP_breg22";
8788 return "DW_OP_breg23";
8790 return "DW_OP_breg24";
8792 return "DW_OP_breg25";
8794 return "DW_OP_breg26";
8796 return "DW_OP_breg27";
8798 return "DW_OP_breg28";
8800 return "DW_OP_breg29";
8802 return "DW_OP_breg30";
8804 return "DW_OP_breg31";
8806 return "DW_OP_regx";
8808 return "DW_OP_fbreg";
8810 return "DW_OP_bregx";
8812 return "DW_OP_piece";
8813 case DW_OP_deref_size
:
8814 return "DW_OP_deref_size";
8815 case DW_OP_xderef_size
:
8816 return "DW_OP_xderef_size";
8819 /* DWARF 3 extensions. */
8820 case DW_OP_push_object_address
:
8821 return "DW_OP_push_object_address";
8823 return "DW_OP_call2";
8825 return "DW_OP_call4";
8826 case DW_OP_call_ref
:
8827 return "DW_OP_call_ref";
8828 /* GNU extensions. */
8829 case DW_OP_form_tls_address
:
8830 return "DW_OP_form_tls_address";
8831 case DW_OP_call_frame_cfa
:
8832 return "DW_OP_call_frame_cfa";
8833 case DW_OP_bit_piece
:
8834 return "DW_OP_bit_piece";
8835 case DW_OP_GNU_push_tls_address
:
8836 return "DW_OP_GNU_push_tls_address";
8837 case DW_OP_GNU_uninit
:
8838 return "DW_OP_GNU_uninit";
8839 /* HP extensions. */
8840 case DW_OP_HP_is_value
:
8841 return "DW_OP_HP_is_value";
8842 case DW_OP_HP_fltconst4
:
8843 return "DW_OP_HP_fltconst4";
8844 case DW_OP_HP_fltconst8
:
8845 return "DW_OP_HP_fltconst8";
8846 case DW_OP_HP_mod_range
:
8847 return "DW_OP_HP_mod_range";
8848 case DW_OP_HP_unmod_range
:
8849 return "DW_OP_HP_unmod_range";
8851 return "DW_OP_HP_tls";
8853 return "OP_<unknown>";
8858 dwarf_bool_name (unsigned mybool
)
8866 /* Convert a DWARF type code into its string name. */
8869 dwarf_type_encoding_name (unsigned enc
)
8874 return "DW_ATE_void";
8875 case DW_ATE_address
:
8876 return "DW_ATE_address";
8877 case DW_ATE_boolean
:
8878 return "DW_ATE_boolean";
8879 case DW_ATE_complex_float
:
8880 return "DW_ATE_complex_float";
8882 return "DW_ATE_float";
8884 return "DW_ATE_signed";
8885 case DW_ATE_signed_char
:
8886 return "DW_ATE_signed_char";
8887 case DW_ATE_unsigned
:
8888 return "DW_ATE_unsigned";
8889 case DW_ATE_unsigned_char
:
8890 return "DW_ATE_unsigned_char";
8892 case DW_ATE_imaginary_float
:
8893 return "DW_ATE_imaginary_float";
8894 case DW_ATE_packed_decimal
:
8895 return "DW_ATE_packed_decimal";
8896 case DW_ATE_numeric_string
:
8897 return "DW_ATE_numeric_string";
8899 return "DW_ATE_edited";
8900 case DW_ATE_signed_fixed
:
8901 return "DW_ATE_signed_fixed";
8902 case DW_ATE_unsigned_fixed
:
8903 return "DW_ATE_unsigned_fixed";
8904 case DW_ATE_decimal_float
:
8905 return "DW_ATE_decimal_float";
8906 /* HP extensions. */
8907 case DW_ATE_HP_float80
:
8908 return "DW_ATE_HP_float80";
8909 case DW_ATE_HP_complex_float80
:
8910 return "DW_ATE_HP_complex_float80";
8911 case DW_ATE_HP_float128
:
8912 return "DW_ATE_HP_float128";
8913 case DW_ATE_HP_complex_float128
:
8914 return "DW_ATE_HP_complex_float128";
8915 case DW_ATE_HP_floathpintel
:
8916 return "DW_ATE_HP_floathpintel";
8917 case DW_ATE_HP_imaginary_float80
:
8918 return "DW_ATE_HP_imaginary_float80";
8919 case DW_ATE_HP_imaginary_float128
:
8920 return "DW_ATE_HP_imaginary_float128";
8922 return "DW_ATE_<unknown>";
8926 /* Convert a DWARF call frame info operation to its string name. */
8930 dwarf_cfi_name (unsigned cfi_opc
)
8934 case DW_CFA_advance_loc
:
8935 return "DW_CFA_advance_loc";
8937 return "DW_CFA_offset";
8938 case DW_CFA_restore
:
8939 return "DW_CFA_restore";
8941 return "DW_CFA_nop";
8942 case DW_CFA_set_loc
:
8943 return "DW_CFA_set_loc";
8944 case DW_CFA_advance_loc1
:
8945 return "DW_CFA_advance_loc1";
8946 case DW_CFA_advance_loc2
:
8947 return "DW_CFA_advance_loc2";
8948 case DW_CFA_advance_loc4
:
8949 return "DW_CFA_advance_loc4";
8950 case DW_CFA_offset_extended
:
8951 return "DW_CFA_offset_extended";
8952 case DW_CFA_restore_extended
:
8953 return "DW_CFA_restore_extended";
8954 case DW_CFA_undefined
:
8955 return "DW_CFA_undefined";
8956 case DW_CFA_same_value
:
8957 return "DW_CFA_same_value";
8958 case DW_CFA_register
:
8959 return "DW_CFA_register";
8960 case DW_CFA_remember_state
:
8961 return "DW_CFA_remember_state";
8962 case DW_CFA_restore_state
:
8963 return "DW_CFA_restore_state";
8964 case DW_CFA_def_cfa
:
8965 return "DW_CFA_def_cfa";
8966 case DW_CFA_def_cfa_register
:
8967 return "DW_CFA_def_cfa_register";
8968 case DW_CFA_def_cfa_offset
:
8969 return "DW_CFA_def_cfa_offset";
8971 case DW_CFA_def_cfa_expression
:
8972 return "DW_CFA_def_cfa_expression";
8973 case DW_CFA_expression
:
8974 return "DW_CFA_expression";
8975 case DW_CFA_offset_extended_sf
:
8976 return "DW_CFA_offset_extended_sf";
8977 case DW_CFA_def_cfa_sf
:
8978 return "DW_CFA_def_cfa_sf";
8979 case DW_CFA_def_cfa_offset_sf
:
8980 return "DW_CFA_def_cfa_offset_sf";
8981 case DW_CFA_val_offset
:
8982 return "DW_CFA_val_offset";
8983 case DW_CFA_val_offset_sf
:
8984 return "DW_CFA_val_offset_sf";
8985 case DW_CFA_val_expression
:
8986 return "DW_CFA_val_expression";
8987 /* SGI/MIPS specific. */
8988 case DW_CFA_MIPS_advance_loc8
:
8989 return "DW_CFA_MIPS_advance_loc8";
8990 /* GNU extensions. */
8991 case DW_CFA_GNU_window_save
:
8992 return "DW_CFA_GNU_window_save";
8993 case DW_CFA_GNU_args_size
:
8994 return "DW_CFA_GNU_args_size";
8995 case DW_CFA_GNU_negative_offset_extended
:
8996 return "DW_CFA_GNU_negative_offset_extended";
8998 return "DW_CFA_<unknown>";
9004 dump_die (struct die_info
*die
)
9008 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
9009 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
9010 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
9011 dwarf_bool_name (die
->child
!= NULL
));
9013 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
9014 for (i
= 0; i
< die
->num_attrs
; ++i
)
9016 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
9017 dwarf_attr_name (die
->attrs
[i
].name
),
9018 dwarf_form_name (die
->attrs
[i
].form
));
9019 switch (die
->attrs
[i
].form
)
9021 case DW_FORM_ref_addr
:
9023 fprintf_unfiltered (gdb_stderr
, "address: ");
9024 fputs_filtered (paddress (DW_ADDR (&die
->attrs
[i
])), gdb_stderr
);
9026 case DW_FORM_block2
:
9027 case DW_FORM_block4
:
9029 case DW_FORM_block1
:
9030 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
9035 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
9036 (long) (DW_ADDR (&die
->attrs
[i
])));
9044 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
9046 case DW_FORM_string
:
9048 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
9049 DW_STRING (&die
->attrs
[i
])
9050 ? DW_STRING (&die
->attrs
[i
]) : "");
9053 if (DW_UNSND (&die
->attrs
[i
]))
9054 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
9056 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
9058 case DW_FORM_indirect
:
9059 /* the reader will have reduced the indirect form to
9060 the "base form" so this form should not occur */
9061 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
9064 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
9065 die
->attrs
[i
].form
);
9067 fprintf_unfiltered (gdb_stderr
, "\n");
9072 dump_die_list (struct die_info
*die
)
9077 if (die
->child
!= NULL
)
9078 dump_die_list (die
->child
);
9079 if (die
->sibling
!= NULL
)
9080 dump_die_list (die
->sibling
);
9085 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
9089 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
9095 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
9097 unsigned int result
= 0;
9101 case DW_FORM_ref_addr
:
9106 case DW_FORM_ref_udata
:
9107 result
= DW_ADDR (attr
);
9110 complaint (&symfile_complaints
,
9111 _("unsupported die ref attribute form: '%s'"),
9112 dwarf_form_name (attr
->form
));
9117 /* Return the constant value held by the given attribute. Return -1
9118 if the value held by the attribute is not constant. */
9121 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
9123 if (attr
->form
== DW_FORM_sdata
)
9124 return DW_SND (attr
);
9125 else if (attr
->form
== DW_FORM_udata
9126 || attr
->form
== DW_FORM_data1
9127 || attr
->form
== DW_FORM_data2
9128 || attr
->form
== DW_FORM_data4
9129 || attr
->form
== DW_FORM_data8
)
9130 return DW_UNSND (attr
);
9133 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
9134 dwarf_form_name (attr
->form
));
9135 return default_value
;
9139 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
9140 unit and add it to our queue. */
9143 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
9144 struct dwarf2_per_cu_data
*per_cu
)
9146 /* Mark the dependence relation so that we don't flush PER_CU
9148 dwarf2_add_dependence (this_cu
, per_cu
);
9150 /* If it's already on the queue, we have nothing to do. */
9154 /* If the compilation unit is already loaded, just mark it as
9156 if (per_cu
->cu
!= NULL
)
9158 per_cu
->cu
->last_used
= 0;
9162 /* Add it to the queue. */
9163 queue_comp_unit (per_cu
, this_cu
->objfile
);
9166 static struct die_info
*
9167 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
9168 struct dwarf2_cu
**ref_cu
)
9170 struct die_info
*die
;
9171 unsigned int offset
;
9172 struct die_info temp_die
;
9173 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
9175 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
9177 if (DW_ADDR (attr
) < cu
->header
.offset
9178 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
9180 struct dwarf2_per_cu_data
*per_cu
;
9181 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
9184 /* If necessary, add it to the queue and load its DIEs. */
9185 maybe_queue_comp_unit (cu
, per_cu
);
9187 target_cu
= per_cu
->cu
;
9192 *ref_cu
= target_cu
;
9193 temp_die
.offset
= offset
;
9194 die
= htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
9198 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
9199 "at 0x%lx [in module %s]"),
9200 (long) offset
, (long) src_die
->offset
, cu
->objfile
->name
);
9203 /* Decode simple location descriptions.
9204 Given a pointer to a dwarf block that defines a location, compute
9205 the location and return the value.
9207 NOTE drow/2003-11-18: This function is called in two situations
9208 now: for the address of static or global variables (partial symbols
9209 only) and for offsets into structures which are expected to be
9210 (more or less) constant. The partial symbol case should go away,
9211 and only the constant case should remain. That will let this
9212 function complain more accurately. A few special modes are allowed
9213 without complaint for global variables (for instance, global
9214 register values and thread-local values).
9216 A location description containing no operations indicates that the
9217 object is optimized out. The return value is 0 for that case.
9218 FIXME drow/2003-11-16: No callers check for this case any more; soon all
9219 callers will only want a very basic result and this can become a
9222 Note that stack[0] is unused except as a default error return.
9223 Note that stack overflow is not yet handled. */
9226 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
9228 struct objfile
*objfile
= cu
->objfile
;
9229 struct comp_unit_head
*cu_header
= &cu
->header
;
9231 int size
= blk
->size
;
9232 gdb_byte
*data
= blk
->data
;
9233 CORE_ADDR stack
[64];
9235 unsigned int bytes_read
, unsnd
;
9279 stack
[++stacki
] = op
- DW_OP_lit0
;
9314 stack
[++stacki
] = op
- DW_OP_reg0
;
9316 dwarf2_complex_location_expr_complaint ();
9320 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9322 stack
[++stacki
] = unsnd
;
9324 dwarf2_complex_location_expr_complaint ();
9328 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
9334 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
9339 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
9344 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
9349 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
9354 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
9359 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
9364 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
9370 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
9375 stack
[stacki
+ 1] = stack
[stacki
];
9380 stack
[stacki
- 1] += stack
[stacki
];
9384 case DW_OP_plus_uconst
:
9385 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9390 stack
[stacki
- 1] -= stack
[stacki
];
9395 /* If we're not the last op, then we definitely can't encode
9396 this using GDB's address_class enum. This is valid for partial
9397 global symbols, although the variable's address will be bogus
9400 dwarf2_complex_location_expr_complaint ();
9403 case DW_OP_GNU_push_tls_address
:
9404 /* The top of the stack has the offset from the beginning
9405 of the thread control block at which the variable is located. */
9406 /* Nothing should follow this operator, so the top of stack would
9408 /* This is valid for partial global symbols, but the variable's
9409 address will be bogus in the psymtab. */
9411 dwarf2_complex_location_expr_complaint ();
9414 case DW_OP_GNU_uninit
:
9418 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
9419 dwarf_stack_op_name (op
));
9420 return (stack
[stacki
]);
9423 return (stack
[stacki
]);
9426 /* memory allocation interface */
9428 static struct dwarf_block
*
9429 dwarf_alloc_block (struct dwarf2_cu
*cu
)
9431 struct dwarf_block
*blk
;
9433 blk
= (struct dwarf_block
*)
9434 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
9438 static struct abbrev_info
*
9439 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
9441 struct abbrev_info
*abbrev
;
9443 abbrev
= (struct abbrev_info
*)
9444 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
9445 memset (abbrev
, 0, sizeof (struct abbrev_info
));
9449 static struct die_info
*
9450 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
9452 struct die_info
*die
;
9453 size_t size
= sizeof (struct die_info
);
9456 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
9458 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
9459 memset (die
, 0, sizeof (struct die_info
));
9464 /* Macro support. */
9467 /* Return the full name of file number I in *LH's file name table.
9468 Use COMP_DIR as the name of the current directory of the
9469 compilation. The result is allocated using xmalloc; the caller is
9470 responsible for freeing it. */
9472 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
9474 /* Is the file number a valid index into the line header's file name
9475 table? Remember that file numbers start with one, not zero. */
9476 if (1 <= file
&& file
<= lh
->num_file_names
)
9478 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9480 if (IS_ABSOLUTE_PATH (fe
->name
))
9481 return xstrdup (fe
->name
);
9489 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9495 dir_len
= strlen (dir
);
9496 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
9497 strcpy (full_name
, dir
);
9498 full_name
[dir_len
] = '/';
9499 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
9503 return xstrdup (fe
->name
);
9508 /* The compiler produced a bogus file number. We can at least
9509 record the macro definitions made in the file, even if we
9510 won't be able to find the file by name. */
9512 sprintf (fake_name
, "<bad macro file number %d>", file
);
9514 complaint (&symfile_complaints
,
9515 _("bad file number in macro information (%d)"),
9518 return xstrdup (fake_name
);
9523 static struct macro_source_file
*
9524 macro_start_file (int file
, int line
,
9525 struct macro_source_file
*current_file
,
9526 const char *comp_dir
,
9527 struct line_header
*lh
, struct objfile
*objfile
)
9529 /* The full name of this source file. */
9530 char *full_name
= file_full_name (file
, lh
, comp_dir
);
9532 /* We don't create a macro table for this compilation unit
9533 at all until we actually get a filename. */
9534 if (! pending_macros
)
9535 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
9536 objfile
->macro_cache
);
9539 /* If we have no current file, then this must be the start_file
9540 directive for the compilation unit's main source file. */
9541 current_file
= macro_set_main (pending_macros
, full_name
);
9543 current_file
= macro_include (current_file
, line
, full_name
);
9547 return current_file
;
9551 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9552 followed by a null byte. */
9554 copy_string (const char *buf
, int len
)
9556 char *s
= xmalloc (len
+ 1);
9557 memcpy (s
, buf
, len
);
9565 consume_improper_spaces (const char *p
, const char *body
)
9569 complaint (&symfile_complaints
,
9570 _("macro definition contains spaces in formal argument list:\n`%s'"),
9582 parse_macro_definition (struct macro_source_file
*file
, int line
,
9587 /* The body string takes one of two forms. For object-like macro
9588 definitions, it should be:
9590 <macro name> " " <definition>
9592 For function-like macro definitions, it should be:
9594 <macro name> "() " <definition>
9596 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9598 Spaces may appear only where explicitly indicated, and in the
9601 The Dwarf 2 spec says that an object-like macro's name is always
9602 followed by a space, but versions of GCC around March 2002 omit
9603 the space when the macro's definition is the empty string.
9605 The Dwarf 2 spec says that there should be no spaces between the
9606 formal arguments in a function-like macro's formal argument list,
9607 but versions of GCC around March 2002 include spaces after the
9611 /* Find the extent of the macro name. The macro name is terminated
9612 by either a space or null character (for an object-like macro) or
9613 an opening paren (for a function-like macro). */
9614 for (p
= body
; *p
; p
++)
9615 if (*p
== ' ' || *p
== '(')
9618 if (*p
== ' ' || *p
== '\0')
9620 /* It's an object-like macro. */
9621 int name_len
= p
- body
;
9622 char *name
= copy_string (body
, name_len
);
9623 const char *replacement
;
9626 replacement
= body
+ name_len
+ 1;
9629 dwarf2_macro_malformed_definition_complaint (body
);
9630 replacement
= body
+ name_len
;
9633 macro_define_object (file
, line
, name
, replacement
);
9639 /* It's a function-like macro. */
9640 char *name
= copy_string (body
, p
- body
);
9643 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9647 p
= consume_improper_spaces (p
, body
);
9649 /* Parse the formal argument list. */
9650 while (*p
&& *p
!= ')')
9652 /* Find the extent of the current argument name. */
9653 const char *arg_start
= p
;
9655 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9658 if (! *p
|| p
== arg_start
)
9659 dwarf2_macro_malformed_definition_complaint (body
);
9662 /* Make sure argv has room for the new argument. */
9663 if (argc
>= argv_size
)
9666 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9669 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9672 p
= consume_improper_spaces (p
, body
);
9674 /* Consume the comma, if present. */
9679 p
= consume_improper_spaces (p
, body
);
9688 /* Perfectly formed definition, no complaints. */
9689 macro_define_function (file
, line
, name
,
9690 argc
, (const char **) argv
,
9692 else if (*p
== '\0')
9694 /* Complain, but do define it. */
9695 dwarf2_macro_malformed_definition_complaint (body
);
9696 macro_define_function (file
, line
, name
,
9697 argc
, (const char **) argv
,
9701 /* Just complain. */
9702 dwarf2_macro_malformed_definition_complaint (body
);
9705 /* Just complain. */
9706 dwarf2_macro_malformed_definition_complaint (body
);
9712 for (i
= 0; i
< argc
; i
++)
9718 dwarf2_macro_malformed_definition_complaint (body
);
9723 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9724 char *comp_dir
, bfd
*abfd
,
9725 struct dwarf2_cu
*cu
)
9727 gdb_byte
*mac_ptr
, *mac_end
;
9728 struct macro_source_file
*current_file
= 0;
9730 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9732 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9736 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9737 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9738 + dwarf2_per_objfile
->macinfo_size
;
9742 enum dwarf_macinfo_record_type macinfo_type
;
9744 /* Do we at least have room for a macinfo type byte? */
9745 if (mac_ptr
>= mac_end
)
9747 dwarf2_macros_too_long_complaint ();
9751 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9754 switch (macinfo_type
)
9756 /* A zero macinfo type indicates the end of the macro
9761 case DW_MACINFO_define
:
9762 case DW_MACINFO_undef
:
9764 unsigned int bytes_read
;
9768 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9769 mac_ptr
+= bytes_read
;
9770 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9771 mac_ptr
+= bytes_read
;
9774 complaint (&symfile_complaints
,
9775 _("debug info gives macro %s outside of any file: %s"),
9777 DW_MACINFO_define
? "definition" : macinfo_type
==
9778 DW_MACINFO_undef
? "undefinition" :
9779 "something-or-other", body
);
9782 if (macinfo_type
== DW_MACINFO_define
)
9783 parse_macro_definition (current_file
, line
, body
);
9784 else if (macinfo_type
== DW_MACINFO_undef
)
9785 macro_undef (current_file
, line
, body
);
9790 case DW_MACINFO_start_file
:
9792 unsigned int bytes_read
;
9795 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9796 mac_ptr
+= bytes_read
;
9797 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9798 mac_ptr
+= bytes_read
;
9800 current_file
= macro_start_file (file
, line
,
9801 current_file
, comp_dir
,
9806 case DW_MACINFO_end_file
:
9808 complaint (&symfile_complaints
,
9809 _("macro debug info has an unmatched `close_file' directive"));
9812 current_file
= current_file
->included_by
;
9815 enum dwarf_macinfo_record_type next_type
;
9817 /* GCC circa March 2002 doesn't produce the zero
9818 type byte marking the end of the compilation
9819 unit. Complain if it's not there, but exit no
9822 /* Do we at least have room for a macinfo type byte? */
9823 if (mac_ptr
>= mac_end
)
9825 dwarf2_macros_too_long_complaint ();
9829 /* We don't increment mac_ptr here, so this is just
9831 next_type
= read_1_byte (abfd
, mac_ptr
);
9833 complaint (&symfile_complaints
,
9834 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9841 case DW_MACINFO_vendor_ext
:
9843 unsigned int bytes_read
;
9847 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9848 mac_ptr
+= bytes_read
;
9849 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9850 mac_ptr
+= bytes_read
;
9852 /* We don't recognize any vendor extensions. */
9859 /* Check if the attribute's form is a DW_FORM_block*
9860 if so return true else false. */
9862 attr_form_is_block (struct attribute
*attr
)
9864 return (attr
== NULL
? 0 :
9865 attr
->form
== DW_FORM_block1
9866 || attr
->form
== DW_FORM_block2
9867 || attr
->form
== DW_FORM_block4
9868 || attr
->form
== DW_FORM_block
);
9871 /* Return non-zero if ATTR's value is a section offset --- classes
9872 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
9873 You may use DW_UNSND (attr) to retrieve such offsets.
9875 Section 7.5.4, "Attribute Encodings", explains that no attribute
9876 may have a value that belongs to more than one of these classes; it
9877 would be ambiguous if we did, because we use the same forms for all
9880 attr_form_is_section_offset (struct attribute
*attr
)
9882 return (attr
->form
== DW_FORM_data4
9883 || attr
->form
== DW_FORM_data8
);
9887 /* Return non-zero if ATTR's value falls in the 'constant' class, or
9888 zero otherwise. When this function returns true, you can apply
9889 dwarf2_get_attr_constant_value to it.
9891 However, note that for some attributes you must check
9892 attr_form_is_section_offset before using this test. DW_FORM_data4
9893 and DW_FORM_data8 are members of both the constant class, and of
9894 the classes that contain offsets into other debug sections
9895 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
9896 that, if an attribute's can be either a constant or one of the
9897 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
9898 taken as section offsets, not constants. */
9900 attr_form_is_constant (struct attribute
*attr
)
9917 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9918 struct dwarf2_cu
*cu
)
9920 if (attr_form_is_section_offset (attr
)
9921 /* ".debug_loc" may not exist at all, or the offset may be outside
9922 the section. If so, fall through to the complaint in the
9924 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9926 struct dwarf2_loclist_baton
*baton
;
9928 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9929 sizeof (struct dwarf2_loclist_baton
));
9930 baton
->per_cu
= cu
->per_cu
;
9931 gdb_assert (baton
->per_cu
);
9933 /* We don't know how long the location list is, but make sure we
9934 don't run off the edge of the section. */
9935 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9936 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9937 baton
->base_address
= cu
->header
.base_address
;
9938 if (cu
->header
.base_known
== 0)
9939 complaint (&symfile_complaints
,
9940 _("Location list used without specifying the CU base address."));
9942 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9943 SYMBOL_LOCATION_BATON (sym
) = baton
;
9947 struct dwarf2_locexpr_baton
*baton
;
9949 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9950 sizeof (struct dwarf2_locexpr_baton
));
9951 baton
->per_cu
= cu
->per_cu
;
9952 gdb_assert (baton
->per_cu
);
9954 if (attr_form_is_block (attr
))
9956 /* Note that we're just copying the block's data pointer
9957 here, not the actual data. We're still pointing into the
9958 info_buffer for SYM's objfile; right now we never release
9959 that buffer, but when we do clean up properly this may
9961 baton
->size
= DW_BLOCK (attr
)->size
;
9962 baton
->data
= DW_BLOCK (attr
)->data
;
9966 dwarf2_invalid_attrib_class_complaint ("location description",
9967 SYMBOL_NATURAL_NAME (sym
));
9972 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9973 SYMBOL_LOCATION_BATON (sym
) = baton
;
9977 /* Return the OBJFILE associated with the compilation unit CU. */
9980 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
9982 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
9984 /* Return the master objfile, so that we can report and look up the
9985 correct file containing this variable. */
9986 if (objfile
->separate_debug_objfile_backlink
)
9987 objfile
= objfile
->separate_debug_objfile_backlink
;
9992 /* Return the address size given in the compilation unit header for CU. */
9995 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
9998 return per_cu
->cu
->header
.addr_size
;
10001 /* If the CU is not currently read in, we re-read its header. */
10002 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
10003 struct dwarf2_per_objfile
*per_objfile
10004 = objfile_data (objfile
, dwarf2_objfile_data_key
);
10005 gdb_byte
*info_ptr
= per_objfile
->info_buffer
+ per_cu
->offset
;
10007 struct comp_unit_head cu_header
;
10008 memset (&cu_header
, 0, sizeof cu_header
);
10009 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
10010 return cu_header
.addr_size
;
10014 /* Locate the compilation unit from CU's objfile which contains the
10015 DIE at OFFSET. Raises an error on failure. */
10017 static struct dwarf2_per_cu_data
*
10018 dwarf2_find_containing_comp_unit (unsigned long offset
,
10019 struct objfile
*objfile
)
10021 struct dwarf2_per_cu_data
*this_cu
;
10025 high
= dwarf2_per_objfile
->n_comp_units
- 1;
10028 int mid
= low
+ (high
- low
) / 2;
10029 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
10034 gdb_assert (low
== high
);
10035 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
10038 error (_("Dwarf Error: could not find partial DIE containing "
10039 "offset 0x%lx [in module %s]"),
10040 (long) offset
, bfd_get_filename (objfile
->obfd
));
10042 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
10043 return dwarf2_per_objfile
->all_comp_units
[low
-1];
10047 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
10048 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
10049 && offset
>= this_cu
->offset
+ this_cu
->length
)
10050 error (_("invalid dwarf2 offset %ld"), offset
);
10051 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
10056 /* Locate the compilation unit from OBJFILE which is located at exactly
10057 OFFSET. Raises an error on failure. */
10059 static struct dwarf2_per_cu_data
*
10060 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
10062 struct dwarf2_per_cu_data
*this_cu
;
10063 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
10064 if (this_cu
->offset
!= offset
)
10065 error (_("no compilation unit with offset %ld."), offset
);
10069 /* Release one cached compilation unit, CU. We unlink it from the tree
10070 of compilation units, but we don't remove it from the read_in_chain;
10071 the caller is responsible for that. */
10074 free_one_comp_unit (void *data
)
10076 struct dwarf2_cu
*cu
= data
;
10078 if (cu
->per_cu
!= NULL
)
10079 cu
->per_cu
->cu
= NULL
;
10082 obstack_free (&cu
->comp_unit_obstack
, NULL
);
10087 /* This cleanup function is passed the address of a dwarf2_cu on the stack
10088 when we're finished with it. We can't free the pointer itself, but be
10089 sure to unlink it from the cache. Also release any associated storage
10090 and perform cache maintenance.
10092 Only used during partial symbol parsing. */
10095 free_stack_comp_unit (void *data
)
10097 struct dwarf2_cu
*cu
= data
;
10099 obstack_free (&cu
->comp_unit_obstack
, NULL
);
10100 cu
->partial_dies
= NULL
;
10102 if (cu
->per_cu
!= NULL
)
10104 /* This compilation unit is on the stack in our caller, so we
10105 should not xfree it. Just unlink it. */
10106 cu
->per_cu
->cu
= NULL
;
10109 /* If we had a per-cu pointer, then we may have other compilation
10110 units loaded, so age them now. */
10111 age_cached_comp_units ();
10115 /* Free all cached compilation units. */
10118 free_cached_comp_units (void *data
)
10120 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10122 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10123 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10124 while (per_cu
!= NULL
)
10126 struct dwarf2_per_cu_data
*next_cu
;
10128 next_cu
= per_cu
->cu
->read_in_chain
;
10130 free_one_comp_unit (per_cu
->cu
);
10131 *last_chain
= next_cu
;
10137 /* Increase the age counter on each cached compilation unit, and free
10138 any that are too old. */
10141 age_cached_comp_units (void)
10143 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10145 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
10146 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10147 while (per_cu
!= NULL
)
10149 per_cu
->cu
->last_used
++;
10150 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
10151 dwarf2_mark (per_cu
->cu
);
10152 per_cu
= per_cu
->cu
->read_in_chain
;
10155 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10156 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10157 while (per_cu
!= NULL
)
10159 struct dwarf2_per_cu_data
*next_cu
;
10161 next_cu
= per_cu
->cu
->read_in_chain
;
10163 if (!per_cu
->cu
->mark
)
10165 free_one_comp_unit (per_cu
->cu
);
10166 *last_chain
= next_cu
;
10169 last_chain
= &per_cu
->cu
->read_in_chain
;
10175 /* Remove a single compilation unit from the cache. */
10178 free_one_cached_comp_unit (void *target_cu
)
10180 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10182 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10183 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10184 while (per_cu
!= NULL
)
10186 struct dwarf2_per_cu_data
*next_cu
;
10188 next_cu
= per_cu
->cu
->read_in_chain
;
10190 if (per_cu
->cu
== target_cu
)
10192 free_one_comp_unit (per_cu
->cu
);
10193 *last_chain
= next_cu
;
10197 last_chain
= &per_cu
->cu
->read_in_chain
;
10203 /* Release all extra memory associated with OBJFILE. */
10206 dwarf2_free_objfile (struct objfile
*objfile
)
10208 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
10210 if (dwarf2_per_objfile
== NULL
)
10213 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
10214 free_cached_comp_units (NULL
);
10216 /* Everything else should be on the objfile obstack. */
10219 /* A pair of DIE offset and GDB type pointer. We store these
10220 in a hash table separate from the DIEs, and preserve them
10221 when the DIEs are flushed out of cache. */
10223 struct dwarf2_offset_and_type
10225 unsigned int offset
;
10229 /* Hash function for a dwarf2_offset_and_type. */
10232 offset_and_type_hash (const void *item
)
10234 const struct dwarf2_offset_and_type
*ofs
= item
;
10235 return ofs
->offset
;
10238 /* Equality function for a dwarf2_offset_and_type. */
10241 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
10243 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
10244 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
10245 return ofs_lhs
->offset
== ofs_rhs
->offset
;
10248 /* Set the type associated with DIE to TYPE. Save it in CU's hash
10249 table if necessary. For convenience, return TYPE. */
10251 static struct type
*
10252 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
10254 struct dwarf2_offset_and_type
**slot
, ofs
;
10256 if (cu
->type_hash
== NULL
)
10258 gdb_assert (cu
->per_cu
!= NULL
);
10259 cu
->per_cu
->type_hash
10260 = htab_create_alloc_ex (cu
->header
.length
/ 24,
10261 offset_and_type_hash
,
10262 offset_and_type_eq
,
10264 &cu
->objfile
->objfile_obstack
,
10265 hashtab_obstack_allocate
,
10266 dummy_obstack_deallocate
);
10267 cu
->type_hash
= cu
->per_cu
->type_hash
;
10270 ofs
.offset
= die
->offset
;
10272 slot
= (struct dwarf2_offset_and_type
**)
10273 htab_find_slot_with_hash (cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
10274 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
10279 /* Find the type for DIE in CU's type_hash, or return NULL if DIE does
10280 not have a saved type. */
10282 static struct type
*
10283 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10285 struct dwarf2_offset_and_type
*slot
, ofs
;
10286 htab_t type_hash
= cu
->type_hash
;
10288 if (type_hash
== NULL
)
10291 ofs
.offset
= die
->offset
;
10292 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
10299 /* Set the mark field in CU and in every other compilation unit in the
10300 cache that we must keep because we are keeping CU. */
10302 /* Add a dependence relationship from CU to REF_PER_CU. */
10305 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
10306 struct dwarf2_per_cu_data
*ref_per_cu
)
10310 if (cu
->dependencies
== NULL
)
10312 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
10313 NULL
, &cu
->comp_unit_obstack
,
10314 hashtab_obstack_allocate
,
10315 dummy_obstack_deallocate
);
10317 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
10319 *slot
= ref_per_cu
;
10322 /* Set the mark field in CU and in every other compilation unit in the
10323 cache that we must keep because we are keeping CU. */
10326 dwarf2_mark_helper (void **slot
, void *data
)
10328 struct dwarf2_per_cu_data
*per_cu
;
10330 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
10331 if (per_cu
->cu
->mark
)
10333 per_cu
->cu
->mark
= 1;
10335 if (per_cu
->cu
->dependencies
!= NULL
)
10336 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10342 dwarf2_mark (struct dwarf2_cu
*cu
)
10347 if (cu
->dependencies
!= NULL
)
10348 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10352 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
10356 per_cu
->cu
->mark
= 0;
10357 per_cu
= per_cu
->cu
->read_in_chain
;
10361 /* Trivial hash function for partial_die_info: the hash value of a DIE
10362 is its offset in .debug_info for this objfile. */
10365 partial_die_hash (const void *item
)
10367 const struct partial_die_info
*part_die
= item
;
10368 return part_die
->offset
;
10371 /* Trivial comparison function for partial_die_info structures: two DIEs
10372 are equal if they have the same offset. */
10375 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
10377 const struct partial_die_info
*part_die_lhs
= item_lhs
;
10378 const struct partial_die_info
*part_die_rhs
= item_rhs
;
10379 return part_die_lhs
->offset
== part_die_rhs
->offset
;
10382 static struct cmd_list_element
*set_dwarf2_cmdlist
;
10383 static struct cmd_list_element
*show_dwarf2_cmdlist
;
10386 set_dwarf2_cmd (char *args
, int from_tty
)
10388 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
10392 show_dwarf2_cmd (char *args
, int from_tty
)
10394 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
10397 void _initialize_dwarf2_read (void);
10400 _initialize_dwarf2_read (void)
10402 dwarf2_objfile_data_key
= register_objfile_data ();
10404 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
10405 Set DWARF 2 specific variables.\n\
10406 Configure DWARF 2 variables such as the cache size"),
10407 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
10408 0/*allow-unknown*/, &maintenance_set_cmdlist
);
10410 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
10411 Show DWARF 2 specific variables\n\
10412 Show DWARF 2 variables such as the cache size"),
10413 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
10414 0/*allow-unknown*/, &maintenance_show_cmdlist
);
10416 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
10417 &dwarf2_max_cache_age
, _("\
10418 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
10419 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
10420 A higher limit means that cached compilation units will be stored\n\
10421 in memory longer, and more total memory will be used. Zero disables\n\
10422 caching, which can slow down startup."),
10424 show_dwarf2_max_cache_age
,
10425 &set_dwarf2_cmdlist
,
10426 &show_dwarf2_cmdlist
);